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