drivers/s390/char/sclp_early_core.c

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