device.c 48.4 KB
Newer Older
1
// SPDX-License-Identifier: GPL-1.0+
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4
/*
 *  bus driver for ccw devices
 *
5
 *    Copyright IBM Corp. 2002, 2008
Linus Torvalds's avatar
Linus Torvalds committed
6
 *    Author(s): Arnd Bergmann (arndb@de.ibm.com)
7
 *		 Cornelia Huck (cornelia.huck@de.ibm.com)
Linus Torvalds's avatar
Linus Torvalds committed
8 9
 *		 Martin Schwidefsky (schwidefsky@de.ibm.com)
 */
10 11 12 13

#define KMSG_COMPONENT "cio"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

14
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
15 16 17 18 19 20 21 22
#include <linux/init.h>
#include <linux/spinlock.h>
#include <linux/errno.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/device.h>
#include <linux/workqueue.h>
23
#include <linux/delay.h>
24
#include <linux/timer.h>
25
#include <linux/kernel_stat.h>
26
#include <linux/sched/signal.h>
27
#include <linux/dma-mapping.h>
Linus Torvalds's avatar
Linus Torvalds committed
28 29 30

#include <asm/ccwdev.h>
#include <asm/cio.h>
Tim Schmielau's avatar
Tim Schmielau committed
31
#include <asm/param.h>		/* HZ */
32
#include <asm/cmb.h>
33
#include <asm/isc.h>
Linus Torvalds's avatar
Linus Torvalds committed
34

35
#include "chp.h"
Linus Torvalds's avatar
Linus Torvalds committed
36
#include "cio.h"
37
#include "cio_debug.h"
Linus Torvalds's avatar
Linus Torvalds committed
38 39 40
#include "css.h"
#include "device.h"
#include "ioasm.h"
41
#include "io_sch.h"
42
#include "blacklist.h"
43
#include "chsc.h"
Linus Torvalds's avatar
Linus Torvalds committed
44

45
static struct timer_list recovery_timer;
46
static DEFINE_SPINLOCK(recovery_lock);
47 48 49
static int recovery_phase;
static const unsigned long recovery_delay[] = { 3, 30, 300 };

50 51 52 53
static atomic_t ccw_device_init_count = ATOMIC_INIT(0);
static DECLARE_WAIT_QUEUE_HEAD(ccw_device_init_wq);
static struct bus_type ccw_bus_type;

Linus Torvalds's avatar
Linus Torvalds committed
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
/******************* bus type handling ***********************/

/* The Linux driver model distinguishes between a bus type and
 * the bus itself. Of course we only have one channel
 * subsystem driver and one channel system per machine, but
 * we still use the abstraction. T.R. says it's a good idea. */
static int
ccw_bus_match (struct device * dev, struct device_driver * drv)
{
	struct ccw_device *cdev = to_ccwdev(dev);
	struct ccw_driver *cdrv = to_ccwdrv(drv);
	const struct ccw_device_id *ids = cdrv->ids, *found;

	if (!ids)
		return 0;

	found = ccw_device_id_match(ids, &cdev->id);
	if (!found)
		return 0;

	cdev->id.driver_info = found->driver_info;

	return 1;
}

79 80 81
/* Store modalias string delimited by prefix/suffix string into buffer with
 * specified size. Return length of resulting string (excluding trailing '\0')
 * even if string doesn't fit buffer (snprintf semantics). */
82
static int snprint_alias(char *buf, size_t size,
83
			 struct ccw_device_id *id, const char *suffix)
Linus Torvalds's avatar
Linus Torvalds committed
84
{
85
	int len;
Linus Torvalds's avatar
Linus Torvalds committed
86

87
	len = snprintf(buf, size, "ccw:t%04Xm%02X", id->cu_type, id->cu_model);
88 89 90 91
	if (len > size)
		return len;
	buf += len;
	size -= len;
Linus Torvalds's avatar
Linus Torvalds committed
92

93 94 95 96 97
	if (id->dev_type != 0)
		len += snprintf(buf, size, "dt%04Xdm%02X%s", id->dev_type,
				id->dev_model, suffix);
	else
		len += snprintf(buf, size, "dtdm%s", suffix);
Linus Torvalds's avatar
Linus Torvalds committed
98

99 100 101 102 103
	return len;
}

/* Set up environment variables for ccw device uevent. Return 0 on success,
 * non-zero otherwise. */
104
static int ccw_uevent(struct device *dev, struct kobj_uevent_env *env)
105 106 107
{
	struct ccw_device *cdev = to_ccwdev(dev);
	struct ccw_device_id *id = &(cdev->id);
108 109
	int ret;
	char modalias_buf[30];
Linus Torvalds's avatar
Linus Torvalds committed
110

111
	/* CU_TYPE= */
112
	ret = add_uevent_var(env, "CU_TYPE=%04X", id->cu_type);
113 114
	if (ret)
		return ret;
115 116

	/* CU_MODEL= */
117
	ret = add_uevent_var(env, "CU_MODEL=%02X", id->cu_model);
118 119
	if (ret)
		return ret;
Linus Torvalds's avatar
Linus Torvalds committed
120 121

	/* The next two can be zero, that's ok for us */
122
	/* DEV_TYPE= */
123
	ret = add_uevent_var(env, "DEV_TYPE=%04X", id->dev_type);
124 125
	if (ret)
		return ret;
Linus Torvalds's avatar
Linus Torvalds committed
126

127
	/* DEV_MODEL= */
128
	ret = add_uevent_var(env, "DEV_MODEL=%02X", id->dev_model);
129 130
	if (ret)
		return ret;
131 132

	/* MODALIAS=  */
133
	snprint_alias(modalias_buf, sizeof(modalias_buf), id, "");
134 135
	ret = add_uevent_var(env, "MODALIAS=%s", modalias_buf);
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
136 137
}

138 139
static void io_subchannel_irq(struct subchannel *);
static int io_subchannel_probe(struct subchannel *);
140
static void io_subchannel_remove(struct subchannel *);
141
static void io_subchannel_shutdown(struct subchannel *);
142
static int io_subchannel_sch_event(struct subchannel *, int);
143 144
static int io_subchannel_chp_event(struct subchannel *, struct chp_link *,
				   int);
145
static void recovery_func(struct timer_list *unused);
Linus Torvalds's avatar
Linus Torvalds committed
146

147 148 149 150 151
static struct css_device_id io_subchannel_ids[] = {
	{ .match_flags = 0x1, .type = SUBCHANNEL_TYPE_IO, },
	{ /* end of list */ },
};

152
static int io_subchannel_settle(void)
153
{
154 155 156 157 158 159
	int ret;

	ret = wait_event_interruptible(ccw_device_init_wq,
				atomic_read(&ccw_device_init_count) == 0);
	if (ret)
		return -EINTR;
160
	flush_workqueue(cio_work_q);
161
	return 0;
162 163
}

164
static struct css_driver io_subchannel_driver = {
165 166 167 168
	.drv = {
		.owner = THIS_MODULE,
		.name = "io_subchannel",
	},
169
	.subchannel_type = io_subchannel_ids,
Linus Torvalds's avatar
Linus Torvalds committed
170
	.irq = io_subchannel_irq,
171 172
	.sch_event = io_subchannel_sch_event,
	.chp_event = io_subchannel_chp_event,
173 174 175
	.probe = io_subchannel_probe,
	.remove = io_subchannel_remove,
	.shutdown = io_subchannel_shutdown,
176
	.settle = io_subchannel_settle,
Linus Torvalds's avatar
Linus Torvalds committed
177 178
};

Sebastian Ott's avatar
Sebastian Ott committed
179
int __init io_subchannel_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
180 181 182
{
	int ret;

183
	timer_setup(&recovery_timer, recovery_func, 0);
184 185 186
	ret = bus_register(&ccw_bus_type);
	if (ret)
		return ret;
187 188
	ret = css_driver_register(&io_subchannel_driver);
	if (ret)
189
		bus_unregister(&ccw_bus_type);
Linus Torvalds's avatar
Linus Torvalds committed
190 191 192 193 194 195 196 197

	return ret;
}


/************************ device handling **************************/

static ssize_t
198
devtype_show (struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
199 200 201 202 203 204 205 206 207 208 209 210
{
	struct ccw_device *cdev = to_ccwdev(dev);
	struct ccw_device_id *id = &(cdev->id);

	if (id->dev_type != 0)
		return sprintf(buf, "%04x/%02x\n",
				id->dev_type, id->dev_model);
	else
		return sprintf(buf, "n/a\n");
}

static ssize_t
211
cutype_show (struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
212 213 214 215 216 217 218 219
{
	struct ccw_device *cdev = to_ccwdev(dev);
	struct ccw_device_id *id = &(cdev->id);

	return sprintf(buf, "%04x/%02x\n",
		       id->cu_type, id->cu_model);
}

220 221 222 223 224
static ssize_t
modalias_show (struct device *dev, struct device_attribute *attr, char *buf)
{
	struct ccw_device *cdev = to_ccwdev(dev);
	struct ccw_device_id *id = &(cdev->id);
225
	int len;
226

227
	len = snprint_alias(buf, PAGE_SIZE, id, "\n");
228 229

	return len > PAGE_SIZE ? PAGE_SIZE : len;
230 231
}

Linus Torvalds's avatar
Linus Torvalds committed
232
static ssize_t
233
online_show (struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
234 235 236 237 238 239
{
	struct ccw_device *cdev = to_ccwdev(dev);

	return sprintf(buf, cdev->online ? "1\n" : "0\n");
}

240 241 242 243 244
int ccw_device_is_orphan(struct ccw_device *cdev)
{
	return sch_is_pseudo_sch(to_subchannel(cdev->dev.parent));
}

245
static void ccw_device_unregister(struct ccw_device *cdev)
246
{
247
	if (device_is_registered(&cdev->dev)) {
248
		/* Undo device_add(). */
249
		device_del(&cdev->dev);
250 251 252
	}
	if (cdev->private->flags.initialized) {
		cdev->private->flags.initialized = 0;
253 254 255
		/* Release reference from device_initialize(). */
		put_device(&cdev->dev);
	}
256 257
}

258 259
static void io_subchannel_quiesce(struct subchannel *);

260 261 262 263 264 265 266 267 268 269 270 271
/**
 * ccw_device_set_offline() - disable a ccw device for I/O
 * @cdev: target ccw device
 *
 * This function calls the driver's set_offline() function for @cdev, if
 * given, and then disables @cdev.
 * Returns:
 *   %0 on success and a negative error value on failure.
 * Context:
 *  enabled, ccw device lock not held
 */
int ccw_device_set_offline(struct ccw_device *cdev)
Linus Torvalds's avatar
Linus Torvalds committed
272
{
273 274
	struct subchannel *sch;
	int ret, state;
Linus Torvalds's avatar
Linus Torvalds committed
275 276 277 278 279 280 281 282 283 284 285 286

	if (!cdev)
		return -ENODEV;
	if (!cdev->online || !cdev->drv)
		return -EINVAL;

	if (cdev->drv->set_offline) {
		ret = cdev->drv->set_offline(cdev);
		if (ret != 0)
			return ret;
	}
	spin_lock_irq(cdev->ccwlock);
287
	sch = to_subchannel(cdev->dev.parent);
288
	cdev->online = 0;
289 290 291
	/* Wait until a final state or DISCONNECTED is reached */
	while (!dev_fsm_final_state(cdev) &&
	       cdev->private->state != DEV_STATE_DISCONNECTED) {
Linus Torvalds's avatar
Linus Torvalds committed
292
		spin_unlock_irq(cdev->ccwlock);
293 294 295
		wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
			   cdev->private->state == DEV_STATE_DISCONNECTED));
		spin_lock_irq(cdev->ccwlock);
Linus Torvalds's avatar
Linus Torvalds committed
296
	}
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
	do {
		ret = ccw_device_offline(cdev);
		if (!ret)
			break;
		CIO_MSG_EVENT(0, "ccw_device_offline returned %d, device "
			      "0.%x.%04x\n", ret, cdev->private->dev_id.ssid,
			      cdev->private->dev_id.devno);
		if (ret != -EBUSY)
			goto error;
		state = cdev->private->state;
		spin_unlock_irq(cdev->ccwlock);
		io_subchannel_quiesce(sch);
		spin_lock_irq(cdev->ccwlock);
		cdev->private->state = state;
	} while (ret == -EBUSY);
Linus Torvalds's avatar
Linus Torvalds committed
312
	spin_unlock_irq(cdev->ccwlock);
313 314
	wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
		   cdev->private->state == DEV_STATE_DISCONNECTED));
315 316
	/* Inform the user if set offline failed. */
	if (cdev->private->state == DEV_STATE_BOXED) {
317 318
		pr_warn("%s: The device entered boxed state while being set offline\n",
			dev_name(&cdev->dev));
319
	} else if (cdev->private->state == DEV_STATE_NOT_OPER) {
320 321
		pr_warn("%s: The device stopped operating while being set offline\n",
			dev_name(&cdev->dev));
322
	}
323 324 325 326 327 328 329 330 331 332 333
	/* Give up reference from ccw_device_set_online(). */
	put_device(&cdev->dev);
	return 0;

error:
	cdev->private->state = DEV_STATE_OFFLINE;
	dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
	spin_unlock_irq(cdev->ccwlock);
	/* Give up reference from ccw_device_set_online(). */
	put_device(&cdev->dev);
	return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
334 335
}

336 337 338 339 340 341 342 343 344 345 346 347 348
/**
 * ccw_device_set_online() - enable a ccw device for I/O
 * @cdev: target ccw device
 *
 * This function first enables @cdev and then calls the driver's set_online()
 * function for @cdev, if given. If set_online() returns an error, @cdev is
 * disabled again.
 * Returns:
 *   %0 on success and a negative error value on failure.
 * Context:
 *  enabled, ccw device lock not held
 */
int ccw_device_set_online(struct ccw_device *cdev)
Linus Torvalds's avatar
Linus Torvalds committed
349 350
{
	int ret;
351
	int ret2;
Linus Torvalds's avatar
Linus Torvalds committed
352 353 354 355 356

	if (!cdev)
		return -ENODEV;
	if (cdev->online || !cdev->drv)
		return -EINVAL;
357 358 359
	/* Hold on to an extra reference while device is online. */
	if (!get_device(&cdev->dev))
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
360 361 362 363 364 365 366

	spin_lock_irq(cdev->ccwlock);
	ret = ccw_device_online(cdev);
	spin_unlock_irq(cdev->ccwlock);
	if (ret == 0)
		wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));
	else {
367
		CIO_MSG_EVENT(0, "ccw_device_online returned %d, "
368 369 370
			      "device 0.%x.%04x\n",
			      ret, cdev->private->dev_id.ssid,
			      cdev->private->dev_id.devno);
371 372
		/* Give up online reference since onlining failed. */
		put_device(&cdev->dev);
Linus Torvalds's avatar
Linus Torvalds committed
373 374
		return ret;
	}
375 376 377 378 379
	spin_lock_irq(cdev->ccwlock);
	/* Check if online processing was successful */
	if ((cdev->private->state != DEV_STATE_ONLINE) &&
	    (cdev->private->state != DEV_STATE_W4SENSE)) {
		spin_unlock_irq(cdev->ccwlock);
380 381
		/* Inform the user that set online failed. */
		if (cdev->private->state == DEV_STATE_BOXED) {
382 383
			pr_warn("%s: Setting the device online failed because it is boxed\n",
				dev_name(&cdev->dev));
384
		} else if (cdev->private->state == DEV_STATE_NOT_OPER) {
385 386
			pr_warn("%s: Setting the device online failed because it is not operational\n",
				dev_name(&cdev->dev));
387
		}
388 389
		/* Give up online reference since onlining failed. */
		put_device(&cdev->dev);
Linus Torvalds's avatar
Linus Torvalds committed
390
		return -ENODEV;
391
	}
392 393 394 395 396
	spin_unlock_irq(cdev->ccwlock);
	if (cdev->drv->set_online)
		ret = cdev->drv->set_online(cdev);
	if (ret)
		goto rollback;
397 398

	spin_lock_irq(cdev->ccwlock);
399
	cdev->online = 1;
400
	spin_unlock_irq(cdev->ccwlock);
401 402 403
	return 0;

rollback:
Linus Torvalds's avatar
Linus Torvalds committed
404
	spin_lock_irq(cdev->ccwlock);
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
	/* Wait until a final state or DISCONNECTED is reached */
	while (!dev_fsm_final_state(cdev) &&
	       cdev->private->state != DEV_STATE_DISCONNECTED) {
		spin_unlock_irq(cdev->ccwlock);
		wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
			   cdev->private->state == DEV_STATE_DISCONNECTED));
		spin_lock_irq(cdev->ccwlock);
	}
	ret2 = ccw_device_offline(cdev);
	if (ret2)
		goto error;
	spin_unlock_irq(cdev->ccwlock);
	wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
		   cdev->private->state == DEV_STATE_DISCONNECTED));
	/* Give up online reference since onlining failed. */
	put_device(&cdev->dev);
	return ret;

error:
	CIO_MSG_EVENT(0, "rollback ccw_device_offline returned %d, "
		      "device 0.%x.%04x\n",
		      ret2, cdev->private->dev_id.ssid,
		      cdev->private->dev_id.devno);
	cdev->private->state = DEV_STATE_OFFLINE;
Linus Torvalds's avatar
Linus Torvalds committed
429
	spin_unlock_irq(cdev->ccwlock);
430 431
	/* Give up online reference since onlining failed. */
	put_device(&cdev->dev);
432
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
433 434
}

435
static int online_store_handle_offline(struct ccw_device *cdev)
436
{
437 438 439 440
	if (cdev->private->state == DEV_STATE_DISCONNECTED) {
		spin_lock_irq(cdev->ccwlock);
		ccw_device_sched_todo(cdev, CDEV_TODO_UNREG_EVAL);
		spin_unlock_irq(cdev->ccwlock);
441 442 443
		return 0;
	}
	if (cdev->drv && cdev->drv->set_offline)
444
		return ccw_device_set_offline(cdev);
445
	return -EINVAL;
446 447 448 449 450
}

static int online_store_recog_and_online(struct ccw_device *cdev)
{
	/* Do device recognition, if needed. */
451
	if (cdev->private->state == DEV_STATE_BOXED) {
452
		spin_lock_irq(cdev->ccwlock);
453
		ccw_device_recognition(cdev);
454
		spin_unlock_irq(cdev->ccwlock);
455 456
		wait_event(cdev->private->wait_q,
			   cdev->private->flags.recog_done);
457 458 459
		if (cdev->private->state != DEV_STATE_OFFLINE)
			/* recognition failed */
			return -EAGAIN;
460 461
	}
	if (cdev->drv && cdev->drv->set_online)
462 463
		return ccw_device_set_online(cdev);
	return -EINVAL;
464
}
465

466
static int online_store_handle_online(struct ccw_device *cdev, int force)
467 468 469 470
{
	int ret;

	ret = online_store_recog_and_online(cdev);
471
	if (ret && !force)
472
		return ret;
473 474
	if (force && cdev->private->state == DEV_STATE_BOXED) {
		ret = ccw_device_stlck(cdev);
475 476
		if (ret)
			return ret;
477 478
		if (cdev->id.cu_type == 0)
			cdev->private->state = DEV_STATE_NOT_OPER;
479 480 481
		ret = online_store_recog_and_online(cdev);
		if (ret)
			return ret;
482
	}
483
	return 0;
484 485 486 487
}

static ssize_t online_store (struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
Linus Torvalds's avatar
Linus Torvalds committed
488 489
{
	struct ccw_device *cdev = to_ccwdev(dev);
490 491
	int force, ret;
	unsigned long i;
Linus Torvalds's avatar
Linus Torvalds committed
492

493
	/* Prevent conflict between multiple on-/offline processing requests. */
494
	if (atomic_cmpxchg(&cdev->private->onoff, 0, 1) != 0)
Linus Torvalds's avatar
Linus Torvalds committed
495
		return -EAGAIN;
496 497 498 499
	/* Prevent conflict between internal I/Os and on-/offline processing. */
	if (!dev_fsm_final_state(cdev) &&
	    cdev->private->state != DEV_STATE_DISCONNECTED) {
		ret = -EAGAIN;
500
		goto out;
501 502 503 504
	}
	/* Prevent conflict between pending work and on-/offline processing.*/
	if (work_pending(&cdev->private->todo_work)) {
		ret = -EAGAIN;
505
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
506 507 508 509
	}
	if (!strncmp(buf, "force\n", count)) {
		force = 1;
		i = 1;
510
		ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
511 512
	} else {
		force = 0;
513
		ret = kstrtoul(buf, 16, &i);
Linus Torvalds's avatar
Linus Torvalds committed
514
	}
515 516
	if (ret)
		goto out;
517 518

	device_lock(dev);
519 520
	switch (i) {
	case 0:
521
		ret = online_store_handle_offline(cdev);
522 523
		break;
	case 1:
524
		ret = online_store_handle_online(cdev, force);
525 526
		break;
	default:
527
		ret = -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
528
	}
529 530
	device_unlock(dev);

531
out:
Linus Torvalds's avatar
Linus Torvalds committed
532
	atomic_set(&cdev->private->onoff, 0);
533
	return (ret < 0) ? ret : count;
Linus Torvalds's avatar
Linus Torvalds committed
534 535 536
}

static ssize_t
537
available_show (struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
538 539 540 541
{
	struct ccw_device *cdev = to_ccwdev(dev);
	struct subchannel *sch;

542 543
	if (ccw_device_is_orphan(cdev))
		return sprintf(buf, "no device\n");
Linus Torvalds's avatar
Linus Torvalds committed
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
	switch (cdev->private->state) {
	case DEV_STATE_BOXED:
		return sprintf(buf, "boxed\n");
	case DEV_STATE_DISCONNECTED:
	case DEV_STATE_DISCONNECTED_SENSE_ID:
	case DEV_STATE_NOT_OPER:
		sch = to_subchannel(dev->parent);
		if (!sch->lpm)
			return sprintf(buf, "no path\n");
		else
			return sprintf(buf, "no device\n");
	default:
		/* All other states considered fine. */
		return sprintf(buf, "good\n");
	}
}

561 562 563 564 565 566 567 568 569
static ssize_t
initiate_logging(struct device *dev, struct device_attribute *attr,
		 const char *buf, size_t count)
{
	struct subchannel *sch = to_subchannel(dev);
	int rc;

	rc = chsc_siosl(sch->schid);
	if (rc < 0) {
570 571
		pr_warn("Logging for subchannel 0.%x.%04x failed with errno=%d\n",
			sch->schid.ssid, sch->schid.sch_no, rc);
572 573 574 575 576 577 578
		return rc;
	}
	pr_notice("Logging for subchannel 0.%x.%04x was triggered\n",
		  sch->schid.ssid, sch->schid.sch_no);
	return count;
}

579 580 581 582 583 584 585 586
static ssize_t vpm_show(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	struct subchannel *sch = to_subchannel(dev);

	return sprintf(buf, "%02x\n", sch->vpm);
}

Joe Perches's avatar
Joe Perches committed
587 588 589
static DEVICE_ATTR_RO(devtype);
static DEVICE_ATTR_RO(cutype);
static DEVICE_ATTR_RO(modalias);
Joe Perches's avatar
Joe Perches committed
590
static DEVICE_ATTR_RW(online);
Linus Torvalds's avatar
Linus Torvalds committed
591
static DEVICE_ATTR(availability, 0444, available_show, NULL);
592
static DEVICE_ATTR(logging, 0200, NULL, initiate_logging);
Joe Perches's avatar
Joe Perches committed
593
static DEVICE_ATTR_RO(vpm);
Linus Torvalds's avatar
Linus Torvalds committed
594

595
static struct attribute *io_subchannel_attrs[] = {
596
	&dev_attr_logging.attr,
597
	&dev_attr_vpm.attr,
Linus Torvalds's avatar
Linus Torvalds committed
598 599 600
	NULL,
};

601
static const struct attribute_group io_subchannel_attr_group = {
602
	.attrs = io_subchannel_attrs,
603
};
Linus Torvalds's avatar
Linus Torvalds committed
604 605 606 607

static struct attribute * ccwdev_attrs[] = {
	&dev_attr_devtype.attr,
	&dev_attr_cutype.attr,
608
	&dev_attr_modalias.attr,
Linus Torvalds's avatar
Linus Torvalds committed
609 610 611 612 613 614
	&dev_attr_online.attr,
	&dev_attr_cmb_enable.attr,
	&dev_attr_availability.attr,
	NULL,
};

615
static const struct attribute_group ccwdev_attr_group = {
Linus Torvalds's avatar
Linus Torvalds committed
616 617 618
	.attrs = ccwdev_attrs,
};

619
static const struct attribute_group *ccwdev_attr_groups[] = {
620 621 622
	&ccwdev_attr_group,
	NULL,
};
Linus Torvalds's avatar
Linus Torvalds committed
623

624
static int match_dev_id(struct device *dev, const void *data)
625
{
626
	struct ccw_device *cdev = to_ccwdev(dev);
627
	struct ccw_dev_id *dev_id = (void *)data;
628 629 630 631

	return ccw_dev_id_is_equal(&cdev->private->dev_id, dev_id);
}

632 633 634 635 636 637 638 639 640 641 642
/**
 * get_ccwdev_by_dev_id() - obtain device from a ccw device id
 * @dev_id: id of the device to be searched
 *
 * This function searches all devices attached to the ccw bus for a device
 * matching @dev_id.
 * Returns:
 *  If a device is found its reference count is increased and returned;
 *  else %NULL is returned.
 */
struct ccw_device *get_ccwdev_by_dev_id(struct ccw_dev_id *dev_id)
643 644 645
{
	struct device *dev;

646
	dev = bus_find_device(&ccw_bus_type, NULL, dev_id, match_dev_id);
647 648 649

	return dev ? to_ccwdev(dev) : NULL;
}
650
EXPORT_SYMBOL_GPL(get_ccwdev_by_dev_id);
651

652
static void ccw_device_do_unbind_bind(struct ccw_device *cdev)
Linus Torvalds's avatar
Linus Torvalds committed
653
{
654
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
655

656
	if (device_is_registered(&cdev->dev)) {
657 658 659 660
		device_release_driver(&cdev->dev);
		ret = device_attach(&cdev->dev);
		WARN_ON(ret == -ENODEV);
	}
Linus Torvalds's avatar
Linus Torvalds committed
661 662 663 664 665 666 667 668
}

static void
ccw_device_release(struct device *dev)
{
	struct ccw_device *cdev;

	cdev = to_ccwdev(dev);
669 670 671
	cio_gp_dma_free(cdev->private->dma_pool, cdev->private->dma_area,
			sizeof(*cdev->private->dma_area));
	cio_gp_dma_destroy(cdev->private->dma_pool, &cdev->dev);
672 673
	/* Release reference of parent subchannel. */
	put_device(cdev->dev.parent);
Linus Torvalds's avatar
Linus Torvalds committed
674 675 676 677
	kfree(cdev->private);
	kfree(cdev);
}

678 679 680
static struct ccw_device * io_subchannel_allocate_dev(struct subchannel *sch)
{
	struct ccw_device *cdev;
681
	struct gen_pool *dma_pool;
682
	int ret;
683 684

	cdev  = kzalloc(sizeof(*cdev), GFP_KERNEL);
685 686
	if (!cdev) {
		ret = -ENOMEM;
687
		goto err_cdev;
688
	}
689 690
	cdev->private = kzalloc(sizeof(struct ccw_device_private),
				GFP_KERNEL | GFP_DMA);
691 692
	if (!cdev->private) {
		ret = -ENOMEM;
693
		goto err_priv;
694 695
	}

696
	cdev->dev.dma_mask = sch->dev.dma_mask;
697 698 699 700
	ret = dma_set_coherent_mask(&cdev->dev, sch->dev.coherent_dma_mask);
	if (ret)
		goto err_coherent_mask;

701
	dma_pool = cio_gp_dma_create(&cdev->dev, 1);
702 703
	if (!dma_pool) {
		ret = -ENOMEM;
704
		goto err_dma_pool;
705
	}
706 707 708
	cdev->private->dma_pool = dma_pool;
	cdev->private->dma_area = cio_gp_dma_zalloc(dma_pool, &cdev->dev,
					sizeof(*cdev->private->dma_area));
709 710
	if (!cdev->private->dma_area) {
		ret = -ENOMEM;
711
		goto err_dma_area;
712
	}
713 714 715 716
	return cdev;
err_dma_area:
	cio_gp_dma_destroy(dma_pool, &cdev->dev);
err_dma_pool:
717
err_coherent_mask:
718 719
	kfree(cdev->private);
err_priv:
720
	kfree(cdev);
721
err_cdev:
722
	return ERR_PTR(ret);
723 724
}

725 726
static void ccw_device_todo(struct work_struct *work);

727 728 729
static int io_subchannel_initialize_dev(struct subchannel *sch,
					struct ccw_device *cdev)
{
730 731 732 733 734 735 736 737 738 739 740 741
	struct ccw_device_private *priv = cdev->private;
	int ret;

	priv->cdev = cdev;
	priv->int_class = IRQIO_CIO;
	priv->state = DEV_STATE_NOT_OPER;
	priv->dev_id.devno = sch->schib.pmcw.dev;
	priv->dev_id.ssid = sch->schid.ssid;

	INIT_WORK(&priv->todo_work, ccw_device_todo);
	INIT_LIST_HEAD(&priv->cmb_list);
	init_waitqueue_head(&priv->wait_q);
742
	timer_setup(&priv->timer, ccw_device_timeout, 0);
743 744 745

	atomic_set(&priv->onoff, 0);
	cdev->ccwlock = sch->lock;
746 747
	cdev->dev.parent = &sch->dev;
	cdev->dev.release = ccw_device_release;
748
	cdev->dev.bus = &ccw_bus_type;
749
	cdev->dev.groups = ccwdev_attr_groups;
750 751
	/* Do first half of device_register. */
	device_initialize(&cdev->dev);
752 753 754 755
	ret = dev_set_name(&cdev->dev, "0.%x.%04x", cdev->private->dev_id.ssid,
			   cdev->private->dev_id.devno);
	if (ret)
		goto out_put;
756
	if (!get_device(&sch->dev)) {
757 758
		ret = -ENODEV;
		goto out_put;
759
	}
760 761 762 763
	priv->flags.initialized = 1;
	spin_lock_irq(sch->lock);
	sch_set_cdev(sch, cdev);
	spin_unlock_irq(sch->lock);
764
	return 0;
765 766 767 768 769

out_put:
	/* Release reference from device_initialize(). */
	put_device(&cdev->dev);
	return ret;
770 771 772 773 774 775 776 777 778 779
}

static struct ccw_device * io_subchannel_create_ccwdev(struct subchannel *sch)
{
	struct ccw_device *cdev;
	int ret;

	cdev = io_subchannel_allocate_dev(sch);
	if (!IS_ERR(cdev)) {
		ret = io_subchannel_initialize_dev(sch, cdev);
780
		if (ret)
781 782 783 784 785
			cdev = ERR_PTR(ret);
	}
	return cdev;
}

786
static void io_subchannel_recog(struct ccw_device *, struct subchannel *);
787 788 789 790 791 792 793 794 795 796 797 798 799

static void sch_create_and_recog_new_device(struct subchannel *sch)
{
	struct ccw_device *cdev;

	/* Need to allocate a new ccw device. */
	cdev = io_subchannel_create_ccwdev(sch);
	if (IS_ERR(cdev)) {
		/* OK, we did everything we could... */
		css_sch_device_unregister(sch);
		return;
	}
	/* Start recognition for the new ccw device. */
800
	io_subchannel_recog(cdev, sch);
801 802
}

Linus Torvalds's avatar
Linus Torvalds committed
803 804 805
/*
 * Register recognized device.
 */
806
static void io_subchannel_register(struct ccw_device *cdev)
Linus Torvalds's avatar
Linus Torvalds committed
807 808
{
	struct subchannel *sch;
809
	int ret, adjust_init_count = 1;
Linus Torvalds's avatar
Linus Torvalds committed
810 811 812
	unsigned long flags;

	sch = to_subchannel(cdev->dev.parent);
813 814 815 816 817 818 819 820
	/*
	 * Check if subchannel is still registered. It may have become
	 * unregistered if a machine check hit us after finishing
	 * device recognition but before the register work could be
	 * queued.
	 */
	if (!device_is_registered(&sch->dev))
		goto out_err;
821
	css_update_ssd_info(sch);
822 823 824 825 826 827
	/*
	 * io_subchannel_register() will also be called after device
	 * recognition has been done for a boxed device (which will already
	 * be registered). We need to reprobe since we may now have sense id
	 * information.
	 */
828
	if (device_is_registered(&cdev->dev)) {
829 830 831 832
		if (!cdev->drv) {
			ret = device_reprobe(&cdev->dev);
			if (ret)
				/* We can't do much here. */
833
				CIO_MSG_EVENT(0, "device_reprobe() returned"
834 835 836
					      " %d for 0.%x.%04x\n", ret,
					      cdev->private->dev_id.ssid,
					      cdev->private->dev_id.devno);
837
		}
838
		adjust_init_count = 0;
Linus Torvalds's avatar
Linus Torvalds committed
839 840
		goto out;
	}
841 842 843 844
	/*
	 * Now we know this subchannel will stay, we can throw
	 * our delayed uevent.
	 */
845 846 847 848
	if (dev_get_uevent_suppress(&sch->dev)) {
		dev_set_uevent_suppress(&sch->dev, 0);
		kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
	}
Linus Torvalds's avatar
Linus Torvalds committed
849
	/* make it known to the system */
850
	ret = device_add(&cdev->dev);
Linus Torvalds's avatar
Linus Torvalds committed
851
	if (ret) {
852 853 854
		CIO_MSG_EVENT(0, "Could not register ccw dev 0.%x.%04x: %d\n",
			      cdev->private->dev_id.ssid,
			      cdev->private->dev_id.devno, ret);
855
		spin_lock_irqsave(sch->lock, flags);
856
		sch_set_cdev(sch, NULL);
857
		spin_unlock_irqrestore(sch->lock, flags);
858 859
		/* Release initial device reference. */
		put_device(&cdev->dev);
860
		goto out_err;
Linus Torvalds's avatar
Linus Torvalds committed
861 862 863 864
	}
out:
	cdev->private->flags.recog_done = 1;
	wake_up(&cdev->private->wait_q);
865
out_err:
866
	if (adjust_init_count && atomic_dec_and_test(&ccw_device_init_count))
Linus Torvalds's avatar
Linus Torvalds committed
867 868 869 870 871 872 873 874 875 876 877 878 879 880
		wake_up(&ccw_device_init_wq);
}

/*
 * subchannel recognition done. Called from the state machine.
 */
void
io_subchannel_recog_done(struct ccw_device *cdev)
{
	if (css_init_done == 0) {
		cdev->private->flags.recog_done = 1;
		return;
	}
	switch (cdev->private->state) {
881 882
	case DEV_STATE_BOXED:
		/* Device did not respond in time. */
Linus Torvalds's avatar
Linus Torvalds committed
883 884
	case DEV_STATE_NOT_OPER:
		cdev->private->flags.recog_done = 1;
885 886
		/* Remove device found not operational. */
		ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
Linus Torvalds's avatar
Linus Torvalds committed
887 888 889 890
		if (atomic_dec_and_test(&ccw_device_init_count))
			wake_up(&ccw_device_init_wq);
		break;
	case DEV_STATE_OFFLINE:
891
		/*
Linus Torvalds's avatar
Linus Torvalds committed
892 893 894
		 * We can't register the device in interrupt context so
		 * we schedule a work item.
		 */
895
		ccw_device_sched_todo(cdev, CDEV_TODO_REGISTER);
Linus Torvalds's avatar
Linus Torvalds committed
896 897 898 899
		break;
	}
}

900
static void io_subchannel_recog(struct ccw_device *cdev, struct subchannel *sch)
Linus Torvalds's avatar
Linus Torvalds committed
901 902 903 904 905
{
	/* Increase counter of devices currently in recognition. */
	atomic_inc(&ccw_device_init_count);

	/* Start async. device sensing. */
906
	spin_lock_irq(sch->lock);
907
	ccw_device_recognition(cdev);
908
	spin_unlock_irq(sch->lock);
Linus Torvalds's avatar
Linus Torvalds committed
909 910
}

911 912
static int ccw_device_move_to_sch(struct ccw_device *cdev,
				  struct subchannel *sch)
913
{
914
	struct subchannel *old_sch;
915
	int rc, old_enabled = 0;
916

917 918
	old_sch = to_subchannel(cdev->dev.parent);
	/* Obtain child reference for new parent. */
919
	if (!get_device(&sch->dev))
920
		return -ENODEV;
921 922 923 924 925 926 927 928 929 930 931 932 933 934 935

	if (!sch_is_pseudo_sch(old_sch)) {
		spin_lock_irq(old_sch->lock);
		old_enabled = old_sch->schib.pmcw.ena;
		rc = 0;
		if (old_enabled)
			rc = cio_disable_subchannel(old_sch);
		spin_unlock_irq(old_sch->lock);
		if (rc == -EBUSY) {
			/* Release child reference for new parent. */
			put_device(&sch->dev);
			return rc;
		}
	}

936
	mutex_lock(&sch->reg_mutex);
937
	rc = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
938 939
	mutex_unlock(&sch->reg_mutex);
	if (rc) {
940
		CIO_MSG_EVENT(0, "device_move(0.%x.%04x,0.%x.%04x)=%d\n",
941 942
			      cdev->private->dev_id.ssid,
			      cdev->private->dev_id.devno, sch->schid.ssid,
943
			      sch->schib.pmcw.dev, rc);
944 945 946 947 948 949
		if (old_enabled) {
			/* Try to reenable the old subchannel. */
			spin_lock_irq(old_sch->lock);
			cio_enable_subchannel(old_sch, (u32)(addr_t)old_sch);
			spin_unlock_irq(old_sch->lock);
		}
950
		/* Release child reference for new parent. */
951
		put_device(&sch->dev);
952
		return rc;
953
	}
954 955 956 957 958 959
	/* Clean up old subchannel. */
	if (!sch_is_pseudo_sch(old_sch)) {
		spin_lock_irq(old_sch->lock);
		sch_set_cdev(old_sch, NULL);
		spin_unlock_irq(old_sch->lock);
		css_schedule_eval(old_sch->schid);
960
	}
961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979
	/* Release child reference for old parent. */
	put_device(&old_sch->dev);
	/* Initialize new subchannel. */
	spin_lock_irq(sch->lock);
	cdev->ccwlock = sch->lock;
	if (!sch_is_pseudo_sch(sch))
		sch_set_cdev(sch, cdev);
	spin_unlock_irq(sch->lock);
	if (!sch_is_pseudo_sch(sch))
		css_update_ssd_info(sch);
	return 0;
}

static int ccw_device_move_to_orph(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct channel_subsystem *css = to_css(sch->dev.parent);

	return ccw_device_move_to_sch(cdev, css->pseudo_subchannel);
980 981
}

982 983 984 985
static void io_subchannel_irq(struct subchannel *sch)
{
	struct ccw_device *cdev;

986
	cdev = sch_get_cdev(sch);
987

988 989
	CIO_TRACE_EVENT(6, "IRQ");
	CIO_TRACE_EVENT(6, dev_name(&sch->dev));
990 991
	if (cdev)
		dev_fsm_event(cdev, DEV_EVENT_INTERRUPT);
992
	else
993
		inc_irq_stat(IRQIO_CIO);
994 995
}

996 997 998 999 1000 1001
void io_subchannel_init_config(struct subchannel *sch)
{
	memset(&sch->config, 0, sizeof(sch->config));
	sch->config.csense = 1;
}

1002 1003 1004 1005 1006 1007 1008
static void io_subchannel_init_fields(struct subchannel *sch)
{
	if (cio_is_console(sch->schid))
		sch->opm = 0xff;
	else
		sch->opm = chp_get_sch_opm(sch);
	sch->lpm = sch->schib.pmcw.pam & sch->opm;
1009
	sch->isc = cio_is_console(sch->schid) ? CONSOLE_ISC : IO_SCH_ISC;
1010 1011 1012 1013 1014 1015

	CIO_MSG_EVENT(6, "Detected device %04x on subchannel 0.%x.%04X"
		      " - PIM = %02X, PAM = %02X, POM = %02X\n",
		      sch->schib.pmcw.dev, sch->schid.ssid,
		      sch->schid.sch_no, sch->schib.pmcw.pim,
		      sch->schib.pmcw.pam, sch->schib.pmcw.pom);
1016 1017

	io_subchannel_init_config(sch);
1018 1019
}

1020 1021 1022 1023
/*
 * Note: We always return 0 so that we bind to the device even on error.
 * This is needed so that our remove function is called on unregister.
 */
1024
static int io_subchannel_probe(struct subchannel *sch)
Linus Torvalds's avatar
Linus Torvalds committed
1025
{
1026
	struct io_subchannel_private *io_priv;
Linus Torvalds's avatar
Linus Torvalds committed
1027 1028 1029
	struct ccw_device *cdev;
	int rc;

1030
	if (cio_is_console(sch->schid)) {
1031 1032 1033 1034 1035 1036 1037
		rc = sysfs_create_group(&sch->dev.kobj,
					&io_subchannel_attr_group);
		if (rc)
			CIO_MSG_EVENT(0, "Failed to create io subchannel "
				      "attributes for subchannel "
				      "0.%x.%04x (rc=%d)\n",
				      sch->schid.ssid, sch->schid.sch_no, rc);
Linus Torvalds's avatar
Linus Torvalds committed
1038
		/*
1039
		 * The console subchannel already has an associated ccw_device.
1040
		 * Throw the delayed uevent for the subchannel, register
1041
		 * the ccw_device and exit.
Linus Torvalds's avatar
Linus Torvalds committed
1042
		 */
1043 1044 1045 1046 1047
		if (dev_get_uevent_suppress(&sch->dev)) {
			/* should always be the case for the console */
			dev_set_uevent_suppress(&sch->dev, 0);
			kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
		}
1048
		cdev = sch_get_cdev(sch);
1049
		rc = device_add(&cdev->dev);
1050 1051 1052 1053 1054
		if (rc) {
			/* Release online reference. */
			put_device(&cdev->dev);
			goto out_schedule;
		}
1055 1056
		if (atomic_dec_and_test(&ccw_device_init_count))
			wake_up(&ccw_device_init_wq);
Linus Torvalds's avatar
Linus Torvalds committed
1057 1058
		return 0;
	}
1059
	io_subchannel_init_fields(sch);
1060 1061 1062
	rc = cio_commit_config(sch);
	if (rc)
		goto out_schedule;
1063 1064 1065
	rc = sysfs_create_group(&sch->dev.kobj,
				&io_subchannel_attr_group);
	if (rc)
1066
		goto out_schedule;
1067
	/* Allocate I/O subchannel private data. */
1068 1069
	io_priv = kzalloc(sizeof(*io_priv), GFP_KERNEL | GFP_DMA);
	if (!io_priv)
1070
		goto out_schedule;
1071

1072 1073 1074 1075 1076 1077 1078 1079
	io_priv->dma_area = dma_alloc_coherent(&sch->dev,
				sizeof(*io_priv->dma_area),
				&io_priv->dma_area_dma, GFP_KERNEL);
	if (!io_priv->dma_area) {
		kfree(io_priv);
		goto out_schedule;
	}

1080
	set_io_private(sch, io_priv);
1081
	css_schedule_eval(sch->schid);
1082
	return 0;
1083

1084
out_schedule:
1085 1086 1087
	spin_lock_irq(sch->lock);
	css_sched_sch_todo(sch, SCH_TODO_UNREG);
	spin_unlock_irq(sch->lock);
1088
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1089 1090
}

1091
static void io_subchannel_remove(struct subchannel *sch)
Linus Torvalds's avatar
Linus Torvalds committed
1092
{
1093
	struct io_subchannel_private *io_priv = to_io_private(sch);
Linus Torvalds's avatar
Linus Torvalds committed
1094 1095
	struct ccw_device *cdev;

1096 1097
	cdev = sch_get_cdev(sch);
	if (!cdev)
1098
		goto out_free;
1099 1100 1101

	ccw_device_unregister(cdev);
	spin_lock_irq(sch->lock);
1102
	sch_set_cdev(sch, NULL);
1103
	set_io_private(sch, NULL);
1104
	spin_unlock_irq(sch->lock);
1105
out_free:
1106 1107
	dma_free_coherent(&sch->dev, sizeof(*io_priv->dma_area),
			  io_priv->dma_area, io_priv->dma_area_dma);
1108
	kfree(io_priv);
1109
	sysfs_remove_group(&sch->dev.kobj, &io_subchannel_attr_group);
Linus Torvalds's avatar
Linus Torvalds committed
1110 1111
}

1112
static void io_subchannel_verify(struct subchannel *sch)
Linus Torvalds's avatar
Linus Torvalds committed
1113 1114 1115
{
	struct ccw_device *cdev;

1116
	cdev = sch_get_cdev(sch);
Linus Torvalds's avatar
Linus Torvalds committed
1117 1118 1119 1120
	if (cdev)
		dev_fsm_event(cdev, DEV_EVENT_VERIFY);
}

1121 1122 1123 1124 1125 1126 1127
static void io_subchannel_terminate_path(struct subchannel *sch, u8 mask)
{
	struct ccw_device *cdev;

	cdev = sch_get_cdev(sch);
	if (!cdev)
		return;
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
	if (cio_update_schib(sch))
		goto err;
	/* Check for I/O on path. */
	if (scsw_actl(&sch->schib.scsw) == 0 || sch->schib.pmcw.lpum != mask)
		goto out;
	if (cdev->private->state == DEV_STATE_ONLINE) {
		ccw_device_kill_io(cdev);
		goto out;
	}
	if (cio_clear(sch))
		goto err;
out:
	/* Trigger path verification. */
	dev_fsm_event(cdev, DEV_EVENT_VERIFY);
	return;
1143

1144 1145
err:
	dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
1146 1147
}

1148 1149
static int io_subchannel_chp_event(struct subchannel *sch,
				   struct chp_link *link, int event)
1150
{
1151
	struct ccw_device *cdev = sch_get_cdev(sch);
1152 1153
	int mask, chpid, valid_bit;
	int path_event[8];
1154

1155
	mask = chp_ssd_get_mask(&sch->ssd_info, link);
1156 1157 1158 1159 1160 1161
	if (!mask)
		return 0;
	switch (event) {
	case CHP_VARY_OFF:
		sch->opm &= ~mask;
		sch->lpm &= ~mask;
1162 1163
		if (cdev)
			cdev->private->path_gone_mask |= mask;
1164 1165 1166 1167 1168
		io_subchannel_terminate_path(sch, mask);
		break;
	case CHP_VARY_ON:
		sch->opm |= mask;
		sch->lpm |= mask;
1169 1170
		if (cdev)
			cdev->private->path_new_mask |= mask;
1171 1172 1173
		io_subchannel_verify(sch);
		break;
	case CHP_OFFLINE:
1174
		if (cio_update_schib(sch))
1175
			return -ENODEV;
1176 1177
		if (cdev)
			cdev->private->path_gone_mask |= mask;
1178 1179 1180
		io_subchannel_terminate_path(sch, mask);
		break;
	case CHP_ONLINE:
1181 1182
		if (cio_update_schib(sch))
			return -ENODEV;
1183
		sch->lpm |= mask & sch->opm;
1184 1185
		if (cdev)
			cdev->private->path_new_mask |= mask;
1186 1187
		io_subchannel_verify(sch);
		break;
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
	case CHP_FCES_EVENT:
		/* Forward Endpoint Security event */
		for (chpid = 0, valid_bit = 0x80; chpid < 8; chpid++,
				valid_bit >>= 1) {
			if (mask & valid_bit)
				path_event[chpid] = PE_PATH_FCES_EVENT;
			else
				path_event[chpid] = PE_NONE;
		}
		if (cdev)
			cdev->drv->path_event(cdev, path_event);
		break;
1200 1201 1202 1203
	}
	return 0;
}

1204
static void io_subchannel_quiesce(struct subchannel *sch)
Linus Torvalds's avatar
Linus Torvalds committed
1205 1206 1207 1208
{
	struct ccw_device *cdev;
	int ret;

1209
	spin_lock_irq(sch->lock);
1210
	cdev = sch_get_cdev(sch);
1211
	if (cio_is_console(sch->schid))
1212
		goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
1213
	if (!sch->schib.pmcw.ena)
1214
		goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
1215 1216
	ret = cio_disable_subchannel(sch);
	if (ret != -EBUSY)
1217
		goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
1218
	if (cdev->handler)
1219 1220 1221
		cdev->handler(cdev, cdev->private->intparm, ERR_PTR(-EIO));
	while (ret == -EBUSY) {
		cdev->private->state = DEV_STATE_QUIESCE;
1222
		cdev->private->iretry = 255;
1223 1224 1225 1226 1227 1228 1229 1230 1231
		ret = ccw_device_cancel_halt_clear(cdev);
		if (ret == -EBUSY) {
			ccw_device_set_timeout(cdev, HZ/10);
			spin_unlock_irq(sch->lock);
			wait_event(cdev->private->wait_q,
				   cdev->private->state != DEV_STATE_QUIESCE);
			spin_lock_irq(sch->lock);
		}
		ret = cio_disable_subchannel(sch);
Linus Torvalds's avatar
Linus Torvalds committed
1232
	}
1233 1234
out_unlock:
	spin_unlock_irq(sch->lock);
Linus Torvalds's avatar
Linus Torvalds committed
1235 1236
}

1237 1238 1239 1240 1241
static void io_subchannel_shutdown(struct subchannel *sch)
{
	io_subchannel_quiesce(sch);
}

1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
static int device_is_disconnected(struct ccw_device *cdev)
{
	if (!cdev)
		return 0;
	return (cdev->private->state == DEV_STATE_DISCONNECTED ||
		cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID);
}

static int recovery_check(struct device *dev, void *data)
{
	struct ccw_device *cdev = to_ccwdev(dev);
1253
	struct subchannel *sch;
1254 1255 1256 1257
	int *redo = data;

	spin_lock_irq(cdev->ccwlock);
	switch (cdev->private->state) {
1258 1259 1260 1261
	case DEV_STATE_ONLINE:
		sch = to_subchannel(cdev->dev.parent);
		if ((sch->schib.pmcw.pam & sch->opm) == sch->vpm)
			break;
Joe Perches's avatar
Joe Perches committed
1262
		fallthrough;
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
	case DEV_STATE_DISCONNECTED:
		CIO_MSG_EVENT(3, "recovery: trigger 0.%x.%04x\n",
			      cdev->private->dev_id.ssid,
			      cdev->private->dev_id.devno);
		dev_fsm_event(cdev, DEV_EVENT_VERIFY);
		*redo = 1;
		break;
	case DEV_STATE_DISCONNECTED_SENSE_ID:
		*redo = 1;
		break;
	}
	spin_unlock_irq(cdev->ccwlock);

	return 0;
}

static void recovery_work_func(struct work_struct *unused)
{
	int redo = 0;

	bus_for_each_dev(&ccw_bus_type, NULL, &redo, recovery_check);
	if (redo) {
		spin_lock_irq(&recovery_lock);
		if (!timer_pending(&recovery_timer)) {
			if (recovery_phase < ARRAY_SIZE(recovery_delay) - 1)
				recovery_phase++;
			mod_timer(&recovery_timer, jiffies +
				  recovery_delay[recovery_phase] * HZ);
		}
		spin_unlock_irq(&recovery_lock);
	} else
1294
		CIO_MSG_EVENT(3, "recovery: end\n");
1295 1296 1297 1298
}

static DECLARE_WORK(recovery_work, recovery_work_func);

1299
static void recovery_func(struct timer_list *unused)
1300 1301 1302 1303 1304 1305 1306 1307
{
	/*
	 * We can't do our recovery in softirq context and it's not
	 * performance critical, so we schedule it.
	 */
	schedule_work(&recovery_work);
}

1308
void ccw_device_schedule_recovery(void)
1309 1310 1311
{
	unsigned long flags;

1312
	CIO_MSG_EVENT(3, "recovery: schedule\n");
1313 1314 1315 1316 1317 1318 1319 1320
	spin_lock_irqsave(&recovery_lock, flags);
	if (!timer_pending(&recovery_timer) || (recovery_phase != 0)) {
		recovery_phase = 0;
		mod_timer(&recovery_timer, jiffies + recovery_delay[0] * HZ);
	}
	spin_unlock_irqrestore(&recovery_lock, flags);
}

1321 1322 1323
static int purge_fn(struct device *dev, void *data)
{
	struct ccw_device *cdev = to_ccwdev(dev);
1324
	struct ccw_dev_id *id = &cdev->private->dev_id;
1325
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
1326 1327

	spin_lock_irq(cdev->ccwlock);
1328
	if (is_blacklisted(id->ssid, id->devno) &&
1329 1330
	    (cdev->private->state == DEV_STATE_OFFLINE) &&
	    (atomic_cmpxchg(&cdev->private->onoff, 0, 1) == 0)) {
1331 1332 1333
		CIO_MSG_EVENT(3, "ccw: purging 0.%x.%04x\n", id->ssid,
			      id->devno);
		ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
1334
		css_sched_sch_todo(sch, SCH_TODO_UNREG);
1335
		atomic_set(&cdev->private->onoff, 0);
1336
	}
1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356
	spin_unlock_irq(cdev->ccwlock);
	/* Abort loop in case of pending signal. */
	if (signal_pending(current))
		return -EINTR;

	return 0;
}

/**
 * ccw_purge_blacklisted - purge unused, blacklisted devices
 *
 * Unregister all ccw devices that are offline and on the blacklist.
 */
int ccw_purge_blacklisted(void)
{
	CIO_MSG_EVENT(2, "ccw: purging blacklisted devices\n");
	bus_for_each_dev(&ccw_bus_type, NULL, NULL, purge_fn);
	return 0;
}

1357
void ccw_device_set_disconnected(struct ccw_device *cdev)
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
{
	if (!cdev)
		return;
	ccw_device_set_timeout(cdev, 0);
	cdev->private->flags.fake_irb = 0;
	cdev->private->state = DEV_STATE_DISCONNECTED;
	if (cdev->online)
		ccw_device_schedule_recovery();
}

1368 1369 1370 1371 1372
void ccw_device_set_notoper(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);

	CIO_TRACE_EVENT(2, "notoper");
1373
	CIO_TRACE_EVENT(2, dev_name(&sch->dev));
1374 1375 1376 1377 1378
	ccw_device_set_timeout(cdev, 0);
	cio_disable_subchannel(sch);
	cdev->private->state = DEV_STATE_NOT_OPER;
}

1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
enum io_sch_action {
	IO_SCH_UNREG,
	IO_SCH_ORPH_UNREG,
	IO_SCH_ATTACH,
	IO_SCH_UNREG_ATTACH,
	IO_SCH_ORPH_ATTACH,
	IO_SCH_REPROBE,
	IO_SCH_VERIFY,
	IO_SCH_DISC,
	IO_SCH_NOP,
};

static enum io_sch_action sch_get_action(struct subchannel *sch)
{
	struct ccw_device *cdev;

	cdev = sch_get_cdev(sch);
	if (cio_update_schib(sch)) {
		/* Not operational. */
		if (!cdev)
			return IO_SCH_UNREG;
1400
		if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
1401 1402 1403 1404 1405 1406 1407
			return IO_SCH_UNREG;
		return IO_SCH_ORPH_UNREG;
	}
	/* Operational. */
	if (!cdev)
		return IO_SCH_ATTACH;
	if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
1408
		if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
1409 1410 1411 1412
			return IO_SCH_UNREG_ATTACH;
		return IO_SCH_ORPH_ATTACH;
	}
	if ((sch->schib.pmcw.pam & sch->opm) == 0) {
1413
		if (ccw_device_notify(cdev, CIO_NO_PATH) != NOTIFY_OK)
1414 1415 1416 1417 1418
			return IO_SCH_UNREG;
		return IO_SCH_DISC;
	}
	if (device_is_disconnected(cdev))
		return IO_SCH_REPROBE;
1419
	if (cdev->online)
1420
		return IO_SCH_VERIFY;
1421 1422
	if (cdev->private->state == DEV_STATE_NOT_OPER)
		return IO_SCH_UNREG_ATTACH;
1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
	return IO_SCH_NOP;
}

/**
 * io_subchannel_sch_event - process subchannel event
 * @sch: subchannel
 * @process: non-zero if function is called in process context
 *
 * An unspecified event occurred for this subchannel. Adjust data according
 * to the current operational state of the subchannel and device. Return
 * zero when the event has been handled sufficiently or -EAGAIN when this
 * function should be called again in process context.
 */
static int io_subchannel_sch_event(struct subchannel *sch, int process)
1437 1438 1439
{
	unsigned long flags;
	struct ccw_device *cdev;
1440 1441 1442
	struct ccw_dev_id dev_id;
	enum io_sch_action action;
	int rc = -EAGAIN;
1443 1444

	spin_lock_irqsave(sch->lock, flags);
1445 1446
	if (!device_is_registered(&sch->dev))
		goto out_unlock;
1447 1448
	if (work_pending(&sch->todo_work))
		goto out_unlock;
1449 1450 1451
	cdev = sch_get_cdev(sch);
	if (cdev && work_pending(&cdev->private->todo_work))
		goto out_unlock;
1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
	action = sch_get_action(sch);
	CIO_MSG_EVENT(2, "event: sch 0.%x.%04x, process=%d, action=%d\n",
		      sch->schid.ssid, sch->schid.sch_no, process,
		      action);
	/* Perform immediate actions while holding the lock. */
	switch (action) {
	case IO_SCH_REPROBE:
		/* Trigger device recognition. */
		ccw_device_trigger_reprobe(cdev);
		rc = 0;
		goto out_unlock;
	case IO_SCH_VERIFY:
		/* Trigger path verification. */
		io_subchannel_verify(sch);
		rc = 0;
		goto out_unlock;
	case IO_SCH_DISC:
		ccw_device_set_disconnected(cdev);
		rc = 0;
		goto out_unlock;
	case IO_SCH_ORPH_UNREG:
	case IO_SCH_ORPH_ATTACH:
		ccw_device_set_disconnected(cdev);
		break;
	case IO_SCH_UNREG_ATTACH:
	case IO_SCH_UNREG:
1478 1479 1480 1481 1482 1483 1484 1485 1486 1487
		if (!cdev)
			break;
		if (cdev->private->state == DEV_STATE_SENSE_ID) {
			/*
			 * Note: delayed work triggered by this event
			 * and repeated calls to sch_event are synchronized
			 * by the above check for work_pending(cdev).
			 */
			dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
		} else
1488 1489 1490 1491 1492 1493 1494
			ccw_device_set_notoper(cdev);
		break;
	case IO_SCH_NOP:
		rc = 0;
		goto out_unlock;
	default:
		break;
1495
	}
1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
	spin_unlock_irqrestore(sch->lock, flags);
	/* All other actions require process context. */
	if (!process)
		goto out;
	/* Handle attached ccw device. */
	switch (action) {
	case IO_SCH_ORPH_UNREG:
	case IO_SCH_ORPH_ATTACH:
		/* Move ccw device to orphanage. */
		rc = ccw_device_move_to_orph(cdev);
		if (rc)
			goto out;
1508
		break;
1509
	case IO_SCH_UNREG_ATTACH:
1510 1511 1512
		spin_lock_irqsave(sch->lock, flags);
		sch_set_cdev(sch, NULL);
		spin_unlock_irqrestore(sch->lock, flags);
1513
		/* Unregister ccw device. */
1514
		ccw_device_unregister(cdev);
1515
		break;
1516
	default:
1517 1518
		break;
	}
1519
	/* Handle subchannel. */
1520
	switch (action) {
1521 1522
	case IO_SCH_ORPH_UNREG:
	case IO_SCH_UNREG:
1523
		css_sch_device_unregister(sch);
1524
		break;
1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
	case IO_SCH_ORPH_ATTACH:
	case IO_SCH_UNREG_ATTACH:
	case IO_SCH_ATTACH:
		dev_id.ssid = sch->schid.ssid;
		dev_id.devno = sch->schib.pmcw.dev;
		cdev = get_ccwdev_by_dev_id(&dev_id);
		if (!cdev) {
			sch_create_and_recog_new_device(sch);
			break;
		}
		rc = ccw_device_move_to_sch(cdev, sch);
		if (rc) {
			/* Release reference from get_ccwdev_by_dev_id() */
			put_device(&cdev->dev);
			goto out;
		}
		spin_lock_irqsave(sch->lock, flags);
1542
		ccw_device_trigger_reprobe(cdev);
1543 1544 1545
		spin_unlock_irqrestore(sch->lock, flags);
		/* Release reference from get_ccwdev_by_dev_id() */
		put_device(&cdev->dev);
1546
		break;
1547 1548 1549
	default:
		break;
	}
1550
	return 0;
1551

1552 1553 1554 1555
out_unlock:
	spin_unlock_irqrestore(sch->lock, flags);
out:
	return rc;
1556 1557
}

1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
static void ccw_device_set_int_class(struct ccw_device *cdev)
{
	struct ccw_driver *cdrv = cdev->drv;

	/* Note: we interpret class 0 in this context as an uninitialized
	 * field since it translates to a non-I/O interrupt class. */
	if (cdrv->int_class != 0)
		cdev->private->int_class = cdrv->int_class;
	else
		cdev->private->int_class = IRQIO_CIO;
}

Linus Torvalds's avatar
Linus Torvalds committed
1570
#ifdef CONFIG_CCW_CONSOLE
1571
int __init ccw_device_enable_console(struct ccw_device *cdev)
Linus Torvalds's avatar
Linus Torvalds committed
1572
{
1573
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
Linus Torvalds's avatar
Linus Torvalds committed
1574 1575
	int rc;

1576 1577 1578
	if (!cdev->drv || !cdev->handler)
		return -EINVAL;

1579
	io_subchannel_init_fields(sch);
1580 1581 1582
	rc = cio_commit_config(sch);
	if (rc)
		return rc;
1583
	sch->driver = &io_subchannel_driver;
1584
	io_subchannel_recog(cdev, sch);
Linus Torvalds's avatar
Linus Torvalds committed
1585 1586 1587
	/* Now wait for the async. recognition to come to an end. */
	spin_lock_irq(cdev->ccwlock);
	while (!dev_fsm_final_state(cdev))
1588 1589
		ccw_device_wait_idle(cdev);

1590 1591 1592 1593
	/* Hold on to an extra reference while device is online. */
	get_device(&cdev->dev);
	rc = ccw_device_online(cdev);
	if (rc)
Linus Torvalds's avatar
Linus Torvalds committed
1594
		goto out_unlock;
1595

Linus Torvalds's avatar
Linus Torvalds committed
1596
	while (!dev_fsm_final_state(cdev))
1597 1598
		ccw_device_wait_idle(cdev);

1599 1600 1601 1602
	if (cdev->private->state == DEV_STATE_ONLINE)
		cdev->online = 1;
	else
		rc = -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
1603 1604
out_unlock:
	spin_unlock_irq(cdev->ccwlock);
1605 1606
	if (rc) /* Give up online reference since onlining failed. */
		put_device(&cdev->dev);
1607
	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
1608 1609
}

1610
struct ccw_device * __init ccw_device_create_console(struct ccw_driver *drv)
Linus Torvalds's avatar
Linus Torvalds committed
1611
{
1612
	struct io_subchannel_private *io_priv;
1613
	struct ccw_device *cdev;
Linus Torvalds's avatar
Linus Torvalds committed
1614 1615 1616
	struct subchannel *sch;

	sch = cio_probe_console();
1617 1618
	if (IS_ERR(sch))
		return ERR_CAST(sch);
1619 1620

	io_priv = kzalloc(sizeof(*io_priv), GFP_KERNEL | GFP_DMA);
1621 1622 1623 1624 1625 1626 1627
	if (!io_priv)
		goto err_priv;
	io_priv->dma_area = dma_alloc_coherent(&sch->dev,
				sizeof(*io_priv->dma_area),
				&io_priv->dma_area_dma, GFP_KERNEL);
	if (!io_priv->dma_area)
		goto err_dma_area;
1628
	set_io_private(sch, io_priv);
1629 1630
	cdev = io_subchannel_create_ccwdev(sch);
	if (IS_ERR(cdev)) {
1631 1632 1633
		dma_free_coherent(&sch->dev, sizeof(*io_priv->dma_area),
				  io_priv->dma_area, io_priv->dma_area_dma);
		set_io_private(sch, NULL);
1634 1635 1636 1637
		put_device(&sch->dev);
		kfree(io_priv);
		return cdev;
	}
1638
	cdev->drv = drv;
1639
	ccw_device_set_int_class(cdev);
1640
	return cdev;
1641 1642 1643 1644 1645 1646

err_dma_area:
	kfree(io_priv);
err_priv:
	put_device(&sch->dev);
	return ERR_PTR(-ENOMEM);
Linus Torvalds's avatar
Linus Torvalds committed
1647
}
1648

1649 1650 1651 1652 1653 1654
void __init ccw_device_destroy_console(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);
	struct io_subchannel_private *io_priv = to_io_private(sch);

	set_io_private(sch, NULL);
1655 1656
	dma_free_coherent(&sch->dev, sizeof(*io_priv->dma_area),
			  io_priv->dma_area, io_priv->dma_area_dma);
1657 1658
	put_device(&sch->dev);
	put_device(&cdev->dev);
1659 1660 1661
	kfree(io_priv);
}

1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677
/**
 * ccw_device_wait_idle() - busy wait for device to become idle
 * @cdev: ccw device
 *
 * Poll until activity control is zero, that is, no function or data
 * transfer is pending/active.
 * Called with device lock being held.
 */
void ccw_device_wait_idle(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);

	while (1) {
		cio_tsch(sch);
		if (sch->schib.scsw.cmd.actl == 0)
			break;
1678
		udelay(100);
1679 1680
	}
}
Linus Torvalds's avatar
Linus Torvalds committed
1681 1682
#endif

1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695
/**
 * get_ccwdev_by_busid() - obtain device from a bus id
 * @cdrv: driver the device is owned by
 * @bus_id: bus id of the device to be searched
 *
 * This function searches all devices owned by @cdrv for a device with a bus
 * id matching @bus_id.
 * Returns:
 *  If a match is found, its reference count of the found device is increased
 *  and it is returned; else %NULL is returned.
 */
struct ccw_device *get_ccwdev_by_busid(struct ccw_driver *cdrv,
				       const char *bus_id)
Linus Torvalds's avatar
Linus Torvalds committed
1696
{
1697
	struct device *dev;
Linus Torvalds's avatar
Linus Torvalds committed
1698

1699
	dev = driver_find_device_by_name(&cdrv->driver, bus_id);
Linus Torvalds's avatar
Linus Torvalds committed
1700

Heiko Carstens's avatar
Heiko Carstens committed
1701
	return dev ? to_ccwdev(dev) : NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721
}

/************************** device driver handling ************************/

/* This is the implementation of the ccw_driver class. The probe, remove
 * and release methods are initially very similar to the device_driver
 * implementations, with the difference that they have ccw_device
 * arguments.
 *
 * A ccw driver also contains the information that is needed for
 * device matching.
 */
static int
ccw_device_probe (struct device *dev)
{
	struct ccw_device *cdev = to_ccwdev(dev);
	struct ccw_driver *cdrv = to_ccwdrv(dev->driver);
	int ret;

	cdev->drv = cdrv; /* to let the driver call _set_online */
1722
	ccw_device_set_int_class(cdev);
Linus Torvalds's avatar
Linus Torvalds committed
1723 1724
	ret = cdrv->probe ? cdrv->probe(cdev) : -ENODEV;
	if (ret) {
Heiko Carstens's avatar
Heiko Carstens committed
1725
		cdev->drv = NULL;
1726
		cdev->private->int_class = IRQIO_CIO;
Linus Torvalds's avatar
Linus Torvalds committed
1727 1728 1729 1730 1731 1732
		return ret;
	}

	return 0;
}

1733
static void ccw_device_remove(struct device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1734 1735 1736
{
	struct ccw_device *cdev = to_ccwdev(dev);
	struct ccw_driver *cdrv = cdev->drv;
1737
	struct subchannel *sch;
Linus Torvalds's avatar
Linus Torvalds committed
1738 1739 1740 1741
	int ret;

	if (cdrv->remove)
		cdrv->remove(cdev);
1742 1743

	spin_lock_irq(cdev->ccwlock);
Linus Torvalds's avatar
Linus Torvalds committed
1744 1745 1746 1747 1748 1749 1750 1751
	if (cdev->online) {
		cdev->online = 0;
		ret = ccw_device_offline(cdev);
		spin_unlock_irq(cdev->ccwlock);
		if (ret == 0)
			wait_event(cdev->private->wait_q,
				   dev_fsm_final_state(cdev));
		else
1752
			CIO_MSG_EVENT(0, "ccw_device_offline returned %d, "
1753 1754 1755
				      "device 0.%x.%04x\n",
				      ret, cdev->private->dev_id.ssid,
				      cdev->private->dev_id.devno);
1756 1757
		/* Give up reference obtained in ccw_device_set_online(). */
		put_device(&cdev->dev);
1758
		spin_lock_irq(cdev->ccwlock);
Linus Torvalds's avatar
Linus Torvalds committed
1759 1760
	}
	ccw_device_set_timeout(cdev, 0);
Heiko Carstens's avatar
Heiko Carstens committed
1761
	cdev->drv = NULL;
1762
	cdev->private->int_class = IRQIO_CIO;
1763
	sch = to_subchannel(cdev->dev.parent);
1764
	spin_unlock_irq(cdev->ccwlock);
1765
	io_subchannel_quiesce(sch);
1766
	__disable_cmf(cdev);
Linus Torvalds's avatar
Linus Torvalds committed
1767 1768
}

1769 1770 1771 1772 1773 1774 1775
static void ccw_device_shutdown(struct device *dev)
{
	struct ccw_device *cdev;

	cdev = to_ccwdev(dev);
	if (cdev->drv && cdev->drv->shutdown)
		cdev->drv->shutdown(cdev);
1776
	__disable_cmf(cdev);
1777 1778
}

1779
static struct bus_type ccw_bus_type = {
1780 1781 1782 1783 1784
	.name   = "ccw",
	.match  = ccw_bus_match,
	.uevent = ccw_uevent,
	.probe  = ccw_device_probe,
	.remove = ccw_device_remove,
1785
	.shutdown = ccw_device_shutdown,
1786 1787
};

1788 1789 1790 1791 1792 1793 1794 1795 1796
/**
 * ccw_driver_register() - register a ccw driver
 * @cdriver: driver to be registered
 *
 * This function is mainly a wrapper around driver_register().
 * Returns:
 *   %0 on success and a negative error value on failure.
 */
int ccw_driver_register(struct ccw_driver *cdriver)
Linus Torvalds's avatar
Linus Torvalds committed
1797 1798 1799 1800 1801 1802 1803 1804
{
	struct device_driver *drv = &cdriver->driver;

	drv->bus = &ccw_bus_type;

	return driver_register(drv);
}

1805 1806 1807 1808 1809 1810 1811
/**
 * ccw_driver_unregister() - deregister a ccw driver
 * @cdriver: driver to be deregistered
 *
 * This function is mainly a wrapper around driver_unregister().
 */
void ccw_driver_unregister(struct ccw_driver *cdriver)
Linus Torvalds's avatar
Linus Torvalds committed
1812 1813 1814 1815
{
	driver_unregister(&cdriver->driver);
}

1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846
static void ccw_device_todo(struct work_struct *work)
{
	struct ccw_device_private *priv;
	struct ccw_device *cdev;
	struct subchannel *sch;
	enum cdev_todo todo;

	priv = container_of(work, struct ccw_device_private, todo_work);
	cdev = priv->cdev;
	sch = to_subchannel(cdev->dev.parent);
	/* Find out todo. */
	spin_lock_irq(cdev->ccwlock);
	todo = priv->todo;
	priv->todo = CDEV_TODO_NOTHING;
	CIO_MSG_EVENT(4, "cdev_todo: cdev=0.%x.%04x todo=%d\n",
		      priv->dev_id.ssid, priv->dev_id.devno, todo);
	spin_unlock_irq(cdev->ccwlock);
	/* Perform todo. */
	switch (todo) {
	case CDEV_TODO_ENABLE_CMF:
		cmf_reenable(cdev);
		break;
	case CDEV_TODO_REBIND:
		ccw_device_do_unbind_bind(cdev);
		break;
	case CDEV_TODO_REGISTER:
		io_subchannel_register(cdev);
		break;
	case CDEV_TODO_UNREG_EVAL:
		if (!sch_is_pseudo_sch(sch))
			css_schedule_eval(sch->schid);
Joe Perches's avatar
Joe Perches committed
1847
		fallthrough;
1848
	case CDEV_TODO_UNREG:
1849 1850 1851 1852
		spin_lock_irq(sch->lock);
		sch_set_cdev(sch, NULL);
		spin_unlock_irq(sch->lock);
		ccw_device_unregister(cdev);
1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
		break;
	default:
		break;
	}
	/* Release workqueue ref. */
	put_device(&cdev->dev);
}

/**
 * ccw_device_sched_todo - schedule ccw device operation
 * @cdev: ccw device
 * @todo: todo
 *
 * Schedule the operation identified by @todo to be performed on the slow path
 * workqueue. Do nothing if another operation with higher priority is already
 * scheduled. Needs to be called with ccwdev lock held.
 */
void ccw_device_sched_todo(struct ccw_device *cdev, enum cdev_todo todo)
{
	CIO_MSG_EVENT(4, "cdev_todo: sched cdev=0.%x.%04x todo=%d\n",
		      cdev->private->dev_id.ssid, cdev->private->dev_id.devno,
		      todo);
	if (cdev->private->todo >= todo)
		return;
	cdev->private->todo = todo;
	/* Get workqueue ref. */
	if (!get_device(&cdev->dev))
		return;
1881
	if (!queue_work(cio_work_q, &cdev->private->todo_work)) {
1882 1883 1884 1885 1886
		/* Already queued, release workqueue ref. */
		put_device(&cdev->dev);
	}
}

1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901
/**
 * ccw_device_siosl() - initiate logging
 * @cdev: ccw device
 *
 * This function is used to invoke model-dependent logging within the channel
 * subsystem.
 */
int ccw_device_siosl(struct ccw_device *cdev)
{
	struct subchannel *sch = to_subchannel(cdev->dev.parent);

	return chsc_siosl(sch->schid);
}
EXPORT_SYMBOL_GPL(ccw_device_siosl);

Linus Torvalds's avatar
Linus Torvalds committed
1902 1903 1904 1905 1906
EXPORT_SYMBOL(ccw_device_set_online);
EXPORT_SYMBOL(ccw_device_set_offline);
EXPORT_SYMBOL(ccw_driver_register);
EXPORT_SYMBOL(ccw_driver_unregister);
EXPORT_SYMBOL(get_ccwdev_by_busid);