1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corp. 2015 4 * Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com> 5 */ 6 7 #include <linux/kernel.h> 8 #include <asm/processor.h> 9 #include <asm/lowcore.h> 10 #include <asm/ctlreg.h> 11 #include <asm/ebcdic.h> 12 #include <asm/irq.h> 13 #include <asm/sections.h> 14 #include <asm/physmem_info.h> 15 #include <asm/facility.h> 16 #include "sclp.h" 17 #include "sclp_rw.h" 18 19 static struct read_info_sccb __bootdata(sclp_info_sccb); 20 static int __bootdata(sclp_info_sccb_valid); 21 char *__bootdata_preserved(sclp_early_sccb); 22 int sclp_init_state = sclp_init_state_uninitialized; 23 /* 24 * Used to keep track of the size of the event masks. Qemu until version 2.11 25 * only supports 4 and needs a workaround. 26 */ 27 bool sclp_mask_compat_mode; 28 sclp_early_wait_irq(void)29 void sclp_early_wait_irq(void) 30 { 31 unsigned long psw_mask, addr; 32 psw_t psw_ext_save, psw_wait; 33 union ctlreg0 cr0, cr0_new; 34 35 local_ctl_store(0, &cr0.reg); 36 cr0_new.val = cr0.val & ~CR0_IRQ_SUBCLASS_MASK; 37 cr0_new.lap = 0; 38 cr0_new.sssm = 1; 39 local_ctl_load(0, &cr0_new.reg); 40 41 psw_ext_save = get_lowcore()->external_new_psw; 42 psw_mask = __extract_psw(); 43 get_lowcore()->external_new_psw.mask = psw_mask; 44 psw_wait.mask = psw_mask | PSW_MASK_EXT | PSW_MASK_WAIT; 45 get_lowcore()->ext_int_code = 0; 46 47 do { 48 asm volatile( 49 " larl %[addr],0f\n" 50 " stg %[addr],%[psw_wait_addr]\n" 51 " stg %[addr],%[psw_ext_addr]\n" 52 " lpswe %[psw_wait]\n" 53 "0:\n" 54 : [addr] "=&d" (addr), 55 [psw_wait_addr] "=Q" (psw_wait.addr), 56 [psw_ext_addr] "=Q" (get_lowcore()->external_new_psw.addr) 57 : [psw_wait] "Q" (psw_wait) 58 : "cc", "memory"); 59 } while (get_lowcore()->ext_int_code != EXT_IRQ_SERVICE_SIG); 60 61 get_lowcore()->external_new_psw = psw_ext_save; 62 local_ctl_load(0, &cr0.reg); 63 } 64 sclp_early_cmd(sclp_cmdw_t cmd,void * sccb)65 int sclp_early_cmd(sclp_cmdw_t cmd, void *sccb) 66 { 67 unsigned long flags; 68 int rc; 69 70 flags = arch_local_irq_save(); 71 rc = sclp_service_call(cmd, sccb); 72 if (rc) 73 goto out; 74 sclp_early_wait_irq(); 75 out: 76 arch_local_irq_restore(flags); 77 return rc; 78 } 79 80 struct write_sccb { 81 struct sccb_header header; 82 struct msg_buf msg; 83 } __packed; 84 85 /* Output multi-line text using SCLP Message interface. */ sclp_early_print_lm(const char * str,unsigned int len)86 static void sclp_early_print_lm(const char *str, unsigned int len) 87 { 88 unsigned char *ptr, *end, ch; 89 unsigned int count, offset; 90 struct write_sccb *sccb; 91 struct msg_buf *msg; 92 struct mdb *mdb; 93 struct mto *mto; 94 struct go *go; 95 96 sccb = (struct write_sccb *) sclp_early_sccb; 97 end = (unsigned char *) sccb + EARLY_SCCB_SIZE - 1; 98 memset(sccb, 0, sizeof(*sccb)); 99 ptr = (unsigned char *) &sccb->msg.mdb.mto; 100 offset = 0; 101 do { 102 for (count = sizeof(*mto); offset < len; count++) { 103 ch = str[offset++]; 104 if ((ch == 0x0a) || (ptr + count > end)) 105 break; 106 ptr[count] = _ascebc[ch]; 107 } 108 mto = (struct mto *) ptr; 109 memset(mto, 0, sizeof(*mto)); 110 mto->length = count; 111 mto->type = 4; 112 mto->line_type_flags = LNTPFLGS_ENDTEXT; 113 ptr += count; 114 } while ((offset < len) && (ptr + sizeof(*mto) <= end)); 115 len = ptr - (unsigned char *) sccb; 116 sccb->header.length = len - offsetof(struct write_sccb, header); 117 msg = &sccb->msg; 118 msg->header.type = EVTYP_MSG; 119 msg->header.length = len - offsetof(struct write_sccb, msg.header); 120 mdb = &msg->mdb; 121 mdb->header.type = 1; 122 mdb->header.tag = 0xD4C4C240; 123 mdb->header.revision_code = 1; 124 mdb->header.length = len - offsetof(struct write_sccb, msg.mdb.header); 125 go = &mdb->go; 126 go->length = sizeof(*go); 127 go->type = 1; 128 sclp_early_cmd(SCLP_CMDW_WRITE_EVENT_DATA, sccb); 129 } 130 131 struct vt220_sccb { 132 struct sccb_header header; 133 struct { 134 struct evbuf_header header; 135 char data[]; 136 } msg; 137 } __packed; 138 139 /* Output multi-line text using SCLP VT220 interface. */ sclp_early_print_vt220(const char * str,unsigned int len)140 static void sclp_early_print_vt220(const char *str, unsigned int len) 141 { 142 struct vt220_sccb *sccb; 143 144 sccb = (struct vt220_sccb *) sclp_early_sccb; 145 if (sizeof(*sccb) + len >= EARLY_SCCB_SIZE) 146 len = EARLY_SCCB_SIZE - sizeof(*sccb); 147 memset(sccb, 0, sizeof(*sccb)); 148 memcpy(&sccb->msg.data, str, len); 149 sccb->header.length = sizeof(*sccb) + len; 150 sccb->msg.header.length = sizeof(sccb->msg) + len; 151 sccb->msg.header.type = EVTYP_VT220MSG; 152 sclp_early_cmd(SCLP_CMDW_WRITE_EVENT_DATA, sccb); 153 } 154 sclp_early_set_event_mask(struct init_sccb * sccb,sccb_mask_t receive_mask,sccb_mask_t send_mask)155 int sclp_early_set_event_mask(struct init_sccb *sccb, 156 sccb_mask_t receive_mask, 157 sccb_mask_t send_mask) 158 { 159 retry: 160 memset(sccb, 0, sizeof(*sccb)); 161 sccb->header.length = sizeof(*sccb); 162 if (sclp_mask_compat_mode) 163 sccb->mask_length = SCLP_MASK_SIZE_COMPAT; 164 else 165 sccb->mask_length = sizeof(sccb_mask_t); 166 sccb_set_recv_mask(sccb, receive_mask); 167 sccb_set_send_mask(sccb, send_mask); 168 if (sclp_early_cmd(SCLP_CMDW_WRITE_EVENT_MASK, sccb)) 169 return -EIO; 170 if ((sccb->header.response_code == 0x74f0) && !sclp_mask_compat_mode) { 171 sclp_mask_compat_mode = true; 172 goto retry; 173 } 174 if (sccb->header.response_code != 0x20) 175 return -EIO; 176 return 0; 177 } 178 sclp_early_con_check_linemode(struct init_sccb * sccb)179 unsigned int sclp_early_con_check_linemode(struct init_sccb *sccb) 180 { 181 if (!(sccb_get_sclp_send_mask(sccb) & EVTYP_OPCMD_MASK)) 182 return 0; 183 if (!(sccb_get_sclp_recv_mask(sccb) & (EVTYP_MSG_MASK | EVTYP_PMSGCMD_MASK))) 184 return 0; 185 return 1; 186 } 187 sclp_early_con_check_vt220(struct init_sccb * sccb)188 unsigned int sclp_early_con_check_vt220(struct init_sccb *sccb) 189 { 190 if (sccb_get_sclp_send_mask(sccb) & EVTYP_VT220MSG_MASK) 191 return 1; 192 return 0; 193 } 194 sclp_early_setup(int disable,int * have_linemode,int * have_vt220)195 static int sclp_early_setup(int disable, int *have_linemode, int *have_vt220) 196 { 197 unsigned long receive_mask, send_mask; 198 struct init_sccb *sccb; 199 int rc; 200 201 BUILD_BUG_ON(sizeof(struct init_sccb) > PAGE_SIZE); 202 203 *have_linemode = *have_vt220 = 0; 204 sccb = (struct init_sccb *) sclp_early_sccb; 205 receive_mask = disable ? 0 : EVTYP_OPCMD_MASK; 206 send_mask = disable ? 0 : EVTYP_VT220MSG_MASK | EVTYP_MSG_MASK; 207 rc = sclp_early_set_event_mask(sccb, receive_mask, send_mask); 208 if (rc) 209 return rc; 210 *have_linemode = sclp_early_con_check_linemode(sccb); 211 *have_vt220 = !!(sccb_get_send_mask(sccb) & EVTYP_VT220MSG_MASK); 212 return rc; 213 } 214 sclp_early_set_buffer(void * sccb)215 void sclp_early_set_buffer(void *sccb) 216 { 217 sclp_early_sccb = sccb; 218 } 219 220 /* 221 * Output one or more lines of text on the SCLP console (VT220 and / 222 * or line-mode). 223 */ __sclp_early_printk(const char * str,unsigned int len)224 void __sclp_early_printk(const char *str, unsigned int len) 225 { 226 int have_linemode, have_vt220; 227 228 if (sclp_init_state != sclp_init_state_uninitialized) 229 return; 230 if (sclp_early_setup(0, &have_linemode, &have_vt220) != 0) 231 return; 232 if (have_linemode) 233 sclp_early_print_lm(str, len); 234 if (have_vt220) 235 sclp_early_print_vt220(str, len); 236 sclp_early_setup(1, &have_linemode, &have_vt220); 237 } 238 sclp_early_printk(const char * str)239 void sclp_early_printk(const char *str) 240 { 241 __sclp_early_printk(str, strlen(str)); 242 } 243 244 /* 245 * Use sclp_emergency_printk() to print a string when the system is in a 246 * state where regular console drivers cannot be assumed to work anymore. 247 * 248 * Callers must make sure that no concurrent SCLP requests are outstanding 249 * and all other CPUs are stopped, or at least disabled for external 250 * interrupts. 251 */ sclp_emergency_printk(const char * str)252 void sclp_emergency_printk(const char *str) 253 { 254 int have_linemode, have_vt220; 255 unsigned int len; 256 257 len = strlen(str); 258 /* 259 * Don't care about return values; if requests fail, just ignore and 260 * continue to have a rather high chance that anything is printed. 261 */ 262 sclp_early_setup(0, &have_linemode, &have_vt220); 263 sclp_early_print_lm(str, len); 264 sclp_early_print_vt220(str, len); 265 sclp_early_setup(1, &have_linemode, &have_vt220); 266 } 267 268 /* 269 * We can't pass sclp_info_sccb to sclp_early_cmd() here directly, 270 * because it might not fulfil the requiremets for a SCLP communication buffer: 271 * - lie below 2G in memory 272 * - be page-aligned 273 * Therefore, we use the buffer sclp_early_sccb (which fulfils all those 274 * requirements) temporarily for communication and copy a received response 275 * back into the buffer sclp_info_sccb upon successful completion. 276 */ sclp_early_read_info(void)277 int __init sclp_early_read_info(void) 278 { 279 int i; 280 int length = test_facility(140) ? EXT_SCCB_READ_SCP : PAGE_SIZE; 281 struct read_info_sccb *sccb = (struct read_info_sccb *)sclp_early_sccb; 282 sclp_cmdw_t commands[] = {SCLP_CMDW_READ_SCP_INFO_FORCED, 283 SCLP_CMDW_READ_SCP_INFO}; 284 285 for (i = 0; i < ARRAY_SIZE(commands); i++) { 286 memset(sccb, 0, length); 287 sccb->header.length = length; 288 sccb->header.function_code = 0x80; 289 sccb->header.control_mask[2] = 0x80; 290 if (sclp_early_cmd(commands[i], sccb)) 291 break; 292 if (sccb->header.response_code == 0x10) { 293 memcpy(&sclp_info_sccb, sccb, length); 294 sclp_info_sccb_valid = 1; 295 return 0; 296 } 297 if (sccb->header.response_code != 0x1f0) 298 break; 299 } 300 return -EIO; 301 } 302 sclp_early_get_info(void)303 struct read_info_sccb * __init sclp_early_get_info(void) 304 { 305 if (!sclp_info_sccb_valid) 306 return NULL; 307 308 return &sclp_info_sccb; 309 } 310 sclp_early_get_memsize(unsigned long * mem)311 int __init sclp_early_get_memsize(unsigned long *mem) 312 { 313 unsigned long rnmax; 314 unsigned long rnsize; 315 struct read_info_sccb *sccb = &sclp_info_sccb; 316 317 if (!sclp_info_sccb_valid) 318 return -EIO; 319 320 rnmax = sccb->rnmax ? sccb->rnmax : sccb->rnmax2; 321 rnsize = sccb->rnsize ? sccb->rnsize : sccb->rnsize2; 322 rnsize <<= 20; 323 *mem = rnsize * rnmax; 324 return 0; 325 } 326 sclp_early_get_hsa_size(unsigned long * hsa_size)327 int __init sclp_early_get_hsa_size(unsigned long *hsa_size) 328 { 329 if (!sclp_info_sccb_valid) 330 return -EIO; 331 332 *hsa_size = 0; 333 if (sclp_info_sccb.hsa_size) 334 *hsa_size = (sclp_info_sccb.hsa_size - 1) * PAGE_SIZE; 335 return 0; 336 } 337 338 #define SCLP_STORAGE_INFO_FACILITY 0x0000400000000000UL 339 add_physmem_online_range(u64 start,u64 end)340 void __weak __init add_physmem_online_range(u64 start, u64 end) {} sclp_early_read_storage_info(void)341 int __init sclp_early_read_storage_info(void) 342 { 343 struct read_storage_sccb *sccb = (struct read_storage_sccb *)sclp_early_sccb; 344 int rc, id, max_id = 0; 345 unsigned long rn, rzm; 346 sclp_cmdw_t command; 347 u16 sn; 348 349 if (!sclp_info_sccb_valid) 350 return -EIO; 351 352 if (!(sclp_info_sccb.facilities & SCLP_STORAGE_INFO_FACILITY)) 353 return -EOPNOTSUPP; 354 355 rzm = sclp_info_sccb.rnsize ?: sclp_info_sccb.rnsize2; 356 rzm <<= 20; 357 358 for (id = 0; id <= max_id; id++) { 359 memset(sclp_early_sccb, 0, EARLY_SCCB_SIZE); 360 sccb->header.length = EARLY_SCCB_SIZE; 361 command = SCLP_CMDW_READ_STORAGE_INFO | (id << 8); 362 rc = sclp_early_cmd(command, sccb); 363 if (rc) 364 goto fail; 365 366 max_id = sccb->max_id; 367 switch (sccb->header.response_code) { 368 case 0x0010: 369 for (sn = 0; sn < sccb->assigned; sn++) { 370 if (!sccb->entries[sn]) 371 continue; 372 rn = sccb->entries[sn] >> 16; 373 add_physmem_online_range((rn - 1) * rzm, rn * rzm); 374 } 375 break; 376 case 0x0310: 377 case 0x0410: 378 break; 379 default: 380 goto fail; 381 } 382 } 383 384 return 0; 385 fail: 386 physmem_info.range_count = 0; 387 return -EIO; 388 } 389