cio.c 23 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3
/*
 *   S/390 common I/O routines -- low level i/o calls
 *
4
 *    Copyright IBM Corp. 1999, 2008
Linus Torvalds's avatar
Linus Torvalds committed
5
 *    Author(s): Ingo Adlung (adlung@de.ibm.com)
6
 *		 Cornelia Huck (cornelia.huck@de.ibm.com)
Linus Torvalds's avatar
Linus Torvalds committed
7 8 9 10
 *		 Arnd Bergmann (arndb@de.ibm.com)
 *		 Martin Schwidefsky (schwidefsky@de.ibm.com)
 */

11 12 13
#define KMSG_COMPONENT "cio"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

14
#include <linux/ftrace.h>
Linus Torvalds's avatar
Linus Torvalds committed
15 16 17 18 19 20
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/kernel_stat.h>
#include <linux/interrupt.h>
21
#include <linux/irq.h>
Linus Torvalds's avatar
Linus Torvalds committed
22 23 24
#include <asm/cio.h>
#include <asm/delay.h>
#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/sched/cputime.h>
33
#include <asm/fcx.h>
34 35
#include <asm/nmi.h>
#include <asm/crw.h>
Linus Torvalds's avatar
Linus Torvalds committed
36 37 38 39
#include "cio.h"
#include "css.h"
#include "chsc.h"
#include "ioasm.h"
40
#include "io_sch.h"
Linus Torvalds's avatar
Linus Torvalds committed
41 42
#include "blacklist.h"
#include "cio_debug.h"
43
#include "chp.h"
44
#include "trace.h"
Linus Torvalds's avatar
Linus Torvalds committed
45 46 47 48 49

debug_info_t *cio_debug_msg_id;
debug_info_t *cio_debug_trace_id;
debug_info_t *cio_debug_crw_id;

50 51 52
DEFINE_PER_CPU_ALIGNED(struct irb, cio_irb);
EXPORT_PER_CPU_SYMBOL(cio_irb);

Linus Torvalds's avatar
Linus Torvalds committed
53 54
/*
 * Function: cio_debug_init
55 56
 * Initializes three debug logs for common I/O:
 * - cio_msg logs generic cio messages
Linus Torvalds's avatar
Linus Torvalds committed
57
 * - cio_trace logs the calling of different functions
58
 * - cio_crw logs machine check related cio messages
Linus Torvalds's avatar
Linus Torvalds committed
59
 */
60
static int __init cio_debug_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
61
{
62
	cio_debug_msg_id = debug_register("cio_msg", 16, 1, 11 * sizeof(long));
Linus Torvalds's avatar
Linus Torvalds committed
63 64
	if (!cio_debug_msg_id)
		goto out_unregister;
65 66
	debug_register_view(cio_debug_msg_id, &debug_sprintf_view);
	debug_set_level(cio_debug_msg_id, 2);
67
	cio_debug_trace_id = debug_register("cio_trace", 16, 1, 16);
Linus Torvalds's avatar
Linus Torvalds committed
68 69
	if (!cio_debug_trace_id)
		goto out_unregister;
70 71
	debug_register_view(cio_debug_trace_id, &debug_hex_ascii_view);
	debug_set_level(cio_debug_trace_id, 2);
72
	cio_debug_crw_id = debug_register("cio_crw", 8, 1, 8 * sizeof(long));
Linus Torvalds's avatar
Linus Torvalds committed
73 74
	if (!cio_debug_crw_id)
		goto out_unregister;
75 76
	debug_register_view(cio_debug_crw_id, &debug_sprintf_view);
	debug_set_level(cio_debug_crw_id, 4);
Linus Torvalds's avatar
Linus Torvalds committed
77 78 79
	return 0;

out_unregister:
80 81 82
	debug_unregister(cio_debug_msg_id);
	debug_unregister(cio_debug_trace_id);
	debug_unregister(cio_debug_crw_id);
Linus Torvalds's avatar
Linus Torvalds committed
83 84 85 86 87
	return -1;
}

arch_initcall (cio_debug_init);

88
int cio_set_options(struct subchannel *sch, int flags)
Linus Torvalds's avatar
Linus Torvalds committed
89
{
90
	struct io_subchannel_private *priv = to_io_private(sch);
Linus Torvalds's avatar
Linus Torvalds committed
91

92 93 94 95
	priv->options.suspend = (flags & DOIO_ALLOW_SUSPEND) != 0;
	priv->options.prefetch = (flags & DOIO_DENY_PREFETCH) != 0;
	priv->options.inter = (flags & DOIO_SUPPRESS_INTER) != 0;
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
96 97
}

98
static int
Linus Torvalds's avatar
Linus Torvalds committed
99 100 101 102 103 104 105 106 107
cio_start_handle_notoper(struct subchannel *sch, __u8 lpm)
{
	char dbf_text[15];

	if (lpm != 0)
		sch->lpm &= ~lpm;
	else
		sch->lpm = 0;

108
	CIO_MSG_EVENT(2, "cio_start: 'not oper' status for "
109 110
		      "subchannel 0.%x.%04x!\n", sch->schid.ssid,
		      sch->schid.sch_no);
111 112 113 114

	if (cio_update_schib(sch))
		return -ENODEV;

115
	sprintf(dbf_text, "no%s", dev_name(&sch->dev));
Linus Torvalds's avatar
Linus Torvalds committed
116 117 118 119 120 121 122 123 124 125 126 127
	CIO_TRACE_EVENT(0, dbf_text);
	CIO_HEX_EVENT(0, &sch->schib, sizeof (struct schib));

	return (sch->lpm ? -EACCES : -ENODEV);
}

int
cio_start_key (struct subchannel *sch,	/* subchannel structure */
	       struct ccw1 * cpa,	/* logical channel prog addr */
	       __u8 lpm,		/* logical path mask */
	       __u8 key)                /* storage key */
{
128 129
	struct io_subchannel_private *priv = to_io_private(sch);
	union orb *orb = &priv->orb;
Linus Torvalds's avatar
Linus Torvalds committed
130 131
	int ccode;

132 133
	CIO_TRACE_EVENT(5, "stIO");
	CIO_TRACE_EVENT(5, dev_name(&sch->dev));
Linus Torvalds's avatar
Linus Torvalds committed
134

135
	memset(orb, 0, sizeof(union orb));
Linus Torvalds's avatar
Linus Torvalds committed
136
	/* sch is always under 2G. */
137 138
	orb->cmd.intparm = (u32)(addr_t)sch;
	orb->cmd.fmt = 1;
Linus Torvalds's avatar
Linus Torvalds committed
139

140 141 142
	orb->cmd.pfch = priv->options.prefetch == 0;
	orb->cmd.spnd = priv->options.suspend;
	orb->cmd.ssic = priv->options.suspend && priv->options.inter;
143
	orb->cmd.lpm = (lpm != 0) ? lpm : sch->lpm;
Linus Torvalds's avatar
Linus Torvalds committed
144 145 146
	/*
	 * for 64 bit we always support 64 bit IDAWs with 4k page size only
	 */
147 148 149
	orb->cmd.c64 = 1;
	orb->cmd.i2k = 0;
	orb->cmd.key = key >> 4;
Linus Torvalds's avatar
Linus Torvalds committed
150
	/* issue "Start Subchannel" */
151
	orb->cmd.cpa = (__u32) __pa(cpa);
152
	ccode = ssch(sch->schid, orb);
Linus Torvalds's avatar
Linus Torvalds committed
153 154

	/* process condition code */
155
	CIO_HEX_EVENT(5, &ccode, sizeof(ccode));
Linus Torvalds's avatar
Linus Torvalds committed
156 157 158 159 160 161

	switch (ccode) {
	case 0:
		/*
		 * initialize device status information
		 */
162
		sch->schib.scsw.cmd.actl |= SCSW_ACTL_START_PEND;
Linus Torvalds's avatar
Linus Torvalds committed
163 164 165 166
		return 0;
	case 1:		/* status pending */
	case 2:		/* busy */
		return -EBUSY;
167
	case 3:		/* device/path not operational */
Linus Torvalds's avatar
Linus Torvalds committed
168
		return cio_start_handle_notoper(sch, lpm);
169 170
	default:
		return ccode;
Linus Torvalds's avatar
Linus Torvalds committed
171 172 173 174 175 176
	}
}

int
cio_start (struct subchannel *sch, struct ccw1 *cpa, __u8 lpm)
{
177
	return cio_start_key(sch, cpa, lpm, PAGE_DEFAULT_KEY);
Linus Torvalds's avatar
Linus Torvalds committed
178 179 180 181 182 183 184 185 186 187
}

/*
 * resume suspended I/O operation
 */
int
cio_resume (struct subchannel *sch)
{
	int ccode;

188
	CIO_TRACE_EVENT(4, "resIO");
189
	CIO_TRACE_EVENT(4, dev_name(&sch->dev));
Linus Torvalds's avatar
Linus Torvalds committed
190

191
	ccode = rsch (sch->schid);
Linus Torvalds's avatar
Linus Torvalds committed
192

193
	CIO_HEX_EVENT(4, &ccode, sizeof(ccode));
Linus Torvalds's avatar
Linus Torvalds committed
194 195 196

	switch (ccode) {
	case 0:
197
		sch->schib.scsw.cmd.actl |= SCSW_ACTL_RESUME_PEND;
Linus Torvalds's avatar
Linus Torvalds committed
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
		return 0;
	case 1:
		return -EBUSY;
	case 2:
		return -EINVAL;
	default:
		/*
		 * useless to wait for request completion
		 *  as device is no longer operational !
		 */
		return -ENODEV;
	}
}

/*
 * halt I/O operation
 */
int
cio_halt(struct subchannel *sch)
{
	int ccode;

	if (!sch)
		return -ENODEV;

223
	CIO_TRACE_EVENT(2, "haltIO");
224
	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
Linus Torvalds's avatar
Linus Torvalds committed
225 226 227 228

	/*
	 * Issue "Halt subchannel" and process condition code
	 */
229
	ccode = hsch (sch->schid);
Linus Torvalds's avatar
Linus Torvalds committed
230

231
	CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
Linus Torvalds's avatar
Linus Torvalds committed
232 233 234

	switch (ccode) {
	case 0:
235
		sch->schib.scsw.cmd.actl |= SCSW_ACTL_HALT_PEND;
Linus Torvalds's avatar
Linus Torvalds committed
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
		return 0;
	case 1:		/* status pending */
	case 2:		/* busy */
		return -EBUSY;
	default:		/* device not operational */
		return -ENODEV;
	}
}

/*
 * Clear I/O operation
 */
int
cio_clear(struct subchannel *sch)
{
	int ccode;

	if (!sch)
		return -ENODEV;

256
	CIO_TRACE_EVENT(2, "clearIO");
257
	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
Linus Torvalds's avatar
Linus Torvalds committed
258 259 260 261

	/*
	 * Issue "Clear subchannel" and process condition code
	 */
262
	ccode = csch (sch->schid);
Linus Torvalds's avatar
Linus Torvalds committed
263

264
	CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
Linus Torvalds's avatar
Linus Torvalds committed
265 266 267

	switch (ccode) {
	case 0:
268
		sch->schib.scsw.cmd.actl |= SCSW_ACTL_CLEAR_PEND;
Linus Torvalds's avatar
Linus Torvalds committed
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
		return 0;
	default:		/* device not operational */
		return -ENODEV;
	}
}

/*
 * Function: cio_cancel
 * Issues a "Cancel Subchannel" on the specified subchannel
 * Note: We don't need any fancy intparms and flags here
 *	 since xsch is executed synchronously.
 * Only for common I/O internal use as for now.
 */
int
cio_cancel (struct subchannel *sch)
{
	int ccode;

	if (!sch)
		return -ENODEV;

290
	CIO_TRACE_EVENT(2, "cancelIO");
291
	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
Linus Torvalds's avatar
Linus Torvalds committed
292

293
	ccode = xsch (sch->schid);
Linus Torvalds's avatar
Linus Torvalds committed
294

295
	CIO_HEX_EVENT(2, &ccode, sizeof(ccode));
Linus Torvalds's avatar
Linus Torvalds committed
296 297 298 299

	switch (ccode) {
	case 0:		/* success */
		/* Update information in scsw. */
300 301
		if (cio_update_schib(sch))
			return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
302 303 304 305 306 307 308 309 310 311
		return 0;
	case 1:		/* status pending */
		return -EBUSY;
	case 2:		/* not applicable */
		return -EINVAL;
	default:	/* not oper */
		return -ENODEV;
	}
}

312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339

static void cio_apply_config(struct subchannel *sch, struct schib *schib)
{
	schib->pmcw.intparm = sch->config.intparm;
	schib->pmcw.mbi = sch->config.mbi;
	schib->pmcw.isc = sch->config.isc;
	schib->pmcw.ena = sch->config.ena;
	schib->pmcw.mme = sch->config.mme;
	schib->pmcw.mp = sch->config.mp;
	schib->pmcw.csense = sch->config.csense;
	schib->pmcw.mbfc = sch->config.mbfc;
	if (sch->config.mbfc)
		schib->mba = sch->config.mba;
}

static int cio_check_config(struct subchannel *sch, struct schib *schib)
{
	return (schib->pmcw.intparm == sch->config.intparm) &&
		(schib->pmcw.mbi == sch->config.mbi) &&
		(schib->pmcw.isc == sch->config.isc) &&
		(schib->pmcw.ena == sch->config.ena) &&
		(schib->pmcw.mme == sch->config.mme) &&
		(schib->pmcw.mp == sch->config.mp) &&
		(schib->pmcw.csense == sch->config.csense) &&
		(schib->pmcw.mbfc == sch->config.mbfc) &&
		(!sch->config.mbfc || (schib->mba == sch->config.mba));
}

Linus Torvalds's avatar
Linus Torvalds committed
340
/*
341
 * cio_commit_config - apply configuration to the subchannel
Linus Torvalds's avatar
Linus Torvalds committed
342
 */
343
int cio_commit_config(struct subchannel *sch)
Linus Torvalds's avatar
Linus Torvalds committed
344
{
345
	int ccode, retry, ret = 0;
346 347
	struct schib schib;
	struct irb irb;
348

349
	if (stsch(sch->schid, &schib) || !css_sch_is_valid(&schib))
350
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
351 352

	for (retry = 0; retry < 5; retry++) {
353 354
		/* copy desired changes to local schib */
		cio_apply_config(sch, &schib);
355
		ccode = msch(sch->schid, &schib);
356
		if (ccode < 0) /* -EIO if msch gets a program check. */
Linus Torvalds's avatar
Linus Torvalds committed
357 358
			return ccode;
		switch (ccode) {
359
		case 0: /* successful */
360
			if (stsch(sch->schid, &schib) ||
361 362 363 364 365 366 367 368 369 370
			    !css_sch_is_valid(&schib))
				return -ENODEV;
			if (cio_check_config(sch, &schib)) {
				/* commit changes from local schib */
				memcpy(&sch->schib, &schib, sizeof(schib));
				return 0;
			}
			ret = -EAGAIN;
			break;
		case 1: /* status pending */
371 372 373 374
			ret = -EBUSY;
			if (tsch(sch->schid, &irb))
				return ret;
			break;
375 376
		case 2: /* busy */
			udelay(100); /* allow for recovery */
Linus Torvalds's avatar
Linus Torvalds committed
377 378
			ret = -EBUSY;
			break;
379
		case 3: /* not operational */
Linus Torvalds's avatar
Linus Torvalds committed
380 381 382 383 384 385
			return -ENODEV;
		}
	}
	return ret;
}

386 387 388 389 390 391 392 393 394
/**
 * cio_update_schib - Perform stsch and update schib if subchannel is valid.
 * @sch: subchannel on which to perform stsch
 * Return zero on success, -ENODEV otherwise.
 */
int cio_update_schib(struct subchannel *sch)
{
	struct schib schib;

395
	if (stsch(sch->schid, &schib) || !css_sch_is_valid(&schib))
396 397 398 399 400 401 402
		return -ENODEV;

	memcpy(&sch->schib, &schib, sizeof(schib));
	return 0;
}
EXPORT_SYMBOL_GPL(cio_update_schib);

403 404 405 406
/**
 * cio_enable_subchannel - enable a subchannel.
 * @sch: subchannel to be enabled
 * @intparm: interruption parameter to set
Linus Torvalds's avatar
Linus Torvalds committed
407
 */
408
int cio_enable_subchannel(struct subchannel *sch, u32 intparm)
Linus Torvalds's avatar
Linus Torvalds committed
409 410 411
{
	int ret;

412
	CIO_TRACE_EVENT(2, "ensch");
413
	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
Linus Torvalds's avatar
Linus Torvalds committed
414

415 416
	if (sch_is_pseudo_sch(sch))
		return -EINVAL;
417
	if (cio_update_schib(sch))
Linus Torvalds's avatar
Linus Torvalds committed
418 419
		return -ENODEV;

420 421 422 423
	sch->config.ena = 1;
	sch->config.isc = sch->isc;
	sch->config.intparm = intparm;

424 425 426 427 428 429 430
	ret = cio_commit_config(sch);
	if (ret == -EIO) {
		/*
		 * Got a program check in msch. Try without
		 * the concurrent sense bit the next time.
		 */
		sch->config.csense = 0;
431
		ret = cio_commit_config(sch);
Linus Torvalds's avatar
Linus Torvalds committed
432
	}
433
	CIO_HEX_EVENT(2, &ret, sizeof(ret));
Linus Torvalds's avatar
Linus Torvalds committed
434 435
	return ret;
}
436
EXPORT_SYMBOL_GPL(cio_enable_subchannel);
Linus Torvalds's avatar
Linus Torvalds committed
437

438 439 440
/**
 * cio_disable_subchannel - disable a subchannel.
 * @sch: subchannel to disable
Linus Torvalds's avatar
Linus Torvalds committed
441
 */
442
int cio_disable_subchannel(struct subchannel *sch)
Linus Torvalds's avatar
Linus Torvalds committed
443 444 445
{
	int ret;

446
	CIO_TRACE_EVENT(2, "dissch");
447
	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
Linus Torvalds's avatar
Linus Torvalds committed
448

449 450
	if (sch_is_pseudo_sch(sch))
		return 0;
451
	if (cio_update_schib(sch))
Linus Torvalds's avatar
Linus Torvalds committed
452 453
		return -ENODEV;

454
	sch->config.ena = 0;
455
	ret = cio_commit_config(sch);
456

457
	CIO_HEX_EVENT(2, &ret, sizeof(ret));
Linus Torvalds's avatar
Linus Torvalds committed
458 459
	return ret;
}
460
EXPORT_SYMBOL_GPL(cio_disable_subchannel);
Linus Torvalds's avatar
Linus Torvalds committed
461

462
static int cio_check_devno_blacklisted(struct subchannel *sch)
463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
{
	if (is_blacklisted(sch->schid.ssid, sch->schib.pmcw.dev)) {
		/*
		 * This device must not be known to Linux. So we simply
		 * say that there is no device and return ENODEV.
		 */
		CIO_MSG_EVENT(6, "Blacklisted device detected "
			      "at devno %04X, subchannel set %x\n",
			      sch->schib.pmcw.dev, sch->schid.ssid);
		return -ENODEV;
	}
	return 0;
}

/**
 * cio_validate_subchannel - basic validation of subchannel
 * @sch: subchannel structure to be filled out
 * @schid: subchannel id
Linus Torvalds's avatar
Linus Torvalds committed
481 482 483
 *
 * Find out subchannel type and initialize struct subchannel.
 * Return codes:
484
 *   0 on success
Linus Torvalds's avatar
Linus Torvalds committed
485
 *   -ENXIO for non-defined subchannels
486 487
 *   -ENODEV for invalid subchannels or blacklisted devices
 *   -EIO for subchannels in an invalid subchannel set
Linus Torvalds's avatar
Linus Torvalds committed
488
 */
489
int cio_validate_subchannel(struct subchannel *sch, struct subchannel_id schid)
Linus Torvalds's avatar
Linus Torvalds committed
490 491 492
{
	char dbf_txt[15];
	int ccode;
493
	int err;
Linus Torvalds's avatar
Linus Torvalds committed
494

495 496
	sprintf(dbf_txt, "valsch%x", schid.sch_no);
	CIO_TRACE_EVENT(4, dbf_txt);
Linus Torvalds's avatar
Linus Torvalds committed
497 498 499

	/*
	 * The first subchannel that is not-operational (ccode==3)
500
	 * indicates that there aren't any more devices available.
501
	 * If stsch gets an exception, it means the current subchannel set
502
	 * is not valid.
Linus Torvalds's avatar
Linus Torvalds committed
503
	 */
504
	ccode = stsch(schid, &sch->schib);
505 506 507 508
	if (ccode) {
		err = (ccode == 3) ? -ENXIO : ccode;
		goto out;
	}
Linus Torvalds's avatar
Linus Torvalds committed
509
	sch->st = sch->schib.pmcw.st;
510
	sch->schid = schid;
511

512 513
	switch (sch->st) {
	case SUBCHANNEL_TYPE_IO:
514
	case SUBCHANNEL_TYPE_MSG:
515 516 517 518
		if (!css_sch_is_valid(&sch->schib))
			err = -ENODEV;
		else
			err = cio_check_devno_blacklisted(sch);
519
		break;
520 521
	default:
		err = 0;
Linus Torvalds's avatar
Linus Torvalds committed
522
	}
523
	if (err)
524 525
		goto out;

526 527
	CIO_MSG_EVENT(4, "Subchannel 0.%x.%04x reports subchannel type %04X\n",
		      sch->schid.ssid, sch->schid.sch_no, sch->st);
528 529
out:
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
530 531 532
}

/*
533
 * do_cio_interrupt() handles all normal I/O device IRQ's
Linus Torvalds's avatar
Linus Torvalds committed
534
 */
535
static irqreturn_t do_cio_interrupt(int irq, void *dummy)
Linus Torvalds's avatar
Linus Torvalds committed
536
{
537
	struct tpi_info *tpi_info;
Linus Torvalds's avatar
Linus Torvalds committed
538 539 540
	struct subchannel *sch;
	struct irb *irb;

541
	set_cpu_flag(CIF_NOHZ_DELAY);
542
	tpi_info = (struct tpi_info *) &get_irq_regs()->int_code;
543
	trace_s390_cio_interrupt(tpi_info);
544
	irb = this_cpu_ptr(&cio_irb);
545 546 547 548 549
	sch = (struct subchannel *)(unsigned long) tpi_info->intparm;
	if (!sch) {
		/* Clear pending interrupt condition. */
		inc_irq_stat(IRQIO_CIO);
		tsch(tpi_info->schid, irb);
550
		return IRQ_HANDLED;
551 552 553 554 555 556 557 558 559 560
	}
	spin_lock(sch->lock);
	/* Store interrupt response block to lowcore. */
	if (tsch(tpi_info->schid, irb) == 0) {
		/* Keep subchannel information word up to date. */
		memcpy (&sch->schib.scsw, &irb->scsw, sizeof (irb->scsw));
		/* Call interrupt handler if there is one. */
		if (sch->driver && sch->driver->irq)
			sch->driver->irq(sch);
		else
561
			inc_irq_stat(IRQIO_CIO);
562 563 564
	} else
		inc_irq_stat(IRQIO_CIO);
	spin_unlock(sch->lock);
565 566 567 568 569 570 571 572 573 574 575 576 577 578

	return IRQ_HANDLED;
}

static struct irqaction io_interrupt = {
	.name	 = "IO",
	.handler = do_cio_interrupt,
};

void __init init_cio_interrupts(void)
{
	irq_set_chip_and_handler(IO_INTERRUPT,
				 &dummy_irq_chip, handle_percpu_irq);
	setup_irq(IO_INTERRUPT, &io_interrupt);
Linus Torvalds's avatar
Linus Torvalds committed
579 580 581
}

#ifdef CONFIG_CCW_CONSOLE
582
static struct subchannel *console_sch;
583
static struct lock_class_key console_sch_key;
Linus Torvalds's avatar
Linus Torvalds committed
584

585
/*
586
 * Use cio_tsch to update the subchannel status and call the interrupt handler
587
 * if status had been pending. Called with the subchannel's lock held.
588
 */
589
void cio_tsch(struct subchannel *sch)
590 591 592 593
{
	struct irb *irb;
	int irq_context;

594
	irb = this_cpu_ptr(&cio_irb);
595
	/* Store interrupt response block to lowcore. */
596
	if (tsch(sch->schid, irb) != 0)
597
		/* Not status pending or not operational. */
598 599 600
		return;
	memcpy(&sch->schib.scsw, &irb->scsw, sizeof(union scsw));
	/* Call interrupt handler with updated status. */
601
	irq_context = in_interrupt();
602
	if (!irq_context) {
603
		local_bh_disable();
604 605
		irq_enter();
	}
606
	kstat_incr_irq_this_cpu(IO_INTERRUPT);
607 608
	if (sch->driver && sch->driver->irq)
		sch->driver->irq(sch);
609
	else
610
		inc_irq_stat(IRQIO_CIO);
611 612
	if (!irq_context) {
		irq_exit();
613
		_local_bh_enable();
614
	}
615 616
}

617
static int cio_test_for_console(struct subchannel_id schid, void *data)
618
{
619
	struct schib schib;
620

621
	if (stsch(schid, &schib) != 0)
622
		return -ENXIO;
623 624
	if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv &&
	    (schib.pmcw.dev == console_devno)) {
625 626 627 628 629 630
		console_irq = schid.sch_no;
		return 1; /* found */
	}
	return 0;
}

631
static int cio_get_console_sch_no(void)
Linus Torvalds's avatar
Linus Torvalds committed
632
{
633
	struct subchannel_id schid;
634 635
	struct schib schib;

636
	init_subchannel_id(&schid);
Linus Torvalds's avatar
Linus Torvalds committed
637 638
	if (console_irq != -1) {
		/* VM provided us with the irq number of the console. */
639
		schid.sch_no = console_irq;
640
		if (stsch(schid, &schib) != 0 ||
641
		    (schib.pmcw.st != SUBCHANNEL_TYPE_IO) || !schib.pmcw.dnv)
Linus Torvalds's avatar
Linus Torvalds committed
642
			return -1;
643
		console_devno = schib.pmcw.dev;
Linus Torvalds's avatar
Linus Torvalds committed
644 645
	} else if (console_devno != -1) {
		/* At least the console device number is known. */
646
		for_each_subchannel(cio_test_for_console, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
647 648 649 650
	}
	return console_irq;
}

651
struct subchannel *cio_probe_console(void)
Linus Torvalds's avatar
Linus Torvalds committed
652
{
653
	struct subchannel_id schid;
654 655
	struct subchannel *sch;
	int sch_no, ret;
Linus Torvalds's avatar
Linus Torvalds committed
656

657 658
	sch_no = cio_get_console_sch_no();
	if (sch_no == -1) {
659
		pr_warn("No CCW console was found\n");
Linus Torvalds's avatar
Linus Torvalds committed
660 661
		return ERR_PTR(-ENODEV);
	}
662
	init_subchannel_id(&schid);
663
	schid.sch_no = sch_no;
664 665 666
	sch = css_alloc_subchannel(schid);
	if (IS_ERR(sch))
		return sch;
Linus Torvalds's avatar
Linus Torvalds committed
667

668
	lockdep_set_class(sch->lock, &console_sch_key);
669
	isc_register(CONSOLE_ISC);
670 671 672
	sch->config.isc = CONSOLE_ISC;
	sch->config.intparm = (u32)(addr_t)sch;
	ret = cio_commit_config(sch);
Linus Torvalds's avatar
Linus Torvalds committed
673
	if (ret) {
674
		isc_unregister(CONSOLE_ISC);
675
		put_device(&sch->dev);
Linus Torvalds's avatar
Linus Torvalds committed
676 677
		return ERR_PTR(ret);
	}
678 679
	console_sch = sch;
	return sch;
Linus Torvalds's avatar
Linus Torvalds committed
680 681
}

682
int cio_is_console(struct subchannel_id schid)
Linus Torvalds's avatar
Linus Torvalds committed
683
{
684
	if (!console_sch)
Linus Torvalds's avatar
Linus Torvalds committed
685
		return 0;
686
	return schid_equal(&schid, &console_sch->schid);
Linus Torvalds's avatar
Linus Torvalds committed
687 688
}

689
void cio_register_early_subchannels(void)
Linus Torvalds's avatar
Linus Torvalds committed
690
{
691 692 693 694 695 696 697 698
	int ret;

	if (!console_sch)
		return;

	ret = css_register_subchannel(console_sch);
	if (ret)
		put_device(&console_sch->dev);
Linus Torvalds's avatar
Linus Torvalds committed
699
}
700
#endif /* CONFIG_CCW_CONSOLE */
Linus Torvalds's avatar
Linus Torvalds committed
701

702
static int
703
__disable_subchannel_easy(struct subchannel_id schid, struct schib *schib)
Linus Torvalds's avatar
Linus Torvalds committed
704 705 706 707 708 709
{
	int retry, cc;

	cc = 0;
	for (retry=0;retry<3;retry++) {
		schib->pmcw.ena = 0;
710
		cc = msch(schid, schib);
Linus Torvalds's avatar
Linus Torvalds committed
711 712
		if (cc)
			return (cc==3?-ENODEV:-EBUSY);
713
		if (stsch(schid, schib) || !css_sch_is_valid(schib))
714
			return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
715 716 717 718 719 720
		if (!schib->pmcw.ena)
			return 0;
	}
	return -EBUSY; /* uhm... */
}

721
static int
722
__clear_io_subchannel_easy(struct subchannel_id schid)
Linus Torvalds's avatar
Linus Torvalds committed
723 724 725 726 727 728 729 730 731
{
	int retry;

	if (csch(schid))
		return -ENODEV;
	for (retry=0;retry<20;retry++) {
		struct tpi_info ti;

		if (tpi(&ti)) {
732
			tsch(ti.schid, this_cpu_ptr(&cio_irb));
733
			if (schid_equal(&ti.schid, &schid))
734
				return 0;
Linus Torvalds's avatar
Linus Torvalds committed
735
		}
736
		udelay_simple(100);
Linus Torvalds's avatar
Linus Torvalds committed
737 738 739 740
	}
	return -EBUSY;
}

741 742 743
static void __clear_chsc_subchannel_easy(void)
{
	/* It seems we can only wait for a bit here :/ */
744
	udelay_simple(100);
745 746
}

747 748 749 750 751 752 753
static int pgm_check_occured;

static void cio_reset_pgm_check_handler(void)
{
	pgm_check_occured = 1;
}

754
static int stsch_reset(struct subchannel_id schid, struct schib *addr)
755 756 757 758
{
	int rc;

	pgm_check_occured = 0;
759
	s390_base_pgm_handler_fn = cio_reset_pgm_check_handler;
760
	rc = stsch(schid, addr);
761
	s390_base_pgm_handler_fn = NULL;
762

763
	/* The program check handler could have changed pgm_check_occured. */
764
	barrier();
765

766 767 768 769 770 771
	if (pgm_check_occured)
		return -EIO;
	else
		return rc;
}

772
static int __shutdown_subchannel_easy(struct subchannel_id schid, void *data)
773 774 775
{
	struct schib schib;

776
	if (stsch_reset(schid, &schib))
777 778 779 780 781 782 783 784
		return -ENXIO;
	if (!schib.pmcw.ena)
		return 0;
	switch(__disable_subchannel_easy(schid, &schib)) {
	case 0:
	case -ENODEV:
		break;
	default: /* -EBUSY */
785 786 787 788 789
		switch (schib.pmcw.st) {
		case SUBCHANNEL_TYPE_IO:
			if (__clear_io_subchannel_easy(schid))
				goto out; /* give up... */
			break;
790 791 792
		case SUBCHANNEL_TYPE_CHSC:
			__clear_chsc_subchannel_easy();
			break;
793 794 795 796
		default:
			/* No default clear strategy */
			break;
		}
797
		stsch(schid, &schib);
798 799
		__disable_subchannel_easy(schid, &schib);
	}
800
out:
801 802
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
803

804 805 806 807 808
static atomic_t chpid_reset_count;

static void s390_reset_chpids_mcck_handler(void)
{
	struct crw crw;
Heiko Carstens's avatar
Heiko Carstens committed
809
	union mci mci;
810 811

	/* Check for pending channel report word. */
Heiko Carstens's avatar
Heiko Carstens committed
812 813
	mci.val = S390_lowcore.mcck_interruption_code;
	if (!mci.cp)
814 815 816 817 818 819 820 821 822 823 824 825 826 827
		return;
	/* Process channel report words. */
	while (stcrw(&crw) == 0) {
		/* Check for responses to RCHP. */
		if (crw.slct && crw.rsc == CRW_RSC_CPATH)
			atomic_dec(&chpid_reset_count);
	}
}

#define RCHP_TIMEOUT (30 * USEC_PER_SEC)
static void css_reset(void)
{
	int i, ret;
	unsigned long long timeout;
828
	struct chp_id chpid;
829 830 831 832

	/* Reset subchannels. */
	for_each_subchannel(__shutdown_subchannel_easy,  NULL);
	/* Reset channel paths. */
833
	s390_base_mcck_handler_fn = s390_reset_chpids_mcck_handler;
834 835 836 837
	/* Enable channel report machine checks. */
	__ctl_set_bit(14, 28);
	/* Temporarily reenable machine checks. */
	local_mcck_enable();
838
	chp_id_init(&chpid);
839
	for (i = 0; i <= __MAX_CHPID; i++) {
840 841
		chpid.id = i;
		ret = rchp(chpid);
842 843 844 845 846 847 848 849
		if ((ret == 0) || (ret == 2))
			/*
			 * rchp either succeeded, or another rchp is already
			 * in progress. In either case, we'll get a crw.
			 */
			atomic_inc(&chpid_reset_count);
	}
	/* Wait for machine check for all channel paths. */
850
	timeout = get_tod_clock_fast() + (RCHP_TIMEOUT << 12);
851
	while (atomic_read(&chpid_reset_count) != 0) {
852
		if (get_tod_clock_fast() > timeout)
853 854 855 856 857 858 859
			break;
		cpu_relax();
	}
	/* Disable machine checks again. */
	local_mcck_disable();
	/* Disable channel report machine checks. */
	__ctl_clear_bit(14, 28);
860
	s390_base_mcck_handler_fn = NULL;
861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886
}

static struct reset_call css_reset_call = {
	.fn = css_reset,
};

static int __init init_css_reset_call(void)
{
	atomic_set(&chpid_reset_count, 0);
	register_reset_call(&css_reset_call);
	return 0;
}

arch_initcall(init_css_reset_call);

struct sch_match_id {
	struct subchannel_id schid;
	struct ccw_dev_id devid;
	int rc;
};

static int __reipl_subchannel_match(struct subchannel_id schid, void *data)
{
	struct schib schib;
	struct sch_match_id *match_id = data;

887
	if (stsch_reset(schid, &schib))
888
		return -ENXIO;
889
	if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv &&
890 891 892 893 894 895 896 897 898 899 900
	    (schib.pmcw.dev == match_id->devid.devno) &&
	    (schid.ssid == match_id->devid.ssid)) {
		match_id->schid = schid;
		match_id->rc = 0;
		return 1;
	}
	return 0;
}

static int reipl_find_schid(struct ccw_dev_id *devid,
			    struct subchannel_id *schid)
Linus Torvalds's avatar
Linus Torvalds committed
901
{
902 903 904 905
	struct sch_match_id match_id;

	match_id.devid = *devid;
	match_id.rc = -ENODEV;
906
	for_each_subchannel(__reipl_subchannel_match, &match_id);
907 908 909
	if (match_id.rc == 0)
		*schid = match_id.schid;
	return match_id.rc;
Linus Torvalds's avatar
Linus Torvalds committed
910 911
}

912 913
extern void do_reipl_asm(__u32 schid);

Linus Torvalds's avatar
Linus Torvalds committed
914
/* Make sure all subchannels are quiet before we re-ipl an lpar. */
915
void reipl_ccw_dev(struct ccw_dev_id *devid)
Linus Torvalds's avatar
Linus Torvalds committed
916
{
917
	struct subchannel_id uninitialized_var(schid);
918

919
	s390_reset_system();
920
	if (reipl_find_schid(devid, &schid) != 0)
921 922
		panic("IPL Device not found\n");
	do_reipl_asm(*((__u32*)&schid));
Linus Torvalds's avatar
Linus Torvalds committed
923
}
924

925
int __init cio_get_iplinfo(struct cio_iplinfo *iplinfo)
926
{
927
	static struct chsc_sda_area sda_area __initdata;
928
	struct subchannel_id schid;
929
	struct schib schib;
930

931
	schid = *(struct subchannel_id *)&S390_lowcore.subchannel_id;
932
	if (!schid.one)
933
		return -ENODEV;
934 935 936 937 938 939 940 941 942 943 944

	if (schid.ssid) {
		/*
		 * Firmware should have already enabled MSS but whoever started
		 * the kernel might have initiated a channel subsystem reset.
		 * Ensure that MSS is enabled.
		 */
		memset(&sda_area, 0, sizeof(sda_area));
		if (__chsc_enable_facility(&sda_area, CHSC_SDA_OC_MSS))
			return -ENODEV;
	}
945
	if (stsch(schid, &schib))
946
		return -ENODEV;
947 948
	if (schib.pmcw.st != SUBCHANNEL_TYPE_IO)
		return -ENODEV;
949 950
	if (!schib.pmcw.dnv)
		return -ENODEV;
951 952

	iplinfo->ssid = schid.ssid;
953 954 955
	iplinfo->devno = schib.pmcw.dev;
	iplinfo->is_qdio = schib.pmcw.qf;
	return 0;
956
}
957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014

/**
 * cio_tm_start_key - perform start function
 * @sch: subchannel on which to perform the start function
 * @tcw: transport-command word to be started
 * @lpm: mask of paths to use
 * @key: storage key to use for storage access
 *
 * Start the tcw on the given subchannel. Return zero on success, non-zero
 * otherwise.
 */
int cio_tm_start_key(struct subchannel *sch, struct tcw *tcw, u8 lpm, u8 key)
{
	int cc;
	union orb *orb = &to_io_private(sch)->orb;

	memset(orb, 0, sizeof(union orb));
	orb->tm.intparm = (u32) (addr_t) sch;
	orb->tm.key = key >> 4;
	orb->tm.b = 1;
	orb->tm.lpm = lpm ? lpm : sch->lpm;
	orb->tm.tcw = (u32) (addr_t) tcw;
	cc = ssch(sch->schid, orb);
	switch (cc) {
	case 0:
		return 0;
	case 1:
	case 2:
		return -EBUSY;
	default:
		return cio_start_handle_notoper(sch, lpm);
	}
}

/**
 * cio_tm_intrg - perform interrogate function
 * @sch - subchannel on which to perform the interrogate function
 *
 * If the specified subchannel is running in transport-mode, perform the
 * interrogate function. Return zero on success, non-zero otherwie.
 */
int cio_tm_intrg(struct subchannel *sch)
{
	int cc;

	if (!to_io_private(sch)->orb.tm.b)
		return -EINVAL;
	cc = xsch(sch->schid);
	switch (cc) {
	case 0:
	case 2:
		return 0;
	case 1:
		return -EBUSY;
	default:
		return -ENODEV;
	}
}