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