1 /* 2 * SCLP early driver 3 * 4 * Copyright IBM Corp. 2013 5 */ 6 7 #define KMSG_COMPONENT "sclp_early" 8 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 9 10 #include <asm/ctl_reg.h> 11 #include <asm/sclp.h> 12 #include <asm/ipl.h> 13 #include "sclp_sdias.h" 14 #include "sclp.h" 15 16 #define SCLP_CMDW_READ_SCP_INFO 0x00020001 17 #define SCLP_CMDW_READ_SCP_INFO_FORCED 0x00120001 18 19 struct read_info_sccb { 20 struct sccb_header header; /* 0-7 */ 21 u16 rnmax; /* 8-9 */ 22 u8 rnsize; /* 10 */ 23 u8 _reserved0[24 - 11]; /* 11-15 */ 24 u8 loadparm[8]; /* 24-31 */ 25 u8 _reserved1[48 - 32]; /* 32-47 */ 26 u64 facilities; /* 48-55 */ 27 u8 _reserved2[84 - 56]; /* 56-83 */ 28 u8 fac84; /* 84 */ 29 u8 fac85; /* 85 */ 30 u8 _reserved3[91 - 86]; /* 86-90 */ 31 u8 flags; /* 91 */ 32 u8 _reserved4[100 - 92]; /* 92-99 */ 33 u32 rnsize2; /* 100-103 */ 34 u64 rnmax2; /* 104-111 */ 35 u8 _reserved5[4096 - 112]; /* 112-4095 */ 36 } __packed __aligned(PAGE_SIZE); 37 38 static char sccb_early[PAGE_SIZE] __aligned(PAGE_SIZE) __initdata; 39 static unsigned int sclp_con_has_vt220 __initdata; 40 static unsigned int sclp_con_has_linemode __initdata; 41 static unsigned long sclp_hsa_size; 42 static struct sclp_ipl_info sclp_ipl_info; 43 44 u64 sclp_facilities; 45 u8 sclp_fac84; 46 unsigned long long sclp_rzm; 47 unsigned long long sclp_rnmax; 48 49 static int __init sclp_cmd_sync_early(sclp_cmdw_t cmd, void *sccb) 50 { 51 int rc; 52 53 __ctl_set_bit(0, 9); 54 rc = sclp_service_call(cmd, sccb); 55 if (rc) 56 goto out; 57 __load_psw_mask(PSW_DEFAULT_KEY | PSW_MASK_BASE | PSW_MASK_EA | 58 PSW_MASK_BA | PSW_MASK_EXT | PSW_MASK_WAIT); 59 local_irq_disable(); 60 out: 61 /* Contents of the sccb might have changed. */ 62 barrier(); 63 __ctl_clear_bit(0, 9); 64 return rc; 65 } 66 67 static int __init sclp_read_info_early(struct read_info_sccb *sccb) 68 { 69 int rc, i; 70 sclp_cmdw_t commands[] = {SCLP_CMDW_READ_SCP_INFO_FORCED, 71 SCLP_CMDW_READ_SCP_INFO}; 72 73 for (i = 0; i < ARRAY_SIZE(commands); i++) { 74 do { 75 memset(sccb, 0, sizeof(*sccb)); 76 sccb->header.length = sizeof(*sccb); 77 sccb->header.function_code = 0x80; 78 sccb->header.control_mask[2] = 0x80; 79 rc = sclp_cmd_sync_early(commands[i], sccb); 80 } while (rc == -EBUSY); 81 82 if (rc) 83 break; 84 if (sccb->header.response_code == 0x10) 85 return 0; 86 if (sccb->header.response_code != 0x1f0) 87 break; 88 } 89 return -EIO; 90 } 91 92 static void __init sclp_facilities_detect(struct read_info_sccb *sccb) 93 { 94 if (sclp_read_info_early(sccb)) 95 return; 96 97 sclp_facilities = sccb->facilities; 98 sclp_fac84 = sccb->fac84; 99 if (sccb->fac85 & 0x02) 100 S390_lowcore.machine_flags |= MACHINE_FLAG_ESOP; 101 sclp_rnmax = sccb->rnmax ? sccb->rnmax : sccb->rnmax2; 102 sclp_rzm = sccb->rnsize ? sccb->rnsize : sccb->rnsize2; 103 sclp_rzm <<= 20; 104 105 /* Save IPL information */ 106 sclp_ipl_info.is_valid = 1; 107 if (sccb->flags & 0x2) 108 sclp_ipl_info.has_dump = 1; 109 memcpy(&sclp_ipl_info.loadparm, &sccb->loadparm, LOADPARM_LEN); 110 } 111 112 bool __init sclp_has_linemode(void) 113 { 114 return !!sclp_con_has_linemode; 115 } 116 117 bool __init sclp_has_vt220(void) 118 { 119 return !!sclp_con_has_vt220; 120 } 121 122 unsigned long long sclp_get_rnmax(void) 123 { 124 return sclp_rnmax; 125 } 126 127 unsigned long long sclp_get_rzm(void) 128 { 129 return sclp_rzm; 130 } 131 132 /* 133 * This function will be called after sclp_facilities_detect(), which gets 134 * called from early.c code. The sclp_facilities_detect() function retrieves 135 * and saves the IPL information. 136 */ 137 void __init sclp_get_ipl_info(struct sclp_ipl_info *info) 138 { 139 *info = sclp_ipl_info; 140 } 141 142 static int __init sclp_cmd_early(sclp_cmdw_t cmd, void *sccb) 143 { 144 int rc; 145 146 do { 147 rc = sclp_cmd_sync_early(cmd, sccb); 148 } while (rc == -EBUSY); 149 150 if (rc) 151 return -EIO; 152 if (((struct sccb_header *) sccb)->response_code != 0x0020) 153 return -EIO; 154 return 0; 155 } 156 157 static void __init sccb_init_eq_size(struct sdias_sccb *sccb) 158 { 159 memset(sccb, 0, sizeof(*sccb)); 160 161 sccb->hdr.length = sizeof(*sccb); 162 sccb->evbuf.hdr.length = sizeof(struct sdias_evbuf); 163 sccb->evbuf.hdr.type = EVTYP_SDIAS; 164 sccb->evbuf.event_qual = SDIAS_EQ_SIZE; 165 sccb->evbuf.data_id = SDIAS_DI_FCP_DUMP; 166 sccb->evbuf.event_id = 4712; 167 sccb->evbuf.dbs = 1; 168 } 169 170 static int __init sclp_set_event_mask(struct init_sccb *sccb, 171 unsigned long receive_mask, 172 unsigned long send_mask) 173 { 174 memset(sccb, 0, sizeof(*sccb)); 175 sccb->header.length = sizeof(*sccb); 176 sccb->mask_length = sizeof(sccb_mask_t); 177 sccb->receive_mask = receive_mask; 178 sccb->send_mask = send_mask; 179 return sclp_cmd_early(SCLP_CMDW_WRITE_EVENT_MASK, sccb); 180 } 181 182 static long __init sclp_hsa_size_init(struct sdias_sccb *sccb) 183 { 184 sccb_init_eq_size(sccb); 185 if (sclp_cmd_early(SCLP_CMDW_WRITE_EVENT_DATA, sccb)) 186 return -EIO; 187 if (sccb->evbuf.blk_cnt != 0) 188 return (sccb->evbuf.blk_cnt - 1) * PAGE_SIZE; 189 return 0; 190 } 191 192 static long __init sclp_hsa_copy_wait(struct sccb_header *sccb) 193 { 194 memset(sccb, 0, PAGE_SIZE); 195 sccb->length = PAGE_SIZE; 196 if (sclp_cmd_early(SCLP_CMDW_READ_EVENT_DATA, sccb)) 197 return -EIO; 198 return (((struct sdias_sccb *) sccb)->evbuf.blk_cnt - 1) * PAGE_SIZE; 199 } 200 201 unsigned long sclp_get_hsa_size(void) 202 { 203 return sclp_hsa_size; 204 } 205 206 static void __init sclp_hsa_size_detect(void *sccb) 207 { 208 long size; 209 210 /* First try synchronous interface (LPAR) */ 211 if (sclp_set_event_mask(sccb, 0, 0x40000010)) 212 return; 213 size = sclp_hsa_size_init(sccb); 214 if (size < 0) 215 return; 216 if (size != 0) 217 goto out; 218 /* Then try asynchronous interface (z/VM) */ 219 if (sclp_set_event_mask(sccb, 0x00000010, 0x40000010)) 220 return; 221 size = sclp_hsa_size_init(sccb); 222 if (size < 0) 223 return; 224 size = sclp_hsa_copy_wait(sccb); 225 if (size < 0) 226 return; 227 out: 228 sclp_hsa_size = size; 229 } 230 231 static unsigned int __init sclp_con_check_linemode(struct init_sccb *sccb) 232 { 233 if (!(sccb->sclp_send_mask & (EVTYP_OPCMD_MASK | EVTYP_PMSGCMD_MASK))) 234 return 0; 235 if (!(sccb->sclp_receive_mask & (EVTYP_MSG_MASK | EVTYP_PMSGCMD_MASK))) 236 return 0; 237 return 1; 238 } 239 240 static void __init sclp_console_detect(struct init_sccb *sccb) 241 { 242 if (sccb->header.response_code != 0x20) 243 return; 244 245 if (sccb->sclp_send_mask & EVTYP_VT220MSG_MASK) 246 sclp_con_has_vt220 = 1; 247 248 if (sclp_con_check_linemode(sccb)) 249 sclp_con_has_linemode = 1; 250 } 251 252 void __init sclp_early_detect(void) 253 { 254 void *sccb = &sccb_early; 255 256 sclp_facilities_detect(sccb); 257 sclp_hsa_size_detect(sccb); 258 259 /* Turn off SCLP event notifications. Also save remote masks in the 260 * sccb. These are sufficient to detect sclp console capabilities. 261 */ 262 sclp_set_event_mask(sccb, 0, 0); 263 sclp_console_detect(sccb); 264 } 265