xref: /openbmc/linux/drivers/s390/char/sclp_early.c (revision 6774def6)
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