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      fac91;                  /* 91 */
  43         u8      _pad_92[98 - 92];       /* 92-97 */
  44         u8      fac98;                  /* 98 */
  45         u8      hamaxpow;               /* 99 */
  46         u32     rnsize2;                /* 100-103 */
  47         u64     rnmax2;                 /* 104-111 */
  48         u8      _pad_112[116 - 112];    /* 112-115 */
  49         u8      fac116;                 /* 116 */
  50         u8      fac117;                 /* 117 */
  51         u8      _pad_118;               /* 118 */
  52         u8      fac119;                 /* 119 */
  53         u16     hcpua;                  /* 120-121 */
  54         u8      _pad_122[124 - 122];    /* 122-123 */
  55         u32     hmfai;                  /* 124-127 */
  56         u8      _pad_128[4096 - 128];   /* 128-4095 */
  57 } __packed __aligned(PAGE_SIZE);
  58
  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_early_read_info(struct read_info_sccb *sccb)
  65 {
  66         int i;
  67         sclp_cmdw_t commands[] = {SCLP_CMDW_READ_SCP_INFO_FORCED,
  68                                   SCLP_CMDW_READ_SCP_INFO};
  69
  70         for (i = 0; i < ARRAY_SIZE(commands); i++) {
  71                 memset(sccb, 0, sizeof(*sccb));
  72                 sccb->header.length = sizeof(*sccb);
  73                 sccb->header.function_code = 0x80;
  74                 sccb->header.control_mask[2] = 0x80;
  75                 if (sclp_early_cmd(commands[i], sccb))
  76                         break;
  77                 if (sccb->header.response_code == 0x10)
  78                         return 0;
  79                 if (sccb->header.response_code != 0x1f0)
  80                         break;
  81         }
  82         return -EIO;
  83 }
  84
  85 static void __init sclp_early_facilities_detect(struct read_info_sccb *sccb)
  86 {
  87         struct sclp_core_entry *cpue;
  88         u16 boot_cpu_address, cpu;
  89
  90         if (sclp_early_read_info(sccb))
  91                 return;
  92
  93         sclp.facilities = sccb->facilities;
  94         sclp.has_sprp = !!(sccb->fac84 & 0x02);
  95         sclp.has_core_type = !!(sccb->fac84 & 0x01);
  96         sclp.has_gsls = !!(sccb->fac85 & 0x80);
  97         sclp.has_64bscao = !!(sccb->fac116 & 0x80);
  98         sclp.has_cmma = !!(sccb->fac116 & 0x40);
  99         sclp.has_esca = !!(sccb->fac116 & 0x08);
 100         sclp.has_pfmfi = !!(sccb->fac117 & 0x40);
 101         sclp.has_ibs = !!(sccb->fac117 & 0x20);
 102         sclp.has_hvs = !!(sccb->fac119 & 0x80);
 103         sclp.has_kss = !!(sccb->fac98 & 0x01);
 104         if (sccb->fac85 & 0x02)
 105                 S390_lowcore.machine_flags |= MACHINE_FLAG_ESOP;
 106         if (sccb->fac91 & 0x40)
 107                 S390_lowcore.machine_flags |= MACHINE_FLAG_TLB_GUEST;
 108         sclp.rnmax = sccb->rnmax ? sccb->rnmax : sccb->rnmax2;
 109         sclp.rzm = sccb->rnsize ? sccb->rnsize : sccb->rnsize2;
 110         sclp.rzm <<= 20;
 111         sclp.ibc = sccb->ibc;
 112
 113         if (sccb->hamaxpow && sccb->hamaxpow < 64)
 114                 sclp.hamax = (1UL << sccb->hamaxpow) - 1;
 115         else
 116                 sclp.hamax = U64_MAX;
 117
 118         if (!sccb->hcpua) {
 119                 if (MACHINE_IS_VM)
 120                         sclp.max_cores = 64;
 121                 else
 122                         sclp.max_cores = sccb->ncpurl;
 123         } else {
 124                 sclp.max_cores = sccb->hcpua + 1;
 125         }
 126
 127         boot_cpu_address = stap();
 128         cpue = (void *)sccb + sccb->cpuoff;
 129         for (cpu = 0; cpu < sccb->ncpurl; cpue++, cpu++) {
 130                 if (boot_cpu_address != cpue->core_id)
 131                         continue;
 132                 sclp.has_siif = cpue->siif;
 133                 sclp.has_sigpif = cpue->sigpif;
 134                 sclp.has_sief2 = cpue->sief2;
 135                 sclp.has_gpere = cpue->gpere;
 136                 sclp.has_ib = cpue->ib;
 137                 sclp.has_cei = cpue->cei;
 138                 sclp.has_skey = cpue->skey;
 139                 break;
 140         }
 141
 142         /* Save IPL information */
 143         sclp_ipl_info.is_valid = 1;
 144         if (sccb->fac91 & 0x2)
 145                 sclp_ipl_info.has_dump = 1;
 146         memcpy(&sclp_ipl_info.loadparm, &sccb->loadparm, LOADPARM_LEN);
 147
 148         sclp.mtid = (sccb->fac42 & 0x80) ? (sccb->fac42 & 31) : 0;
 149         sclp.mtid_cp = (sccb->fac42 & 0x80) ? (sccb->fac43 & 31) : 0;
 150         sclp.mtid_prev = (sccb->fac42 & 0x80) ? (sccb->fac66 & 31) : 0;
 151
 152         sclp.hmfai = sccb->hmfai;
 153 }
 154
 155 /*
 156  * This function will be called after sclp_early_facilities_detect(), which gets
 157  * called from early.c code. The sclp_early_facilities_detect() function retrieves
 158  * and saves the IPL information.
 159  */
 160 void __init sclp_early_get_ipl_info(struct sclp_ipl_info *info)
 161 {
 162         *info = sclp_ipl_info;
 163 }
 164
 165 static struct sclp_core_info sclp_early_core_info __initdata;
 166 static int sclp_early_core_info_valid __initdata;
 167
 168 static void __init sclp_early_init_core_info(struct read_cpu_info_sccb *sccb)
 169 {
 170         if (!SCLP_HAS_CPU_INFO)
 171                 return;
 172         memset(sccb, 0, sizeof(*sccb));
 173         sccb->header.length = sizeof(*sccb);
 174         if (sclp_early_cmd(SCLP_CMDW_READ_CPU_INFO, sccb))
 175                 return;
 176         if (sccb->header.response_code != 0x0010)
 177                 return;
 178         sclp_fill_core_info(&sclp_early_core_info, sccb);
 179         sclp_early_core_info_valid = 1;
 180 }
 181
 182 int __init sclp_early_get_core_info(struct sclp_core_info *info)
 183 {
 184         if (!sclp_early_core_info_valid)
 185                 return -EIO;
 186         *info = sclp_early_core_info;
 187         return 0;
 188 }
 189
 190 static long __init sclp_early_hsa_size_init(struct sdias_sccb *sccb)
 191 {
 192         memset(sccb, 0, sizeof(*sccb));
 193         sccb->hdr.length = sizeof(*sccb);
 194         sccb->evbuf.hdr.length = sizeof(struct sdias_evbuf);
 195         sccb->evbuf.hdr.type = EVTYP_SDIAS;
 196         sccb->evbuf.event_qual = SDIAS_EQ_SIZE;
 197         sccb->evbuf.data_id = SDIAS_DI_FCP_DUMP;
 198         sccb->evbuf.event_id = 4712;
 199         sccb->evbuf.dbs = 1;
 200         if (sclp_early_cmd(SCLP_CMDW_WRITE_EVENT_DATA, sccb))
 201                 return -EIO;
 202         if (sccb->hdr.response_code != 0x20)
 203                 return -EIO;
 204         if (sccb->evbuf.blk_cnt == 0)
 205                 return 0;
 206         return (sccb->evbuf.blk_cnt - 1) * PAGE_SIZE;
 207 }
 208
 209 static long __init sclp_early_hsa_copy_wait(struct sdias_sccb *sccb)
 210 {
 211         memset(sccb, 0, PAGE_SIZE);
 212         sccb->hdr.length = PAGE_SIZE;
 213         if (sclp_early_cmd(SCLP_CMDW_READ_EVENT_DATA, sccb))
 214                 return -EIO;
 215         if ((sccb->hdr.response_code != 0x20) && (sccb->hdr.response_code != 0x220))
 216                 return -EIO;
 217         if (sccb->evbuf.blk_cnt == 0)
 218                 return 0;
 219         return (sccb->evbuf.blk_cnt - 1) * PAGE_SIZE;
 220 }
 221
 222 static void __init sclp_early_hsa_size_detect(void *sccb)
 223 {
 224         unsigned long flags;
 225         long size = -EIO;
 226
 227         raw_local_irq_save(flags);
 228         if (sclp_early_set_event_mask(sccb, EVTYP_SDIAS_MASK, EVTYP_SDIAS_MASK))
 229                 goto out;
 230         size = sclp_early_hsa_size_init(sccb);
 231         /* First check for synchronous response (LPAR) */
 232         if (size)
 233                 goto out_mask;
 234         if (!(S390_lowcore.ext_params & 1))
 235                 sclp_early_wait_irq();
 236         size = sclp_early_hsa_copy_wait(sccb);
 237 out_mask:
 238         sclp_early_set_event_mask(sccb, 0, 0);
 239 out:
 240         raw_local_irq_restore(flags);
 241         if (size > 0)
 242                 sclp.hsa_size = size;
 243 }
 244
 245 static void __init sclp_early_console_detect(struct init_sccb *sccb)
 246 {
 247         if (sccb->header.response_code != 0x20)
 248                 return;
 249
 250         if (sccb->sclp_send_mask & EVTYP_VT220MSG_MASK)
 251                 sclp.has_vt220 = 1;
 252
 253         if (sclp_early_con_check_linemode(sccb))
 254                 sclp.has_linemode = 1;
 255 }
 256
 257 void __init sclp_early_detect(void)
 258 {
 259         void *sccb = &sclp_early_sccb;
 260
 261         sclp_early_facilities_detect(sccb);
 262         sclp_early_init_core_info(sccb);
 263         sclp_early_hsa_size_detect(sccb);
 264
 265         /*
 266          * Turn off SCLP event notifications.  Also save remote masks in the
 267          * sccb.  These are sufficient to detect sclp console capabilities.
 268          */
 269         sclp_early_set_event_mask(sccb, 0, 0);
 270         sclp_early_console_detect(sccb);
 271 }