include/hw/s390x/sclp.h

   1 /*
   2  * SCLP Support
   3  *
   4  * Copyright IBM, Corp. 2012
   5  *
   6  * Authors:
   7  *  Christian Borntraeger <borntraeger@de.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or (at your
  10  * option) any later version.  See the COPYING file in the top-level directory.
  11  *
  12  */
  13
  14 #ifndef HW_S390_SCLP_H
  15 #define HW_S390_SCLP_H
  16
  17 #include <hw/sysbus.h>
  18 #include <hw/qdev.h>
  19
  20 #define SCLP_CMD_CODE_MASK                      0xffff00ff
  21
  22 /* SCLP command codes */
  23 #define SCLP_CMDW_READ_SCP_INFO                 0x00020001
  24 #define SCLP_CMDW_READ_SCP_INFO_FORCED          0x00120001
  25 #define SCLP_READ_STORAGE_ELEMENT_INFO          0x00040001
  26 #define SCLP_ATTACH_STORAGE_ELEMENT             0x00080001
  27 #define SCLP_ASSIGN_STORAGE                     0x000D0001
  28 #define SCLP_UNASSIGN_STORAGE                   0x000C0001
  29 #define SCLP_CMD_READ_EVENT_DATA                0x00770005
  30 #define SCLP_CMD_WRITE_EVENT_DATA               0x00760005
  31 #define SCLP_CMD_READ_EVENT_DATA                0x00770005
  32 #define SCLP_CMD_WRITE_EVENT_DATA               0x00760005
  33 #define SCLP_CMD_WRITE_EVENT_MASK               0x00780005
  34
  35 /* SCLP Memory hotplug codes */
  36 #define SCLP_FC_ASSIGN_ATTACH_READ_STOR         0xE00000000000ULL
  37 #define SCLP_STARTING_SUBINCREMENT_ID           0x10001
  38 #define SCLP_INCREMENT_UNIT                     0x10000
  39 #define MAX_AVAIL_SLOTS                         32
  40
  41 /* CPU hotplug SCLP codes */
  42 #define SCLP_HAS_CPU_INFO                       0x0C00000000000000ULL
  43 #define SCLP_CMDW_READ_CPU_INFO                 0x00010001
  44 #define SCLP_CMDW_CONFIGURE_CPU                 0x00110001
  45 #define SCLP_CMDW_DECONFIGURE_CPU               0x00100001
  46
  47 /* SCLP response codes */
  48 #define SCLP_RC_NORMAL_READ_COMPLETION          0x0010
  49 #define SCLP_RC_NORMAL_COMPLETION               0x0020
  50 #define SCLP_RC_SCCB_BOUNDARY_VIOLATION         0x0100
  51 #define SCLP_RC_INVALID_SCLP_COMMAND            0x01f0
  52 #define SCLP_RC_CONTAINED_EQUIPMENT_CHECK       0x0340
  53 #define SCLP_RC_INSUFFICIENT_SCCB_LENGTH        0x0300
  54 #define SCLP_RC_STANDBY_READ_COMPLETION         0x0410
  55 #define SCLP_RC_INVALID_FUNCTION                0x40f0
  56 #define SCLP_RC_NO_EVENT_BUFFERS_STORED         0x60f0
  57 #define SCLP_RC_INVALID_SELECTION_MASK          0x70f0
  58 #define SCLP_RC_INCONSISTENT_LENGTHS            0x72f0
  59 #define SCLP_RC_EVENT_BUFFER_SYNTAX_ERROR       0x73f0
  60 #define SCLP_RC_INVALID_MASK_LENGTH             0x74f0
  61
  62
  63 /* Service Call Control Block (SCCB) and its elements */
  64
  65 #define SCCB_SIZE 4096
  66
  67 #define SCLP_VARIABLE_LENGTH_RESPONSE           0x80
  68 #define SCLP_EVENT_BUFFER_ACCEPTED              0x80
  69
  70 #define SCLP_FC_NORMAL_WRITE                    0
  71
  72 /*
  73  * Normally packed structures are not the right thing to do, since all code
  74  * must take care of endianness. We cannot use ldl_phys and friends for two
  75  * reasons, though:
  76  * - some of the embedded structures below the SCCB can appear multiple times
  77  *   at different locations, so there is no fixed offset
  78  * - we work on a private copy of the SCCB, since there are several length
  79  *   fields, that would cause a security nightmare if we allow the guest to
  80  *   alter the structure while we parse it. We cannot use ldl_p and friends
  81  *   either without doing pointer arithmetics
  82  * So we have to double check that all users of sclp data structures use the
  83  * right endianness wrappers.
  84  */
  85 typedef struct SCCBHeader {
  86     uint16_t length;
  87     uint8_t function_code;
  88     uint8_t control_mask[3];
  89     uint16_t response_code;
  90 } QEMU_PACKED SCCBHeader;
  91
  92 #define SCCB_DATA_LEN (SCCB_SIZE - sizeof(SCCBHeader))
  93
  94 /* CPU information */
  95 typedef struct CPUEntry {
  96     uint8_t address;
  97     uint8_t reserved0[13];
  98     uint8_t type;
  99     uint8_t reserved1;
 100 } QEMU_PACKED CPUEntry;
 101
 102 typedef struct ReadInfo {
 103     SCCBHeader h;
 104     uint16_t rnmax;
 105     uint8_t rnsize;
 106     uint8_t  _reserved1[16 - 11];       /* 11-15 */
 107     uint16_t entries_cpu;               /* 16-17 */
 108     uint16_t offset_cpu;                /* 18-19 */
 109     uint8_t  _reserved2[24 - 20];       /* 20-23 */
 110     uint8_t  loadparm[8];               /* 24-31 */
 111     uint8_t  _reserved3[48 - 32];       /* 32-47 */
 112     uint64_t facilities;                /* 48-55 */
 113     uint8_t  _reserved0[100 - 56];
 114     uint32_t rnsize2;
 115     uint64_t rnmax2;
 116     uint8_t  _reserved4[120-112];       /* 112-119 */
 117     uint16_t highest_cpu;
 118     uint8_t  _reserved5[128 - 122];     /* 122-127 */
 119     struct CPUEntry entries[0];
 120 } QEMU_PACKED ReadInfo;
 121
 122 typedef struct ReadCpuInfo {
 123     SCCBHeader h;
 124     uint16_t nr_configured;         /* 8-9 */
 125     uint16_t offset_configured;     /* 10-11 */
 126     uint16_t nr_standby;            /* 12-13 */
 127     uint16_t offset_standby;        /* 14-15 */
 128     uint8_t reserved0[24-16];       /* 16-23 */
 129     struct CPUEntry entries[0];
 130 } QEMU_PACKED ReadCpuInfo;
 131
 132 typedef struct ReadStorageElementInfo {
 133     SCCBHeader h;
 134     uint16_t max_id;
 135     uint16_t assigned;
 136     uint16_t standby;
 137     uint8_t _reserved0[16 - 14]; /* 14-15 */
 138     uint32_t entries[0];
 139 } QEMU_PACKED ReadStorageElementInfo;
 140
 141 typedef struct AttachStorageElement {
 142     SCCBHeader h;
 143     uint8_t _reserved0[10 - 8];  /* 8-9 */
 144     uint16_t assigned;
 145     uint8_t _reserved1[16 - 12]; /* 12-15 */
 146     uint32_t entries[0];
 147 } QEMU_PACKED AttachStorageElement;
 148
 149 typedef struct AssignStorage {
 150     SCCBHeader h;
 151     uint16_t rn;
 152 } QEMU_PACKED AssignStorage;
 153
 154 typedef struct SCCB {
 155     SCCBHeader h;
 156     char data[SCCB_DATA_LEN];
 157  } QEMU_PACKED SCCB;
 158
 159 static inline int sccb_data_len(SCCB *sccb)
 160 {
 161     return be16_to_cpu(sccb->h.length) - sizeof(sccb->h);
 162 }
 163
 164
 165 void s390_sclp_init(void);
 166 void sclp_service_interrupt(uint32_t sccb);
 167 void raise_irq_cpu_hotplug(void);
 168
 169 #endif