1 /*
2  * driver for channel subsystem
3  *
4  * Copyright IBM Corp. 2002, 2010
5  *
6  * Author(s): Arnd Bergmann (arndb@de.ibm.com)
7  *	      Cornelia Huck (cornelia.huck@de.ibm.com)
8  */
9 
10 #define KMSG_COMPONENT "cio"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/device.h>
16 #include <linux/slab.h>
17 #include <linux/errno.h>
18 #include <linux/list.h>
19 #include <linux/reboot.h>
20 #include <linux/suspend.h>
21 #include <linux/proc_fs.h>
22 #include <asm/isc.h>
23 #include <asm/crw.h>
24 
25 #include "css.h"
26 #include "cio.h"
27 #include "cio_debug.h"
28 #include "ioasm.h"
29 #include "chsc.h"
30 #include "device.h"
31 #include "idset.h"
32 #include "chp.h"
33 
34 int css_init_done = 0;
35 int max_ssid;
36 
37 struct channel_subsystem *channel_subsystems[__MAX_CSSID + 1];
38 static struct bus_type css_bus_type;
39 
40 int
for_each_subchannel(int (* fn)(struct subchannel_id,void *),void * data)41 for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *data)
42 {
43 	struct subchannel_id schid;
44 	int ret;
45 
46 	init_subchannel_id(&schid);
47 	ret = -ENODEV;
48 	do {
49 		do {
50 			ret = fn(schid, data);
51 			if (ret)
52 				break;
53 		} while (schid.sch_no++ < __MAX_SUBCHANNEL);
54 		schid.sch_no = 0;
55 	} while (schid.ssid++ < max_ssid);
56 	return ret;
57 }
58 
59 struct cb_data {
60 	void *data;
61 	struct idset *set;
62 	int (*fn_known_sch)(struct subchannel *, void *);
63 	int (*fn_unknown_sch)(struct subchannel_id, void *);
64 };
65 
call_fn_known_sch(struct device * dev,void * data)66 static int call_fn_known_sch(struct device *dev, void *data)
67 {
68 	struct subchannel *sch = to_subchannel(dev);
69 	struct cb_data *cb = data;
70 	int rc = 0;
71 
72 	idset_sch_del(cb->set, sch->schid);
73 	if (cb->fn_known_sch)
74 		rc = cb->fn_known_sch(sch, cb->data);
75 	return rc;
76 }
77 
call_fn_unknown_sch(struct subchannel_id schid,void * data)78 static int call_fn_unknown_sch(struct subchannel_id schid, void *data)
79 {
80 	struct cb_data *cb = data;
81 	int rc = 0;
82 
83 	if (idset_sch_contains(cb->set, schid))
84 		rc = cb->fn_unknown_sch(schid, cb->data);
85 	return rc;
86 }
87 
call_fn_all_sch(struct subchannel_id schid,void * data)88 static int call_fn_all_sch(struct subchannel_id schid, void *data)
89 {
90 	struct cb_data *cb = data;
91 	struct subchannel *sch;
92 	int rc = 0;
93 
94 	sch = get_subchannel_by_schid(schid);
95 	if (sch) {
96 		if (cb->fn_known_sch)
97 			rc = cb->fn_known_sch(sch, cb->data);
98 		put_device(&sch->dev);
99 	} else {
100 		if (cb->fn_unknown_sch)
101 			rc = cb->fn_unknown_sch(schid, cb->data);
102 	}
103 
104 	return rc;
105 }
106 
for_each_subchannel_staged(int (* fn_known)(struct subchannel *,void *),int (* fn_unknown)(struct subchannel_id,void *),void * data)107 int for_each_subchannel_staged(int (*fn_known)(struct subchannel *, void *),
108 			       int (*fn_unknown)(struct subchannel_id,
109 			       void *), void *data)
110 {
111 	struct cb_data cb;
112 	int rc;
113 
114 	cb.data = data;
115 	cb.fn_known_sch = fn_known;
116 	cb.fn_unknown_sch = fn_unknown;
117 
118 	cb.set = idset_sch_new();
119 	if (!cb.set)
120 		/* fall back to brute force scanning in case of oom */
121 		return for_each_subchannel(call_fn_all_sch, &cb);
122 
123 	idset_fill(cb.set);
124 
125 	/* Process registered subchannels. */
126 	rc = bus_for_each_dev(&css_bus_type, NULL, &cb, call_fn_known_sch);
127 	if (rc)
128 		goto out;
129 	/* Process unregistered subchannels. */
130 	if (fn_unknown)
131 		rc = for_each_subchannel(call_fn_unknown_sch, &cb);
132 out:
133 	idset_free(cb.set);
134 
135 	return rc;
136 }
137 
138 static void css_sch_todo(struct work_struct *work);
139 
140 static struct subchannel *
css_alloc_subchannel(struct subchannel_id schid)141 css_alloc_subchannel(struct subchannel_id schid)
142 {
143 	struct subchannel *sch;
144 	int ret;
145 
146 	sch = kmalloc (sizeof (*sch), GFP_KERNEL | GFP_DMA);
147 	if (sch == NULL)
148 		return ERR_PTR(-ENOMEM);
149 	ret = cio_validate_subchannel (sch, schid);
150 	if (ret < 0) {
151 		kfree(sch);
152 		return ERR_PTR(ret);
153 	}
154 	INIT_WORK(&sch->todo_work, css_sch_todo);
155 	return sch;
156 }
157 
158 static void
css_subchannel_release(struct device * dev)159 css_subchannel_release(struct device *dev)
160 {
161 	struct subchannel *sch;
162 
163 	sch = to_subchannel(dev);
164 	if (!cio_is_console(sch->schid)) {
165 		/* Reset intparm to zeroes. */
166 		sch->config.intparm = 0;
167 		cio_commit_config(sch);
168 		kfree(sch->lock);
169 		kfree(sch);
170 	}
171 }
172 
css_sch_device_register(struct subchannel * sch)173 static int css_sch_device_register(struct subchannel *sch)
174 {
175 	int ret;
176 
177 	mutex_lock(&sch->reg_mutex);
178 	dev_set_name(&sch->dev, "0.%x.%04x", sch->schid.ssid,
179 		     sch->schid.sch_no);
180 	ret = device_register(&sch->dev);
181 	mutex_unlock(&sch->reg_mutex);
182 	return ret;
183 }
184 
185 /**
186  * css_sch_device_unregister - unregister a subchannel
187  * @sch: subchannel to be unregistered
188  */
css_sch_device_unregister(struct subchannel * sch)189 void css_sch_device_unregister(struct subchannel *sch)
190 {
191 	mutex_lock(&sch->reg_mutex);
192 	if (device_is_registered(&sch->dev))
193 		device_unregister(&sch->dev);
194 	mutex_unlock(&sch->reg_mutex);
195 }
196 EXPORT_SYMBOL_GPL(css_sch_device_unregister);
197 
ssd_from_pmcw(struct chsc_ssd_info * ssd,struct pmcw * pmcw)198 static void ssd_from_pmcw(struct chsc_ssd_info *ssd, struct pmcw *pmcw)
199 {
200 	int i;
201 	int mask;
202 
203 	memset(ssd, 0, sizeof(struct chsc_ssd_info));
204 	ssd->path_mask = pmcw->pim;
205 	for (i = 0; i < 8; i++) {
206 		mask = 0x80 >> i;
207 		if (pmcw->pim & mask) {
208 			chp_id_init(&ssd->chpid[i]);
209 			ssd->chpid[i].id = pmcw->chpid[i];
210 		}
211 	}
212 }
213 
ssd_register_chpids(struct chsc_ssd_info * ssd)214 static void ssd_register_chpids(struct chsc_ssd_info *ssd)
215 {
216 	int i;
217 	int mask;
218 
219 	for (i = 0; i < 8; i++) {
220 		mask = 0x80 >> i;
221 		if (ssd->path_mask & mask)
222 			if (!chp_is_registered(ssd->chpid[i]))
223 				chp_new(ssd->chpid[i]);
224 	}
225 }
226 
css_update_ssd_info(struct subchannel * sch)227 void css_update_ssd_info(struct subchannel *sch)
228 {
229 	int ret;
230 
231 	if (cio_is_console(sch->schid)) {
232 		/* Console is initialized too early for functions requiring
233 		 * memory allocation. */
234 		ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
235 	} else {
236 		ret = chsc_get_ssd_info(sch->schid, &sch->ssd_info);
237 		if (ret)
238 			ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
239 		ssd_register_chpids(&sch->ssd_info);
240 	}
241 }
242 
type_show(struct device * dev,struct device_attribute * attr,char * buf)243 static ssize_t type_show(struct device *dev, struct device_attribute *attr,
244 			 char *buf)
245 {
246 	struct subchannel *sch = to_subchannel(dev);
247 
248 	return sprintf(buf, "%01x\n", sch->st);
249 }
250 
251 static DEVICE_ATTR(type, 0444, type_show, NULL);
252 
modalias_show(struct device * dev,struct device_attribute * attr,char * buf)253 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
254 			     char *buf)
255 {
256 	struct subchannel *sch = to_subchannel(dev);
257 
258 	return sprintf(buf, "css:t%01X\n", sch->st);
259 }
260 
261 static DEVICE_ATTR(modalias, 0444, modalias_show, NULL);
262 
263 static struct attribute *subch_attrs[] = {
264 	&dev_attr_type.attr,
265 	&dev_attr_modalias.attr,
266 	NULL,
267 };
268 
269 static struct attribute_group subch_attr_group = {
270 	.attrs = subch_attrs,
271 };
272 
273 static const struct attribute_group *default_subch_attr_groups[] = {
274 	&subch_attr_group,
275 	NULL,
276 };
277 
css_register_subchannel(struct subchannel * sch)278 static int css_register_subchannel(struct subchannel *sch)
279 {
280 	int ret;
281 
282 	/* Initialize the subchannel structure */
283 	sch->dev.parent = &channel_subsystems[0]->device;
284 	sch->dev.bus = &css_bus_type;
285 	sch->dev.release = &css_subchannel_release;
286 	sch->dev.groups = default_subch_attr_groups;
287 	/*
288 	 * We don't want to generate uevents for I/O subchannels that don't
289 	 * have a working ccw device behind them since they will be
290 	 * unregistered before they can be used anyway, so we delay the add
291 	 * uevent until after device recognition was successful.
292 	 * Note that we suppress the uevent for all subchannel types;
293 	 * the subchannel driver can decide itself when it wants to inform
294 	 * userspace of its existence.
295 	 */
296 	dev_set_uevent_suppress(&sch->dev, 1);
297 	css_update_ssd_info(sch);
298 	/* make it known to the system */
299 	ret = css_sch_device_register(sch);
300 	if (ret) {
301 		CIO_MSG_EVENT(0, "Could not register sch 0.%x.%04x: %d\n",
302 			      sch->schid.ssid, sch->schid.sch_no, ret);
303 		return ret;
304 	}
305 	if (!sch->driver) {
306 		/*
307 		 * No driver matched. Generate the uevent now so that
308 		 * a fitting driver module may be loaded based on the
309 		 * modalias.
310 		 */
311 		dev_set_uevent_suppress(&sch->dev, 0);
312 		kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
313 	}
314 	return ret;
315 }
316 
css_probe_device(struct subchannel_id schid)317 int css_probe_device(struct subchannel_id schid)
318 {
319 	int ret;
320 	struct subchannel *sch;
321 
322 	if (cio_is_console(schid))
323 		sch = cio_get_console_subchannel();
324 	else {
325 		sch = css_alloc_subchannel(schid);
326 		if (IS_ERR(sch))
327 			return PTR_ERR(sch);
328 	}
329 	ret = css_register_subchannel(sch);
330 	if (ret) {
331 		if (!cio_is_console(schid))
332 			put_device(&sch->dev);
333 	}
334 	return ret;
335 }
336 
337 static int
check_subchannel(struct device * dev,void * data)338 check_subchannel(struct device * dev, void * data)
339 {
340 	struct subchannel *sch;
341 	struct subchannel_id *schid = data;
342 
343 	sch = to_subchannel(dev);
344 	return schid_equal(&sch->schid, schid);
345 }
346 
347 struct subchannel *
get_subchannel_by_schid(struct subchannel_id schid)348 get_subchannel_by_schid(struct subchannel_id schid)
349 {
350 	struct device *dev;
351 
352 	dev = bus_find_device(&css_bus_type, NULL,
353 			      &schid, check_subchannel);
354 
355 	return dev ? to_subchannel(dev) : NULL;
356 }
357 
358 /**
359  * css_sch_is_valid() - check if a subchannel is valid
360  * @schib: subchannel information block for the subchannel
361  */
css_sch_is_valid(struct schib * schib)362 int css_sch_is_valid(struct schib *schib)
363 {
364 	if ((schib->pmcw.st == SUBCHANNEL_TYPE_IO) && !schib->pmcw.dnv)
365 		return 0;
366 	if ((schib->pmcw.st == SUBCHANNEL_TYPE_MSG) && !schib->pmcw.w)
367 		return 0;
368 	return 1;
369 }
370 EXPORT_SYMBOL_GPL(css_sch_is_valid);
371 
css_evaluate_new_subchannel(struct subchannel_id schid,int slow)372 static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow)
373 {
374 	struct schib schib;
375 
376 	if (!slow) {
377 		/* Will be done on the slow path. */
378 		return -EAGAIN;
379 	}
380 	if (stsch_err(schid, &schib) || !css_sch_is_valid(&schib)) {
381 		/* Unusable - ignore. */
382 		return 0;
383 	}
384 	CIO_MSG_EVENT(4, "event: sch 0.%x.%04x, new\n", schid.ssid,
385 		      schid.sch_no);
386 
387 	return css_probe_device(schid);
388 }
389 
css_evaluate_known_subchannel(struct subchannel * sch,int slow)390 static int css_evaluate_known_subchannel(struct subchannel *sch, int slow)
391 {
392 	int ret = 0;
393 
394 	if (sch->driver) {
395 		if (sch->driver->sch_event)
396 			ret = sch->driver->sch_event(sch, slow);
397 		else
398 			dev_dbg(&sch->dev,
399 				"Got subchannel machine check but "
400 				"no sch_event handler provided.\n");
401 	}
402 	if (ret != 0 && ret != -EAGAIN) {
403 		CIO_MSG_EVENT(2, "eval: sch 0.%x.%04x, rc=%d\n",
404 			      sch->schid.ssid, sch->schid.sch_no, ret);
405 	}
406 	return ret;
407 }
408 
css_evaluate_subchannel(struct subchannel_id schid,int slow)409 static void css_evaluate_subchannel(struct subchannel_id schid, int slow)
410 {
411 	struct subchannel *sch;
412 	int ret;
413 
414 	sch = get_subchannel_by_schid(schid);
415 	if (sch) {
416 		ret = css_evaluate_known_subchannel(sch, slow);
417 		put_device(&sch->dev);
418 	} else
419 		ret = css_evaluate_new_subchannel(schid, slow);
420 	if (ret == -EAGAIN)
421 		css_schedule_eval(schid);
422 }
423 
424 /**
425  * css_sched_sch_todo - schedule a subchannel operation
426  * @sch: subchannel
427  * @todo: todo
428  *
429  * Schedule the operation identified by @todo to be performed on the slow path
430  * workqueue. Do nothing if another operation with higher priority is already
431  * scheduled. Needs to be called with subchannel lock held.
432  */
css_sched_sch_todo(struct subchannel * sch,enum sch_todo todo)433 void css_sched_sch_todo(struct subchannel *sch, enum sch_todo todo)
434 {
435 	CIO_MSG_EVENT(4, "sch_todo: sched sch=0.%x.%04x todo=%d\n",
436 		      sch->schid.ssid, sch->schid.sch_no, todo);
437 	if (sch->todo >= todo)
438 		return;
439 	/* Get workqueue ref. */
440 	if (!get_device(&sch->dev))
441 		return;
442 	sch->todo = todo;
443 	if (!queue_work(cio_work_q, &sch->todo_work)) {
444 		/* Already queued, release workqueue ref. */
445 		put_device(&sch->dev);
446 	}
447 }
448 
css_sch_todo(struct work_struct * work)449 static void css_sch_todo(struct work_struct *work)
450 {
451 	struct subchannel *sch;
452 	enum sch_todo todo;
453 	int ret;
454 
455 	sch = container_of(work, struct subchannel, todo_work);
456 	/* Find out todo. */
457 	spin_lock_irq(sch->lock);
458 	todo = sch->todo;
459 	CIO_MSG_EVENT(4, "sch_todo: sch=0.%x.%04x, todo=%d\n", sch->schid.ssid,
460 		      sch->schid.sch_no, todo);
461 	sch->todo = SCH_TODO_NOTHING;
462 	spin_unlock_irq(sch->lock);
463 	/* Perform todo. */
464 	switch (todo) {
465 	case SCH_TODO_NOTHING:
466 		break;
467 	case SCH_TODO_EVAL:
468 		ret = css_evaluate_known_subchannel(sch, 1);
469 		if (ret == -EAGAIN) {
470 			spin_lock_irq(sch->lock);
471 			css_sched_sch_todo(sch, todo);
472 			spin_unlock_irq(sch->lock);
473 		}
474 		break;
475 	case SCH_TODO_UNREG:
476 		css_sch_device_unregister(sch);
477 		break;
478 	}
479 	/* Release workqueue ref. */
480 	put_device(&sch->dev);
481 }
482 
483 static struct idset *slow_subchannel_set;
484 static spinlock_t slow_subchannel_lock;
485 static wait_queue_head_t css_eval_wq;
486 static atomic_t css_eval_scheduled;
487 
slow_subchannel_init(void)488 static int __init slow_subchannel_init(void)
489 {
490 	spin_lock_init(&slow_subchannel_lock);
491 	atomic_set(&css_eval_scheduled, 0);
492 	init_waitqueue_head(&css_eval_wq);
493 	slow_subchannel_set = idset_sch_new();
494 	if (!slow_subchannel_set) {
495 		CIO_MSG_EVENT(0, "could not allocate slow subchannel set\n");
496 		return -ENOMEM;
497 	}
498 	return 0;
499 }
500 
slow_eval_known_fn(struct subchannel * sch,void * data)501 static int slow_eval_known_fn(struct subchannel *sch, void *data)
502 {
503 	int eval;
504 	int rc;
505 
506 	spin_lock_irq(&slow_subchannel_lock);
507 	eval = idset_sch_contains(slow_subchannel_set, sch->schid);
508 	idset_sch_del(slow_subchannel_set, sch->schid);
509 	spin_unlock_irq(&slow_subchannel_lock);
510 	if (eval) {
511 		rc = css_evaluate_known_subchannel(sch, 1);
512 		if (rc == -EAGAIN)
513 			css_schedule_eval(sch->schid);
514 	}
515 	return 0;
516 }
517 
slow_eval_unknown_fn(struct subchannel_id schid,void * data)518 static int slow_eval_unknown_fn(struct subchannel_id schid, void *data)
519 {
520 	int eval;
521 	int rc = 0;
522 
523 	spin_lock_irq(&slow_subchannel_lock);
524 	eval = idset_sch_contains(slow_subchannel_set, schid);
525 	idset_sch_del(slow_subchannel_set, schid);
526 	spin_unlock_irq(&slow_subchannel_lock);
527 	if (eval) {
528 		rc = css_evaluate_new_subchannel(schid, 1);
529 		switch (rc) {
530 		case -EAGAIN:
531 			css_schedule_eval(schid);
532 			rc = 0;
533 			break;
534 		case -ENXIO:
535 		case -ENOMEM:
536 		case -EIO:
537 			/* These should abort looping */
538 			break;
539 		default:
540 			rc = 0;
541 		}
542 	}
543 	return rc;
544 }
545 
css_slow_path_func(struct work_struct * unused)546 static void css_slow_path_func(struct work_struct *unused)
547 {
548 	unsigned long flags;
549 
550 	CIO_TRACE_EVENT(4, "slowpath");
551 	for_each_subchannel_staged(slow_eval_known_fn, slow_eval_unknown_fn,
552 				   NULL);
553 	spin_lock_irqsave(&slow_subchannel_lock, flags);
554 	if (idset_is_empty(slow_subchannel_set)) {
555 		atomic_set(&css_eval_scheduled, 0);
556 		wake_up(&css_eval_wq);
557 	}
558 	spin_unlock_irqrestore(&slow_subchannel_lock, flags);
559 }
560 
561 static DECLARE_WORK(slow_path_work, css_slow_path_func);
562 struct workqueue_struct *cio_work_q;
563 
css_schedule_eval(struct subchannel_id schid)564 void css_schedule_eval(struct subchannel_id schid)
565 {
566 	unsigned long flags;
567 
568 	spin_lock_irqsave(&slow_subchannel_lock, flags);
569 	idset_sch_add(slow_subchannel_set, schid);
570 	atomic_set(&css_eval_scheduled, 1);
571 	queue_work(cio_work_q, &slow_path_work);
572 	spin_unlock_irqrestore(&slow_subchannel_lock, flags);
573 }
574 
css_schedule_eval_all(void)575 void css_schedule_eval_all(void)
576 {
577 	unsigned long flags;
578 
579 	spin_lock_irqsave(&slow_subchannel_lock, flags);
580 	idset_fill(slow_subchannel_set);
581 	atomic_set(&css_eval_scheduled, 1);
582 	queue_work(cio_work_q, &slow_path_work);
583 	spin_unlock_irqrestore(&slow_subchannel_lock, flags);
584 }
585 
__unset_registered(struct device * dev,void * data)586 static int __unset_registered(struct device *dev, void *data)
587 {
588 	struct idset *set = data;
589 	struct subchannel *sch = to_subchannel(dev);
590 
591 	idset_sch_del(set, sch->schid);
592 	return 0;
593 }
594 
css_schedule_eval_all_unreg(void)595 static void css_schedule_eval_all_unreg(void)
596 {
597 	unsigned long flags;
598 	struct idset *unreg_set;
599 
600 	/* Find unregistered subchannels. */
601 	unreg_set = idset_sch_new();
602 	if (!unreg_set) {
603 		/* Fallback. */
604 		css_schedule_eval_all();
605 		return;
606 	}
607 	idset_fill(unreg_set);
608 	bus_for_each_dev(&css_bus_type, NULL, unreg_set, __unset_registered);
609 	/* Apply to slow_subchannel_set. */
610 	spin_lock_irqsave(&slow_subchannel_lock, flags);
611 	idset_add_set(slow_subchannel_set, unreg_set);
612 	atomic_set(&css_eval_scheduled, 1);
613 	queue_work(cio_work_q, &slow_path_work);
614 	spin_unlock_irqrestore(&slow_subchannel_lock, flags);
615 	idset_free(unreg_set);
616 }
617 
css_wait_for_slow_path(void)618 void css_wait_for_slow_path(void)
619 {
620 	flush_workqueue(cio_work_q);
621 }
622 
623 /* Schedule reprobing of all unregistered subchannels. */
css_schedule_reprobe(void)624 void css_schedule_reprobe(void)
625 {
626 	css_schedule_eval_all_unreg();
627 }
628 EXPORT_SYMBOL_GPL(css_schedule_reprobe);
629 
630 /*
631  * Called from the machine check handler for subchannel report words.
632  */
css_process_crw(struct crw * crw0,struct crw * crw1,int overflow)633 static void css_process_crw(struct crw *crw0, struct crw *crw1, int overflow)
634 {
635 	struct subchannel_id mchk_schid;
636 	struct subchannel *sch;
637 
638 	if (overflow) {
639 		css_schedule_eval_all();
640 		return;
641 	}
642 	CIO_CRW_EVENT(2, "CRW0 reports slct=%d, oflw=%d, "
643 		      "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
644 		      crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc,
645 		      crw0->erc, crw0->rsid);
646 	if (crw1)
647 		CIO_CRW_EVENT(2, "CRW1 reports slct=%d, oflw=%d, "
648 			      "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
649 			      crw1->slct, crw1->oflw, crw1->chn, crw1->rsc,
650 			      crw1->anc, crw1->erc, crw1->rsid);
651 	init_subchannel_id(&mchk_schid);
652 	mchk_schid.sch_no = crw0->rsid;
653 	if (crw1)
654 		mchk_schid.ssid = (crw1->rsid >> 4) & 3;
655 
656 	if (crw0->erc == CRW_ERC_PMOD) {
657 		sch = get_subchannel_by_schid(mchk_schid);
658 		if (sch) {
659 			css_update_ssd_info(sch);
660 			put_device(&sch->dev);
661 		}
662 	}
663 	/*
664 	 * Since we are always presented with IPI in the CRW, we have to
665 	 * use stsch() to find out if the subchannel in question has come
666 	 * or gone.
667 	 */
668 	css_evaluate_subchannel(mchk_schid, 0);
669 }
670 
671 static void __init
css_generate_pgid(struct channel_subsystem * css,u32 tod_high)672 css_generate_pgid(struct channel_subsystem *css, u32 tod_high)
673 {
674 	struct cpuid cpu_id;
675 
676 	if (css_general_characteristics.mcss) {
677 		css->global_pgid.pgid_high.ext_cssid.version = 0x80;
678 		css->global_pgid.pgid_high.ext_cssid.cssid = css->cssid;
679 	} else {
680 #ifdef CONFIG_SMP
681 		css->global_pgid.pgid_high.cpu_addr = stap();
682 #else
683 		css->global_pgid.pgid_high.cpu_addr = 0;
684 #endif
685 	}
686 	get_cpu_id(&cpu_id);
687 	css->global_pgid.cpu_id = cpu_id.ident;
688 	css->global_pgid.cpu_model = cpu_id.machine;
689 	css->global_pgid.tod_high = tod_high;
690 
691 }
692 
693 static void
channel_subsystem_release(struct device * dev)694 channel_subsystem_release(struct device *dev)
695 {
696 	struct channel_subsystem *css;
697 
698 	css = to_css(dev);
699 	mutex_destroy(&css->mutex);
700 	if (css->pseudo_subchannel) {
701 		/* Implies that it has been generated but never registered. */
702 		css_subchannel_release(&css->pseudo_subchannel->dev);
703 		css->pseudo_subchannel = NULL;
704 	}
705 	kfree(css);
706 }
707 
708 static ssize_t
css_cm_enable_show(struct device * dev,struct device_attribute * attr,char * buf)709 css_cm_enable_show(struct device *dev, struct device_attribute *attr,
710 		   char *buf)
711 {
712 	struct channel_subsystem *css = to_css(dev);
713 	int ret;
714 
715 	if (!css)
716 		return 0;
717 	mutex_lock(&css->mutex);
718 	ret = sprintf(buf, "%x\n", css->cm_enabled);
719 	mutex_unlock(&css->mutex);
720 	return ret;
721 }
722 
723 static ssize_t
css_cm_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)724 css_cm_enable_store(struct device *dev, struct device_attribute *attr,
725 		    const char *buf, size_t count)
726 {
727 	struct channel_subsystem *css = to_css(dev);
728 	int ret;
729 	unsigned long val;
730 
731 	ret = strict_strtoul(buf, 16, &val);
732 	if (ret)
733 		return ret;
734 	mutex_lock(&css->mutex);
735 	switch (val) {
736 	case 0:
737 		ret = css->cm_enabled ? chsc_secm(css, 0) : 0;
738 		break;
739 	case 1:
740 		ret = css->cm_enabled ? 0 : chsc_secm(css, 1);
741 		break;
742 	default:
743 		ret = -EINVAL;
744 	}
745 	mutex_unlock(&css->mutex);
746 	return ret < 0 ? ret : count;
747 }
748 
749 static DEVICE_ATTR(cm_enable, 0644, css_cm_enable_show, css_cm_enable_store);
750 
setup_css(int nr)751 static int __init setup_css(int nr)
752 {
753 	u32 tod_high;
754 	int ret;
755 	struct channel_subsystem *css;
756 
757 	css = channel_subsystems[nr];
758 	memset(css, 0, sizeof(struct channel_subsystem));
759 	css->pseudo_subchannel =
760 		kzalloc(sizeof(*css->pseudo_subchannel), GFP_KERNEL);
761 	if (!css->pseudo_subchannel)
762 		return -ENOMEM;
763 	css->pseudo_subchannel->dev.parent = &css->device;
764 	css->pseudo_subchannel->dev.release = css_subchannel_release;
765 	dev_set_name(&css->pseudo_subchannel->dev, "defunct");
766 	mutex_init(&css->pseudo_subchannel->reg_mutex);
767 	ret = cio_create_sch_lock(css->pseudo_subchannel);
768 	if (ret) {
769 		kfree(css->pseudo_subchannel);
770 		return ret;
771 	}
772 	mutex_init(&css->mutex);
773 	css->valid = 1;
774 	css->cssid = nr;
775 	dev_set_name(&css->device, "css%x", nr);
776 	css->device.release = channel_subsystem_release;
777 	tod_high = (u32) (get_clock() >> 32);
778 	css_generate_pgid(css, tod_high);
779 	return 0;
780 }
781 
css_reboot_event(struct notifier_block * this,unsigned long event,void * ptr)782 static int css_reboot_event(struct notifier_block *this,
783 			    unsigned long event,
784 			    void *ptr)
785 {
786 	int ret, i;
787 
788 	ret = NOTIFY_DONE;
789 	for (i = 0; i <= __MAX_CSSID; i++) {
790 		struct channel_subsystem *css;
791 
792 		css = channel_subsystems[i];
793 		mutex_lock(&css->mutex);
794 		if (css->cm_enabled)
795 			if (chsc_secm(css, 0))
796 				ret = NOTIFY_BAD;
797 		mutex_unlock(&css->mutex);
798 	}
799 
800 	return ret;
801 }
802 
803 static struct notifier_block css_reboot_notifier = {
804 	.notifier_call = css_reboot_event,
805 };
806 
807 /*
808  * Since the css devices are neither on a bus nor have a class
809  * nor have a special device type, we cannot stop/restart channel
810  * path measurements via the normal suspend/resume callbacks, but have
811  * to use notifiers.
812  */
css_power_event(struct notifier_block * this,unsigned long event,void * ptr)813 static int css_power_event(struct notifier_block *this, unsigned long event,
814 			   void *ptr)
815 {
816 	int ret, i;
817 
818 	switch (event) {
819 	case PM_HIBERNATION_PREPARE:
820 	case PM_SUSPEND_PREPARE:
821 		ret = NOTIFY_DONE;
822 		for (i = 0; i <= __MAX_CSSID; i++) {
823 			struct channel_subsystem *css;
824 
825 			css = channel_subsystems[i];
826 			mutex_lock(&css->mutex);
827 			if (!css->cm_enabled) {
828 				mutex_unlock(&css->mutex);
829 				continue;
830 			}
831 			ret = __chsc_do_secm(css, 0);
832 			ret = notifier_from_errno(ret);
833 			mutex_unlock(&css->mutex);
834 		}
835 		break;
836 	case PM_POST_HIBERNATION:
837 	case PM_POST_SUSPEND:
838 		ret = NOTIFY_DONE;
839 		for (i = 0; i <= __MAX_CSSID; i++) {
840 			struct channel_subsystem *css;
841 
842 			css = channel_subsystems[i];
843 			mutex_lock(&css->mutex);
844 			if (!css->cm_enabled) {
845 				mutex_unlock(&css->mutex);
846 				continue;
847 			}
848 			ret = __chsc_do_secm(css, 1);
849 			ret = notifier_from_errno(ret);
850 			mutex_unlock(&css->mutex);
851 		}
852 		/* search for subchannels, which appeared during hibernation */
853 		css_schedule_reprobe();
854 		break;
855 	default:
856 		ret = NOTIFY_DONE;
857 	}
858 	return ret;
859 
860 }
861 static struct notifier_block css_power_notifier = {
862 	.notifier_call = css_power_event,
863 };
864 
865 /*
866  * Now that the driver core is running, we can setup our channel subsystem.
867  * The struct subchannel's are created during probing (except for the
868  * static console subchannel).
869  */
css_bus_init(void)870 static int __init css_bus_init(void)
871 {
872 	int ret, i;
873 
874 	ret = chsc_init();
875 	if (ret)
876 		return ret;
877 
878 	chsc_determine_css_characteristics();
879 	/* Try to enable MSS. */
880 	ret = chsc_enable_facility(CHSC_SDA_OC_MSS);
881 	if (ret)
882 		max_ssid = 0;
883 	else /* Success. */
884 		max_ssid = __MAX_SSID;
885 
886 	ret = slow_subchannel_init();
887 	if (ret)
888 		goto out;
889 
890 	ret = crw_register_handler(CRW_RSC_SCH, css_process_crw);
891 	if (ret)
892 		goto out;
893 
894 	if ((ret = bus_register(&css_bus_type)))
895 		goto out;
896 
897 	/* Setup css structure. */
898 	for (i = 0; i <= __MAX_CSSID; i++) {
899 		struct channel_subsystem *css;
900 
901 		css = kmalloc(sizeof(struct channel_subsystem), GFP_KERNEL);
902 		if (!css) {
903 			ret = -ENOMEM;
904 			goto out_unregister;
905 		}
906 		channel_subsystems[i] = css;
907 		ret = setup_css(i);
908 		if (ret) {
909 			kfree(channel_subsystems[i]);
910 			goto out_unregister;
911 		}
912 		ret = device_register(&css->device);
913 		if (ret) {
914 			put_device(&css->device);
915 			goto out_unregister;
916 		}
917 		if (css_chsc_characteristics.secm) {
918 			ret = device_create_file(&css->device,
919 						 &dev_attr_cm_enable);
920 			if (ret)
921 				goto out_device;
922 		}
923 		ret = device_register(&css->pseudo_subchannel->dev);
924 		if (ret) {
925 			put_device(&css->pseudo_subchannel->dev);
926 			goto out_file;
927 		}
928 	}
929 	ret = register_reboot_notifier(&css_reboot_notifier);
930 	if (ret)
931 		goto out_unregister;
932 	ret = register_pm_notifier(&css_power_notifier);
933 	if (ret) {
934 		unregister_reboot_notifier(&css_reboot_notifier);
935 		goto out_unregister;
936 	}
937 	css_init_done = 1;
938 
939 	/* Enable default isc for I/O subchannels. */
940 	isc_register(IO_SCH_ISC);
941 
942 	return 0;
943 out_file:
944 	if (css_chsc_characteristics.secm)
945 		device_remove_file(&channel_subsystems[i]->device,
946 				   &dev_attr_cm_enable);
947 out_device:
948 	device_unregister(&channel_subsystems[i]->device);
949 out_unregister:
950 	while (i > 0) {
951 		struct channel_subsystem *css;
952 
953 		i--;
954 		css = channel_subsystems[i];
955 		device_unregister(&css->pseudo_subchannel->dev);
956 		css->pseudo_subchannel = NULL;
957 		if (css_chsc_characteristics.secm)
958 			device_remove_file(&css->device,
959 					   &dev_attr_cm_enable);
960 		device_unregister(&css->device);
961 	}
962 	bus_unregister(&css_bus_type);
963 out:
964 	crw_unregister_handler(CRW_RSC_SCH);
965 	idset_free(slow_subchannel_set);
966 	chsc_init_cleanup();
967 	pr_alert("The CSS device driver initialization failed with "
968 		 "errno=%d\n", ret);
969 	return ret;
970 }
971 
css_bus_cleanup(void)972 static void __init css_bus_cleanup(void)
973 {
974 	struct channel_subsystem *css;
975 	int i;
976 
977 	for (i = 0; i <= __MAX_CSSID; i++) {
978 		css = channel_subsystems[i];
979 		device_unregister(&css->pseudo_subchannel->dev);
980 		css->pseudo_subchannel = NULL;
981 		if (css_chsc_characteristics.secm)
982 			device_remove_file(&css->device, &dev_attr_cm_enable);
983 		device_unregister(&css->device);
984 	}
985 	bus_unregister(&css_bus_type);
986 	crw_unregister_handler(CRW_RSC_SCH);
987 	idset_free(slow_subchannel_set);
988 	chsc_init_cleanup();
989 	isc_unregister(IO_SCH_ISC);
990 }
991 
channel_subsystem_init(void)992 static int __init channel_subsystem_init(void)
993 {
994 	int ret;
995 
996 	ret = css_bus_init();
997 	if (ret)
998 		return ret;
999 	cio_work_q = create_singlethread_workqueue("cio");
1000 	if (!cio_work_q) {
1001 		ret = -ENOMEM;
1002 		goto out_bus;
1003 	}
1004 	ret = io_subchannel_init();
1005 	if (ret)
1006 		goto out_wq;
1007 
1008 	return ret;
1009 out_wq:
1010 	destroy_workqueue(cio_work_q);
1011 out_bus:
1012 	css_bus_cleanup();
1013 	return ret;
1014 }
1015 subsys_initcall(channel_subsystem_init);
1016 
css_settle(struct device_driver * drv,void * unused)1017 static int css_settle(struct device_driver *drv, void *unused)
1018 {
1019 	struct css_driver *cssdrv = to_cssdriver(drv);
1020 
1021 	if (cssdrv->settle)
1022 		return cssdrv->settle();
1023 	return 0;
1024 }
1025 
css_complete_work(void)1026 int css_complete_work(void)
1027 {
1028 	int ret;
1029 
1030 	/* Wait for the evaluation of subchannels to finish. */
1031 	ret = wait_event_interruptible(css_eval_wq,
1032 				       atomic_read(&css_eval_scheduled) == 0);
1033 	if (ret)
1034 		return -EINTR;
1035 	flush_workqueue(cio_work_q);
1036 	/* Wait for the subchannel type specific initialization to finish */
1037 	return bus_for_each_drv(&css_bus_type, NULL, NULL, css_settle);
1038 }
1039 
1040 
1041 /*
1042  * Wait for the initialization of devices to finish, to make sure we are
1043  * done with our setup if the search for the root device starts.
1044  */
channel_subsystem_init_sync(void)1045 static int __init channel_subsystem_init_sync(void)
1046 {
1047 	/* Start initial subchannel evaluation. */
1048 	css_schedule_eval_all();
1049 	css_complete_work();
1050 	return 0;
1051 }
1052 subsys_initcall_sync(channel_subsystem_init_sync);
1053 
channel_subsystem_reinit(void)1054 void channel_subsystem_reinit(void)
1055 {
1056 	struct channel_path *chp;
1057 	struct chp_id chpid;
1058 
1059 	chsc_enable_facility(CHSC_SDA_OC_MSS);
1060 	chp_id_for_each(&chpid) {
1061 		chp = chpid_to_chp(chpid);
1062 		if (!chp)
1063 			continue;
1064 		chsc_determine_base_channel_path_desc(chpid, &chp->desc);
1065 	}
1066 }
1067 
1068 #ifdef CONFIG_PROC_FS
cio_settle_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)1069 static ssize_t cio_settle_write(struct file *file, const char __user *buf,
1070 				size_t count, loff_t *ppos)
1071 {
1072 	int ret;
1073 
1074 	/* Handle pending CRW's. */
1075 	crw_wait_for_channel_report();
1076 	ret = css_complete_work();
1077 
1078 	return ret ? ret : count;
1079 }
1080 
1081 static const struct file_operations cio_settle_proc_fops = {
1082 	.open = nonseekable_open,
1083 	.write = cio_settle_write,
1084 	.llseek = no_llseek,
1085 };
1086 
cio_settle_init(void)1087 static int __init cio_settle_init(void)
1088 {
1089 	struct proc_dir_entry *entry;
1090 
1091 	entry = proc_create("cio_settle", S_IWUSR, NULL,
1092 			    &cio_settle_proc_fops);
1093 	if (!entry)
1094 		return -ENOMEM;
1095 	return 0;
1096 }
1097 device_initcall(cio_settle_init);
1098 #endif /*CONFIG_PROC_FS*/
1099 
sch_is_pseudo_sch(struct subchannel * sch)1100 int sch_is_pseudo_sch(struct subchannel *sch)
1101 {
1102 	return sch == to_css(sch->dev.parent)->pseudo_subchannel;
1103 }
1104 
css_bus_match(struct device * dev,struct device_driver * drv)1105 static int css_bus_match(struct device *dev, struct device_driver *drv)
1106 {
1107 	struct subchannel *sch = to_subchannel(dev);
1108 	struct css_driver *driver = to_cssdriver(drv);
1109 	struct css_device_id *id;
1110 
1111 	for (id = driver->subchannel_type; id->match_flags; id++) {
1112 		if (sch->st == id->type)
1113 			return 1;
1114 	}
1115 
1116 	return 0;
1117 }
1118 
css_probe(struct device * dev)1119 static int css_probe(struct device *dev)
1120 {
1121 	struct subchannel *sch;
1122 	int ret;
1123 
1124 	sch = to_subchannel(dev);
1125 	sch->driver = to_cssdriver(dev->driver);
1126 	ret = sch->driver->probe ? sch->driver->probe(sch) : 0;
1127 	if (ret)
1128 		sch->driver = NULL;
1129 	return ret;
1130 }
1131 
css_remove(struct device * dev)1132 static int css_remove(struct device *dev)
1133 {
1134 	struct subchannel *sch;
1135 	int ret;
1136 
1137 	sch = to_subchannel(dev);
1138 	ret = sch->driver->remove ? sch->driver->remove(sch) : 0;
1139 	sch->driver = NULL;
1140 	return ret;
1141 }
1142 
css_shutdown(struct device * dev)1143 static void css_shutdown(struct device *dev)
1144 {
1145 	struct subchannel *sch;
1146 
1147 	sch = to_subchannel(dev);
1148 	if (sch->driver && sch->driver->shutdown)
1149 		sch->driver->shutdown(sch);
1150 }
1151 
css_uevent(struct device * dev,struct kobj_uevent_env * env)1152 static int css_uevent(struct device *dev, struct kobj_uevent_env *env)
1153 {
1154 	struct subchannel *sch = to_subchannel(dev);
1155 	int ret;
1156 
1157 	ret = add_uevent_var(env, "ST=%01X", sch->st);
1158 	if (ret)
1159 		return ret;
1160 	ret = add_uevent_var(env, "MODALIAS=css:t%01X", sch->st);
1161 	return ret;
1162 }
1163 
css_pm_prepare(struct device * dev)1164 static int css_pm_prepare(struct device *dev)
1165 {
1166 	struct subchannel *sch = to_subchannel(dev);
1167 	struct css_driver *drv;
1168 
1169 	if (mutex_is_locked(&sch->reg_mutex))
1170 		return -EAGAIN;
1171 	if (!sch->dev.driver)
1172 		return 0;
1173 	drv = to_cssdriver(sch->dev.driver);
1174 	/* Notify drivers that they may not register children. */
1175 	return drv->prepare ? drv->prepare(sch) : 0;
1176 }
1177 
css_pm_complete(struct device * dev)1178 static void css_pm_complete(struct device *dev)
1179 {
1180 	struct subchannel *sch = to_subchannel(dev);
1181 	struct css_driver *drv;
1182 
1183 	if (!sch->dev.driver)
1184 		return;
1185 	drv = to_cssdriver(sch->dev.driver);
1186 	if (drv->complete)
1187 		drv->complete(sch);
1188 }
1189 
css_pm_freeze(struct device * dev)1190 static int css_pm_freeze(struct device *dev)
1191 {
1192 	struct subchannel *sch = to_subchannel(dev);
1193 	struct css_driver *drv;
1194 
1195 	if (!sch->dev.driver)
1196 		return 0;
1197 	drv = to_cssdriver(sch->dev.driver);
1198 	return drv->freeze ? drv->freeze(sch) : 0;
1199 }
1200 
css_pm_thaw(struct device * dev)1201 static int css_pm_thaw(struct device *dev)
1202 {
1203 	struct subchannel *sch = to_subchannel(dev);
1204 	struct css_driver *drv;
1205 
1206 	if (!sch->dev.driver)
1207 		return 0;
1208 	drv = to_cssdriver(sch->dev.driver);
1209 	return drv->thaw ? drv->thaw(sch) : 0;
1210 }
1211 
css_pm_restore(struct device * dev)1212 static int css_pm_restore(struct device *dev)
1213 {
1214 	struct subchannel *sch = to_subchannel(dev);
1215 	struct css_driver *drv;
1216 
1217 	css_update_ssd_info(sch);
1218 	if (!sch->dev.driver)
1219 		return 0;
1220 	drv = to_cssdriver(sch->dev.driver);
1221 	return drv->restore ? drv->restore(sch) : 0;
1222 }
1223 
1224 static const struct dev_pm_ops css_pm_ops = {
1225 	.prepare = css_pm_prepare,
1226 	.complete = css_pm_complete,
1227 	.freeze = css_pm_freeze,
1228 	.thaw = css_pm_thaw,
1229 	.restore = css_pm_restore,
1230 };
1231 
1232 static struct bus_type css_bus_type = {
1233 	.name     = "css",
1234 	.match    = css_bus_match,
1235 	.probe    = css_probe,
1236 	.remove   = css_remove,
1237 	.shutdown = css_shutdown,
1238 	.uevent   = css_uevent,
1239 	.pm = &css_pm_ops,
1240 };
1241 
1242 /**
1243  * css_driver_register - register a css driver
1244  * @cdrv: css driver to register
1245  *
1246  * This is mainly a wrapper around driver_register that sets name
1247  * and bus_type in the embedded struct device_driver correctly.
1248  */
css_driver_register(struct css_driver * cdrv)1249 int css_driver_register(struct css_driver *cdrv)
1250 {
1251 	cdrv->drv.bus = &css_bus_type;
1252 	return driver_register(&cdrv->drv);
1253 }
1254 EXPORT_SYMBOL_GPL(css_driver_register);
1255 
1256 /**
1257  * css_driver_unregister - unregister a css driver
1258  * @cdrv: css driver to unregister
1259  *
1260  * This is a wrapper around driver_unregister.
1261  */
css_driver_unregister(struct css_driver * cdrv)1262 void css_driver_unregister(struct css_driver *cdrv)
1263 {
1264 	driver_unregister(&cdrv->drv);
1265 }
1266 EXPORT_SYMBOL_GPL(css_driver_unregister);
1267 
1268 MODULE_LICENSE("GPL");
1269