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