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