s390x/css: Make schib parameter of css_do_msch const

[qemu.git] / target-s390x / ioinst.c

diff --git a/target-s390x/ioinst.c b/target-s390x/ioinst.c
index 85fd2857361de65a3ab57895724e436d87c2132f..1ac5d61c560981ca5299b59e5d5501abe137f54b 100644 (file)
--- a/target-s390x/ioinst.c
+++ b/target-s390x/ioinst.c
@@ -14,6 +14,7 @@
 #include "cpu.h"
 #include "ioinst.h"
 #include "trace.h"
 #include "cpu.h"
 #include "ioinst.h"
 #include "trace.h"

+#include "hw/s390x/s390-pci-bus.h"

 
 int ioinst_disassemble_sch_ident(uint32_t value, int *m, int *cssid, int *ssid,
                                  int *schid)
 
 int ioinst_disassemble_sch_ident(uint32_t value, int *m, int *cssid, int *ssid,
                                  int *schid)


@@ -36,7 +37,7 @@ int ioinst_disassemble_sch_ident(uint32_t value, int *m, int *cssid, int *ssid,
     return 0;
 }
 
     return 0;
 }
 

-int ioinst_handle_xsch(CPUS390XState *env, uint64_t reg1)
+void ioinst_handle_xsch(S390CPU *cpu, uint64_t reg1)

 {
     int cssid, ssid, schid, m;
     SubchDev *sch;
 {
     int cssid, ssid, schid, m;
     SubchDev *sch;


@@ -44,8 +45,8 @@ int ioinst_handle_xsch(CPUS390XState *env, uint64_t reg1)
     int cc;
 
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) {
     int cc;
 
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) {

-        program_interrupt(env, PGM_OPERAND, 2);
-        return -EIO;
+        program_interrupt(&cpu->env, PGM_OPERAND, 2);
+        return;

     }
     trace_ioinst_sch_id("xsch", cssid, ssid, schid);
     sch = css_find_subch(m, cssid, ssid, schid);
     }
     trace_ioinst_sch_id("xsch", cssid, ssid, schid);
     sch = css_find_subch(m, cssid, ssid, schid);


@@ -66,11 +67,10 @@ int ioinst_handle_xsch(CPUS390XState *env, uint64_t reg1)
         cc = 1;
         break;
     }
         cc = 1;
         break;
     }

-
-    return cc;
+    setcc(cpu, cc);

 }
 
 }
 

-int ioinst_handle_csch(CPUS390XState *env, uint64_t reg1)
+void ioinst_handle_csch(S390CPU *cpu, uint64_t reg1)

 {
     int cssid, ssid, schid, m;
     SubchDev *sch;
 {
     int cssid, ssid, schid, m;
     SubchDev *sch;


@@ -78,8 +78,8 @@ int ioinst_handle_csch(CPUS390XState *env, uint64_t reg1)
     int cc;
 
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) {
     int cc;
 
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) {

-        program_interrupt(env, PGM_OPERAND, 2);
-        return -EIO;
+        program_interrupt(&cpu->env, PGM_OPERAND, 2);
+        return;

     }
     trace_ioinst_sch_id("csch", cssid, ssid, schid);
     sch = css_find_subch(m, cssid, ssid, schid);
     }
     trace_ioinst_sch_id("csch", cssid, ssid, schid);
     sch = css_find_subch(m, cssid, ssid, schid);


@@ -91,10 +91,10 @@ int ioinst_handle_csch(CPUS390XState *env, uint64_t reg1)
     } else {
         cc = 0;
     }
     } else {
         cc = 0;
     }

-    return cc;
+    setcc(cpu, cc);

 }
 
 }
 

-int ioinst_handle_hsch(CPUS390XState *env, uint64_t reg1)
+void ioinst_handle_hsch(S390CPU *cpu, uint64_t reg1)

 {
     int cssid, ssid, schid, m;
     SubchDev *sch;
 {
     int cssid, ssid, schid, m;
     SubchDev *sch;


@@ -102,8 +102,8 @@ int ioinst_handle_hsch(CPUS390XState *env, uint64_t reg1)
     int cc;
 
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) {
     int cc;
 
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) {

-        program_interrupt(env, PGM_OPERAND, 2);
-        return -EIO;
+        program_interrupt(&cpu->env, PGM_OPERAND, 2);
+        return;

     }
     trace_ioinst_sch_id("hsch", cssid, ssid, schid);
     sch = css_find_subch(m, cssid, ssid, schid);
     }
     trace_ioinst_sch_id("hsch", cssid, ssid, schid);
     sch = css_find_subch(m, cssid, ssid, schid);


@@ -124,8 +124,7 @@ int ioinst_handle_hsch(CPUS390XState *env, uint64_t reg1)
         cc = 1;
         break;
     }
         cc = 1;
         break;
     }

-
-    return cc;
+    setcc(cpu, cc);

 }
 
 static int ioinst_schib_valid(SCHIB *schib)
 }
 
 static int ioinst_schib_valid(SCHIB *schib)


@@ -141,7 +140,7 @@ static int ioinst_schib_valid(SCHIB *schib)
     return 1;
 }
 
     return 1;
 }
 

-int ioinst_handle_msch(CPUS390XState *env, uint64_t reg1, uint32_t ipb)
+void ioinst_handle_msch(S390CPU *cpu, uint64_t reg1, uint32_t ipb)

 {
     int cssid, ssid, schid, m;
     SubchDev *sch;
 {
     int cssid, ssid, schid, m;
     SubchDev *sch;


@@ -150,22 +149,21 @@ int ioinst_handle_msch(CPUS390XState *env, uint64_t reg1, uint32_t ipb)
     int ret = -ENODEV;
     int cc;
     hwaddr len = sizeof(*schib);
     int ret = -ENODEV;
     int cc;
     hwaddr len = sizeof(*schib);

+    CPUS390XState *env = &cpu->env;

 
     addr = decode_basedisp_s(env, ipb);
     if (addr & 3) {
         program_interrupt(env, PGM_SPECIFICATION, 2);
 
     addr = decode_basedisp_s(env, ipb);
     if (addr & 3) {
         program_interrupt(env, PGM_SPECIFICATION, 2);

-        return -EIO;
+        return;

     }
     schib = s390_cpu_physical_memory_map(env, addr, &len, 0);
     if (!schib || len != sizeof(*schib)) {
         program_interrupt(env, PGM_ADDRESSING, 2);
     }
     schib = s390_cpu_physical_memory_map(env, addr, &len, 0);
     if (!schib || len != sizeof(*schib)) {
         program_interrupt(env, PGM_ADDRESSING, 2);

-        cc = -EIO;

         goto out;
     }
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid) ||
         !ioinst_schib_valid(schib)) {
         program_interrupt(env, PGM_OPERAND, 2);
         goto out;
     }
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid) ||
         !ioinst_schib_valid(schib)) {
         program_interrupt(env, PGM_OPERAND, 2);

-        cc = -EIO;

         goto out;
     }
     trace_ioinst_sch_id("msch", cssid, ssid, schid);
         goto out;
     }
     trace_ioinst_sch_id("msch", cssid, ssid, schid);


@@ -187,9 +185,10 @@ int ioinst_handle_msch(CPUS390XState *env, uint64_t reg1, uint32_t ipb)
         cc = 1;
         break;
     }
         cc = 1;
         break;
     }

+    setcc(cpu, cc);
+

 out:
     s390_cpu_physical_memory_unmap(env, schib, len, 0);
 out:
     s390_cpu_physical_memory_unmap(env, schib, len, 0);

-    return cc;

 }
 
 static void copy_orb_from_guest(ORB *dest, const ORB *src)
 }
 
 static void copy_orb_from_guest(ORB *dest, const ORB *src)


@@ -213,7 +212,7 @@ static int ioinst_orb_valid(ORB *orb)
     return 1;
 }
 
     return 1;
 }
 

-int ioinst_handle_ssch(CPUS390XState *env, uint64_t reg1, uint32_t ipb)
+void ioinst_handle_ssch(S390CPU *cpu, uint64_t reg1, uint32_t ipb)

 {
     int cssid, ssid, schid, m;
     SubchDev *sch;
 {
     int cssid, ssid, schid, m;
     SubchDev *sch;


@@ -222,23 +221,22 @@ int ioinst_handle_ssch(CPUS390XState *env, uint64_t reg1, uint32_t ipb)
     int ret = -ENODEV;
     int cc;
     hwaddr len = sizeof(*orig_orb);
     int ret = -ENODEV;
     int cc;
     hwaddr len = sizeof(*orig_orb);

+    CPUS390XState *env = &cpu->env;

 
     addr = decode_basedisp_s(env, ipb);
     if (addr & 3) {
         program_interrupt(env, PGM_SPECIFICATION, 2);
 
     addr = decode_basedisp_s(env, ipb);
     if (addr & 3) {
         program_interrupt(env, PGM_SPECIFICATION, 2);

-        return -EIO;
+        return;

     }
     orig_orb = s390_cpu_physical_memory_map(env, addr, &len, 0);
     if (!orig_orb || len != sizeof(*orig_orb)) {
         program_interrupt(env, PGM_ADDRESSING, 2);
     }
     orig_orb = s390_cpu_physical_memory_map(env, addr, &len, 0);
     if (!orig_orb || len != sizeof(*orig_orb)) {
         program_interrupt(env, PGM_ADDRESSING, 2);

-        cc = -EIO;

         goto out;
     }
     copy_orb_from_guest(&orb, orig_orb);
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid) ||
         !ioinst_orb_valid(&orb)) {
         program_interrupt(env, PGM_OPERAND, 2);
         goto out;
     }
     copy_orb_from_guest(&orb, orig_orb);
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid) ||
         !ioinst_orb_valid(&orb)) {
         program_interrupt(env, PGM_OPERAND, 2);

-        cc = -EIO;

         goto out;
     }
     trace_ioinst_sch_id("ssch", cssid, ssid, schid);
         goto out;
     }
     trace_ioinst_sch_id("ssch", cssid, ssid, schid);


@@ -260,38 +258,39 @@ int ioinst_handle_ssch(CPUS390XState *env, uint64_t reg1, uint32_t ipb)
         cc = 1;
         break;
     }
         cc = 1;
         break;
     }

+    setcc(cpu, cc);

 
 out:
     s390_cpu_physical_memory_unmap(env, orig_orb, len, 0);
 
 out:
     s390_cpu_physical_memory_unmap(env, orig_orb, len, 0);

-    return cc;

 }
 
 }
 

-int ioinst_handle_stcrw(CPUS390XState *env, uint32_t ipb)
+void ioinst_handle_stcrw(S390CPU *cpu, uint32_t ipb)

 {
     CRW *crw;
     uint64_t addr;
     int cc;
     hwaddr len = sizeof(*crw);
 {
     CRW *crw;
     uint64_t addr;
     int cc;
     hwaddr len = sizeof(*crw);

+    CPUS390XState *env = &cpu->env;

 
     addr = decode_basedisp_s(env, ipb);
     if (addr & 3) {
         program_interrupt(env, PGM_SPECIFICATION, 2);
 
     addr = decode_basedisp_s(env, ipb);
     if (addr & 3) {
         program_interrupt(env, PGM_SPECIFICATION, 2);

-        return -EIO;
+        return;

     }
     crw = s390_cpu_physical_memory_map(env, addr, &len, 1);
     if (!crw || len != sizeof(*crw)) {
         program_interrupt(env, PGM_ADDRESSING, 2);
     }
     crw = s390_cpu_physical_memory_map(env, addr, &len, 1);
     if (!crw || len != sizeof(*crw)) {
         program_interrupt(env, PGM_ADDRESSING, 2);

-        cc = -EIO;

         goto out;
     }
     cc = css_do_stcrw(crw);
     /* 0 - crw stored, 1 - zeroes stored */
         goto out;
     }
     cc = css_do_stcrw(crw);
     /* 0 - crw stored, 1 - zeroes stored */

+    setcc(cpu, cc);
+

 out:
     s390_cpu_physical_memory_unmap(env, crw, len, 1);
 out:
     s390_cpu_physical_memory_unmap(env, crw, len, 1);

-    return cc;

 }
 
 }
 

-int ioinst_handle_stsch(CPUS390XState *env, uint64_t reg1, uint32_t ipb)
+void ioinst_handle_stsch(S390CPU *cpu, uint64_t reg1, uint32_t ipb)

 {
     int cssid, ssid, schid, m;
     SubchDev *sch;
 {
     int cssid, ssid, schid, m;
     SubchDev *sch;


@@ -299,22 +298,21 @@ int ioinst_handle_stsch(CPUS390XState *env, uint64_t reg1, uint32_t ipb)
     int cc;
     SCHIB *schib;
     hwaddr len = sizeof(*schib);
     int cc;
     SCHIB *schib;
     hwaddr len = sizeof(*schib);

+    CPUS390XState *env = &cpu->env;

 
     addr = decode_basedisp_s(env, ipb);
     if (addr & 3) {
         program_interrupt(env, PGM_SPECIFICATION, 2);
 
     addr = decode_basedisp_s(env, ipb);
     if (addr & 3) {
         program_interrupt(env, PGM_SPECIFICATION, 2);

-        return -EIO;
+        return;

     }
     schib = s390_cpu_physical_memory_map(env, addr, &len, 1);
     if (!schib || len != sizeof(*schib)) {
         program_interrupt(env, PGM_ADDRESSING, 2);
     }
     schib = s390_cpu_physical_memory_map(env, addr, &len, 1);
     if (!schib || len != sizeof(*schib)) {
         program_interrupt(env, PGM_ADDRESSING, 2);

-        cc = -EIO;

         goto out;
     }
 
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) {
         program_interrupt(env, PGM_OPERAND, 2);
         goto out;
     }
 
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) {
         program_interrupt(env, PGM_OPERAND, 2);

-        cc = -EIO;

         goto out;
     }
     trace_ioinst_sch_id("stsch", cssid, ssid, schid);
         goto out;
     }
     trace_ioinst_sch_id("stsch", cssid, ssid, schid);


@@ -336,9 +334,10 @@ int ioinst_handle_stsch(CPUS390XState *env, uint64_t reg1, uint32_t ipb)
             cc = 0;
         }
     }
             cc = 0;
         }
     }

+    setcc(cpu, cc);
+

 out:
     s390_cpu_physical_memory_unmap(env, schib, len, 1);
 out:
     s390_cpu_physical_memory_unmap(env, schib, len, 1);

-    return cc;

 }
 
 int ioinst_handle_tsch(CPUS390XState *env, uint64_t reg1, uint32_t ipb)
 }
 
 int ioinst_handle_tsch(CPUS390XState *env, uint64_t reg1, uint32_t ipb)


@@ -400,6 +399,7 @@ typedef struct ChscResp {
 #define CHSC_SCPD 0x0002
 #define CHSC_SCSC 0x0010
 #define CHSC_SDA  0x0031
 #define CHSC_SCPD 0x0002
 #define CHSC_SCSC 0x0010
 #define CHSC_SDA  0x0031

+#define CHSC_SEI  0x000e

 
 #define CHSC_SCPD_0_M 0x20000000
 #define CHSC_SCPD_0_C 0x10000000
 
 #define CHSC_SCPD_0_M 0x20000000
 #define CHSC_SCPD_0_C 0x10000000


@@ -568,6 +568,53 @@ out:
     res->param = 0;
 }
 
     res->param = 0;
 }
 

+static int chsc_sei_nt0_get_event(void *res)
+{
+    /* no events yet */
+    return 1;
+}
+
+static int chsc_sei_nt0_have_event(void)
+{
+    /* no events yet */
+    return 0;
+}
+
+#define CHSC_SEI_NT0    (1ULL << 63)
+#define CHSC_SEI_NT2    (1ULL << 61)
+static void ioinst_handle_chsc_sei(ChscReq *req, ChscResp *res)
+{
+    uint64_t selection_mask = ldq_p(&req->param1);
+    uint8_t *res_flags = (uint8_t *)res->data;
+    int have_event = 0;
+    int have_more = 0;
+
+    /* regarding architecture nt0 can not be masked */
+    have_event = !chsc_sei_nt0_get_event(res);
+    have_more = chsc_sei_nt0_have_event();
+
+    if (selection_mask & CHSC_SEI_NT2) {
+        if (!have_event) {
+            have_event = !chsc_sei_nt2_get_event(res);
+        }
+
+        if (!have_more) {
+            have_more = chsc_sei_nt2_have_event();
+        }
+    }
+
+    if (have_event) {
+        res->code = cpu_to_be16(0x0001);
+        if (have_more) {
+            (*res_flags) |= 0x80;
+        } else {
+            (*res_flags) &= ~0x80;
+        }
+    } else {
+        res->code = cpu_to_be16(0x0004);
+    }
+}
+

 static void ioinst_handle_chsc_unimplemented(ChscResp *res)
 {
     res->len = cpu_to_be16(CHSC_MIN_RESP_LEN);
 static void ioinst_handle_chsc_unimplemented(ChscResp *res)
 {
     res->len = cpu_to_be16(CHSC_MIN_RESP_LEN);


@@ -575,7 +622,7 @@ static void ioinst_handle_chsc_unimplemented(ChscResp *res)
     res->param = 0;
 }
 
     res->param = 0;
 }
 

-int ioinst_handle_chsc(CPUS390XState *env, uint32_t ipb)
+void ioinst_handle_chsc(S390CPU *cpu, uint32_t ipb)

 {
     ChscReq *req;
     ChscResp *res;
 {
     ChscReq *req;
     ChscResp *res;


@@ -584,7 +631,7 @@ int ioinst_handle_chsc(CPUS390XState *env, uint32_t ipb)
     uint16_t len;
     uint16_t command;
     hwaddr map_size = TARGET_PAGE_SIZE;
     uint16_t len;
     uint16_t command;
     hwaddr map_size = TARGET_PAGE_SIZE;

-    int ret = 0;
+    CPUS390XState *env = &cpu->env;

 
     trace_ioinst("chsc");
     reg = (ipb >> 20) & 0x00f;
 
     trace_ioinst("chsc");
     reg = (ipb >> 20) & 0x00f;


@@ -592,19 +639,17 @@ int ioinst_handle_chsc(CPUS390XState *env, uint32_t ipb)
     /* Page boundary? */
     if (addr & 0xfff) {
         program_interrupt(env, PGM_SPECIFICATION, 2);
     /* Page boundary? */
     if (addr & 0xfff) {
         program_interrupt(env, PGM_SPECIFICATION, 2);

-        return -EIO;
+        return;

     }
     req = s390_cpu_physical_memory_map(env, addr, &map_size, 1);
     if (!req || map_size != TARGET_PAGE_SIZE) {
         program_interrupt(env, PGM_ADDRESSING, 2);
     }
     req = s390_cpu_physical_memory_map(env, addr, &map_size, 1);
     if (!req || map_size != TARGET_PAGE_SIZE) {
         program_interrupt(env, PGM_ADDRESSING, 2);

-        ret = -EIO;

         goto out;
     }
     len = be16_to_cpu(req->len);
     /* Length field valid? */
     if ((len < 16) || (len > 4088) || (len & 7)) {
         program_interrupt(env, PGM_OPERAND, 2);
         goto out;
     }
     len = be16_to_cpu(req->len);
     /* Length field valid? */
     if ((len < 16) || (len > 4088) || (len & 7)) {
         program_interrupt(env, PGM_OPERAND, 2);

-        ret = -EIO;

         goto out;
     }
     memset((char *)req + len, 0, TARGET_PAGE_SIZE - len);
         goto out;
     }
     memset((char *)req + len, 0, TARGET_PAGE_SIZE - len);


@@ -621,14 +666,17 @@ int ioinst_handle_chsc(CPUS390XState *env, uint32_t ipb)
     case CHSC_SDA:
         ioinst_handle_chsc_sda(req, res);
         break;
     case CHSC_SDA:
         ioinst_handle_chsc_sda(req, res);
         break;

+    case CHSC_SEI:
+        ioinst_handle_chsc_sei(req, res);
+        break;

     default:
         ioinst_handle_chsc_unimplemented(res);
         break;
     }
 
     default:
         ioinst_handle_chsc_unimplemented(res);
         break;
     }
 

+    setcc(cpu, 0);    /* Command execution complete */

 out:
     s390_cpu_physical_memory_unmap(env, req, map_size, 1);
 out:
     s390_cpu_physical_memory_unmap(env, req, map_size, 1);

-    return ret;

 }
 
 int ioinst_handle_tpi(CPUS390XState *env, uint32_t ipb)
 }
 
 int ioinst_handle_tpi(CPUS390XState *env, uint32_t ipb)


@@ -666,18 +714,19 @@ out:
 #define SCHM_REG1_UPD(_reg) ((_reg & 0x0000000000000002) >> 1)
 #define SCHM_REG1_DCT(_reg) (_reg & 0x0000000000000001)
 
 #define SCHM_REG1_UPD(_reg) ((_reg & 0x0000000000000002) >> 1)
 #define SCHM_REG1_DCT(_reg) (_reg & 0x0000000000000001)
 

-int ioinst_handle_schm(CPUS390XState *env, uint64_t reg1, uint64_t reg2,
-                       uint32_t ipb)
+void ioinst_handle_schm(S390CPU *cpu, uint64_t reg1, uint64_t reg2,
+                        uint32_t ipb)

 {
     uint8_t mbk;
     int update;
     int dct;
 {
     uint8_t mbk;
     int update;
     int dct;

+    CPUS390XState *env = &cpu->env;

 
     trace_ioinst("schm");
 
     if (SCHM_REG1_RES(reg1)) {
         program_interrupt(env, PGM_OPERAND, 2);
 
     trace_ioinst("schm");
 
     if (SCHM_REG1_RES(reg1)) {
         program_interrupt(env, PGM_OPERAND, 2);

-        return -EIO;
+        return;

     }
 
     mbk = SCHM_REG1_MBK(reg1);
     }
 
     mbk = SCHM_REG1_MBK(reg1);


@@ -686,15 +735,13 @@ int ioinst_handle_schm(CPUS390XState *env, uint64_t reg1, uint64_t reg2,
 
     if (update && (reg2 & 0x000000000000001f)) {
         program_interrupt(env, PGM_OPERAND, 2);
 
     if (update && (reg2 & 0x000000000000001f)) {
         program_interrupt(env, PGM_OPERAND, 2);

-        return -EIO;
+        return;

     }
 
     css_do_schm(mbk, update, dct, update ? reg2 : 0);
     }
 
     css_do_schm(mbk, update, dct, update ? reg2 : 0);

-
-    return 0;

 }
 
 }
 

-int ioinst_handle_rsch(CPUS390XState *env, uint64_t reg1)
+void ioinst_handle_rsch(S390CPU *cpu, uint64_t reg1)

 {
     int cssid, ssid, schid, m;
     SubchDev *sch;
 {
     int cssid, ssid, schid, m;
     SubchDev *sch;


@@ -702,8 +749,8 @@ int ioinst_handle_rsch(CPUS390XState *env, uint64_t reg1)
     int cc;
 
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) {
     int cc;
 
     if (ioinst_disassemble_sch_ident(reg1, &m, &cssid, &ssid, &schid)) {

-        program_interrupt(env, PGM_OPERAND, 2);
-        return -EIO;
+        program_interrupt(&cpu->env, PGM_OPERAND, 2);
+        return;

     }
     trace_ioinst_sch_id("rsch", cssid, ssid, schid);
     sch = css_find_subch(m, cssid, ssid, schid);
     }
     trace_ioinst_sch_id("rsch", cssid, ssid, schid);
     sch = css_find_subch(m, cssid, ssid, schid);


@@ -724,24 +771,23 @@ int ioinst_handle_rsch(CPUS390XState *env, uint64_t reg1)
         cc = 1;
         break;
     }
         cc = 1;
         break;
     }

-
-    return cc;
-
+    setcc(cpu, cc);

 }
 
 #define RCHP_REG1_RES(_reg) (_reg & 0x00000000ff00ff00)
 #define RCHP_REG1_CSSID(_reg) ((_reg & 0x0000000000ff0000) >> 16)
 #define RCHP_REG1_CHPID(_reg) (_reg & 0x00000000000000ff)
 }
 
 #define RCHP_REG1_RES(_reg) (_reg & 0x00000000ff00ff00)
 #define RCHP_REG1_CSSID(_reg) ((_reg & 0x0000000000ff0000) >> 16)
 #define RCHP_REG1_CHPID(_reg) (_reg & 0x00000000000000ff)

-int ioinst_handle_rchp(CPUS390XState *env, uint64_t reg1)
+void ioinst_handle_rchp(S390CPU *cpu, uint64_t reg1)

 {
     int cc;
     uint8_t cssid;
     uint8_t chpid;
     int ret;
 {
     int cc;
     uint8_t cssid;
     uint8_t chpid;
     int ret;

+    CPUS390XState *env = &cpu->env;

 
     if (RCHP_REG1_RES(reg1)) {
         program_interrupt(env, PGM_OPERAND, 2);
 
     if (RCHP_REG1_RES(reg1)) {
         program_interrupt(env, PGM_OPERAND, 2);

-        return -EIO;
+        return;

     }
 
     cssid = RCHP_REG1_CSSID(reg1);
     }
 
     cssid = RCHP_REG1_CSSID(reg1);


@@ -764,19 +810,16 @@ int ioinst_handle_rchp(CPUS390XState *env, uint64_t reg1)
     default:
         /* Invalid channel subsystem. */
         program_interrupt(env, PGM_OPERAND, 2);
     default:
         /* Invalid channel subsystem. */
         program_interrupt(env, PGM_OPERAND, 2);

-        return -EIO;
+        return;

     }
     }

-
-    return cc;
+    setcc(cpu, cc);

 }
 
 #define SAL_REG1_INVALID(_reg) (_reg & 0x0000000080000000)
 }
 
 #define SAL_REG1_INVALID(_reg) (_reg & 0x0000000080000000)

-int ioinst_handle_sal(CPUS390XState *env, uint64_t reg1)
+void ioinst_handle_sal(S390CPU *cpu, uint64_t reg1)

 {
     /* We do not provide address limit checking, so let's suppress it. */
     if (SAL_REG1_INVALID(reg1) || reg1 & 0x000000000000ffff) {
 {
     /* We do not provide address limit checking, so let's suppress it. */
     if (SAL_REG1_INVALID(reg1) || reg1 & 0x000000000000ffff) {

-        program_interrupt(env, PGM_OPERAND, 2);
-        return -EIO;
+        program_interrupt(&cpu->env, PGM_OPERAND, 2);

     }
     }

-    return 0;

 }
 }