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