xref: /openbmc/linux/drivers/s390/cio/cio.c (revision 39b6f3aa) 
1 /*
2  *   S/390 common I/O routines -- low level i/o calls
3  *
4  *    Copyright IBM Corp. 1999, 2008
5  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
6  *		 Cornelia Huck (cornelia.huck@de.ibm.com)
7  *		 Arnd Bergmann (arndb@de.ibm.com)
8  *		 Martin Schwidefsky (schwidefsky@de.ibm.com)
9  */
10 
11 #define KMSG_COMPONENT "cio"
12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 
14 #include <linux/ftrace.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/slab.h>
18 #include <linux/device.h>
19 #include <linux/kernel_stat.h>
20 #include <linux/interrupt.h>
21 #include <asm/cio.h>
22 #include <asm/delay.h>
23 #include <asm/irq.h>
24 #include <asm/irq_regs.h>
25 #include <asm/setup.h>
26 #include <asm/reset.h>
27 #include <asm/ipl.h>
28 #include <asm/chpid.h>
29 #include <asm/airq.h>
30 #include <asm/isc.h>
31 #include <asm/cputime.h>
32 #include <asm/fcx.h>
33 #include <asm/nmi.h>
34 #include <asm/crw.h>
35 #include "cio.h"
36 #include "css.h"
37 #include "chsc.h"
38 #include "ioasm.h"
39 #include "io_sch.h"
40 #include "blacklist.h"
41 #include "cio_debug.h"
42 #include "chp.h"
43 
44 debug_info_t *cio_debug_msg_id;
45 debug_info_t *cio_debug_trace_id;
46 debug_info_t *cio_debug_crw_id;
47 
48 /*
49  * Function: cio_debug_init
50  * Initializes three debug logs for common I/O:
51  * - cio_msg logs generic cio messages
52  * - cio_trace logs the calling of different functions
53  * - cio_crw logs machine check related cio messages
54  */
55 static int __init cio_debug_init(void)
56 {
57 	cio_debug_msg_id = debug_register("cio_msg", 16, 1, 16 * sizeof(long));
58 	if (!cio_debug_msg_id)
59 		goto out_unregister;
60 	debug_register_view(cio_debug_msg_id, &debug_sprintf_view);
61 	debug_set_level(cio_debug_msg_id, 2);
62 	cio_debug_trace_id = debug_register("cio_trace", 16, 1, 16);
63 	if (!cio_debug_trace_id)
64 		goto out_unregister;
65 	debug_register_view(cio_debug_trace_id, &debug_hex_ascii_view);
66 	debug_set_level(cio_debug_trace_id, 2);
67 	cio_debug_crw_id = debug_register("cio_crw", 16, 1, 16 * sizeof(long));
68 	if (!cio_debug_crw_id)
69 		goto out_unregister;
70 	debug_register_view(cio_debug_crw_id, &debug_sprintf_view);
71 	debug_set_level(cio_debug_crw_id, 4);
72 	return 0;
73 
74 out_unregister:
75 	if (cio_debug_msg_id)
76 		debug_unregister(cio_debug_msg_id);
77 	if (cio_debug_trace_id)
78 		debug_unregister(cio_debug_trace_id);
79 	if (cio_debug_crw_id)
80 		debug_unregister(cio_debug_crw_id);
81 	return -1;
82 }
83 
84 arch_initcall (cio_debug_init);
85 
86 int cio_set_options(struct subchannel *sch, int flags)
87 {
88 	struct io_subchannel_private *priv = to_io_private(sch);
89 
90 	priv->options.suspend = (flags & DOIO_ALLOW_SUSPEND) != 0;
91 	priv->options.prefetch = (flags & DOIO_DENY_PREFETCH) != 0;
92 	priv->options.inter = (flags & DOIO_SUPPRESS_INTER) != 0;
93 	return 0;
94 }
95 
96 static int
97 cio_start_handle_notoper(struct subchannel *sch, __u8 lpm)
98 {
99 	char dbf_text[15];
100 
101 	if (lpm != 0)
102 		sch->lpm &= ~lpm;
103 	else
104 		sch->lpm = 0;
105 
106 	CIO_MSG_EVENT(2, "cio_start: 'not oper' status for "
107 		      "subchannel 0.%x.%04x!\n", sch->schid.ssid,
108 		      sch->schid.sch_no);
109 
110 	if (cio_update_schib(sch))
111 		return -ENODEV;
112 
113 	sprintf(dbf_text, "no%s", dev_name(&sch->dev));
114 	CIO_TRACE_EVENT(0, dbf_text);
115 	CIO_HEX_EVENT(0, &sch->schib, sizeof (struct schib));
116 
117 	return (sch->lpm ? -EACCES : -ENODEV);
118 }
119 
120 int
121 cio_start_key (struct subchannel *sch,	/* subchannel structure */
122 	       struct ccw1 * cpa,	/* logical channel prog addr */
123 	       __u8 lpm,		/* logical path mask */
124 	       __u8 key)                /* storage key */
125 {
126 	struct io_subchannel_private *priv = to_io_private(sch);
127 	union orb *orb = &priv->orb;
128 	int ccode;
129 
130 	CIO_TRACE_EVENT(5, "stIO");
131 	CIO_TRACE_EVENT(5, dev_name(&sch->dev));
132 
133 	memset(orb, 0, sizeof(union orb));
134 	/* sch is always under 2G. */
135 	orb->cmd.intparm = (u32)(addr_t)sch;
136 	orb->cmd.fmt = 1;
137 
138 	orb->cmd.pfch = priv->options.prefetch == 0;
139 	orb->cmd.spnd = priv->options.suspend;
140 	orb->cmd.ssic = priv->options.suspend && priv->options.inter;
141 	orb->cmd.lpm = (lpm != 0) ? lpm : sch->lpm;
142 #ifdef CONFIG_64BIT
143 	/*
144 	 * for 64 bit we always support 64 bit IDAWs with 4k page size only
145 	 */
146 	orb->cmd.c64 = 1;
147 	orb->cmd.i2k = 0;
148 #endif
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 
174 int
175 cio_start (struct subchannel *sch, struct ccw1 *cpa, __u8 lpm)
176 {
177 	return cio_start_key(sch, cpa, lpm, PAGE_DEFAULT_KEY);
178 }
179 
180 /*
181  * resume suspended I/O operation
182  */
183 int
184 cio_resume (struct subchannel *sch)
185 {
186 	int ccode;
187 
188 	CIO_TRACE_EVENT(4, "resIO");
189 	CIO_TRACE_EVENT(4, dev_name(&sch->dev));
190 
191 	ccode = rsch (sch->schid);
192 
193 	CIO_HEX_EVENT(4, &ccode, sizeof(ccode));
194 
195 	switch (ccode) {
196 	case 0:
197 		sch->schib.scsw.cmd.actl |= SCSW_ACTL_RESUME_PEND;
198 		return 0;
199 	case 1:
200 		return -EBUSY;
201 	case 2:
202 		return -EINVAL;
203 	default:
204 		/*
205 		 * useless to wait for request completion
206 		 *  as device is no longer operational !
207 		 */
208 		return -ENODEV;
209 	}
210 }
211 
212 /*
213  * halt I/O operation
214  */
215 int
216 cio_halt(struct subchannel *sch)
217 {
218 	int ccode;
219 
220 	if (!sch)
221 		return -ENODEV;
222 
223 	CIO_TRACE_EVENT(2, "haltIO");
224 	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
225 
226 	/*
227 	 * Issue "Halt subchannel" and process condition code
228 	 */
229 	ccode = hsch (sch->schid);
230 
231 	CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
232 
233 	switch (ccode) {
234 	case 0:
235 		sch->schib.scsw.cmd.actl |= SCSW_ACTL_HALT_PEND;
236 		return 0;
237 	case 1:		/* status pending */
238 	case 2:		/* busy */
239 		return -EBUSY;
240 	default:		/* device not operational */
241 		return -ENODEV;
242 	}
243 }
244 
245 /*
246  * Clear I/O operation
247  */
248 int
249 cio_clear(struct subchannel *sch)
250 {
251 	int ccode;
252 
253 	if (!sch)
254 		return -ENODEV;
255 
256 	CIO_TRACE_EVENT(2, "clearIO");
257 	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
258 
259 	/*
260 	 * Issue "Clear subchannel" and process condition code
261 	 */
262 	ccode = csch (sch->schid);
263 
264 	CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
265 
266 	switch (ccode) {
267 	case 0:
268 		sch->schib.scsw.cmd.actl |= SCSW_ACTL_CLEAR_PEND;
269 		return 0;
270 	default:		/* device not operational */
271 		return -ENODEV;
272 	}
273 }
274 
275 /*
276  * Function: cio_cancel
277  * Issues a "Cancel Subchannel" on the specified subchannel
278  * Note: We don't need any fancy intparms and flags here
279  *	 since xsch is executed synchronously.
280  * Only for common I/O internal use as for now.
281  */
282 int
283 cio_cancel (struct subchannel *sch)
284 {
285 	int ccode;
286 
287 	if (!sch)
288 		return -ENODEV;
289 
290 	CIO_TRACE_EVENT(2, "cancelIO");
291 	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
292 
293 	ccode = xsch (sch->schid);
294 
295 	CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
296 
297 	switch (ccode) {
298 	case 0:		/* success */
299 		/* Update information in scsw. */
300 		if (cio_update_schib(sch))
301 			return -ENODEV;
302 		return 0;
303 	case 1:		/* status pending */
304 		return -EBUSY;
305 	case 2:		/* not applicable */
306 		return -EINVAL;
307 	default:	/* not oper */
308 		return -ENODEV;
309 	}
310 }
311 
312 
313 static void cio_apply_config(struct subchannel *sch, struct schib *schib)
314 {
315 	schib->pmcw.intparm = sch->config.intparm;
316 	schib->pmcw.mbi = sch->config.mbi;
317 	schib->pmcw.isc = sch->config.isc;
318 	schib->pmcw.ena = sch->config.ena;
319 	schib->pmcw.mme = sch->config.mme;
320 	schib->pmcw.mp = sch->config.mp;
321 	schib->pmcw.csense = sch->config.csense;
322 	schib->pmcw.mbfc = sch->config.mbfc;
323 	if (sch->config.mbfc)
324 		schib->mba = sch->config.mba;
325 }
326 
327 static int cio_check_config(struct subchannel *sch, struct schib *schib)
328 {
329 	return (schib->pmcw.intparm == sch->config.intparm) &&
330 		(schib->pmcw.mbi == sch->config.mbi) &&
331 		(schib->pmcw.isc == sch->config.isc) &&
332 		(schib->pmcw.ena == sch->config.ena) &&
333 		(schib->pmcw.mme == sch->config.mme) &&
334 		(schib->pmcw.mp == sch->config.mp) &&
335 		(schib->pmcw.csense == sch->config.csense) &&
336 		(schib->pmcw.mbfc == sch->config.mbfc) &&
337 		(!sch->config.mbfc || (schib->mba == sch->config.mba));
338 }
339 
340 /*
341  * cio_commit_config - apply configuration to the subchannel
342  */
343 int cio_commit_config(struct subchannel *sch)
344 {
345 	struct schib schib;
346 	int ccode, retry, ret = 0;
347 
348 	if (stsch_err(sch->schid, &schib) || !css_sch_is_valid(&schib))
349 		return -ENODEV;
350 
351 	for (retry = 0; retry < 5; retry++) {
352 		/* copy desired changes to local schib */
353 		cio_apply_config(sch, &schib);
354 		ccode = msch_err(sch->schid, &schib);
355 		if (ccode < 0) /* -EIO if msch gets a program check. */
356 			return ccode;
357 		switch (ccode) {
358 		case 0: /* successful */
359 			if (stsch_err(sch->schid, &schib) ||
360 			    !css_sch_is_valid(&schib))
361 				return -ENODEV;
362 			if (cio_check_config(sch, &schib)) {
363 				/* commit changes from local schib */
364 				memcpy(&sch->schib, &schib, sizeof(schib));
365 				return 0;
366 			}
367 			ret = -EAGAIN;
368 			break;
369 		case 1: /* status pending */
370 			return -EBUSY;
371 		case 2: /* busy */
372 			udelay(100); /* allow for recovery */
373 			ret = -EBUSY;
374 			break;
375 		case 3: /* not operational */
376 			return -ENODEV;
377 		}
378 	}
379 	return ret;
380 }
381 
382 /**
383  * cio_update_schib - Perform stsch and update schib if subchannel is valid.
384  * @sch: subchannel on which to perform stsch
385  * Return zero on success, -ENODEV otherwise.
386  */
387 int cio_update_schib(struct subchannel *sch)
388 {
389 	struct schib schib;
390 
391 	if (stsch_err(sch->schid, &schib) || !css_sch_is_valid(&schib))
392 		return -ENODEV;
393 
394 	memcpy(&sch->schib, &schib, sizeof(schib));
395 	return 0;
396 }
397 EXPORT_SYMBOL_GPL(cio_update_schib);
398 
399 /**
400  * cio_enable_subchannel - enable a subchannel.
401  * @sch: subchannel to be enabled
402  * @intparm: interruption parameter to set
403  */
404 int cio_enable_subchannel(struct subchannel *sch, u32 intparm)
405 {
406 	int retry;
407 	int ret;
408 
409 	CIO_TRACE_EVENT(2, "ensch");
410 	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
411 
412 	if (sch_is_pseudo_sch(sch))
413 		return -EINVAL;
414 	if (cio_update_schib(sch))
415 		return -ENODEV;
416 
417 	sch->config.ena = 1;
418 	sch->config.isc = sch->isc;
419 	sch->config.intparm = intparm;
420 
421 	for (retry = 0; retry < 3; retry++) {
422 		ret = cio_commit_config(sch);
423 		if (ret == -EIO) {
424 			/*
425 			 * Got a program check in msch. Try without
426 			 * the concurrent sense bit the next time.
427 			 */
428 			sch->config.csense = 0;
429 		} else if (ret == -EBUSY) {
430 			struct irb irb;
431 			if (tsch(sch->schid, &irb) != 0)
432 				break;
433 		} else
434 			break;
435 	}
436 	CIO_HEX_EVENT(2, &ret, sizeof(ret));
437 	return ret;
438 }
439 EXPORT_SYMBOL_GPL(cio_enable_subchannel);
440 
441 /**
442  * cio_disable_subchannel - disable a subchannel.
443  * @sch: subchannel to disable
444  */
445 int cio_disable_subchannel(struct subchannel *sch)
446 {
447 	int retry;
448 	int ret;
449 
450 	CIO_TRACE_EVENT(2, "dissch");
451 	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
452 
453 	if (sch_is_pseudo_sch(sch))
454 		return 0;
455 	if (cio_update_schib(sch))
456 		return -ENODEV;
457 
458 	sch->config.ena = 0;
459 
460 	for (retry = 0; retry < 3; retry++) {
461 		ret = cio_commit_config(sch);
462 		if (ret == -EBUSY) {
463 			struct irb irb;
464 			if (tsch(sch->schid, &irb) != 0)
465 				break;
466 		} else
467 			break;
468 	}
469 	CIO_HEX_EVENT(2, &ret, sizeof(ret));
470 	return ret;
471 }
472 EXPORT_SYMBOL_GPL(cio_disable_subchannel);
473 
474 static int cio_check_devno_blacklisted(struct subchannel *sch)
475 {
476 	if (is_blacklisted(sch->schid.ssid, sch->schib.pmcw.dev)) {
477 		/*
478 		 * This device must not be known to Linux. So we simply
479 		 * say that there is no device and return ENODEV.
480 		 */
481 		CIO_MSG_EVENT(6, "Blacklisted device detected "
482 			      "at devno %04X, subchannel set %x\n",
483 			      sch->schib.pmcw.dev, sch->schid.ssid);
484 		return -ENODEV;
485 	}
486 	return 0;
487 }
488 
489 static int cio_validate_io_subchannel(struct subchannel *sch)
490 {
491 	/* Initialization for io subchannels. */
492 	if (!css_sch_is_valid(&sch->schib))
493 		return -ENODEV;
494 
495 	/* Devno is valid. */
496 	return cio_check_devno_blacklisted(sch);
497 }
498 
499 static int cio_validate_msg_subchannel(struct subchannel *sch)
500 {
501 	/* Initialization for message subchannels. */
502 	if (!css_sch_is_valid(&sch->schib))
503 		return -ENODEV;
504 
505 	/* Devno is valid. */
506 	return cio_check_devno_blacklisted(sch);
507 }
508 
509 /**
510  * cio_validate_subchannel - basic validation of subchannel
511  * @sch: subchannel structure to be filled out
512  * @schid: subchannel id
513  *
514  * Find out subchannel type and initialize struct subchannel.
515  * Return codes:
516  *   0 on success
517  *   -ENXIO for non-defined subchannels
518  *   -ENODEV for invalid subchannels or blacklisted devices
519  *   -EIO for subchannels in an invalid subchannel set
520  */
521 int cio_validate_subchannel(struct subchannel *sch, struct subchannel_id schid)
522 {
523 	char dbf_txt[15];
524 	int ccode;
525 	int err;
526 
527 	sprintf(dbf_txt, "valsch%x", schid.sch_no);
528 	CIO_TRACE_EVENT(4, dbf_txt);
529 
530 	/*
531 	 * The first subchannel that is not-operational (ccode==3)
532 	 * indicates that there aren't any more devices available.
533 	 * If stsch gets an exception, it means the current subchannel set
534 	 * is not valid.
535 	 */
536 	ccode = stsch_err(schid, &sch->schib);
537 	if (ccode) {
538 		err = (ccode == 3) ? -ENXIO : ccode;
539 		goto out;
540 	}
541 	sch->st = sch->schib.pmcw.st;
542 	sch->schid = schid;
543 
544 	switch (sch->st) {
545 	case SUBCHANNEL_TYPE_IO:
546 		err = cio_validate_io_subchannel(sch);
547 		break;
548 	case SUBCHANNEL_TYPE_MSG:
549 		err = cio_validate_msg_subchannel(sch);
550 		break;
551 	default:
552 		err = 0;
553 	}
554 	if (err)
555 		goto out;
556 
557 	CIO_MSG_EVENT(4, "Subchannel 0.%x.%04x reports subchannel type %04X\n",
558 		      sch->schid.ssid, sch->schid.sch_no, sch->st);
559 out:
560 	return err;
561 }
562 
563 /*
564  * do_IRQ() handles all normal I/O device IRQ's (the special
565  *	    SMP cross-CPU interrupts have their own specific
566  *	    handlers).
567  *
568  */
569 void __irq_entry do_IRQ(struct pt_regs *regs)
570 {
571 	struct tpi_info *tpi_info;
572 	struct subchannel *sch;
573 	struct irb *irb;
574 	struct pt_regs *old_regs;
575 
576 	old_regs = set_irq_regs(regs);
577 	irq_enter();
578 	__this_cpu_write(s390_idle.nohz_delay, 1);
579 	if (S390_lowcore.int_clock >= S390_lowcore.clock_comparator)
580 		/* Serve timer interrupts first. */
581 		clock_comparator_work();
582 	/*
583 	 * Get interrupt information from lowcore
584 	 */
585 	tpi_info = (struct tpi_info *)&S390_lowcore.subchannel_id;
586 	irb = (struct irb *)&S390_lowcore.irb;
587 	do {
588 		kstat_incr_irqs_this_cpu(IO_INTERRUPT, NULL);
589 		if (tpi_info->adapter_IO) {
590 			do_adapter_IO(tpi_info->isc);
591 			continue;
592 		}
593 		sch = (struct subchannel *)(unsigned long)tpi_info->intparm;
594 		if (!sch) {
595 			/* Clear pending interrupt condition. */
596 			inc_irq_stat(IRQIO_CIO);
597 			tsch(tpi_info->schid, irb);
598 			continue;
599 		}
600 		spin_lock(sch->lock);
601 		/* Store interrupt response block to lowcore. */
602 		if (tsch(tpi_info->schid, irb) == 0) {
603 			/* Keep subchannel information word up to date. */
604 			memcpy (&sch->schib.scsw, &irb->scsw,
605 				sizeof (irb->scsw));
606 			/* Call interrupt handler if there is one. */
607 			if (sch->driver && sch->driver->irq)
608 				sch->driver->irq(sch);
609 			else
610 				inc_irq_stat(IRQIO_CIO);
611 		} else
612 			inc_irq_stat(IRQIO_CIO);
613 		spin_unlock(sch->lock);
614 		/*
615 		 * Are more interrupts pending?
616 		 * If so, the tpi instruction will update the lowcore
617 		 * to hold the info for the next interrupt.
618 		 * We don't do this for VM because a tpi drops the cpu
619 		 * out of the sie which costs more cycles than it saves.
620 		 */
621 	} while (MACHINE_IS_LPAR && tpi(NULL) != 0);
622 	irq_exit();
623 	set_irq_regs(old_regs);
624 }
625 
626 #ifdef CONFIG_CCW_CONSOLE
627 static struct subchannel *console_sch;
628 
629 /*
630  * Use cio_tsch to update the subchannel status and call the interrupt handler
631  * if status had been pending. Called with the subchannel's lock held.
632  */
633 void cio_tsch(struct subchannel *sch)
634 {
635 	struct irb *irb;
636 	int irq_context;
637 
638 	irb = (struct irb *)&S390_lowcore.irb;
639 	/* Store interrupt response block to lowcore. */
640 	if (tsch(sch->schid, irb) != 0)
641 		/* Not status pending or not operational. */
642 		return;
643 	memcpy(&sch->schib.scsw, &irb->scsw, sizeof(union scsw));
644 	/* Call interrupt handler with updated status. */
645 	irq_context = in_interrupt();
646 	if (!irq_context) {
647 		local_bh_disable();
648 		irq_enter();
649 	}
650 	kstat_incr_irqs_this_cpu(IO_INTERRUPT, NULL);
651 	if (sch->driver && sch->driver->irq)
652 		sch->driver->irq(sch);
653 	else
654 		inc_irq_stat(IRQIO_CIO);
655 	if (!irq_context) {
656 		irq_exit();
657 		_local_bh_enable();
658 	}
659 }
660 
661 static int cio_test_for_console(struct subchannel_id schid, void *data)
662 {
663 	struct schib schib;
664 
665 	if (stsch_err(schid, &schib) != 0)
666 		return -ENXIO;
667 	if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv &&
668 	    (schib.pmcw.dev == console_devno)) {
669 		console_irq = schid.sch_no;
670 		return 1; /* found */
671 	}
672 	return 0;
673 }
674 
675 static int cio_get_console_sch_no(void)
676 {
677 	struct subchannel_id schid;
678 	struct schib schib;
679 
680 	init_subchannel_id(&schid);
681 	if (console_irq != -1) {
682 		/* VM provided us with the irq number of the console. */
683 		schid.sch_no = console_irq;
684 		if (stsch_err(schid, &schib) != 0 ||
685 		    (schib.pmcw.st != SUBCHANNEL_TYPE_IO) || !schib.pmcw.dnv)
686 			return -1;
687 		console_devno = schib.pmcw.dev;
688 	} else if (console_devno != -1) {
689 		/* At least the console device number is known. */
690 		for_each_subchannel(cio_test_for_console, NULL);
691 	}
692 	return console_irq;
693 }
694 
695 struct subchannel *cio_probe_console(void)
696 {
697 	struct subchannel_id schid;
698 	struct subchannel *sch;
699 	int sch_no, ret;
700 
701 	sch_no = cio_get_console_sch_no();
702 	if (sch_no == -1) {
703 		pr_warning("No CCW console was found\n");
704 		return ERR_PTR(-ENODEV);
705 	}
706 	init_subchannel_id(&schid);
707 	schid.sch_no = sch_no;
708 	sch = css_alloc_subchannel(schid);
709 	if (IS_ERR(sch))
710 		return sch;
711 
712 	isc_register(CONSOLE_ISC);
713 	sch->config.isc = CONSOLE_ISC;
714 	sch->config.intparm = (u32)(addr_t)sch;
715 	ret = cio_commit_config(sch);
716 	if (ret) {
717 		isc_unregister(CONSOLE_ISC);
718 		put_device(&sch->dev);
719 		return ERR_PTR(ret);
720 	}
721 	console_sch = sch;
722 	return sch;
723 }
724 
725 int cio_is_console(struct subchannel_id schid)
726 {
727 	if (!console_sch)
728 		return 0;
729 	return schid_equal(&schid, &console_sch->schid);
730 }
731 
732 void cio_register_early_subchannels(void)
733 {
734 	int ret;
735 
736 	if (!console_sch)
737 		return;
738 
739 	ret = css_register_subchannel(console_sch);
740 	if (ret)
741 		put_device(&console_sch->dev);
742 }
743 #endif /* CONFIG_CCW_CONSOLE */
744 
745 static int
746 __disable_subchannel_easy(struct subchannel_id schid, struct schib *schib)
747 {
748 	int retry, cc;
749 
750 	cc = 0;
751 	for (retry=0;retry<3;retry++) {
752 		schib->pmcw.ena = 0;
753 		cc = msch_err(schid, schib);
754 		if (cc)
755 			return (cc==3?-ENODEV:-EBUSY);
756 		if (stsch_err(schid, schib) || !css_sch_is_valid(schib))
757 			return -ENODEV;
758 		if (!schib->pmcw.ena)
759 			return 0;
760 	}
761 	return -EBUSY; /* uhm... */
762 }
763 
764 static int
765 __clear_io_subchannel_easy(struct subchannel_id schid)
766 {
767 	int retry;
768 
769 	if (csch(schid))
770 		return -ENODEV;
771 	for (retry=0;retry<20;retry++) {
772 		struct tpi_info ti;
773 
774 		if (tpi(&ti)) {
775 			tsch(ti.schid, (struct irb *)&S390_lowcore.irb);
776 			if (schid_equal(&ti.schid, &schid))
777 				return 0;
778 		}
779 		udelay_simple(100);
780 	}
781 	return -EBUSY;
782 }
783 
784 static void __clear_chsc_subchannel_easy(void)
785 {
786 	/* It seems we can only wait for a bit here :/ */
787 	udelay_simple(100);
788 }
789 
790 static int pgm_check_occured;
791 
792 static void cio_reset_pgm_check_handler(void)
793 {
794 	pgm_check_occured = 1;
795 }
796 
797 static int stsch_reset(struct subchannel_id schid, struct schib *addr)
798 {
799 	int rc;
800 
801 	pgm_check_occured = 0;
802 	s390_base_pgm_handler_fn = cio_reset_pgm_check_handler;
803 	rc = stsch_err(schid, addr);
804 	s390_base_pgm_handler_fn = NULL;
805 
806 	/* The program check handler could have changed pgm_check_occured. */
807 	barrier();
808 
809 	if (pgm_check_occured)
810 		return -EIO;
811 	else
812 		return rc;
813 }
814 
815 static int __shutdown_subchannel_easy(struct subchannel_id schid, void *data)
816 {
817 	struct schib schib;
818 
819 	if (stsch_reset(schid, &schib))
820 		return -ENXIO;
821 	if (!schib.pmcw.ena)
822 		return 0;
823 	switch(__disable_subchannel_easy(schid, &schib)) {
824 	case 0:
825 	case -ENODEV:
826 		break;
827 	default: /* -EBUSY */
828 		switch (schib.pmcw.st) {
829 		case SUBCHANNEL_TYPE_IO:
830 			if (__clear_io_subchannel_easy(schid))
831 				goto out; /* give up... */
832 			break;
833 		case SUBCHANNEL_TYPE_CHSC:
834 			__clear_chsc_subchannel_easy();
835 			break;
836 		default:
837 			/* No default clear strategy */
838 			break;
839 		}
840 		stsch_err(schid, &schib);
841 		__disable_subchannel_easy(schid, &schib);
842 	}
843 out:
844 	return 0;
845 }
846 
847 static atomic_t chpid_reset_count;
848 
849 static void s390_reset_chpids_mcck_handler(void)
850 {
851 	struct crw crw;
852 	struct mci *mci;
853 
854 	/* Check for pending channel report word. */
855 	mci = (struct mci *)&S390_lowcore.mcck_interruption_code;
856 	if (!mci->cp)
857 		return;
858 	/* Process channel report words. */
859 	while (stcrw(&crw) == 0) {
860 		/* Check for responses to RCHP. */
861 		if (crw.slct && crw.rsc == CRW_RSC_CPATH)
862 			atomic_dec(&chpid_reset_count);
863 	}
864 }
865 
866 #define RCHP_TIMEOUT (30 * USEC_PER_SEC)
867 static void css_reset(void)
868 {
869 	int i, ret;
870 	unsigned long long timeout;
871 	struct chp_id chpid;
872 
873 	/* Reset subchannels. */
874 	for_each_subchannel(__shutdown_subchannel_easy,  NULL);
875 	/* Reset channel paths. */
876 	s390_base_mcck_handler_fn = s390_reset_chpids_mcck_handler;
877 	/* Enable channel report machine checks. */
878 	__ctl_set_bit(14, 28);
879 	/* Temporarily reenable machine checks. */
880 	local_mcck_enable();
881 	chp_id_init(&chpid);
882 	for (i = 0; i <= __MAX_CHPID; i++) {
883 		chpid.id = i;
884 		ret = rchp(chpid);
885 		if ((ret == 0) || (ret == 2))
886 			/*
887 			 * rchp either succeeded, or another rchp is already
888 			 * in progress. In either case, we'll get a crw.
889 			 */
890 			atomic_inc(&chpid_reset_count);
891 	}
892 	/* Wait for machine check for all channel paths. */
893 	timeout = get_tod_clock() + (RCHP_TIMEOUT << 12);
894 	while (atomic_read(&chpid_reset_count) != 0) {
895 		if (get_tod_clock() > timeout)
896 			break;
897 		cpu_relax();
898 	}
899 	/* Disable machine checks again. */
900 	local_mcck_disable();
901 	/* Disable channel report machine checks. */
902 	__ctl_clear_bit(14, 28);
903 	s390_base_mcck_handler_fn = NULL;
904 }
905 
906 static struct reset_call css_reset_call = {
907 	.fn = css_reset,
908 };
909 
910 static int __init init_css_reset_call(void)
911 {
912 	atomic_set(&chpid_reset_count, 0);
913 	register_reset_call(&css_reset_call);
914 	return 0;
915 }
916 
917 arch_initcall(init_css_reset_call);
918 
919 struct sch_match_id {
920 	struct subchannel_id schid;
921 	struct ccw_dev_id devid;
922 	int rc;
923 };
924 
925 static int __reipl_subchannel_match(struct subchannel_id schid, void *data)
926 {
927 	struct schib schib;
928 	struct sch_match_id *match_id = data;
929 
930 	if (stsch_reset(schid, &schib))
931 		return -ENXIO;
932 	if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv &&
933 	    (schib.pmcw.dev == match_id->devid.devno) &&
934 	    (schid.ssid == match_id->devid.ssid)) {
935 		match_id->schid = schid;
936 		match_id->rc = 0;
937 		return 1;
938 	}
939 	return 0;
940 }
941 
942 static int reipl_find_schid(struct ccw_dev_id *devid,
943 			    struct subchannel_id *schid)
944 {
945 	struct sch_match_id match_id;
946 
947 	match_id.devid = *devid;
948 	match_id.rc = -ENODEV;
949 	for_each_subchannel(__reipl_subchannel_match, &match_id);
950 	if (match_id.rc == 0)
951 		*schid = match_id.schid;
952 	return match_id.rc;
953 }
954 
955 extern void do_reipl_asm(__u32 schid);
956 
957 /* Make sure all subchannels are quiet before we re-ipl an lpar. */
958 void reipl_ccw_dev(struct ccw_dev_id *devid)
959 {
960 	struct subchannel_id uninitialized_var(schid);
961 
962 	s390_reset_system(NULL, NULL);
963 	if (reipl_find_schid(devid, &schid) != 0)
964 		panic("IPL Device not found\n");
965 	do_reipl_asm(*((__u32*)&schid));
966 }
967 
968 int __init cio_get_iplinfo(struct cio_iplinfo *iplinfo)
969 {
970 	struct subchannel_id schid;
971 	struct schib schib;
972 
973 	schid = *(struct subchannel_id *)&S390_lowcore.subchannel_id;
974 	if (!schid.one)
975 		return -ENODEV;
976 	if (stsch_err(schid, &schib))
977 		return -ENODEV;
978 	if (schib.pmcw.st != SUBCHANNEL_TYPE_IO)
979 		return -ENODEV;
980 	if (!schib.pmcw.dnv)
981 		return -ENODEV;
982 	iplinfo->devno = schib.pmcw.dev;
983 	iplinfo->is_qdio = schib.pmcw.qf;
984 	return 0;
985 }
986 
987 /**
988  * cio_tm_start_key - perform start function
989  * @sch: subchannel on which to perform the start function
990  * @tcw: transport-command word to be started
991  * @lpm: mask of paths to use
992  * @key: storage key to use for storage access
993  *
994  * Start the tcw on the given subchannel. Return zero on success, non-zero
995  * otherwise.
996  */
997 int cio_tm_start_key(struct subchannel *sch, struct tcw *tcw, u8 lpm, u8 key)
998 {
999 	int cc;
1000 	union orb *orb = &to_io_private(sch)->orb;
1001 
1002 	memset(orb, 0, sizeof(union orb));
1003 	orb->tm.intparm = (u32) (addr_t) sch;
1004 	orb->tm.key = key >> 4;
1005 	orb->tm.b = 1;
1006 	orb->tm.lpm = lpm ? lpm : sch->lpm;
1007 	orb->tm.tcw = (u32) (addr_t) tcw;
1008 	cc = ssch(sch->schid, orb);
1009 	switch (cc) {
1010 	case 0:
1011 		return 0;
1012 	case 1:
1013 	case 2:
1014 		return -EBUSY;
1015 	default:
1016 		return cio_start_handle_notoper(sch, lpm);
1017 	}
1018 }
1019 
1020 /**
1021  * cio_tm_intrg - perform interrogate function
1022  * @sch - subchannel on which to perform the interrogate function
1023  *
1024  * If the specified subchannel is running in transport-mode, perform the
1025  * interrogate function. Return zero on success, non-zero otherwie.
1026  */
1027 int cio_tm_intrg(struct subchannel *sch)
1028 {
1029 	int cc;
1030 
1031 	if (!to_io_private(sch)->orb.tm.b)
1032 		return -EINVAL;
1033 	cc = xsch(sch->schid);
1034 	switch (cc) {
1035 	case 0:
1036 	case 2:
1037 		return 0;
1038 	case 1:
1039 		return -EBUSY;
1040 	default:
1041 		return -ENODEV;
1042 	}
1043 }
1044