drivers/s390/char/sclp_early.c

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