xref: /linux/drivers/s390/cio/cio.c (revision b7019ac550eb3916f34d79db583e9b7ea2524afa) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *   S/390 common I/O routines -- low level i/o calls
4  *
5  *    Copyright IBM Corp. 1999, 2008
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  *		 Martin Schwidefsky (schwidefsky@de.ibm.com)
10  */
11 
12 #define KMSG_COMPONENT "cio"
13 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
14 
15 #include <linux/ftrace.h>
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/slab.h>
19 #include <linux/device.h>
20 #include <linux/kernel_stat.h>
21 #include <linux/interrupt.h>
22 #include <linux/irq.h>
23 #include <asm/cio.h>
24 #include <asm/delay.h>
25 #include <asm/irq.h>
26 #include <asm/irq_regs.h>
27 #include <asm/setup.h>
28 #include <asm/ipl.h>
29 #include <asm/chpid.h>
30 #include <asm/airq.h>
31 #include <asm/isc.h>
32 #include <linux/sched/cputime.h>
33 #include <asm/fcx.h>
34 #include <asm/nmi.h>
35 #include <asm/crw.h>
36 #include "cio.h"
37 #include "css.h"
38 #include "chsc.h"
39 #include "ioasm.h"
40 #include "io_sch.h"
41 #include "blacklist.h"
42 #include "cio_debug.h"
43 #include "chp.h"
44 #include "trace.h"
45 
46 debug_info_t *cio_debug_msg_id;
47 debug_info_t *cio_debug_trace_id;
48 debug_info_t *cio_debug_crw_id;
49 
50 DEFINE_PER_CPU_ALIGNED(struct irb, cio_irb);
51 EXPORT_PER_CPU_SYMBOL(cio_irb);
52 
53 /*
54  * Function: cio_debug_init
55  * Initializes three debug logs for common I/O:
56  * - cio_msg logs generic cio messages
57  * - cio_trace logs the calling of different functions
58  * - cio_crw logs machine check related cio messages
59  */
60 static int __init cio_debug_init(void)
61 {
62 	cio_debug_msg_id = debug_register("cio_msg", 16, 1, 11 * sizeof(long));
63 	if (!cio_debug_msg_id)
64 		goto out_unregister;
65 	debug_register_view(cio_debug_msg_id, &debug_sprintf_view);
66 	debug_set_level(cio_debug_msg_id, 2);
67 	cio_debug_trace_id = debug_register("cio_trace", 16, 1, 16);
68 	if (!cio_debug_trace_id)
69 		goto out_unregister;
70 	debug_register_view(cio_debug_trace_id, &debug_hex_ascii_view);
71 	debug_set_level(cio_debug_trace_id, 2);
72 	cio_debug_crw_id = debug_register("cio_crw", 8, 1, 8 * sizeof(long));
73 	if (!cio_debug_crw_id)
74 		goto out_unregister;
75 	debug_register_view(cio_debug_crw_id, &debug_sprintf_view);
76 	debug_set_level(cio_debug_crw_id, 4);
77 	return 0;
78 
79 out_unregister:
80 	debug_unregister(cio_debug_msg_id);
81 	debug_unregister(cio_debug_trace_id);
82 	debug_unregister(cio_debug_crw_id);
83 	return -1;
84 }
85 
86 arch_initcall (cio_debug_init);
87 
88 int cio_set_options(struct subchannel *sch, int flags)
89 {
90 	struct io_subchannel_private *priv = to_io_private(sch);
91 
92 	priv->options.suspend = (flags & DOIO_ALLOW_SUSPEND) != 0;
93 	priv->options.prefetch = (flags & DOIO_DENY_PREFETCH) != 0;
94 	priv->options.inter = (flags & DOIO_SUPPRESS_INTER) != 0;
95 	return 0;
96 }
97 
98 static int
99 cio_start_handle_notoper(struct subchannel *sch, __u8 lpm)
100 {
101 	char dbf_text[15];
102 
103 	if (lpm != 0)
104 		sch->lpm &= ~lpm;
105 	else
106 		sch->lpm = 0;
107 
108 	CIO_MSG_EVENT(2, "cio_start: 'not oper' status for "
109 		      "subchannel 0.%x.%04x!\n", sch->schid.ssid,
110 		      sch->schid.sch_no);
111 
112 	if (cio_update_schib(sch))
113 		return -ENODEV;
114 
115 	sprintf(dbf_text, "no%s", dev_name(&sch->dev));
116 	CIO_TRACE_EVENT(0, dbf_text);
117 	CIO_HEX_EVENT(0, &sch->schib, sizeof (struct schib));
118 
119 	return (sch->lpm ? -EACCES : -ENODEV);
120 }
121 
122 int
123 cio_start_key (struct subchannel *sch,	/* subchannel structure */
124 	       struct ccw1 * cpa,	/* logical channel prog addr */
125 	       __u8 lpm,		/* logical path mask */
126 	       __u8 key)                /* storage key */
127 {
128 	struct io_subchannel_private *priv = to_io_private(sch);
129 	union orb *orb = &priv->orb;
130 	int ccode;
131 
132 	CIO_TRACE_EVENT(5, "stIO");
133 	CIO_TRACE_EVENT(5, dev_name(&sch->dev));
134 
135 	memset(orb, 0, sizeof(union orb));
136 	/* sch is always under 2G. */
137 	orb->cmd.intparm = (u32)(addr_t)sch;
138 	orb->cmd.fmt = 1;
139 
140 	orb->cmd.pfch = priv->options.prefetch == 0;
141 	orb->cmd.spnd = priv->options.suspend;
142 	orb->cmd.ssic = priv->options.suspend && priv->options.inter;
143 	orb->cmd.lpm = (lpm != 0) ? lpm : sch->lpm;
144 	/*
145 	 * for 64 bit we always support 64 bit IDAWs with 4k page size only
146 	 */
147 	orb->cmd.c64 = 1;
148 	orb->cmd.i2k = 0;
149 	orb->cmd.key = key >> 4;
150 	/* issue "Start Subchannel" */
151 	orb->cmd.cpa = (__u32) __pa(cpa);
152 	ccode = ssch(sch->schid, orb);
153 
154 	/* process condition code */
155 	CIO_HEX_EVENT(5, &ccode, sizeof(ccode));
156 
157 	switch (ccode) {
158 	case 0:
159 		/*
160 		 * initialize device status information
161 		 */
162 		sch->schib.scsw.cmd.actl |= SCSW_ACTL_START_PEND;
163 		return 0;
164 	case 1:		/* status pending */
165 	case 2:		/* busy */
166 		return -EBUSY;
167 	case 3:		/* device/path not operational */
168 		return cio_start_handle_notoper(sch, lpm);
169 	default:
170 		return ccode;
171 	}
172 }
173 EXPORT_SYMBOL_GPL(cio_start_key);
174 
175 int
176 cio_start (struct subchannel *sch, struct ccw1 *cpa, __u8 lpm)
177 {
178 	return cio_start_key(sch, cpa, lpm, PAGE_DEFAULT_KEY);
179 }
180 EXPORT_SYMBOL_GPL(cio_start);
181 
182 /*
183  * resume suspended I/O operation
184  */
185 int
186 cio_resume (struct subchannel *sch)
187 {
188 	int ccode;
189 
190 	CIO_TRACE_EVENT(4, "resIO");
191 	CIO_TRACE_EVENT(4, dev_name(&sch->dev));
192 
193 	ccode = rsch (sch->schid);
194 
195 	CIO_HEX_EVENT(4, &ccode, sizeof(ccode));
196 
197 	switch (ccode) {
198 	case 0:
199 		sch->schib.scsw.cmd.actl |= SCSW_ACTL_RESUME_PEND;
200 		return 0;
201 	case 1:
202 		return -EBUSY;
203 	case 2:
204 		return -EINVAL;
205 	default:
206 		/*
207 		 * useless to wait for request completion
208 		 *  as device is no longer operational !
209 		 */
210 		return -ENODEV;
211 	}
212 }
213 EXPORT_SYMBOL_GPL(cio_resume);
214 
215 /*
216  * halt I/O operation
217  */
218 int
219 cio_halt(struct subchannel *sch)
220 {
221 	int ccode;
222 
223 	if (!sch)
224 		return -ENODEV;
225 
226 	CIO_TRACE_EVENT(2, "haltIO");
227 	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
228 
229 	/*
230 	 * Issue "Halt subchannel" and process condition code
231 	 */
232 	ccode = hsch (sch->schid);
233 
234 	CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
235 
236 	switch (ccode) {
237 	case 0:
238 		sch->schib.scsw.cmd.actl |= SCSW_ACTL_HALT_PEND;
239 		return 0;
240 	case 1:		/* status pending */
241 	case 2:		/* busy */
242 		return -EBUSY;
243 	default:		/* device not operational */
244 		return -ENODEV;
245 	}
246 }
247 EXPORT_SYMBOL_GPL(cio_halt);
248 
249 /*
250  * Clear I/O operation
251  */
252 int
253 cio_clear(struct subchannel *sch)
254 {
255 	int ccode;
256 
257 	if (!sch)
258 		return -ENODEV;
259 
260 	CIO_TRACE_EVENT(2, "clearIO");
261 	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
262 
263 	/*
264 	 * Issue "Clear subchannel" and process condition code
265 	 */
266 	ccode = csch (sch->schid);
267 
268 	CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
269 
270 	switch (ccode) {
271 	case 0:
272 		sch->schib.scsw.cmd.actl |= SCSW_ACTL_CLEAR_PEND;
273 		return 0;
274 	default:		/* device not operational */
275 		return -ENODEV;
276 	}
277 }
278 EXPORT_SYMBOL_GPL(cio_clear);
279 
280 /*
281  * Function: cio_cancel
282  * Issues a "Cancel Subchannel" on the specified subchannel
283  * Note: We don't need any fancy intparms and flags here
284  *	 since xsch is executed synchronously.
285  * Only for common I/O internal use as for now.
286  */
287 int
288 cio_cancel (struct subchannel *sch)
289 {
290 	int ccode;
291 
292 	if (!sch)
293 		return -ENODEV;
294 
295 	CIO_TRACE_EVENT(2, "cancelIO");
296 	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
297 
298 	ccode = xsch (sch->schid);
299 
300 	CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
301 
302 	switch (ccode) {
303 	case 0:		/* success */
304 		/* Update information in scsw. */
305 		if (cio_update_schib(sch))
306 			return -ENODEV;
307 		return 0;
308 	case 1:		/* status pending */
309 		return -EBUSY;
310 	case 2:		/* not applicable */
311 		return -EINVAL;
312 	default:	/* not oper */
313 		return -ENODEV;
314 	}
315 }
316 EXPORT_SYMBOL_GPL(cio_cancel);
317 
318 /**
319  * cio_cancel_halt_clear - Cancel running I/O by performing cancel, halt
320  * and clear ordinally if subchannel is valid.
321  * @sch: subchannel on which to perform the cancel_halt_clear operation
322  * @iretry: the number of the times remained to retry the next operation
323  *
324  * This should be called repeatedly since halt/clear are asynchronous
325  * operations. We do one try with cio_cancel, three tries with cio_halt,
326  * 255 tries with cio_clear. The caller should initialize @iretry with
327  * the value 255 for its first call to this, and keep using the same
328  * @iretry in the subsequent calls until it gets a non -EBUSY return.
329  *
330  * Returns 0 if device now idle, -ENODEV for device not operational,
331  * -EBUSY if an interrupt is expected (either from halt/clear or from a
332  * status pending), and -EIO if out of retries.
333  */
334 int cio_cancel_halt_clear(struct subchannel *sch, int *iretry)
335 {
336 	int ret;
337 
338 	if (cio_update_schib(sch))
339 		return -ENODEV;
340 	if (!sch->schib.pmcw.ena)
341 		/* Not operational -> done. */
342 		return 0;
343 	/* Stage 1: cancel io. */
344 	if (!(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_HALT_PEND) &&
345 	    !(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_CLEAR_PEND)) {
346 		if (!scsw_is_tm(&sch->schib.scsw)) {
347 			ret = cio_cancel(sch);
348 			if (ret != -EINVAL)
349 				return ret;
350 		}
351 		/*
352 		 * Cancel io unsuccessful or not applicable (transport mode).
353 		 * Continue with asynchronous instructions.
354 		 */
355 		*iretry = 3;	/* 3 halt retries. */
356 	}
357 	/* Stage 2: halt io. */
358 	if (!(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_CLEAR_PEND)) {
359 		if (*iretry) {
360 			*iretry -= 1;
361 			ret = cio_halt(sch);
362 			if (ret != -EBUSY)
363 				return (ret == 0) ? -EBUSY : ret;
364 		}
365 		/* Halt io unsuccessful. */
366 		*iretry = 255;	/* 255 clear retries. */
367 	}
368 	/* Stage 3: clear io. */
369 	if (*iretry) {
370 		*iretry -= 1;
371 		ret = cio_clear(sch);
372 		return (ret == 0) ? -EBUSY : ret;
373 	}
374 	/* Function was unsuccessful */
375 	return -EIO;
376 }
377 EXPORT_SYMBOL_GPL(cio_cancel_halt_clear);
378 
379 static void cio_apply_config(struct subchannel *sch, struct schib *schib)
380 {
381 	schib->pmcw.intparm = sch->config.intparm;
382 	schib->pmcw.mbi = sch->config.mbi;
383 	schib->pmcw.isc = sch->config.isc;
384 	schib->pmcw.ena = sch->config.ena;
385 	schib->pmcw.mme = sch->config.mme;
386 	schib->pmcw.mp = sch->config.mp;
387 	schib->pmcw.csense = sch->config.csense;
388 	schib->pmcw.mbfc = sch->config.mbfc;
389 	if (sch->config.mbfc)
390 		schib->mba = sch->config.mba;
391 }
392 
393 static int cio_check_config(struct subchannel *sch, struct schib *schib)
394 {
395 	return (schib->pmcw.intparm == sch->config.intparm) &&
396 		(schib->pmcw.mbi == sch->config.mbi) &&
397 		(schib->pmcw.isc == sch->config.isc) &&
398 		(schib->pmcw.ena == sch->config.ena) &&
399 		(schib->pmcw.mme == sch->config.mme) &&
400 		(schib->pmcw.mp == sch->config.mp) &&
401 		(schib->pmcw.csense == sch->config.csense) &&
402 		(schib->pmcw.mbfc == sch->config.mbfc) &&
403 		(!sch->config.mbfc || (schib->mba == sch->config.mba));
404 }
405 
406 /*
407  * cio_commit_config - apply configuration to the subchannel
408  */
409 int cio_commit_config(struct subchannel *sch)
410 {
411 	int ccode, retry, ret = 0;
412 	struct schib schib;
413 	struct irb irb;
414 
415 	if (stsch(sch->schid, &schib) || !css_sch_is_valid(&schib))
416 		return -ENODEV;
417 
418 	for (retry = 0; retry < 5; retry++) {
419 		/* copy desired changes to local schib */
420 		cio_apply_config(sch, &schib);
421 		ccode = msch(sch->schid, &schib);
422 		if (ccode < 0) /* -EIO if msch gets a program check. */
423 			return ccode;
424 		switch (ccode) {
425 		case 0: /* successful */
426 			if (stsch(sch->schid, &schib) ||
427 			    !css_sch_is_valid(&schib))
428 				return -ENODEV;
429 			if (cio_check_config(sch, &schib)) {
430 				/* commit changes from local schib */
431 				memcpy(&sch->schib, &schib, sizeof(schib));
432 				return 0;
433 			}
434 			ret = -EAGAIN;
435 			break;
436 		case 1: /* status pending */
437 			ret = -EBUSY;
438 			if (tsch(sch->schid, &irb))
439 				return ret;
440 			break;
441 		case 2: /* busy */
442 			udelay(100); /* allow for recovery */
443 			ret = -EBUSY;
444 			break;
445 		case 3: /* not operational */
446 			return -ENODEV;
447 		}
448 	}
449 	return ret;
450 }
451 EXPORT_SYMBOL_GPL(cio_commit_config);
452 
453 /**
454  * cio_update_schib - Perform stsch and update schib if subchannel is valid.
455  * @sch: subchannel on which to perform stsch
456  * Return zero on success, -ENODEV otherwise.
457  */
458 int cio_update_schib(struct subchannel *sch)
459 {
460 	struct schib schib;
461 
462 	if (stsch(sch->schid, &schib) || !css_sch_is_valid(&schib))
463 		return -ENODEV;
464 
465 	memcpy(&sch->schib, &schib, sizeof(schib));
466 	return 0;
467 }
468 EXPORT_SYMBOL_GPL(cio_update_schib);
469 
470 /**
471  * cio_enable_subchannel - enable a subchannel.
472  * @sch: subchannel to be enabled
473  * @intparm: interruption parameter to set
474  */
475 int cio_enable_subchannel(struct subchannel *sch, u32 intparm)
476 {
477 	int ret;
478 
479 	CIO_TRACE_EVENT(2, "ensch");
480 	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
481 
482 	if (sch_is_pseudo_sch(sch))
483 		return -EINVAL;
484 	if (cio_update_schib(sch))
485 		return -ENODEV;
486 
487 	sch->config.ena = 1;
488 	sch->config.isc = sch->isc;
489 	sch->config.intparm = intparm;
490 
491 	ret = cio_commit_config(sch);
492 	if (ret == -EIO) {
493 		/*
494 		 * Got a program check in msch. Try without
495 		 * the concurrent sense bit the next time.
496 		 */
497 		sch->config.csense = 0;
498 		ret = cio_commit_config(sch);
499 	}
500 	CIO_HEX_EVENT(2, &ret, sizeof(ret));
501 	return ret;
502 }
503 EXPORT_SYMBOL_GPL(cio_enable_subchannel);
504 
505 /**
506  * cio_disable_subchannel - disable a subchannel.
507  * @sch: subchannel to disable
508  */
509 int cio_disable_subchannel(struct subchannel *sch)
510 {
511 	int ret;
512 
513 	CIO_TRACE_EVENT(2, "dissch");
514 	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
515 
516 	if (sch_is_pseudo_sch(sch))
517 		return 0;
518 	if (cio_update_schib(sch))
519 		return -ENODEV;
520 
521 	sch->config.ena = 0;
522 	ret = cio_commit_config(sch);
523 
524 	CIO_HEX_EVENT(2, &ret, sizeof(ret));
525 	return ret;
526 }
527 EXPORT_SYMBOL_GPL(cio_disable_subchannel);
528 
529 /*
530  * do_cio_interrupt() handles all normal I/O device IRQ's
531  */
532 static irqreturn_t do_cio_interrupt(int irq, void *dummy)
533 {
534 	struct tpi_info *tpi_info;
535 	struct subchannel *sch;
536 	struct irb *irb;
537 
538 	set_cpu_flag(CIF_NOHZ_DELAY);
539 	tpi_info = (struct tpi_info *) &get_irq_regs()->int_code;
540 	trace_s390_cio_interrupt(tpi_info);
541 	irb = this_cpu_ptr(&cio_irb);
542 	sch = (struct subchannel *)(unsigned long) tpi_info->intparm;
543 	if (!sch) {
544 		/* Clear pending interrupt condition. */
545 		inc_irq_stat(IRQIO_CIO);
546 		tsch(tpi_info->schid, irb);
547 		return IRQ_HANDLED;
548 	}
549 	spin_lock(sch->lock);
550 	/* Store interrupt response block to lowcore. */
551 	if (tsch(tpi_info->schid, irb) == 0) {
552 		/* Keep subchannel information word up to date. */
553 		memcpy (&sch->schib.scsw, &irb->scsw, sizeof (irb->scsw));
554 		/* Call interrupt handler if there is one. */
555 		if (sch->driver && sch->driver->irq)
556 			sch->driver->irq(sch);
557 		else
558 			inc_irq_stat(IRQIO_CIO);
559 	} else
560 		inc_irq_stat(IRQIO_CIO);
561 	spin_unlock(sch->lock);
562 
563 	return IRQ_HANDLED;
564 }
565 
566 static struct irqaction io_interrupt = {
567 	.name	 = "I/O",
568 	.handler = do_cio_interrupt,
569 };
570 
571 void __init init_cio_interrupts(void)
572 {
573 	irq_set_chip_and_handler(IO_INTERRUPT,
574 				 &dummy_irq_chip, handle_percpu_irq);
575 	setup_irq(IO_INTERRUPT, &io_interrupt);
576 }
577 
578 #ifdef CONFIG_CCW_CONSOLE
579 static struct subchannel *console_sch;
580 static struct lock_class_key console_sch_key;
581 
582 /*
583  * Use cio_tsch to update the subchannel status and call the interrupt handler
584  * if status had been pending. Called with the subchannel's lock held.
585  */
586 void cio_tsch(struct subchannel *sch)
587 {
588 	struct irb *irb;
589 	int irq_context;
590 
591 	irb = this_cpu_ptr(&cio_irb);
592 	/* Store interrupt response block to lowcore. */
593 	if (tsch(sch->schid, irb) != 0)
594 		/* Not status pending or not operational. */
595 		return;
596 	memcpy(&sch->schib.scsw, &irb->scsw, sizeof(union scsw));
597 	/* Call interrupt handler with updated status. */
598 	irq_context = in_interrupt();
599 	if (!irq_context) {
600 		local_bh_disable();
601 		irq_enter();
602 	}
603 	kstat_incr_irq_this_cpu(IO_INTERRUPT);
604 	if (sch->driver && sch->driver->irq)
605 		sch->driver->irq(sch);
606 	else
607 		inc_irq_stat(IRQIO_CIO);
608 	if (!irq_context) {
609 		irq_exit();
610 		_local_bh_enable();
611 	}
612 }
613 
614 static int cio_test_for_console(struct subchannel_id schid, void *data)
615 {
616 	struct schib schib;
617 
618 	if (stsch(schid, &schib) != 0)
619 		return -ENXIO;
620 	if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv &&
621 	    (schib.pmcw.dev == console_devno)) {
622 		console_irq = schid.sch_no;
623 		return 1; /* found */
624 	}
625 	return 0;
626 }
627 
628 static int cio_get_console_sch_no(void)
629 {
630 	struct subchannel_id schid;
631 	struct schib schib;
632 
633 	init_subchannel_id(&schid);
634 	if (console_irq != -1) {
635 		/* VM provided us with the irq number of the console. */
636 		schid.sch_no = console_irq;
637 		if (stsch(schid, &schib) != 0 ||
638 		    (schib.pmcw.st != SUBCHANNEL_TYPE_IO) || !schib.pmcw.dnv)
639 			return -1;
640 		console_devno = schib.pmcw.dev;
641 	} else if (console_devno != -1) {
642 		/* At least the console device number is known. */
643 		for_each_subchannel(cio_test_for_console, NULL);
644 	}
645 	return console_irq;
646 }
647 
648 struct subchannel *cio_probe_console(void)
649 {
650 	struct subchannel_id schid;
651 	struct subchannel *sch;
652 	struct schib schib;
653 	int sch_no, ret;
654 
655 	sch_no = cio_get_console_sch_no();
656 	if (sch_no == -1) {
657 		pr_warn("No CCW console was found\n");
658 		return ERR_PTR(-ENODEV);
659 	}
660 	init_subchannel_id(&schid);
661 	schid.sch_no = sch_no;
662 	ret = stsch(schid, &schib);
663 	if (ret)
664 		return ERR_PTR(-ENODEV);
665 
666 	sch = css_alloc_subchannel(schid, &schib);
667 	if (IS_ERR(sch))
668 		return sch;
669 
670 	lockdep_set_class(sch->lock, &console_sch_key);
671 	isc_register(CONSOLE_ISC);
672 	sch->config.isc = CONSOLE_ISC;
673 	sch->config.intparm = (u32)(addr_t)sch;
674 	ret = cio_commit_config(sch);
675 	if (ret) {
676 		isc_unregister(CONSOLE_ISC);
677 		put_device(&sch->dev);
678 		return ERR_PTR(ret);
679 	}
680 	console_sch = sch;
681 	return sch;
682 }
683 
684 int cio_is_console(struct subchannel_id schid)
685 {
686 	if (!console_sch)
687 		return 0;
688 	return schid_equal(&schid, &console_sch->schid);
689 }
690 
691 void cio_register_early_subchannels(void)
692 {
693 	int ret;
694 
695 	if (!console_sch)
696 		return;
697 
698 	ret = css_register_subchannel(console_sch);
699 	if (ret)
700 		put_device(&console_sch->dev);
701 }
702 #endif /* CONFIG_CCW_CONSOLE */
703 
704 /**
705  * cio_tm_start_key - perform start function
706  * @sch: subchannel on which to perform the start function
707  * @tcw: transport-command word to be started
708  * @lpm: mask of paths to use
709  * @key: storage key to use for storage access
710  *
711  * Start the tcw on the given subchannel. Return zero on success, non-zero
712  * otherwise.
713  */
714 int cio_tm_start_key(struct subchannel *sch, struct tcw *tcw, u8 lpm, u8 key)
715 {
716 	int cc;
717 	union orb *orb = &to_io_private(sch)->orb;
718 
719 	memset(orb, 0, sizeof(union orb));
720 	orb->tm.intparm = (u32) (addr_t) sch;
721 	orb->tm.key = key >> 4;
722 	orb->tm.b = 1;
723 	orb->tm.lpm = lpm ? lpm : sch->lpm;
724 	orb->tm.tcw = (u32) (addr_t) tcw;
725 	cc = ssch(sch->schid, orb);
726 	switch (cc) {
727 	case 0:
728 		return 0;
729 	case 1:
730 	case 2:
731 		return -EBUSY;
732 	default:
733 		return cio_start_handle_notoper(sch, lpm);
734 	}
735 }
736 EXPORT_SYMBOL_GPL(cio_tm_start_key);
737 
738 /**
739  * cio_tm_intrg - perform interrogate function
740  * @sch: subchannel on which to perform the interrogate function
741  *
742  * If the specified subchannel is running in transport-mode, perform the
743  * interrogate function. Return zero on success, non-zero otherwie.
744  */
745 int cio_tm_intrg(struct subchannel *sch)
746 {
747 	int cc;
748 
749 	if (!to_io_private(sch)->orb.tm.b)
750 		return -EINVAL;
751 	cc = xsch(sch->schid);
752 	switch (cc) {
753 	case 0:
754 	case 2:
755 		return 0;
756 	case 1:
757 		return -EBUSY;
758 	default:
759 		return -ENODEV;
760 	}
761 }
762 EXPORT_SYMBOL_GPL(cio_tm_intrg);
763