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