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      _pad_11[16 - 11];       /* 11-15 */
  25         u16     ncpurl;                 /* 16-17 */
  26         u16     cpuoff;                 /* 18-19 */
  27         u8      _pad_20[24 - 20];       /* 20-23 */
  28         u8      loadparm[8];            /* 24-31 */
  29         u8      _pad_32[42 - 32];       /* 32-41 */
  30         u8      fac42;                  /* 42 */
  31         u8      fac43;                  /* 43 */
  32         u8      _pad_44[48 - 44];       /* 44-47 */
  33         u64     facilities;             /* 48-55 */
  34         u8      _pad_56[66 - 56];       /* 56-65 */
  35         u8      fac66;                  /* 66 */
  36         u8      _pad_67[76 - 67];       /* 67-83 */
  37         u32     ibc;                    /* 76-79 */
  38         u8      _pad80[84 - 80];        /* 80-83 */
  39         u8      fac84;                  /* 84 */
  40         u8      fac85;                  /* 85 */
  41         u8      _pad_86[91 - 86];       /* 86-90 */
  42         u8      flags;                  /* 91 */
  43         u8      _pad_92[99 - 92];       /* 92-98 */
  44         u8      hamaxpow;               /* 99 */
  45         u32     rnsize2;                /* 100-103 */
  46         u64     rnmax2;                 /* 104-111 */
  47         u8      _pad_112[116 - 112];    /* 112-115 */
  48         u8      fac116;                 /* 116 */
  49         u8      fac117;                 /* 117 */
  50         u8      _pad_118;               /* 118 */
  51         u8      fac119;                 /* 119 */
  52         u16     hcpua;                  /* 120-121 */
  53         u8      _pad_122[124 - 122];    /* 122-123 */
  54         u32     hmfai;                  /* 124-127 */
  55         u8      _pad_128[4096 - 128];   /* 128-4095 */
  56 } __packed __aligned(PAGE_SIZE);
  57
  58 static char sccb_early[PAGE_SIZE] __aligned(PAGE_SIZE) __initdata;
  59 static struct sclp_ipl_info sclp_ipl_info;
  60
  61 struct sclp_info sclp;
  62 EXPORT_SYMBOL(sclp);
  63
  64 static int __init sclp_cmd_sync_early(sclp_cmdw_t cmd, void *sccb)
  65 {
  66         int rc;
  67
  68         __ctl_set_bit(0, 9);
  69         rc = sclp_service_call(cmd, sccb);
  70         if (rc)
  71                 goto out;
  72         __load_psw_mask(PSW_DEFAULT_KEY | PSW_MASK_BASE | PSW_MASK_EA |
  73                         PSW_MASK_BA | PSW_MASK_EXT | PSW_MASK_WAIT);
  74         local_irq_disable();
  75 out:
  76         /* Contents of the sccb might have changed. */
  77         barrier();
  78         __ctl_clear_bit(0, 9);
  79         return rc;
  80 }
  81
  82 static int __init sclp_read_info_early(struct read_info_sccb *sccb)
  83 {
  84         int rc, i;
  85         sclp_cmdw_t commands[] = {SCLP_CMDW_READ_SCP_INFO_FORCED,
  86                                   SCLP_CMDW_READ_SCP_INFO};
  87
  88         for (i = 0; i < ARRAY_SIZE(commands); i++) {
  89                 do {
  90                         memset(sccb, 0, sizeof(*sccb));
  91                         sccb->header.length = sizeof(*sccb);
  92                         sccb->header.function_code = 0x80;
  93                         sccb->header.control_mask[2] = 0x80;
  94                         rc = sclp_cmd_sync_early(commands[i], sccb);
  95                 } while (rc == -EBUSY);
  96
  97                 if (rc)
  98                         break;
  99                 if (sccb->header.response_code == 0x10)
 100                         return 0;
 101                 if (sccb->header.response_code != 0x1f0)
 102                         break;
 103         }
 104         return -EIO;
 105 }
 106
 107 static void __init sclp_facilities_detect(struct read_info_sccb *sccb)
 108 {
 109         struct sclp_core_entry *cpue;
 110         u16 boot_cpu_address, cpu;
 111
 112         if (sclp_read_info_early(sccb))
 113                 return;
 114
 115         sclp.facilities = sccb->facilities;
 116         sclp.has_sprp = !!(sccb->fac84 & 0x02);
 117         sclp.has_core_type = !!(sccb->fac84 & 0x01);
 118         sclp.has_gsls = !!(sccb->fac85 & 0x80);
 119         sclp.has_64bscao = !!(sccb->fac116 & 0x80);
 120         sclp.has_cmma = !!(sccb->fac116 & 0x40);
 121         sclp.has_esca = !!(sccb->fac116 & 0x08);
 122         sclp.has_pfmfi = !!(sccb->fac117 & 0x40);
 123         sclp.has_ibs = !!(sccb->fac117 & 0x20);
 124         sclp.has_hvs = !!(sccb->fac119 & 0x80);
 125         if (sccb->fac85 & 0x02)
 126                 S390_lowcore.machine_flags |= MACHINE_FLAG_ESOP;
 127         sclp.rnmax = sccb->rnmax ? sccb->rnmax : sccb->rnmax2;
 128         sclp.rzm = sccb->rnsize ? sccb->rnsize : sccb->rnsize2;
 129         sclp.rzm <<= 20;
 130         sclp.ibc = sccb->ibc;
 131
 132         if (sccb->hamaxpow && sccb->hamaxpow < 64)
 133                 sclp.hamax = (1UL << sccb->hamaxpow) - 1;
 134         else
 135                 sclp.hamax = U64_MAX;
 136
 137         if (!sccb->hcpua) {
 138                 if (MACHINE_IS_VM)
 139                         sclp.max_cores = 64;
 140                 else
 141                         sclp.max_cores = sccb->ncpurl;
 142         } else {
 143                 sclp.max_cores = sccb->hcpua + 1;
 144         }
 145
 146         boot_cpu_address = stap();
 147         cpue = (void *)sccb + sccb->cpuoff;
 148         for (cpu = 0; cpu < sccb->ncpurl; cpue++, cpu++) {
 149                 if (boot_cpu_address != cpue->core_id)
 150                         continue;
 151                 sclp.has_siif = cpue->siif;
 152                 sclp.has_sigpif = cpue->sigpif;
 153                 sclp.has_sief2 = cpue->sief2;
 154                 sclp.has_gpere = cpue->gpere;
 155                 sclp.has_ib = cpue->ib;
 156                 sclp.has_cei = cpue->cei;
 157                 sclp.has_skey = cpue->skey;
 158                 break;
 159         }
 160
 161         /* Save IPL information */
 162         sclp_ipl_info.is_valid = 1;
 163         if (sccb->flags & 0x2)
 164                 sclp_ipl_info.has_dump = 1;
 165         memcpy(&sclp_ipl_info.loadparm, &sccb->loadparm, LOADPARM_LEN);
 166
 167         sclp.mtid = (sccb->fac42 & 0x80) ? (sccb->fac42 & 31) : 0;
 168         sclp.mtid_cp = (sccb->fac42 & 0x80) ? (sccb->fac43 & 31) : 0;
 169         sclp.mtid_prev = (sccb->fac42 & 0x80) ? (sccb->fac66 & 31) : 0;
 170
 171         sclp.hmfai = sccb->hmfai;
 172 }
 173
 174 /*
 175  * This function will be called after sclp_facilities_detect(), which gets
 176  * called from early.c code. The sclp_facilities_detect() function retrieves
 177  * and saves the IPL information.
 178  */
 179 void __init sclp_get_ipl_info(struct sclp_ipl_info *info)
 180 {
 181         *info = sclp_ipl_info;
 182 }
 183
 184 static int __init sclp_cmd_early(sclp_cmdw_t cmd, void *sccb)
 185 {
 186         int rc;
 187
 188         do {
 189                 rc = sclp_cmd_sync_early(cmd, sccb);
 190         } while (rc == -EBUSY);
 191
 192         if (rc)
 193                 return -EIO;
 194         if (((struct sccb_header *) sccb)->response_code != 0x0020)
 195                 return -EIO;
 196         return 0;
 197 }
 198
 199 static void __init sccb_init_eq_size(struct sdias_sccb *sccb)
 200 {
 201         memset(sccb, 0, sizeof(*sccb));
 202
 203         sccb->hdr.length = sizeof(*sccb);
 204         sccb->evbuf.hdr.length = sizeof(struct sdias_evbuf);
 205         sccb->evbuf.hdr.type = EVTYP_SDIAS;
 206         sccb->evbuf.event_qual = SDIAS_EQ_SIZE;
 207         sccb->evbuf.data_id = SDIAS_DI_FCP_DUMP;
 208         sccb->evbuf.event_id = 4712;
 209         sccb->evbuf.dbs = 1;
 210 }
 211
 212 static int __init sclp_set_event_mask(struct init_sccb *sccb,
 213                                       unsigned long receive_mask,
 214                                       unsigned long send_mask)
 215 {
 216         memset(sccb, 0, sizeof(*sccb));
 217         sccb->header.length = sizeof(*sccb);
 218         sccb->mask_length = sizeof(sccb_mask_t);
 219         sccb->receive_mask = receive_mask;
 220         sccb->send_mask = send_mask;
 221         return sclp_cmd_early(SCLP_CMDW_WRITE_EVENT_MASK, sccb);
 222 }
 223
 224 static struct sclp_core_info sclp_core_info_early __initdata;
 225 static int sclp_core_info_early_valid __initdata;
 226
 227 static void __init sclp_init_core_info_early(struct read_cpu_info_sccb *sccb)
 228 {
 229         int rc;
 230
 231         if (!SCLP_HAS_CPU_INFO)
 232                 return;
 233         memset(sccb, 0, sizeof(*sccb));
 234         sccb->header.length = sizeof(*sccb);
 235         do {
 236                 rc = sclp_cmd_sync_early(SCLP_CMDW_READ_CPU_INFO, sccb);
 237         } while (rc == -EBUSY);
 238         if (rc)
 239                 return;
 240         if (sccb->header.response_code != 0x0010)
 241                 return;
 242         sclp_fill_core_info(&sclp_core_info_early, sccb);
 243         sclp_core_info_early_valid = 1;
 244 }
 245
 246 int __init _sclp_get_core_info_early(struct sclp_core_info *info)
 247 {
 248         if (!sclp_core_info_early_valid)
 249                 return -EIO;
 250         *info = sclp_core_info_early;
 251         return 0;
 252 }
 253
 254 static long __init sclp_hsa_size_init(struct sdias_sccb *sccb)
 255 {
 256         sccb_init_eq_size(sccb);
 257         if (sclp_cmd_early(SCLP_CMDW_WRITE_EVENT_DATA, sccb))
 258                 return -EIO;
 259         if (sccb->evbuf.blk_cnt == 0)
 260                 return 0;
 261         return (sccb->evbuf.blk_cnt - 1) * PAGE_SIZE;
 262 }
 263
 264 static long __init sclp_hsa_copy_wait(struct sccb_header *sccb)
 265 {
 266         memset(sccb, 0, PAGE_SIZE);
 267         sccb->length = PAGE_SIZE;
 268         if (sclp_cmd_early(SCLP_CMDW_READ_EVENT_DATA, sccb))
 269                 return -EIO;
 270         if (((struct sdias_sccb *) sccb)->evbuf.blk_cnt == 0)
 271                 return 0;
 272         return (((struct sdias_sccb *) sccb)->evbuf.blk_cnt - 1) * PAGE_SIZE;
 273 }
 274
 275 static void __init sclp_hsa_size_detect(void *sccb)
 276 {
 277         long size;
 278
 279         /* First try synchronous interface (LPAR) */
 280         if (sclp_set_event_mask(sccb, 0, 0x40000010))
 281                 return;
 282         size = sclp_hsa_size_init(sccb);
 283         if (size < 0)
 284                 return;
 285         if (size != 0)
 286                 goto out;
 287         /* Then try asynchronous interface (z/VM) */
 288         if (sclp_set_event_mask(sccb, 0x00000010, 0x40000010))
 289                 return;
 290         size = sclp_hsa_size_init(sccb);
 291         if (size < 0)
 292                 return;
 293         size = sclp_hsa_copy_wait(sccb);
 294         if (size < 0)
 295                 return;
 296 out:
 297         sclp.hsa_size = size;
 298 }
 299
 300 static unsigned int __init sclp_con_check_linemode(struct init_sccb *sccb)
 301 {
 302         if (!(sccb->sclp_send_mask & EVTYP_OPCMD_MASK))
 303                 return 0;
 304         if (!(sccb->sclp_receive_mask & (EVTYP_MSG_MASK | EVTYP_PMSGCMD_MASK)))
 305                 return 0;
 306         return 1;
 307 }
 308
 309 static void __init sclp_console_detect(struct init_sccb *sccb)
 310 {
 311         if (sccb->header.response_code != 0x20)
 312                 return;
 313
 314         if (sccb->sclp_send_mask & EVTYP_VT220MSG_MASK)
 315                 sclp.has_vt220 = 1;
 316
 317         if (sclp_con_check_linemode(sccb))
 318                 sclp.has_linemode = 1;
 319 }
 320
 321 void __init sclp_early_detect(void)
 322 {
 323         void *sccb = &sccb_early;
 324
 325         sclp_facilities_detect(sccb);
 326         sclp_init_core_info_early(sccb);
 327         sclp_hsa_size_detect(sccb);
 328
 329         /* Turn off SCLP event notifications.  Also save remote masks in the
 330          * sccb.  These are sufficient to detect sclp console capabilities.
 331          */
 332         sclp_set_event_mask(sccb, 0, 0);
 333         sclp_console_detect(sccb);
 334 }