xref: /openbmc/linux/drivers/s390/cio/chsc.c (revision 2010776f)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *   S/390 common I/O routines -- channel subsystem call
4  *
5  *    Copyright IBM Corp. 1999,2012
6  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
7  *		 Cornelia Huck (cornelia.huck@de.ibm.com)
8  *		 Arnd Bergmann (arndb@de.ibm.com)
9  */
10 
11 #define KMSG_COMPONENT "cio"
12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/init.h>
17 #include <linux/device.h>
18 #include <linux/mutex.h>
19 #include <linux/pci.h>
20 
21 #include <asm/cio.h>
22 #include <asm/chpid.h>
23 #include <asm/chsc.h>
24 #include <asm/crw.h>
25 #include <asm/isc.h>
26 #include <asm/ebcdic.h>
27 #include <asm/ap.h>
28 
29 #include "css.h"
30 #include "cio.h"
31 #include "cio_debug.h"
32 #include "ioasm.h"
33 #include "chp.h"
34 #include "chsc.h"
35 
36 static void *sei_page;
37 static void *chsc_page;
38 static DEFINE_SPINLOCK(chsc_page_lock);
39 
40 #define SEI_VF_FLA	0xc0 /* VF flag for Full Link Address */
41 #define SEI_RS_CHPID	0x4  /* 4 in RS field indicates CHPID */
42 
43 /**
44  * chsc_error_from_response() - convert a chsc response to an error
45  * @response: chsc response code
46  *
47  * Returns an appropriate Linux error code for @response.
48  */
49 int chsc_error_from_response(int response)
50 {
51 	switch (response) {
52 	case 0x0001:
53 		return 0;
54 	case 0x0002:
55 	case 0x0003:
56 	case 0x0006:
57 	case 0x0007:
58 	case 0x0008:
59 	case 0x000a:
60 	case 0x0104:
61 		return -EINVAL;
62 	case 0x0004:
63 	case 0x0106:		/* "Wrong Channel Parm" for the op 0x003d */
64 		return -EOPNOTSUPP;
65 	case 0x000b:
66 	case 0x0107:		/* "Channel busy" for the op 0x003d */
67 		return -EBUSY;
68 	case 0x0100:
69 	case 0x0102:
70 		return -ENOMEM;
71 	case 0x0108:		/* "HW limit exceeded" for the op 0x003d */
72 		return -EUSERS;
73 	default:
74 		return -EIO;
75 	}
76 }
77 EXPORT_SYMBOL_GPL(chsc_error_from_response);
78 
79 struct chsc_ssd_area {
80 	struct chsc_header request;
81 	u16 :10;
82 	u16 ssid:2;
83 	u16 :4;
84 	u16 f_sch;	  /* first subchannel */
85 	u16 :16;
86 	u16 l_sch;	  /* last subchannel */
87 	u32 :32;
88 	struct chsc_header response;
89 	u32 :32;
90 	u8 sch_valid : 1;
91 	u8 dev_valid : 1;
92 	u8 st	     : 3; /* subchannel type */
93 	u8 zeroes    : 3;
94 	u8  unit_addr;	  /* unit address */
95 	u16 devno;	  /* device number */
96 	u8 path_mask;
97 	u8 fla_valid_mask;
98 	u16 sch;	  /* subchannel */
99 	u8 chpid[8];	  /* chpids 0-7 */
100 	u16 fla[8];	  /* full link addresses 0-7 */
101 } __packed __aligned(PAGE_SIZE);
102 
103 int chsc_get_ssd_info(struct subchannel_id schid, struct chsc_ssd_info *ssd)
104 {
105 	struct chsc_ssd_area *ssd_area;
106 	unsigned long flags;
107 	int ccode;
108 	int ret;
109 	int i;
110 	int mask;
111 
112 	spin_lock_irqsave(&chsc_page_lock, flags);
113 	memset(chsc_page, 0, PAGE_SIZE);
114 	ssd_area = chsc_page;
115 	ssd_area->request.length = 0x0010;
116 	ssd_area->request.code = 0x0004;
117 	ssd_area->ssid = schid.ssid;
118 	ssd_area->f_sch = schid.sch_no;
119 	ssd_area->l_sch = schid.sch_no;
120 
121 	ccode = chsc(ssd_area);
122 	/* Check response. */
123 	if (ccode > 0) {
124 		ret = (ccode == 3) ? -ENODEV : -EBUSY;
125 		goto out;
126 	}
127 	ret = chsc_error_from_response(ssd_area->response.code);
128 	if (ret != 0) {
129 		CIO_MSG_EVENT(2, "chsc: ssd failed for 0.%x.%04x (rc=%04x)\n",
130 			      schid.ssid, schid.sch_no,
131 			      ssd_area->response.code);
132 		goto out;
133 	}
134 	if (!ssd_area->sch_valid) {
135 		ret = -ENODEV;
136 		goto out;
137 	}
138 	/* Copy data */
139 	ret = 0;
140 	memset(ssd, 0, sizeof(struct chsc_ssd_info));
141 	if ((ssd_area->st != SUBCHANNEL_TYPE_IO) &&
142 	    (ssd_area->st != SUBCHANNEL_TYPE_MSG))
143 		goto out;
144 	ssd->path_mask = ssd_area->path_mask;
145 	ssd->fla_valid_mask = ssd_area->fla_valid_mask;
146 	for (i = 0; i < 8; i++) {
147 		mask = 0x80 >> i;
148 		if (ssd_area->path_mask & mask) {
149 			chp_id_init(&ssd->chpid[i]);
150 			ssd->chpid[i].id = ssd_area->chpid[i];
151 		}
152 		if (ssd_area->fla_valid_mask & mask)
153 			ssd->fla[i] = ssd_area->fla[i];
154 	}
155 out:
156 	spin_unlock_irqrestore(&chsc_page_lock, flags);
157 	return ret;
158 }
159 
160 /**
161  * chsc_ssqd() - store subchannel QDIO data (SSQD)
162  * @schid: id of the subchannel on which SSQD is performed
163  * @ssqd: request and response block for SSQD
164  *
165  * Returns 0 on success.
166  */
167 int chsc_ssqd(struct subchannel_id schid, struct chsc_ssqd_area *ssqd)
168 {
169 	memset(ssqd, 0, sizeof(*ssqd));
170 	ssqd->request.length = 0x0010;
171 	ssqd->request.code = 0x0024;
172 	ssqd->first_sch = schid.sch_no;
173 	ssqd->last_sch = schid.sch_no;
174 	ssqd->ssid = schid.ssid;
175 
176 	if (chsc(ssqd))
177 		return -EIO;
178 
179 	return chsc_error_from_response(ssqd->response.code);
180 }
181 EXPORT_SYMBOL_GPL(chsc_ssqd);
182 
183 /**
184  * chsc_sadc() - set adapter device controls (SADC)
185  * @schid: id of the subchannel on which SADC is performed
186  * @scssc: request and response block for SADC
187  * @summary_indicator_addr: summary indicator address
188  * @subchannel_indicator_addr: subchannel indicator address
189  * @isc: Interruption Subclass for this subchannel
190  *
191  * Returns 0 on success.
192  */
193 int chsc_sadc(struct subchannel_id schid, struct chsc_scssc_area *scssc,
194 	      u64 summary_indicator_addr, u64 subchannel_indicator_addr, u8 isc)
195 {
196 	memset(scssc, 0, sizeof(*scssc));
197 	scssc->request.length = 0x0fe0;
198 	scssc->request.code = 0x0021;
199 	scssc->operation_code = 0;
200 
201 	scssc->summary_indicator_addr = summary_indicator_addr;
202 	scssc->subchannel_indicator_addr = subchannel_indicator_addr;
203 
204 	scssc->ks = PAGE_DEFAULT_KEY >> 4;
205 	scssc->kc = PAGE_DEFAULT_KEY >> 4;
206 	scssc->isc = isc;
207 	scssc->schid = schid;
208 
209 	/* enable the time delay disablement facility */
210 	if (css_general_characteristics.aif_tdd)
211 		scssc->word_with_d_bit = 0x10000000;
212 
213 	if (chsc(scssc))
214 		return -EIO;
215 
216 	return chsc_error_from_response(scssc->response.code);
217 }
218 EXPORT_SYMBOL_GPL(chsc_sadc);
219 
220 static int s390_subchannel_remove_chpid(struct subchannel *sch, void *data)
221 {
222 	spin_lock_irq(sch->lock);
223 	if (sch->driver && sch->driver->chp_event)
224 		if (sch->driver->chp_event(sch, data, CHP_OFFLINE) != 0)
225 			goto out_unreg;
226 	spin_unlock_irq(sch->lock);
227 	return 0;
228 
229 out_unreg:
230 	sch->lpm = 0;
231 	spin_unlock_irq(sch->lock);
232 	css_schedule_eval(sch->schid);
233 	return 0;
234 }
235 
236 void chsc_chp_offline(struct chp_id chpid)
237 {
238 	struct channel_path *chp = chpid_to_chp(chpid);
239 	struct chp_link link;
240 	char dbf_txt[15];
241 
242 	sprintf(dbf_txt, "chpr%x.%02x", chpid.cssid, chpid.id);
243 	CIO_TRACE_EVENT(2, dbf_txt);
244 
245 	if (chp_get_status(chpid) <= 0)
246 		return;
247 	memset(&link, 0, sizeof(struct chp_link));
248 	link.chpid = chpid;
249 	/* Wait until previous actions have settled. */
250 	css_wait_for_slow_path();
251 
252 	mutex_lock(&chp->lock);
253 	chp_update_desc(chp);
254 	mutex_unlock(&chp->lock);
255 
256 	for_each_subchannel_staged(s390_subchannel_remove_chpid, NULL, &link);
257 }
258 
259 static int __s390_process_res_acc(struct subchannel *sch, void *data)
260 {
261 	spin_lock_irq(sch->lock);
262 	if (sch->driver && sch->driver->chp_event)
263 		sch->driver->chp_event(sch, data, CHP_ONLINE);
264 	spin_unlock_irq(sch->lock);
265 
266 	return 0;
267 }
268 
269 static void s390_process_res_acc(struct chp_link *link)
270 {
271 	char dbf_txt[15];
272 
273 	sprintf(dbf_txt, "accpr%x.%02x", link->chpid.cssid,
274 		link->chpid.id);
275 	CIO_TRACE_EVENT( 2, dbf_txt);
276 	if (link->fla != 0) {
277 		sprintf(dbf_txt, "fla%x", link->fla);
278 		CIO_TRACE_EVENT( 2, dbf_txt);
279 	}
280 	/* Wait until previous actions have settled. */
281 	css_wait_for_slow_path();
282 	/*
283 	 * I/O resources may have become accessible.
284 	 * Scan through all subchannels that may be concerned and
285 	 * do a validation on those.
286 	 * The more information we have (info), the less scanning
287 	 * will we have to do.
288 	 */
289 	for_each_subchannel_staged(__s390_process_res_acc, NULL, link);
290 	css_schedule_reprobe();
291 }
292 
293 static int process_fces_event(struct subchannel *sch, void *data)
294 {
295 	spin_lock_irq(sch->lock);
296 	if (sch->driver && sch->driver->chp_event)
297 		sch->driver->chp_event(sch, data, CHP_FCES_EVENT);
298 	spin_unlock_irq(sch->lock);
299 	return 0;
300 }
301 
302 struct chsc_sei_nt0_area {
303 	u8  flags;
304 	u8  vf;				/* validity flags */
305 	u8  rs;				/* reporting source */
306 	u8  cc;				/* content code */
307 	u16 fla;			/* full link address */
308 	u16 rsid;			/* reporting source id */
309 	u32 reserved1;
310 	u32 reserved2;
311 	/* ccdf has to be big enough for a link-incident record */
312 	u8  ccdf[PAGE_SIZE - 24 - 16];	/* content-code dependent field */
313 } __packed;
314 
315 struct chsc_sei_nt2_area {
316 	u8  flags;			/* p and v bit */
317 	u8  reserved1;
318 	u8  reserved2;
319 	u8  cc;				/* content code */
320 	u32 reserved3[13];
321 	u8  ccdf[PAGE_SIZE - 24 - 56];	/* content-code dependent field */
322 } __packed;
323 
324 #define CHSC_SEI_NT0	(1ULL << 63)
325 #define CHSC_SEI_NT2	(1ULL << 61)
326 
327 struct chsc_sei {
328 	struct chsc_header request;
329 	u32 reserved1;
330 	u64 ntsm;			/* notification type mask */
331 	struct chsc_header response;
332 	u32 :24;
333 	u8 nt;
334 	union {
335 		struct chsc_sei_nt0_area nt0_area;
336 		struct chsc_sei_nt2_area nt2_area;
337 		u8 nt_area[PAGE_SIZE - 24];
338 	} u;
339 } __packed __aligned(PAGE_SIZE);
340 
341 /*
342  * Link Incident Record as defined in SA22-7202, "ESCON I/O Interface"
343  */
344 
345 #define LIR_IQ_CLASS_INFO		0
346 #define LIR_IQ_CLASS_DEGRADED		1
347 #define LIR_IQ_CLASS_NOT_OPERATIONAL	2
348 
349 struct lir {
350 	struct {
351 		u32 null:1;
352 		u32 reserved:3;
353 		u32 class:2;
354 		u32 reserved2:2;
355 	} __packed iq;
356 	u32 ic:8;
357 	u32 reserved:16;
358 	struct node_descriptor incident_node;
359 	struct node_descriptor attached_node;
360 	u8 reserved2[32];
361 } __packed;
362 
363 #define PARAMS_LEN	10	/* PARAMS=xx,xxxxxx */
364 #define NODEID_LEN	35	/* NODEID=tttttt/mdl,mmm.ppssssssssssss,xxxx */
365 
366 /* Copy EBCIDC text, convert to ASCII and optionally add delimiter. */
367 static char *store_ebcdic(char *dest, const char *src, unsigned long len,
368 			  char delim)
369 {
370 	memcpy(dest, src, len);
371 	EBCASC(dest, len);
372 
373 	if (delim)
374 		dest[len++] = delim;
375 
376 	return dest + len;
377 }
378 
379 static void chsc_link_from_sei(struct chp_link *link,
380 				struct chsc_sei_nt0_area *sei_area)
381 {
382 	if ((sei_area->vf & SEI_VF_FLA) != 0) {
383 		link->fla	= sei_area->fla;
384 		link->fla_mask	= ((sei_area->vf & SEI_VF_FLA) == SEI_VF_FLA) ?
385 							0xffff : 0xff00;
386 	}
387 }
388 
389 /* Format node ID and parameters for output in LIR log message. */
390 static void format_node_data(char *params, char *id, struct node_descriptor *nd)
391 {
392 	memset(params, 0, PARAMS_LEN);
393 	memset(id, 0, NODEID_LEN);
394 
395 	if (nd->validity != ND_VALIDITY_VALID) {
396 		strncpy(params, "n/a", PARAMS_LEN - 1);
397 		strncpy(id, "n/a", NODEID_LEN - 1);
398 		return;
399 	}
400 
401 	/* PARAMS=xx,xxxxxx */
402 	snprintf(params, PARAMS_LEN, "%02x,%06x", nd->byte0, nd->params);
403 	/* NODEID=tttttt/mdl,mmm.ppssssssssssss,xxxx */
404 	id = store_ebcdic(id, nd->type, sizeof(nd->type), '/');
405 	id = store_ebcdic(id, nd->model, sizeof(nd->model), ',');
406 	id = store_ebcdic(id, nd->manufacturer, sizeof(nd->manufacturer), '.');
407 	id = store_ebcdic(id, nd->plant, sizeof(nd->plant), 0);
408 	id = store_ebcdic(id, nd->seq, sizeof(nd->seq), ',');
409 	sprintf(id, "%04X", nd->tag);
410 }
411 
412 static void chsc_process_sei_link_incident(struct chsc_sei_nt0_area *sei_area)
413 {
414 	struct lir *lir = (struct lir *) &sei_area->ccdf;
415 	char iuparams[PARAMS_LEN], iunodeid[NODEID_LEN], auparams[PARAMS_LEN],
416 	     aunodeid[NODEID_LEN];
417 
418 	CIO_CRW_EVENT(4, "chsc: link incident (rs=%02x, rs_id=%04x, iq=%02x)\n",
419 		      sei_area->rs, sei_area->rsid, sei_area->ccdf[0]);
420 
421 	/* Ignore NULL Link Incident Records. */
422 	if (lir->iq.null)
423 		return;
424 
425 	/* Inform user that a link requires maintenance actions because it has
426 	 * become degraded or not operational. Note that this log message is
427 	 * the primary intention behind a Link Incident Record. */
428 
429 	format_node_data(iuparams, iunodeid, &lir->incident_node);
430 	format_node_data(auparams, aunodeid, &lir->attached_node);
431 
432 	switch (lir->iq.class) {
433 	case LIR_IQ_CLASS_DEGRADED:
434 		pr_warn("Link degraded: RS=%02x RSID=%04x IC=%02x "
435 			"IUPARAMS=%s IUNODEID=%s AUPARAMS=%s AUNODEID=%s\n",
436 			sei_area->rs, sei_area->rsid, lir->ic, iuparams,
437 			iunodeid, auparams, aunodeid);
438 		break;
439 	case LIR_IQ_CLASS_NOT_OPERATIONAL:
440 		pr_err("Link stopped: RS=%02x RSID=%04x IC=%02x "
441 		       "IUPARAMS=%s IUNODEID=%s AUPARAMS=%s AUNODEID=%s\n",
442 		       sei_area->rs, sei_area->rsid, lir->ic, iuparams,
443 		       iunodeid, auparams, aunodeid);
444 		break;
445 	default:
446 		break;
447 	}
448 }
449 
450 static void chsc_process_sei_res_acc(struct chsc_sei_nt0_area *sei_area)
451 {
452 	struct channel_path *chp;
453 	struct chp_link link;
454 	struct chp_id chpid;
455 	int status;
456 
457 	CIO_CRW_EVENT(4, "chsc: resource accessibility event (rs=%02x, "
458 		      "rs_id=%04x)\n", sei_area->rs, sei_area->rsid);
459 	if (sei_area->rs != 4)
460 		return;
461 	chp_id_init(&chpid);
462 	chpid.id = sei_area->rsid;
463 	/* allocate a new channel path structure, if needed */
464 	status = chp_get_status(chpid);
465 	if (!status)
466 		return;
467 
468 	if (status < 0) {
469 		chp_new(chpid);
470 	} else {
471 		chp = chpid_to_chp(chpid);
472 		mutex_lock(&chp->lock);
473 		chp_update_desc(chp);
474 		mutex_unlock(&chp->lock);
475 	}
476 	memset(&link, 0, sizeof(struct chp_link));
477 	link.chpid = chpid;
478 	chsc_link_from_sei(&link, sei_area);
479 	s390_process_res_acc(&link);
480 }
481 
482 static void chsc_process_sei_chp_avail(struct chsc_sei_nt0_area *sei_area)
483 {
484 	struct channel_path *chp;
485 	struct chp_id chpid;
486 	u8 *data;
487 	int num;
488 
489 	CIO_CRW_EVENT(4, "chsc: channel path availability information\n");
490 	if (sei_area->rs != 0)
491 		return;
492 	data = sei_area->ccdf;
493 	chp_id_init(&chpid);
494 	for (num = 0; num <= __MAX_CHPID; num++) {
495 		if (!chp_test_bit(data, num))
496 			continue;
497 		chpid.id = num;
498 
499 		CIO_CRW_EVENT(4, "Update information for channel path "
500 			      "%x.%02x\n", chpid.cssid, chpid.id);
501 		chp = chpid_to_chp(chpid);
502 		if (!chp) {
503 			chp_new(chpid);
504 			continue;
505 		}
506 		mutex_lock(&chp->lock);
507 		chp_update_desc(chp);
508 		mutex_unlock(&chp->lock);
509 	}
510 }
511 
512 struct chp_config_data {
513 	u8 map[32];
514 	u8 op;
515 	u8 pc;
516 };
517 
518 static void chsc_process_sei_chp_config(struct chsc_sei_nt0_area *sei_area)
519 {
520 	struct chp_config_data *data;
521 	struct chp_id chpid;
522 	int num;
523 	char *events[3] = {"configure", "deconfigure", "cancel deconfigure"};
524 
525 	CIO_CRW_EVENT(4, "chsc: channel-path-configuration notification\n");
526 	if (sei_area->rs != 0)
527 		return;
528 	data = (struct chp_config_data *) &(sei_area->ccdf);
529 	chp_id_init(&chpid);
530 	for (num = 0; num <= __MAX_CHPID; num++) {
531 		if (!chp_test_bit(data->map, num))
532 			continue;
533 		chpid.id = num;
534 		pr_notice("Processing %s for channel path %x.%02x\n",
535 			  events[data->op], chpid.cssid, chpid.id);
536 		switch (data->op) {
537 		case 0:
538 			chp_cfg_schedule(chpid, 1);
539 			break;
540 		case 1:
541 			chp_cfg_schedule(chpid, 0);
542 			break;
543 		case 2:
544 			chp_cfg_cancel_deconfigure(chpid);
545 			break;
546 		}
547 	}
548 }
549 
550 static void chsc_process_sei_scm_change(struct chsc_sei_nt0_area *sei_area)
551 {
552 	int ret;
553 
554 	CIO_CRW_EVENT(4, "chsc: scm change notification\n");
555 	if (sei_area->rs != 7)
556 		return;
557 
558 	ret = scm_update_information();
559 	if (ret)
560 		CIO_CRW_EVENT(0, "chsc: updating change notification"
561 			      " failed (rc=%d).\n", ret);
562 }
563 
564 static void chsc_process_sei_scm_avail(struct chsc_sei_nt0_area *sei_area)
565 {
566 	int ret;
567 
568 	CIO_CRW_EVENT(4, "chsc: scm available information\n");
569 	if (sei_area->rs != 7)
570 		return;
571 
572 	ret = scm_process_availability_information();
573 	if (ret)
574 		CIO_CRW_EVENT(0, "chsc: process availability information"
575 			      " failed (rc=%d).\n", ret);
576 }
577 
578 static void chsc_process_sei_ap_cfg_chg(struct chsc_sei_nt0_area *sei_area)
579 {
580 	CIO_CRW_EVENT(3, "chsc: ap config changed\n");
581 	if (sei_area->rs != 5)
582 		return;
583 
584 	ap_bus_cfg_chg();
585 }
586 
587 static void chsc_process_sei_fces_event(struct chsc_sei_nt0_area *sei_area)
588 {
589 	struct chp_link link;
590 	struct chp_id chpid;
591 	struct channel_path *chp;
592 
593 	CIO_CRW_EVENT(4,
594 	"chsc: FCES status notification (rs=%02x, rs_id=%04x, FCES-status=%x)\n",
595 		sei_area->rs, sei_area->rsid, sei_area->ccdf[0]);
596 
597 	if (sei_area->rs != SEI_RS_CHPID)
598 		return;
599 	chp_id_init(&chpid);
600 	chpid.id = sei_area->rsid;
601 
602 	/* Ignore the event on unknown/invalid chp */
603 	chp = chpid_to_chp(chpid);
604 	if (!chp)
605 		return;
606 
607 	memset(&link, 0, sizeof(struct chp_link));
608 	link.chpid = chpid;
609 	chsc_link_from_sei(&link, sei_area);
610 
611 	for_each_subchannel_staged(process_fces_event, NULL, &link);
612 }
613 
614 static void chsc_process_sei_nt2(struct chsc_sei_nt2_area *sei_area)
615 {
616 	switch (sei_area->cc) {
617 	case 1:
618 		zpci_event_error(sei_area->ccdf);
619 		break;
620 	case 2:
621 		zpci_event_availability(sei_area->ccdf);
622 		break;
623 	default:
624 		CIO_CRW_EVENT(2, "chsc: sei nt2 unhandled cc=%d\n",
625 			      sei_area->cc);
626 		break;
627 	}
628 }
629 
630 static void chsc_process_sei_nt0(struct chsc_sei_nt0_area *sei_area)
631 {
632 	/* which kind of information was stored? */
633 	switch (sei_area->cc) {
634 	case 1: /* link incident*/
635 		chsc_process_sei_link_incident(sei_area);
636 		break;
637 	case 2: /* i/o resource accessibility */
638 		chsc_process_sei_res_acc(sei_area);
639 		break;
640 	case 3: /* ap config changed */
641 		chsc_process_sei_ap_cfg_chg(sei_area);
642 		break;
643 	case 7: /* channel-path-availability information */
644 		chsc_process_sei_chp_avail(sei_area);
645 		break;
646 	case 8: /* channel-path-configuration notification */
647 		chsc_process_sei_chp_config(sei_area);
648 		break;
649 	case 12: /* scm change notification */
650 		chsc_process_sei_scm_change(sei_area);
651 		break;
652 	case 14: /* scm available notification */
653 		chsc_process_sei_scm_avail(sei_area);
654 		break;
655 	case 15: /* FCES event notification */
656 		chsc_process_sei_fces_event(sei_area);
657 		break;
658 	default: /* other stuff */
659 		CIO_CRW_EVENT(2, "chsc: sei nt0 unhandled cc=%d\n",
660 			      sei_area->cc);
661 		break;
662 	}
663 
664 	/* Check if we might have lost some information. */
665 	if (sei_area->flags & 0x40) {
666 		CIO_CRW_EVENT(2, "chsc: event overflow\n");
667 		css_schedule_eval_all();
668 	}
669 }
670 
671 static void chsc_process_event_information(struct chsc_sei *sei, u64 ntsm)
672 {
673 	static int ntsm_unsupported;
674 
675 	while (true) {
676 		memset(sei, 0, sizeof(*sei));
677 		sei->request.length = 0x0010;
678 		sei->request.code = 0x000e;
679 		if (!ntsm_unsupported)
680 			sei->ntsm = ntsm;
681 
682 		if (chsc(sei))
683 			break;
684 
685 		if (sei->response.code != 0x0001) {
686 			CIO_CRW_EVENT(2, "chsc: sei failed (rc=%04x, ntsm=%llx)\n",
687 				      sei->response.code, sei->ntsm);
688 
689 			if (sei->response.code == 3 && sei->ntsm) {
690 				/* Fallback for old firmware. */
691 				ntsm_unsupported = 1;
692 				continue;
693 			}
694 			break;
695 		}
696 
697 		CIO_CRW_EVENT(2, "chsc: sei successful (nt=%d)\n", sei->nt);
698 		switch (sei->nt) {
699 		case 0:
700 			chsc_process_sei_nt0(&sei->u.nt0_area);
701 			break;
702 		case 2:
703 			chsc_process_sei_nt2(&sei->u.nt2_area);
704 			break;
705 		default:
706 			CIO_CRW_EVENT(2, "chsc: unhandled nt: %d\n", sei->nt);
707 			break;
708 		}
709 
710 		if (!(sei->u.nt0_area.flags & 0x80))
711 			break;
712 	}
713 }
714 
715 /*
716  * Handle channel subsystem related CRWs.
717  * Use store event information to find out what's going on.
718  *
719  * Note: Access to sei_page is serialized through machine check handler
720  * thread, so no need for locking.
721  */
722 static void chsc_process_crw(struct crw *crw0, struct crw *crw1, int overflow)
723 {
724 	struct chsc_sei *sei = sei_page;
725 
726 	if (overflow) {
727 		css_schedule_eval_all();
728 		return;
729 	}
730 	CIO_CRW_EVENT(2, "CRW reports slct=%d, oflw=%d, "
731 		      "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
732 		      crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc,
733 		      crw0->erc, crw0->rsid);
734 
735 	CIO_TRACE_EVENT(2, "prcss");
736 	chsc_process_event_information(sei, CHSC_SEI_NT0 | CHSC_SEI_NT2);
737 }
738 
739 void chsc_chp_online(struct chp_id chpid)
740 {
741 	struct channel_path *chp = chpid_to_chp(chpid);
742 	struct chp_link link;
743 	char dbf_txt[15];
744 
745 	sprintf(dbf_txt, "cadd%x.%02x", chpid.cssid, chpid.id);
746 	CIO_TRACE_EVENT(2, dbf_txt);
747 
748 	if (chp_get_status(chpid) != 0) {
749 		memset(&link, 0, sizeof(struct chp_link));
750 		link.chpid = chpid;
751 		/* Wait until previous actions have settled. */
752 		css_wait_for_slow_path();
753 
754 		mutex_lock(&chp->lock);
755 		chp_update_desc(chp);
756 		mutex_unlock(&chp->lock);
757 
758 		for_each_subchannel_staged(__s390_process_res_acc, NULL,
759 					   &link);
760 		css_schedule_reprobe();
761 	}
762 }
763 
764 static void __s390_subchannel_vary_chpid(struct subchannel *sch,
765 					 struct chp_id chpid, int on)
766 {
767 	unsigned long flags;
768 	struct chp_link link;
769 
770 	memset(&link, 0, sizeof(struct chp_link));
771 	link.chpid = chpid;
772 	spin_lock_irqsave(sch->lock, flags);
773 	if (sch->driver && sch->driver->chp_event)
774 		sch->driver->chp_event(sch, &link,
775 				       on ? CHP_VARY_ON : CHP_VARY_OFF);
776 	spin_unlock_irqrestore(sch->lock, flags);
777 }
778 
779 static int s390_subchannel_vary_chpid_off(struct subchannel *sch, void *data)
780 {
781 	struct chp_id *chpid = data;
782 
783 	__s390_subchannel_vary_chpid(sch, *chpid, 0);
784 	return 0;
785 }
786 
787 static int s390_subchannel_vary_chpid_on(struct subchannel *sch, void *data)
788 {
789 	struct chp_id *chpid = data;
790 
791 	__s390_subchannel_vary_chpid(sch, *chpid, 1);
792 	return 0;
793 }
794 
795 /**
796  * chsc_chp_vary - propagate channel-path vary operation to subchannels
797  * @chpid: channl-path ID
798  * @on: non-zero for vary online, zero for vary offline
799  */
800 int chsc_chp_vary(struct chp_id chpid, int on)
801 {
802 	struct channel_path *chp = chpid_to_chp(chpid);
803 
804 	/*
805 	 * Redo PathVerification on the devices the chpid connects to
806 	 */
807 	if (on) {
808 		/* Try to update the channel path description. */
809 		chp_update_desc(chp);
810 		for_each_subchannel_staged(s390_subchannel_vary_chpid_on,
811 					   NULL, &chpid);
812 		css_schedule_reprobe();
813 	} else
814 		for_each_subchannel_staged(s390_subchannel_vary_chpid_off,
815 					   NULL, &chpid);
816 
817 	return 0;
818 }
819 
820 static void
821 chsc_remove_cmg_attr(struct channel_subsystem *css)
822 {
823 	int i;
824 
825 	for (i = 0; i <= __MAX_CHPID; i++) {
826 		if (!css->chps[i])
827 			continue;
828 		chp_remove_cmg_attr(css->chps[i]);
829 	}
830 }
831 
832 static int
833 chsc_add_cmg_attr(struct channel_subsystem *css)
834 {
835 	int i, ret;
836 
837 	ret = 0;
838 	for (i = 0; i <= __MAX_CHPID; i++) {
839 		if (!css->chps[i])
840 			continue;
841 		ret = chp_add_cmg_attr(css->chps[i]);
842 		if (ret)
843 			goto cleanup;
844 	}
845 	return ret;
846 cleanup:
847 	for (--i; i >= 0; i--) {
848 		if (!css->chps[i])
849 			continue;
850 		chp_remove_cmg_attr(css->chps[i]);
851 	}
852 	return ret;
853 }
854 
855 int __chsc_do_secm(struct channel_subsystem *css, int enable)
856 {
857 	struct {
858 		struct chsc_header request;
859 		u32 operation_code : 2;
860 		u32 : 30;
861 		u32 key : 4;
862 		u32 : 28;
863 		u32 zeroes1;
864 		u32 cub_addr1;
865 		u32 zeroes2;
866 		u32 cub_addr2;
867 		u32 reserved[13];
868 		struct chsc_header response;
869 		u32 status : 8;
870 		u32 : 4;
871 		u32 fmt : 4;
872 		u32 : 16;
873 	} *secm_area;
874 	unsigned long flags;
875 	int ret, ccode;
876 
877 	spin_lock_irqsave(&chsc_page_lock, flags);
878 	memset(chsc_page, 0, PAGE_SIZE);
879 	secm_area = chsc_page;
880 	secm_area->request.length = 0x0050;
881 	secm_area->request.code = 0x0016;
882 
883 	secm_area->key = PAGE_DEFAULT_KEY >> 4;
884 	secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1;
885 	secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2;
886 
887 	secm_area->operation_code = enable ? 0 : 1;
888 
889 	ccode = chsc(secm_area);
890 	if (ccode > 0) {
891 		ret = (ccode == 3) ? -ENODEV : -EBUSY;
892 		goto out;
893 	}
894 
895 	switch (secm_area->response.code) {
896 	case 0x0102:
897 	case 0x0103:
898 		ret = -EINVAL;
899 		break;
900 	default:
901 		ret = chsc_error_from_response(secm_area->response.code);
902 	}
903 	if (ret != 0)
904 		CIO_CRW_EVENT(2, "chsc: secm failed (rc=%04x)\n",
905 			      secm_area->response.code);
906 out:
907 	spin_unlock_irqrestore(&chsc_page_lock, flags);
908 	return ret;
909 }
910 
911 int
912 chsc_secm(struct channel_subsystem *css, int enable)
913 {
914 	int ret;
915 
916 	if (enable && !css->cm_enabled) {
917 		css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
918 		css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
919 		if (!css->cub_addr1 || !css->cub_addr2) {
920 			free_page((unsigned long)css->cub_addr1);
921 			free_page((unsigned long)css->cub_addr2);
922 			return -ENOMEM;
923 		}
924 	}
925 	ret = __chsc_do_secm(css, enable);
926 	if (!ret) {
927 		css->cm_enabled = enable;
928 		if (css->cm_enabled) {
929 			ret = chsc_add_cmg_attr(css);
930 			if (ret) {
931 				__chsc_do_secm(css, 0);
932 				css->cm_enabled = 0;
933 			}
934 		} else
935 			chsc_remove_cmg_attr(css);
936 	}
937 	if (!css->cm_enabled) {
938 		free_page((unsigned long)css->cub_addr1);
939 		free_page((unsigned long)css->cub_addr2);
940 	}
941 	return ret;
942 }
943 
944 int chsc_determine_channel_path_desc(struct chp_id chpid, int fmt, int rfmt,
945 				     int c, int m, void *page)
946 {
947 	struct chsc_scpd *scpd_area;
948 	int ccode, ret;
949 
950 	if ((rfmt == 1 || rfmt == 0) && c == 1 &&
951 	    !css_general_characteristics.fcs)
952 		return -EINVAL;
953 	if ((rfmt == 2) && !css_general_characteristics.cib)
954 		return -EINVAL;
955 	if ((rfmt == 3) && !css_general_characteristics.util_str)
956 		return -EINVAL;
957 
958 	memset(page, 0, PAGE_SIZE);
959 	scpd_area = page;
960 	scpd_area->request.length = 0x0010;
961 	scpd_area->request.code = 0x0002;
962 	scpd_area->cssid = chpid.cssid;
963 	scpd_area->first_chpid = chpid.id;
964 	scpd_area->last_chpid = chpid.id;
965 	scpd_area->m = m;
966 	scpd_area->c = c;
967 	scpd_area->fmt = fmt;
968 	scpd_area->rfmt = rfmt;
969 
970 	ccode = chsc(scpd_area);
971 	if (ccode > 0)
972 		return (ccode == 3) ? -ENODEV : -EBUSY;
973 
974 	ret = chsc_error_from_response(scpd_area->response.code);
975 	if (ret)
976 		CIO_CRW_EVENT(2, "chsc: scpd failed (rc=%04x)\n",
977 			      scpd_area->response.code);
978 	return ret;
979 }
980 EXPORT_SYMBOL_GPL(chsc_determine_channel_path_desc);
981 
982 #define chsc_det_chp_desc(FMT, c)					\
983 int chsc_determine_fmt##FMT##_channel_path_desc(			\
984 	struct chp_id chpid, struct channel_path_desc_fmt##FMT *desc)	\
985 {									\
986 	struct chsc_scpd *scpd_area;					\
987 	unsigned long flags;						\
988 	int ret;							\
989 									\
990 	spin_lock_irqsave(&chsc_page_lock, flags);			\
991 	scpd_area = chsc_page;						\
992 	ret = chsc_determine_channel_path_desc(chpid, 0, FMT, c, 0,	\
993 					       scpd_area);		\
994 	if (ret)							\
995 		goto out;						\
996 									\
997 	memcpy(desc, scpd_area->data, sizeof(*desc));			\
998 out:									\
999 	spin_unlock_irqrestore(&chsc_page_lock, flags);			\
1000 	return ret;							\
1001 }
1002 
1003 chsc_det_chp_desc(0, 0)
1004 chsc_det_chp_desc(1, 1)
1005 chsc_det_chp_desc(3, 0)
1006 
1007 static void
1008 chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv,
1009 			  struct cmg_chars *chars)
1010 {
1011 	int i, mask;
1012 
1013 	for (i = 0; i < NR_MEASUREMENT_CHARS; i++) {
1014 		mask = 0x80 >> (i + 3);
1015 		if (cmcv & mask)
1016 			chp->cmg_chars.values[i] = chars->values[i];
1017 		else
1018 			chp->cmg_chars.values[i] = 0;
1019 	}
1020 }
1021 
1022 int chsc_get_channel_measurement_chars(struct channel_path *chp)
1023 {
1024 	unsigned long flags;
1025 	int ccode, ret;
1026 
1027 	struct {
1028 		struct chsc_header request;
1029 		u32 : 24;
1030 		u32 first_chpid : 8;
1031 		u32 : 24;
1032 		u32 last_chpid : 8;
1033 		u32 zeroes1;
1034 		struct chsc_header response;
1035 		u32 zeroes2;
1036 		u32 not_valid : 1;
1037 		u32 shared : 1;
1038 		u32 : 22;
1039 		u32 chpid : 8;
1040 		u32 cmcv : 5;
1041 		u32 : 11;
1042 		u32 cmgq : 8;
1043 		u32 cmg : 8;
1044 		u32 zeroes3;
1045 		u32 data[NR_MEASUREMENT_CHARS];
1046 	} *scmc_area;
1047 
1048 	chp->shared = -1;
1049 	chp->cmg = -1;
1050 
1051 	if (!css_chsc_characteristics.scmc || !css_chsc_characteristics.secm)
1052 		return -EINVAL;
1053 
1054 	spin_lock_irqsave(&chsc_page_lock, flags);
1055 	memset(chsc_page, 0, PAGE_SIZE);
1056 	scmc_area = chsc_page;
1057 	scmc_area->request.length = 0x0010;
1058 	scmc_area->request.code = 0x0022;
1059 	scmc_area->first_chpid = chp->chpid.id;
1060 	scmc_area->last_chpid = chp->chpid.id;
1061 
1062 	ccode = chsc(scmc_area);
1063 	if (ccode > 0) {
1064 		ret = (ccode == 3) ? -ENODEV : -EBUSY;
1065 		goto out;
1066 	}
1067 
1068 	ret = chsc_error_from_response(scmc_area->response.code);
1069 	if (ret) {
1070 		CIO_CRW_EVENT(2, "chsc: scmc failed (rc=%04x)\n",
1071 			      scmc_area->response.code);
1072 		goto out;
1073 	}
1074 	if (scmc_area->not_valid)
1075 		goto out;
1076 
1077 	chp->cmg = scmc_area->cmg;
1078 	chp->shared = scmc_area->shared;
1079 	if (chp->cmg != 2 && chp->cmg != 3) {
1080 		/* No cmg-dependent data. */
1081 		goto out;
1082 	}
1083 	chsc_initialize_cmg_chars(chp, scmc_area->cmcv,
1084 				  (struct cmg_chars *) &scmc_area->data);
1085 out:
1086 	spin_unlock_irqrestore(&chsc_page_lock, flags);
1087 	return ret;
1088 }
1089 
1090 int __init chsc_init(void)
1091 {
1092 	int ret;
1093 
1094 	sei_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1095 	chsc_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1096 	if (!sei_page || !chsc_page) {
1097 		ret = -ENOMEM;
1098 		goto out_err;
1099 	}
1100 	ret = crw_register_handler(CRW_RSC_CSS, chsc_process_crw);
1101 	if (ret)
1102 		goto out_err;
1103 	return ret;
1104 out_err:
1105 	free_page((unsigned long)chsc_page);
1106 	free_page((unsigned long)sei_page);
1107 	return ret;
1108 }
1109 
1110 void __init chsc_init_cleanup(void)
1111 {
1112 	crw_unregister_handler(CRW_RSC_CSS);
1113 	free_page((unsigned long)chsc_page);
1114 	free_page((unsigned long)sei_page);
1115 }
1116 
1117 int __chsc_enable_facility(struct chsc_sda_area *sda_area, int operation_code)
1118 {
1119 	int ret;
1120 
1121 	sda_area->request.length = 0x0400;
1122 	sda_area->request.code = 0x0031;
1123 	sda_area->operation_code = operation_code;
1124 
1125 	ret = chsc(sda_area);
1126 	if (ret > 0) {
1127 		ret = (ret == 3) ? -ENODEV : -EBUSY;
1128 		goto out;
1129 	}
1130 
1131 	switch (sda_area->response.code) {
1132 	case 0x0101:
1133 		ret = -EOPNOTSUPP;
1134 		break;
1135 	default:
1136 		ret = chsc_error_from_response(sda_area->response.code);
1137 	}
1138 out:
1139 	return ret;
1140 }
1141 
1142 int chsc_enable_facility(int operation_code)
1143 {
1144 	struct chsc_sda_area *sda_area;
1145 	unsigned long flags;
1146 	int ret;
1147 
1148 	spin_lock_irqsave(&chsc_page_lock, flags);
1149 	memset(chsc_page, 0, PAGE_SIZE);
1150 	sda_area = chsc_page;
1151 
1152 	ret = __chsc_enable_facility(sda_area, operation_code);
1153 	if (ret != 0)
1154 		CIO_CRW_EVENT(2, "chsc: sda (oc=%x) failed (rc=%04x)\n",
1155 			      operation_code, sda_area->response.code);
1156 
1157 	spin_unlock_irqrestore(&chsc_page_lock, flags);
1158 	return ret;
1159 }
1160 
1161 int __init chsc_get_cssid_iid(int idx, u8 *cssid, u8 *iid)
1162 {
1163 	struct {
1164 		struct chsc_header request;
1165 		u8 atype;
1166 		u32 : 24;
1167 		u32 reserved1[6];
1168 		struct chsc_header response;
1169 		u32 reserved2[3];
1170 		struct {
1171 			u8 cssid;
1172 			u8 iid;
1173 			u32 : 16;
1174 		} list[0];
1175 	} *sdcal_area;
1176 	int ret;
1177 
1178 	spin_lock_irq(&chsc_page_lock);
1179 	memset(chsc_page, 0, PAGE_SIZE);
1180 	sdcal_area = chsc_page;
1181 	sdcal_area->request.length = 0x0020;
1182 	sdcal_area->request.code = 0x0034;
1183 	sdcal_area->atype = 4;
1184 
1185 	ret = chsc(sdcal_area);
1186 	if (ret) {
1187 		ret = (ret == 3) ? -ENODEV : -EBUSY;
1188 		goto exit;
1189 	}
1190 
1191 	ret = chsc_error_from_response(sdcal_area->response.code);
1192 	if (ret) {
1193 		CIO_CRW_EVENT(2, "chsc: sdcal failed (rc=%04x)\n",
1194 			      sdcal_area->response.code);
1195 		goto exit;
1196 	}
1197 
1198 	if ((addr_t) &sdcal_area->list[idx] <
1199 	    (addr_t) &sdcal_area->response + sdcal_area->response.length) {
1200 		*cssid = sdcal_area->list[idx].cssid;
1201 		*iid = sdcal_area->list[idx].iid;
1202 	}
1203 	else
1204 		ret = -ENODEV;
1205 exit:
1206 	spin_unlock_irq(&chsc_page_lock);
1207 	return ret;
1208 }
1209 
1210 struct css_general_char css_general_characteristics;
1211 struct css_chsc_char css_chsc_characteristics;
1212 
1213 int __init
1214 chsc_determine_css_characteristics(void)
1215 {
1216 	unsigned long flags;
1217 	int result;
1218 	struct {
1219 		struct chsc_header request;
1220 		u32 reserved1;
1221 		u32 reserved2;
1222 		u32 reserved3;
1223 		struct chsc_header response;
1224 		u32 reserved4;
1225 		u32 general_char[510];
1226 		u32 chsc_char[508];
1227 	} *scsc_area;
1228 
1229 	spin_lock_irqsave(&chsc_page_lock, flags);
1230 	memset(chsc_page, 0, PAGE_SIZE);
1231 	scsc_area = chsc_page;
1232 	scsc_area->request.length = 0x0010;
1233 	scsc_area->request.code = 0x0010;
1234 
1235 	result = chsc(scsc_area);
1236 	if (result) {
1237 		result = (result == 3) ? -ENODEV : -EBUSY;
1238 		goto exit;
1239 	}
1240 
1241 	result = chsc_error_from_response(scsc_area->response.code);
1242 	if (result == 0) {
1243 		memcpy(&css_general_characteristics, scsc_area->general_char,
1244 		       sizeof(css_general_characteristics));
1245 		memcpy(&css_chsc_characteristics, scsc_area->chsc_char,
1246 		       sizeof(css_chsc_characteristics));
1247 	} else
1248 		CIO_CRW_EVENT(2, "chsc: scsc failed (rc=%04x)\n",
1249 			      scsc_area->response.code);
1250 exit:
1251 	spin_unlock_irqrestore(&chsc_page_lock, flags);
1252 	return result;
1253 }
1254 
1255 EXPORT_SYMBOL_GPL(css_general_characteristics);
1256 EXPORT_SYMBOL_GPL(css_chsc_characteristics);
1257 
1258 int chsc_sstpc(void *page, unsigned int op, u16 ctrl, u64 *clock_delta)
1259 {
1260 	struct {
1261 		struct chsc_header request;
1262 		unsigned int rsvd0;
1263 		unsigned int op : 8;
1264 		unsigned int rsvd1 : 8;
1265 		unsigned int ctrl : 16;
1266 		unsigned int rsvd2[5];
1267 		struct chsc_header response;
1268 		unsigned int rsvd3[3];
1269 		u64 clock_delta;
1270 		unsigned int rsvd4[2];
1271 	} *rr;
1272 	int rc;
1273 
1274 	memset(page, 0, PAGE_SIZE);
1275 	rr = page;
1276 	rr->request.length = 0x0020;
1277 	rr->request.code = 0x0033;
1278 	rr->op = op;
1279 	rr->ctrl = ctrl;
1280 	rc = chsc(rr);
1281 	if (rc)
1282 		return -EIO;
1283 	rc = (rr->response.code == 0x0001) ? 0 : -EIO;
1284 	if (clock_delta)
1285 		*clock_delta = rr->clock_delta;
1286 	return rc;
1287 }
1288 
1289 int chsc_sstpi(void *page, void *result, size_t size)
1290 {
1291 	struct {
1292 		struct chsc_header request;
1293 		unsigned int rsvd0[3];
1294 		struct chsc_header response;
1295 		char data[];
1296 	} *rr;
1297 	int rc;
1298 
1299 	memset(page, 0, PAGE_SIZE);
1300 	rr = page;
1301 	rr->request.length = 0x0010;
1302 	rr->request.code = 0x0038;
1303 	rc = chsc(rr);
1304 	if (rc)
1305 		return -EIO;
1306 	memcpy(result, &rr->data, size);
1307 	return (rr->response.code == 0x0001) ? 0 : -EIO;
1308 }
1309 
1310 int chsc_stzi(void *page, void *result, size_t size)
1311 {
1312 	struct {
1313 		struct chsc_header request;
1314 		unsigned int rsvd0[3];
1315 		struct chsc_header response;
1316 		char data[];
1317 	} *rr;
1318 	int rc;
1319 
1320 	memset(page, 0, PAGE_SIZE);
1321 	rr = page;
1322 	rr->request.length = 0x0010;
1323 	rr->request.code = 0x003e;
1324 	rc = chsc(rr);
1325 	if (rc)
1326 		return -EIO;
1327 	memcpy(result, &rr->data, size);
1328 	return (rr->response.code == 0x0001) ? 0 : -EIO;
1329 }
1330 
1331 int chsc_siosl(struct subchannel_id schid)
1332 {
1333 	struct {
1334 		struct chsc_header request;
1335 		u32 word1;
1336 		struct subchannel_id sid;
1337 		u32 word3;
1338 		struct chsc_header response;
1339 		u32 word[11];
1340 	} *siosl_area;
1341 	unsigned long flags;
1342 	int ccode;
1343 	int rc;
1344 
1345 	spin_lock_irqsave(&chsc_page_lock, flags);
1346 	memset(chsc_page, 0, PAGE_SIZE);
1347 	siosl_area = chsc_page;
1348 	siosl_area->request.length = 0x0010;
1349 	siosl_area->request.code = 0x0046;
1350 	siosl_area->word1 = 0x80000000;
1351 	siosl_area->sid = schid;
1352 
1353 	ccode = chsc(siosl_area);
1354 	if (ccode > 0) {
1355 		if (ccode == 3)
1356 			rc = -ENODEV;
1357 		else
1358 			rc = -EBUSY;
1359 		CIO_MSG_EVENT(2, "chsc: chsc failed for 0.%x.%04x (ccode=%d)\n",
1360 			      schid.ssid, schid.sch_no, ccode);
1361 		goto out;
1362 	}
1363 	rc = chsc_error_from_response(siosl_area->response.code);
1364 	if (rc)
1365 		CIO_MSG_EVENT(2, "chsc: siosl failed for 0.%x.%04x (rc=%04x)\n",
1366 			      schid.ssid, schid.sch_no,
1367 			      siosl_area->response.code);
1368 	else
1369 		CIO_MSG_EVENT(4, "chsc: siosl succeeded for 0.%x.%04x\n",
1370 			      schid.ssid, schid.sch_no);
1371 out:
1372 	spin_unlock_irqrestore(&chsc_page_lock, flags);
1373 	return rc;
1374 }
1375 EXPORT_SYMBOL_GPL(chsc_siosl);
1376 
1377 /**
1378  * chsc_scm_info() - store SCM information (SSI)
1379  * @scm_area: request and response block for SSI
1380  * @token: continuation token
1381  *
1382  * Returns 0 on success.
1383  */
1384 int chsc_scm_info(struct chsc_scm_info *scm_area, u64 token)
1385 {
1386 	int ccode, ret;
1387 
1388 	memset(scm_area, 0, sizeof(*scm_area));
1389 	scm_area->request.length = 0x0020;
1390 	scm_area->request.code = 0x004C;
1391 	scm_area->reqtok = token;
1392 
1393 	ccode = chsc(scm_area);
1394 	if (ccode > 0) {
1395 		ret = (ccode == 3) ? -ENODEV : -EBUSY;
1396 		goto out;
1397 	}
1398 	ret = chsc_error_from_response(scm_area->response.code);
1399 	if (ret != 0)
1400 		CIO_MSG_EVENT(2, "chsc: scm info failed (rc=%04x)\n",
1401 			      scm_area->response.code);
1402 out:
1403 	return ret;
1404 }
1405 EXPORT_SYMBOL_GPL(chsc_scm_info);
1406 
1407 /**
1408  * chsc_pnso() - Perform Network-Subchannel Operation
1409  * @schid:		id of the subchannel on which PNSO is performed
1410  * @pnso_area:		request and response block for the operation
1411  * @oc:			Operation Code
1412  * @resume_token:	resume token for multiblock response
1413  * @cnc:		Boolean change-notification control
1414  *
1415  * pnso_area must be allocated by the caller with get_zeroed_page(GFP_KERNEL)
1416  *
1417  * Returns 0 on success.
1418  */
1419 int chsc_pnso(struct subchannel_id schid, struct chsc_pnso_area *pnso_area,
1420 	      u8 oc, struct chsc_pnso_resume_token resume_token, int cnc)
1421 {
1422 	memset(pnso_area, 0, sizeof(*pnso_area));
1423 	pnso_area->request.length = 0x0030;
1424 	pnso_area->request.code = 0x003d; /* network-subchannel operation */
1425 	pnso_area->m	   = schid.m;
1426 	pnso_area->ssid  = schid.ssid;
1427 	pnso_area->sch	 = schid.sch_no;
1428 	pnso_area->cssid = schid.cssid;
1429 	pnso_area->oc	 = oc;
1430 	pnso_area->resume_token = resume_token;
1431 	pnso_area->n	   = (cnc != 0);
1432 	if (chsc(pnso_area))
1433 		return -EIO;
1434 	return chsc_error_from_response(pnso_area->response.code);
1435 }
1436 
1437 int chsc_sgib(u32 origin)
1438 {
1439 	struct {
1440 		struct chsc_header request;
1441 		u16 op;
1442 		u8  reserved01[2];
1443 		u8  reserved02:4;
1444 		u8  fmt:4;
1445 		u8  reserved03[7];
1446 		/* operation data area begin */
1447 		u8  reserved04[4];
1448 		u32 gib_origin;
1449 		u8  reserved05[10];
1450 		u8  aix;
1451 		u8  reserved06[4029];
1452 		struct chsc_header response;
1453 		u8  reserved07[4];
1454 	} *sgib_area;
1455 	int ret;
1456 
1457 	spin_lock_irq(&chsc_page_lock);
1458 	memset(chsc_page, 0, PAGE_SIZE);
1459 	sgib_area = chsc_page;
1460 	sgib_area->request.length = 0x0fe0;
1461 	sgib_area->request.code = 0x0021;
1462 	sgib_area->op = 0x1;
1463 	sgib_area->gib_origin = origin;
1464 
1465 	ret = chsc(sgib_area);
1466 	if (ret == 0)
1467 		ret = chsc_error_from_response(sgib_area->response.code);
1468 	spin_unlock_irq(&chsc_page_lock);
1469 
1470 	return ret;
1471 }
1472 EXPORT_SYMBOL_GPL(chsc_sgib);
1473 
1474 #define SCUD_REQ_LEN	0x10 /* SCUD request block length */
1475 #define SCUD_REQ_CMD	0x4b /* SCUD Command Code */
1476 
1477 struct chse_cudb {
1478 	u16 flags:8;
1479 	u16 chp_valid:8;
1480 	u16 cu;
1481 	u32 esm_valid:8;
1482 	u32:24;
1483 	u8 chpid[8];
1484 	u32:32;
1485 	u32:32;
1486 	u8 esm[8];
1487 	u32 efla[8];
1488 } __packed;
1489 
1490 struct chsc_scud {
1491 	struct chsc_header request;
1492 	u16:4;
1493 	u16 fmt:4;
1494 	u16 cssid:8;
1495 	u16 first_cu;
1496 	u16:16;
1497 	u16 last_cu;
1498 	u32:32;
1499 	struct chsc_header response;
1500 	u16:4;
1501 	u16 fmt_resp:4;
1502 	u32:24;
1503 	struct chse_cudb cudb[];
1504 } __packed;
1505 
1506 /**
1507  * chsc_scud() - Store control-unit description.
1508  * @cu:		number of the control-unit
1509  * @esm:	8 1-byte endpoint security mode values
1510  * @esm_valid:	validity mask for @esm
1511  *
1512  * Interface to retrieve information about the endpoint security
1513  * modes for up to 8 paths of a control unit.
1514  *
1515  * Returns 0 on success.
1516  */
1517 int chsc_scud(u16 cu, u64 *esm, u8 *esm_valid)
1518 {
1519 	struct chsc_scud *scud = chsc_page;
1520 	int ret;
1521 
1522 	spin_lock_irq(&chsc_page_lock);
1523 	memset(chsc_page, 0, PAGE_SIZE);
1524 	scud->request.length = SCUD_REQ_LEN;
1525 	scud->request.code = SCUD_REQ_CMD;
1526 	scud->fmt = 0;
1527 	scud->cssid = 0;
1528 	scud->first_cu = cu;
1529 	scud->last_cu = cu;
1530 
1531 	ret = chsc(scud);
1532 	if (!ret)
1533 		ret = chsc_error_from_response(scud->response.code);
1534 
1535 	if (!ret && (scud->response.length <= 8 || scud->fmt_resp != 0
1536 			|| !(scud->cudb[0].flags & 0x80)
1537 			|| scud->cudb[0].cu != cu)) {
1538 
1539 		CIO_MSG_EVENT(2, "chsc: scud failed rc=%04x, L2=%04x "
1540 			"FMT=%04x, cudb.flags=%02x, cudb.cu=%04x",
1541 			scud->response.code, scud->response.length,
1542 			scud->fmt_resp, scud->cudb[0].flags, scud->cudb[0].cu);
1543 		ret = -EINVAL;
1544 	}
1545 
1546 	if (ret)
1547 		goto out;
1548 
1549 	memcpy(esm, scud->cudb[0].esm, sizeof(*esm));
1550 	*esm_valid = scud->cudb[0].esm_valid;
1551 out:
1552 	spin_unlock_irq(&chsc_page_lock);
1553 	return ret;
1554 }
1555 EXPORT_SYMBOL_GPL(chsc_scud);
1556