blob: 4e2f2bbf4ba5172278d65c32fa6985a1caca86f0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/s390/cio/css.c
3 * driver for channel subsystem
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Cornelia Huck7e9db9e2008-07-14 09:58:44 +02005 * Copyright IBM Corp. 2002,2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * Author(s): Arnd Bergmann (arndb@de.ibm.com)
Cornelia Huck4ce3b302006-01-14 13:21:04 -08007 * Cornelia Huck (cornelia.huck@de.ibm.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 */
9#include <linux/module.h>
10#include <linux/init.h>
11#include <linux/device.h>
12#include <linux/slab.h>
13#include <linux/errno.h>
14#include <linux/list.h>
Cornelia Hucka55360d2007-10-12 16:11:20 +020015#include <linux/reboot.h>
Cornelia Huck3a3fc292008-07-14 09:58:58 +020016#include <asm/isc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
Cornelia Huckc1156182008-07-14 09:58:46 +020018#include "../s390mach.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include "css.h"
20#include "cio.h"
21#include "cio_debug.h"
22#include "ioasm.h"
23#include "chsc.h"
Peter Oberparleiter40154b82006-06-29 14:57:03 +020024#include "device.h"
Peter Oberparleiter83b33702007-04-27 16:01:34 +020025#include "idset.h"
Peter Oberparleiter7ad6a242007-04-27 16:01:35 +020026#include "chp.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
Linus Torvalds1da177e2005-04-16 15:20:36 -070028int css_init_done = 0;
Peter Oberparleiter40154b82006-06-29 14:57:03 +020029static int need_reprobe = 0;
Cornelia Huckfb6958a2006-01-06 00:19:25 -080030static int max_ssid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
Cornelia Huck7c9f4e32007-10-12 16:11:13 +020032struct channel_subsystem *channel_subsystems[__MAX_CSSID + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Heiko Carstens4d284ca2007-02-05 21:18:53 +010034int
Cornelia Huckf97a56f2006-01-06 00:19:22 -080035for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *data)
36{
37 struct subchannel_id schid;
38 int ret;
39
40 init_subchannel_id(&schid);
41 ret = -ENODEV;
42 do {
Cornelia Huckfb6958a2006-01-06 00:19:25 -080043 do {
44 ret = fn(schid, data);
45 if (ret)
46 break;
47 } while (schid.sch_no++ < __MAX_SUBCHANNEL);
48 schid.sch_no = 0;
49 } while (schid.ssid++ < max_ssid);
Cornelia Huckf97a56f2006-01-06 00:19:22 -080050 return ret;
51}
52
Peter Oberparleitere82a1562008-01-26 14:10:48 +010053struct cb_data {
54 void *data;
55 struct idset *set;
56 int (*fn_known_sch)(struct subchannel *, void *);
57 int (*fn_unknown_sch)(struct subchannel_id, void *);
58};
59
60static int call_fn_known_sch(struct device *dev, void *data)
61{
62 struct subchannel *sch = to_subchannel(dev);
63 struct cb_data *cb = data;
64 int rc = 0;
65
66 idset_sch_del(cb->set, sch->schid);
67 if (cb->fn_known_sch)
68 rc = cb->fn_known_sch(sch, cb->data);
69 return rc;
70}
71
72static int call_fn_unknown_sch(struct subchannel_id schid, void *data)
73{
74 struct cb_data *cb = data;
75 int rc = 0;
76
77 if (idset_sch_contains(cb->set, schid))
78 rc = cb->fn_unknown_sch(schid, cb->data);
79 return rc;
80}
81
82int for_each_subchannel_staged(int (*fn_known)(struct subchannel *, void *),
83 int (*fn_unknown)(struct subchannel_id,
84 void *), void *data)
85{
86 struct cb_data cb;
87 int rc;
88
89 cb.set = idset_sch_new();
90 if (!cb.set)
91 return -ENOMEM;
92 idset_fill(cb.set);
93 cb.data = data;
94 cb.fn_known_sch = fn_known;
95 cb.fn_unknown_sch = fn_unknown;
96 /* Process registered subchannels. */
97 rc = bus_for_each_dev(&css_bus_type, NULL, &cb, call_fn_known_sch);
98 if (rc)
99 goto out;
100 /* Process unregistered subchannels. */
101 if (fn_unknown)
102 rc = for_each_subchannel(call_fn_unknown_sch, &cb);
103out:
104 idset_free(cb.set);
105
106 return rc;
107}
108
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109static struct subchannel *
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800110css_alloc_subchannel(struct subchannel_id schid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111{
112 struct subchannel *sch;
113 int ret;
114
115 sch = kmalloc (sizeof (*sch), GFP_KERNEL | GFP_DMA);
116 if (sch == NULL)
117 return ERR_PTR(-ENOMEM);
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800118 ret = cio_validate_subchannel (sch, schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 if (ret < 0) {
120 kfree(sch);
121 return ERR_PTR(ret);
122 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 return sch;
124}
125
126static void
127css_free_subchannel(struct subchannel *sch)
128{
129 if (sch) {
130 /* Reset intparm to zeroes. */
131 sch->schib.pmcw.intparm = 0;
132 cio_modify(sch);
Cornelia Huck2ec22982006-12-08 15:54:26 +0100133 kfree(sch->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 kfree(sch);
135 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
137
138static void
139css_subchannel_release(struct device *dev)
140{
141 struct subchannel *sch;
142
143 sch = to_subchannel(dev);
Cornelia Huck2ec22982006-12-08 15:54:26 +0100144 if (!cio_is_console(sch->schid)) {
145 kfree(sch->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 kfree(sch);
Cornelia Huck2ec22982006-12-08 15:54:26 +0100147 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148}
149
Cornelia Huck07c6a332007-07-27 12:29:10 +0200150static int css_sch_device_register(struct subchannel *sch)
Cornelia Huck6ab48792006-07-12 16:39:50 +0200151{
152 int ret;
153
154 mutex_lock(&sch->reg_mutex);
155 ret = device_register(&sch->dev);
156 mutex_unlock(&sch->reg_mutex);
157 return ret;
158}
159
Cornelia Huck44a1c192008-07-14 09:58:47 +0200160/**
161 * css_sch_device_unregister - unregister a subchannel
162 * @sch: subchannel to be unregistered
163 */
Cornelia Huck6ab48792006-07-12 16:39:50 +0200164void css_sch_device_unregister(struct subchannel *sch)
165{
166 mutex_lock(&sch->reg_mutex);
167 device_unregister(&sch->dev);
168 mutex_unlock(&sch->reg_mutex);
169}
Cornelia Huck44a1c192008-07-14 09:58:47 +0200170EXPORT_SYMBOL_GPL(css_sch_device_unregister);
Cornelia Huck6ab48792006-07-12 16:39:50 +0200171
Peter Oberparleiter7ad6a242007-04-27 16:01:35 +0200172static void ssd_from_pmcw(struct chsc_ssd_info *ssd, struct pmcw *pmcw)
173{
174 int i;
175 int mask;
176
177 memset(ssd, 0, sizeof(struct chsc_ssd_info));
178 ssd->path_mask = pmcw->pim;
179 for (i = 0; i < 8; i++) {
180 mask = 0x80 >> i;
181 if (pmcw->pim & mask) {
182 chp_id_init(&ssd->chpid[i]);
183 ssd->chpid[i].id = pmcw->chpid[i];
184 }
185 }
186}
187
188static void ssd_register_chpids(struct chsc_ssd_info *ssd)
189{
190 int i;
191 int mask;
192
193 for (i = 0; i < 8; i++) {
194 mask = 0x80 >> i;
195 if (ssd->path_mask & mask)
196 if (!chp_is_registered(ssd->chpid[i]))
197 chp_new(ssd->chpid[i]);
198 }
199}
200
201void css_update_ssd_info(struct subchannel *sch)
202{
203 int ret;
204
205 if (cio_is_console(sch->schid)) {
206 /* Console is initialized too early for functions requiring
207 * memory allocation. */
208 ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
209 } else {
210 ret = chsc_get_ssd_info(sch->schid, &sch->ssd_info);
211 if (ret)
212 ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
213 ssd_register_chpids(&sch->ssd_info);
214 }
215}
216
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200217static ssize_t type_show(struct device *dev, struct device_attribute *attr,
218 char *buf)
219{
220 struct subchannel *sch = to_subchannel(dev);
221
222 return sprintf(buf, "%01x\n", sch->st);
223}
224
225static DEVICE_ATTR(type, 0444, type_show, NULL);
226
227static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
228 char *buf)
229{
230 struct subchannel *sch = to_subchannel(dev);
231
232 return sprintf(buf, "css:t%01X\n", sch->st);
233}
234
235static DEVICE_ATTR(modalias, 0444, modalias_show, NULL);
236
237static struct attribute *subch_attrs[] = {
238 &dev_attr_type.attr,
239 &dev_attr_modalias.attr,
240 NULL,
241};
242
243static struct attribute_group subch_attr_group = {
244 .attrs = subch_attrs,
245};
246
247static struct attribute_group *default_subch_attr_groups[] = {
248 &subch_attr_group,
249 NULL,
250};
251
Peter Oberparleiter7ad6a242007-04-27 16:01:35 +0200252static int css_register_subchannel(struct subchannel *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253{
254 int ret;
255
256 /* Initialize the subchannel structure */
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200257 sch->dev.parent = &channel_subsystems[0]->device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 sch->dev.bus = &css_bus_type;
259 sch->dev.release = &css_subchannel_release;
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200260 sch->dev.groups = default_subch_attr_groups;
Cornelia Huck5bf04b22007-10-22 12:52:41 +0200261 /*
262 * We don't want to generate uevents for I/O subchannels that don't
263 * have a working ccw device behind them since they will be
264 * unregistered before they can be used anyway, so we delay the add
265 * uevent until after device recognition was successful.
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200266 * Note that we suppress the uevent for all subchannel types;
267 * the subchannel driver can decide itself when it wants to inform
268 * userspace of its existence.
Cornelia Huck5bf04b22007-10-22 12:52:41 +0200269 */
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200270 sch->dev.uevent_suppress = 1;
Peter Oberparleiter7ad6a242007-04-27 16:01:35 +0200271 css_update_ssd_info(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 /* make it known to the system */
Cornelia Huck6ab48792006-07-12 16:39:50 +0200273 ret = css_sch_device_register(sch);
Cornelia Huck7674da72006-12-08 15:54:21 +0100274 if (ret) {
Cornelia Hucke556bbb2007-07-27 12:29:19 +0200275 CIO_MSG_EVENT(0, "Could not register sch 0.%x.%04x: %d\n",
276 sch->schid.ssid, sch->schid.sch_no, ret);
Cornelia Huck7674da72006-12-08 15:54:21 +0100277 return ret;
278 }
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200279 if (!sch->driver) {
280 /*
281 * No driver matched. Generate the uevent now so that
282 * a fitting driver module may be loaded based on the
283 * modalias.
284 */
285 sch->dev.uevent_suppress = 0;
286 kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
287 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 return ret;
289}
290
Cornelia Huckc820de32008-07-14 09:58:45 +0200291int css_probe_device(struct subchannel_id schid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292{
293 int ret;
294 struct subchannel *sch;
295
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800296 sch = css_alloc_subchannel(schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 if (IS_ERR(sch))
298 return PTR_ERR(sch);
299 ret = css_register_subchannel(sch);
300 if (ret)
301 css_free_subchannel(sch);
302 return ret;
303}
304
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700305static int
306check_subchannel(struct device * dev, void * data)
307{
308 struct subchannel *sch;
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800309 struct subchannel_id *schid = data;
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700310
311 sch = to_subchannel(dev);
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800312 return schid_equal(&sch->schid, schid);
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700313}
314
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315struct subchannel *
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800316get_subchannel_by_schid(struct subchannel_id schid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 struct device *dev;
319
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700320 dev = bus_find_device(&css_bus_type, NULL,
Cornelia Huck12975ae2006-10-11 15:31:47 +0200321 &schid, check_subchannel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700323 return dev ? to_subchannel(dev) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324}
325
Cornelia Huckb279a4f2008-01-26 14:10:45 +0100326/**
327 * css_sch_is_valid() - check if a subchannel is valid
328 * @schib: subchannel information block for the subchannel
329 */
330int css_sch_is_valid(struct schib *schib)
331{
332 if ((schib->pmcw.st == SUBCHANNEL_TYPE_IO) && !schib->pmcw.dnv)
333 return 0;
Cornelia Huckb3a686f2008-07-14 09:58:48 +0200334 if ((schib->pmcw.st == SUBCHANNEL_TYPE_MSG) && !schib->pmcw.w)
335 return 0;
Cornelia Huckb279a4f2008-01-26 14:10:45 +0100336 return 1;
337}
338EXPORT_SYMBOL_GPL(css_sch_is_valid);
339
Peter Oberparleiter564337f2006-09-20 16:00:01 +0200340static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow)
341{
342 struct schib schib;
343
344 if (!slow) {
345 /* Will be done on the slow path. */
346 return -EAGAIN;
347 }
Cornelia Huckb279a4f2008-01-26 14:10:45 +0100348 if (stsch_err(schid, &schib) || !css_sch_is_valid(&schib)) {
Peter Oberparleiter564337f2006-09-20 16:00:01 +0200349 /* Unusable - ignore. */
350 return 0;
351 }
352 CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, unknown, "
353 "slow path.\n", schid.ssid, schid.sch_no, CIO_OPER);
354
355 return css_probe_device(schid);
356}
357
Cornelia Huckc820de32008-07-14 09:58:45 +0200358static int css_evaluate_known_subchannel(struct subchannel *sch, int slow)
359{
360 int ret = 0;
361
362 if (sch->driver) {
363 if (sch->driver->sch_event)
364 ret = sch->driver->sch_event(sch, slow);
365 else
366 dev_dbg(&sch->dev,
367 "Got subchannel machine check but "
368 "no sch_event handler provided.\n");
369 }
370 return ret;
371}
372
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200373static void css_evaluate_subchannel(struct subchannel_id schid, int slow)
Peter Oberparleiter564337f2006-09-20 16:00:01 +0200374{
375 struct subchannel *sch;
376 int ret;
377
378 sch = get_subchannel_by_schid(schid);
379 if (sch) {
380 ret = css_evaluate_known_subchannel(sch, slow);
381 put_device(&sch->dev);
382 } else
383 ret = css_evaluate_new_subchannel(schid, slow);
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200384 if (ret == -EAGAIN)
385 css_schedule_eval(schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386}
387
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200388static struct idset *slow_subchannel_set;
389static spinlock_t slow_subchannel_lock;
390
391static int __init slow_subchannel_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392{
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200393 spin_lock_init(&slow_subchannel_lock);
394 slow_subchannel_set = idset_sch_new();
395 if (!slow_subchannel_set) {
Cornelia Hucke556bbb2007-07-27 12:29:19 +0200396 CIO_MSG_EVENT(0, "could not allocate slow subchannel set\n");
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200397 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 }
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200399 return 0;
400}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
Peter Oberparleitere82a1562008-01-26 14:10:48 +0100402static int slow_eval_known_fn(struct subchannel *sch, void *data)
403{
404 int eval;
405 int rc;
406
407 spin_lock_irq(&slow_subchannel_lock);
408 eval = idset_sch_contains(slow_subchannel_set, sch->schid);
409 idset_sch_del(slow_subchannel_set, sch->schid);
410 spin_unlock_irq(&slow_subchannel_lock);
411 if (eval) {
412 rc = css_evaluate_known_subchannel(sch, 1);
413 if (rc == -EAGAIN)
414 css_schedule_eval(sch->schid);
415 }
416 return 0;
417}
418
419static int slow_eval_unknown_fn(struct subchannel_id schid, void *data)
420{
421 int eval;
422 int rc = 0;
423
424 spin_lock_irq(&slow_subchannel_lock);
425 eval = idset_sch_contains(slow_subchannel_set, schid);
426 idset_sch_del(slow_subchannel_set, schid);
427 spin_unlock_irq(&slow_subchannel_lock);
428 if (eval) {
429 rc = css_evaluate_new_subchannel(schid, 1);
430 switch (rc) {
431 case -EAGAIN:
432 css_schedule_eval(schid);
433 rc = 0;
434 break;
435 case -ENXIO:
436 case -ENOMEM:
437 case -EIO:
438 /* These should abort looping */
439 break;
440 default:
441 rc = 0;
442 }
443 }
444 return rc;
445}
446
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200447static void css_slow_path_func(struct work_struct *unused)
448{
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200449 CIO_TRACE_EVENT(4, "slowpath");
Peter Oberparleitere82a1562008-01-26 14:10:48 +0100450 for_each_subchannel_staged(slow_eval_known_fn, slow_eval_unknown_fn,
451 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452}
453
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200454static DECLARE_WORK(slow_path_work, css_slow_path_func);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455struct workqueue_struct *slow_path_wq;
456
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200457void css_schedule_eval(struct subchannel_id schid)
458{
459 unsigned long flags;
460
461 spin_lock_irqsave(&slow_subchannel_lock, flags);
462 idset_sch_add(slow_subchannel_set, schid);
463 queue_work(slow_path_wq, &slow_path_work);
464 spin_unlock_irqrestore(&slow_subchannel_lock, flags);
465}
466
467void css_schedule_eval_all(void)
468{
469 unsigned long flags;
470
471 spin_lock_irqsave(&slow_subchannel_lock, flags);
472 idset_fill(slow_subchannel_set);
473 queue_work(slow_path_wq, &slow_path_work);
474 spin_unlock_irqrestore(&slow_subchannel_lock, flags);
475}
476
Cornelia Huck22806dc2008-04-17 07:45:59 +0200477void css_wait_for_slow_path(void)
478{
479 flush_workqueue(ccw_device_notify_work);
480 flush_workqueue(slow_path_wq);
481}
482
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200483/* Reprobe subchannel if unregistered. */
484static int reprobe_subchannel(struct subchannel_id schid, void *data)
485{
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200486 int ret;
487
Cornelia Hucke556bbb2007-07-27 12:29:19 +0200488 CIO_MSG_EVENT(6, "cio: reprobe 0.%x.%04x\n",
489 schid.ssid, schid.sch_no);
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200490 if (need_reprobe)
491 return -EAGAIN;
492
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200493 ret = css_probe_device(schid);
494 switch (ret) {
495 case 0:
496 break;
497 case -ENXIO:
498 case -ENOMEM:
Peter Oberparleiter67175612007-12-04 16:09:02 +0100499 case -EIO:
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200500 /* These should abort looping */
501 break;
502 default:
503 ret = 0;
504 }
505
506 return ret;
507}
508
509/* Work function used to reprobe all unregistered subchannels. */
Al Viro4927b3f2006-12-06 19:18:20 +0000510static void reprobe_all(struct work_struct *unused)
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200511{
512 int ret;
513
Michael Ernst139b83d2008-05-07 09:22:54 +0200514 CIO_MSG_EVENT(4, "reprobe start\n");
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200515
516 need_reprobe = 0;
517 /* Make sure initial subchannel scan is done. */
518 wait_event(ccw_device_init_wq,
519 atomic_read(&ccw_device_init_count) == 0);
Peter Oberparleitere82a1562008-01-26 14:10:48 +0100520 ret = for_each_subchannel_staged(NULL, reprobe_subchannel, NULL);
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200521
Michael Ernst139b83d2008-05-07 09:22:54 +0200522 CIO_MSG_EVENT(4, "reprobe done (rc=%d, need_reprobe=%d)\n", ret,
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200523 need_reprobe);
524}
525
Heiko Carstens2b67fc42007-02-05 21:16:47 +0100526static DECLARE_WORK(css_reprobe_work, reprobe_all);
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200527
528/* Schedule reprobing of all unregistered subchannels. */
529void css_schedule_reprobe(void)
530{
531 need_reprobe = 1;
Cornelia Huckc5d4a992007-11-20 11:13:41 +0100532 queue_work(slow_path_wq, &css_reprobe_work);
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200533}
534
535EXPORT_SYMBOL_GPL(css_schedule_reprobe);
536
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 * Called from the machine check handler for subchannel report words.
539 */
Cornelia Huckc1156182008-07-14 09:58:46 +0200540static void css_process_crw(struct crw *crw0, struct crw *crw1, int overflow)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800542 struct subchannel_id mchk_schid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
Cornelia Huckc1156182008-07-14 09:58:46 +0200544 if (overflow) {
545 css_schedule_eval_all();
546 return;
547 }
548 CIO_CRW_EVENT(2, "CRW0 reports slct=%d, oflw=%d, "
549 "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
550 crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc,
551 crw0->erc, crw0->rsid);
552 if (crw1)
553 CIO_CRW_EVENT(2, "CRW1 reports slct=%d, oflw=%d, "
554 "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
555 crw1->slct, crw1->oflw, crw1->chn, crw1->rsc,
556 crw1->anc, crw1->erc, crw1->rsid);
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800557 init_subchannel_id(&mchk_schid);
Cornelia Huckc1156182008-07-14 09:58:46 +0200558 mchk_schid.sch_no = crw0->rsid;
559 if (crw1)
560 mchk_schid.ssid = (crw1->rsid >> 8) & 3;
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800561
Cornelia Huckc1156182008-07-14 09:58:46 +0200562 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 * Since we are always presented with IPI in the CRW, we have to
564 * use stsch() to find out if the subchannel in question has come
565 * or gone.
566 */
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200567 css_evaluate_subchannel(mchk_schid, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568}
569
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800570static int __init
571__init_channel_subsystem(struct subchannel_id schid, void *data)
572{
573 struct subchannel *sch;
574 int ret;
575
576 if (cio_is_console(schid))
577 sch = cio_get_console_subchannel();
578 else {
579 sch = css_alloc_subchannel(schid);
580 if (IS_ERR(sch))
581 ret = PTR_ERR(sch);
582 else
583 ret = 0;
584 switch (ret) {
585 case 0:
586 break;
587 case -ENOMEM:
588 panic("Out of memory in init_channel_subsystem\n");
589 /* -ENXIO: no more subchannels. */
590 case -ENXIO:
591 return ret;
Greg Smithe843e282006-03-14 19:50:17 -0800592 /* -EIO: this subchannel set not supported. */
593 case -EIO:
594 return ret;
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800595 default:
596 return 0;
597 }
598 }
599 /*
600 * We register ALL valid subchannels in ioinfo, even those
601 * that have been present before init_channel_subsystem.
602 * These subchannels can't have been registered yet (kmalloc
603 * not working) so we do it now. This is true e.g. for the
604 * console subchannel.
605 */
606 css_register_subchannel(sch);
607 return 0;
608}
609
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610static void __init
Cornelia Hucka28c6942006-01-06 00:19:23 -0800611css_generate_pgid(struct channel_subsystem *css, u32 tod_high)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
Cornelia Huck75784c02008-07-14 09:58:57 +0200613 if (css_general_characteristics.mcss) {
Cornelia Hucka28c6942006-01-06 00:19:23 -0800614 css->global_pgid.pgid_high.ext_cssid.version = 0x80;
615 css->global_pgid.pgid_high.ext_cssid.cssid = css->cssid;
616 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617#ifdef CONFIG_SMP
Cornelia Hucka28c6942006-01-06 00:19:23 -0800618 css->global_pgid.pgid_high.cpu_addr = hard_smp_processor_id();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619#else
Cornelia Hucka28c6942006-01-06 00:19:23 -0800620 css->global_pgid.pgid_high.cpu_addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621#endif
622 }
Cornelia Hucka28c6942006-01-06 00:19:23 -0800623 css->global_pgid.cpu_id = ((cpuid_t *) __LC_CPUID)->ident;
624 css->global_pgid.cpu_model = ((cpuid_t *) __LC_CPUID)->machine;
625 css->global_pgid.tod_high = tod_high;
626
627}
628
Cornelia Huck3b793062006-01-06 00:19:26 -0800629static void
630channel_subsystem_release(struct device *dev)
631{
632 struct channel_subsystem *css;
633
634 css = to_css(dev);
Cornelia Huck495a5b42006-03-24 03:15:14 -0800635 mutex_destroy(&css->mutex);
Cornelia Huck3b793062006-01-06 00:19:26 -0800636 kfree(css);
637}
638
Cornelia Huck495a5b42006-03-24 03:15:14 -0800639static ssize_t
640css_cm_enable_show(struct device *dev, struct device_attribute *attr,
641 char *buf)
642{
643 struct channel_subsystem *css = to_css(dev);
Michael Ernst8284fb192008-04-17 07:46:01 +0200644 int ret;
Cornelia Huck495a5b42006-03-24 03:15:14 -0800645
646 if (!css)
647 return 0;
Michael Ernst8284fb192008-04-17 07:46:01 +0200648 mutex_lock(&css->mutex);
649 ret = sprintf(buf, "%x\n", css->cm_enabled);
650 mutex_unlock(&css->mutex);
651 return ret;
Cornelia Huck495a5b42006-03-24 03:15:14 -0800652}
653
654static ssize_t
655css_cm_enable_store(struct device *dev, struct device_attribute *attr,
656 const char *buf, size_t count)
657{
658 struct channel_subsystem *css = to_css(dev);
659 int ret;
Cornelia Huck2f972202008-04-30 13:38:33 +0200660 unsigned long val;
Cornelia Huck495a5b42006-03-24 03:15:14 -0800661
Cornelia Huck2f972202008-04-30 13:38:33 +0200662 ret = strict_strtoul(buf, 16, &val);
663 if (ret)
664 return ret;
Michael Ernst8284fb192008-04-17 07:46:01 +0200665 mutex_lock(&css->mutex);
Cornelia Huck2f972202008-04-30 13:38:33 +0200666 switch (val) {
667 case 0:
Cornelia Huck495a5b42006-03-24 03:15:14 -0800668 ret = css->cm_enabled ? chsc_secm(css, 0) : 0;
669 break;
Cornelia Huck2f972202008-04-30 13:38:33 +0200670 case 1:
Cornelia Huck495a5b42006-03-24 03:15:14 -0800671 ret = css->cm_enabled ? 0 : chsc_secm(css, 1);
672 break;
673 default:
674 ret = -EINVAL;
675 }
Michael Ernst8284fb192008-04-17 07:46:01 +0200676 mutex_unlock(&css->mutex);
Cornelia Huck495a5b42006-03-24 03:15:14 -0800677 return ret < 0 ? ret : count;
678}
679
680static DEVICE_ATTR(cm_enable, 0644, css_cm_enable_show, css_cm_enable_store);
681
Heiko Carstens4d284ca2007-02-05 21:18:53 +0100682static int __init setup_css(int nr)
Cornelia Hucka28c6942006-01-06 00:19:23 -0800683{
684 u32 tod_high;
Cornelia Huckd7b5a4c2006-12-08 15:54:28 +0100685 int ret;
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200686 struct channel_subsystem *css;
Cornelia Hucka28c6942006-01-06 00:19:23 -0800687
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200688 css = channel_subsystems[nr];
689 memset(css, 0, sizeof(struct channel_subsystem));
690 css->pseudo_subchannel =
691 kzalloc(sizeof(*css->pseudo_subchannel), GFP_KERNEL);
692 if (!css->pseudo_subchannel)
Cornelia Huckd7b5a4c2006-12-08 15:54:28 +0100693 return -ENOMEM;
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200694 css->pseudo_subchannel->dev.parent = &css->device;
695 css->pseudo_subchannel->dev.release = css_subchannel_release;
696 sprintf(css->pseudo_subchannel->dev.bus_id, "defunct");
697 ret = cio_create_sch_lock(css->pseudo_subchannel);
Cornelia Huckd7b5a4c2006-12-08 15:54:28 +0100698 if (ret) {
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200699 kfree(css->pseudo_subchannel);
Cornelia Huckd7b5a4c2006-12-08 15:54:28 +0100700 return ret;
701 }
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200702 mutex_init(&css->mutex);
703 css->valid = 1;
704 css->cssid = nr;
705 sprintf(css->device.bus_id, "css%x", nr);
706 css->device.release = channel_subsystem_release;
Cornelia Hucka28c6942006-01-06 00:19:23 -0800707 tod_high = (u32) (get_clock() >> 32);
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200708 css_generate_pgid(css, tod_high);
Cornelia Huckd7b5a4c2006-12-08 15:54:28 +0100709 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710}
711
Cornelia Hucka55360d2007-10-12 16:11:20 +0200712static int css_reboot_event(struct notifier_block *this,
713 unsigned long event,
714 void *ptr)
715{
716 int ret, i;
717
718 ret = NOTIFY_DONE;
719 for (i = 0; i <= __MAX_CSSID; i++) {
720 struct channel_subsystem *css;
721
722 css = channel_subsystems[i];
Michael Ernst8284fb192008-04-17 07:46:01 +0200723 mutex_lock(&css->mutex);
Cornelia Hucka55360d2007-10-12 16:11:20 +0200724 if (css->cm_enabled)
725 if (chsc_secm(css, 0))
726 ret = NOTIFY_BAD;
Michael Ernst8284fb192008-04-17 07:46:01 +0200727 mutex_unlock(&css->mutex);
Cornelia Hucka55360d2007-10-12 16:11:20 +0200728 }
729
730 return ret;
731}
732
733static struct notifier_block css_reboot_notifier = {
734 .notifier_call = css_reboot_event,
735};
736
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737/*
738 * Now that the driver core is running, we can setup our channel subsystem.
739 * The struct subchannel's are created during probing (except for the
740 * static console subchannel).
741 */
742static int __init
743init_channel_subsystem (void)
744{
Cornelia Hucka28c6942006-01-06 00:19:23 -0800745 int ret, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
Cornelia Huck4434a382007-07-27 12:29:21 +0200747 ret = chsc_determine_css_characteristics();
748 if (ret == -ENOMEM)
749 goto out; /* No need to continue. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
Cornelia Huck4434a382007-07-27 12:29:21 +0200751 ret = chsc_alloc_sei_area();
752 if (ret)
753 goto out;
754
755 ret = slow_subchannel_init();
756 if (ret)
757 goto out;
758
Cornelia Huckc1156182008-07-14 09:58:46 +0200759 ret = s390_register_crw_handler(CRW_RSC_SCH, css_process_crw);
760 if (ret)
761 goto out;
762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 if ((ret = bus_register(&css_bus_type)))
764 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800766 /* Try to enable MSS. */
767 ret = chsc_enable_facility(CHSC_SDA_OC_MSS);
768 switch (ret) {
769 case 0: /* Success. */
770 max_ssid = __MAX_SSID;
771 break;
772 case -ENOMEM:
773 goto out_bus;
774 default:
775 max_ssid = 0;
776 }
Cornelia Hucka28c6942006-01-06 00:19:23 -0800777 /* Setup css structure. */
778 for (i = 0; i <= __MAX_CSSID; i++) {
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200779 struct channel_subsystem *css;
780
781 css = kmalloc(sizeof(struct channel_subsystem), GFP_KERNEL);
782 if (!css) {
Cornelia Hucka28c6942006-01-06 00:19:23 -0800783 ret = -ENOMEM;
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800784 goto out_unregister;
Cornelia Hucka28c6942006-01-06 00:19:23 -0800785 }
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200786 channel_subsystems[i] = css;
Cornelia Huckd7b5a4c2006-12-08 15:54:28 +0100787 ret = setup_css(i);
Cornelia Hucka28c6942006-01-06 00:19:23 -0800788 if (ret)
789 goto out_free;
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200790 ret = device_register(&css->device);
Cornelia Huckd7b5a4c2006-12-08 15:54:28 +0100791 if (ret)
792 goto out_free_all;
Cornelia Huck75784c02008-07-14 09:58:57 +0200793 if (css_chsc_characteristics.secm) {
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200794 ret = device_create_file(&css->device,
Cornelia Huck7e560812006-07-12 16:40:19 +0200795 &dev_attr_cm_enable);
796 if (ret)
797 goto out_device;
798 }
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200799 ret = device_register(&css->pseudo_subchannel->dev);
Cornelia Huckd7b5a4c2006-12-08 15:54:28 +0100800 if (ret)
801 goto out_file;
Cornelia Hucka28c6942006-01-06 00:19:23 -0800802 }
Cornelia Hucka55360d2007-10-12 16:11:20 +0200803 ret = register_reboot_notifier(&css_reboot_notifier);
804 if (ret)
805 goto out_pseudo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 css_init_done = 1;
807
Cornelia Huck3a3fc292008-07-14 09:58:58 +0200808 /* Enable default isc for I/O subchannels. */
Cornelia Huck6ef556c2008-07-14 09:59:01 +0200809 isc_register(IO_SCH_ISC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800811 for_each_subchannel(__init_channel_subsystem, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 return 0;
Cornelia Hucka55360d2007-10-12 16:11:20 +0200813out_pseudo:
814 device_unregister(&channel_subsystems[i]->pseudo_subchannel->dev);
Cornelia Huckd7b5a4c2006-12-08 15:54:28 +0100815out_file:
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200816 device_remove_file(&channel_subsystems[i]->device,
817 &dev_attr_cm_enable);
Cornelia Huck7e560812006-07-12 16:40:19 +0200818out_device:
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200819 device_unregister(&channel_subsystems[i]->device);
Cornelia Huckd7b5a4c2006-12-08 15:54:28 +0100820out_free_all:
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200821 kfree(channel_subsystems[i]->pseudo_subchannel->lock);
822 kfree(channel_subsystems[i]->pseudo_subchannel);
Cornelia Hucka28c6942006-01-06 00:19:23 -0800823out_free:
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200824 kfree(channel_subsystems[i]);
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800825out_unregister:
Cornelia Hucka28c6942006-01-06 00:19:23 -0800826 while (i > 0) {
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200827 struct channel_subsystem *css;
828
Cornelia Hucka28c6942006-01-06 00:19:23 -0800829 i--;
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200830 css = channel_subsystems[i];
831 device_unregister(&css->pseudo_subchannel->dev);
Cornelia Huck75784c02008-07-14 09:58:57 +0200832 if (css_chsc_characteristics.secm)
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200833 device_remove_file(&css->device,
Cornelia Huck495a5b42006-03-24 03:15:14 -0800834 &dev_attr_cm_enable);
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200835 device_unregister(&css->device);
Cornelia Hucka28c6942006-01-06 00:19:23 -0800836 }
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800837out_bus:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 bus_unregister(&css_bus_type);
839out:
Cornelia Huckc1156182008-07-14 09:58:46 +0200840 s390_unregister_crw_handler(CRW_RSC_CSS);
Cornelia Huck4434a382007-07-27 12:29:21 +0200841 chsc_free_sei_area();
842 kfree(slow_subchannel_set);
843 printk(KERN_WARNING"cio: failed to initialize css driver (%d)!\n",
844 ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 return ret;
846}
847
Cornelia Huckd7b5a4c2006-12-08 15:54:28 +0100848int sch_is_pseudo_sch(struct subchannel *sch)
849{
850 return sch == to_css(sch->dev.parent)->pseudo_subchannel;
851}
852
Cornelia Huckf08adc02008-07-14 09:59:03 +0200853static int css_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854{
Cornelia Huck084325d2008-01-26 14:10:38 +0100855 struct subchannel *sch = to_subchannel(dev);
856 struct css_driver *driver = to_cssdriver(drv);
Cornelia Huckf08adc02008-07-14 09:59:03 +0200857 struct css_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
Cornelia Huckf08adc02008-07-14 09:59:03 +0200859 for (id = driver->subchannel_type; id->match_flags; id++) {
860 if (sch->st == id->type)
861 return 1;
862 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
864 return 0;
865}
866
Cornelia Huck98c13c22008-01-26 14:10:40 +0100867static int css_probe(struct device *dev)
Cornelia Huck8bbace72006-01-11 10:56:22 +0100868{
869 struct subchannel *sch;
Cornelia Huck98c13c22008-01-26 14:10:40 +0100870 int ret;
Cornelia Huck8bbace72006-01-11 10:56:22 +0100871
872 sch = to_subchannel(dev);
Cornelia Huck084325d2008-01-26 14:10:38 +0100873 sch->driver = to_cssdriver(dev->driver);
Cornelia Huck98c13c22008-01-26 14:10:40 +0100874 ret = sch->driver->probe ? sch->driver->probe(sch) : 0;
875 if (ret)
876 sch->driver = NULL;
877 return ret;
Cornelia Huck8bbace72006-01-11 10:56:22 +0100878}
879
Cornelia Huck98c13c22008-01-26 14:10:40 +0100880static int css_remove(struct device *dev)
881{
882 struct subchannel *sch;
883 int ret;
884
885 sch = to_subchannel(dev);
886 ret = sch->driver->remove ? sch->driver->remove(sch) : 0;
887 sch->driver = NULL;
888 return ret;
889}
890
891static void css_shutdown(struct device *dev)
Cornelia Huck8bbace72006-01-11 10:56:22 +0100892{
893 struct subchannel *sch;
894
895 sch = to_subchannel(dev);
Cornelia Huck98c13c22008-01-26 14:10:40 +0100896 if (sch->driver && sch->driver->shutdown)
Cornelia Huck8bbace72006-01-11 10:56:22 +0100897 sch->driver->shutdown(sch);
898}
899
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200900static int css_uevent(struct device *dev, struct kobj_uevent_env *env)
901{
902 struct subchannel *sch = to_subchannel(dev);
903 int ret;
904
905 ret = add_uevent_var(env, "ST=%01X", sch->st);
906 if (ret)
907 return ret;
908 ret = add_uevent_var(env, "MODALIAS=css:t%01X", sch->st);
909 return ret;
910}
911
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912struct bus_type css_bus_type = {
Cornelia Huck8bbace72006-01-11 10:56:22 +0100913 .name = "css",
914 .match = css_bus_match,
915 .probe = css_probe,
916 .remove = css_remove,
917 .shutdown = css_shutdown,
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200918 .uevent = css_uevent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919};
920
Cornelia Huck25b7bb52008-01-26 14:10:41 +0100921/**
922 * css_driver_register - register a css driver
923 * @cdrv: css driver to register
924 *
925 * This is mainly a wrapper around driver_register that sets name
926 * and bus_type in the embedded struct device_driver correctly.
927 */
928int css_driver_register(struct css_driver *cdrv)
929{
930 cdrv->drv.name = cdrv->name;
931 cdrv->drv.bus = &css_bus_type;
Cornelia Huck4beee642008-01-26 14:10:47 +0100932 cdrv->drv.owner = cdrv->owner;
Cornelia Huck25b7bb52008-01-26 14:10:41 +0100933 return driver_register(&cdrv->drv);
934}
935EXPORT_SYMBOL_GPL(css_driver_register);
936
937/**
938 * css_driver_unregister - unregister a css driver
939 * @cdrv: css driver to unregister
940 *
941 * This is a wrapper around driver_unregister.
942 */
943void css_driver_unregister(struct css_driver *cdrv)
944{
945 driver_unregister(&cdrv->drv);
946}
947EXPORT_SYMBOL_GPL(css_driver_unregister);
948
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949subsys_initcall(init_channel_subsystem);
950
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951MODULE_LICENSE("GPL");
952EXPORT_SYMBOL(css_bus_type);