blob: cf9d27c6f44479ecc49fe7df4333578464ecb553 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016
Cornelia Huckc1156182008-07-14 09:58:46 +020017#include "../s390mach.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "css.h"
19#include "cio.h"
20#include "cio_debug.h"
21#include "ioasm.h"
22#include "chsc.h"
Peter Oberparleiter40154b82006-06-29 14:57:03 +020023#include "device.h"
Peter Oberparleiter83b33702007-04-27 16:01:34 +020024#include "idset.h"
Peter Oberparleiter7ad6a242007-04-27 16:01:35 +020025#include "chp.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
Linus Torvalds1da177e2005-04-16 15:20:36 -070027int css_init_done = 0;
Peter Oberparleiter40154b82006-06-29 14:57:03 +020028static int need_reprobe = 0;
Cornelia Huckfb6958a2006-01-06 00:19:25 -080029static int max_ssid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Cornelia Huck7c9f4e32007-10-12 16:11:13 +020031struct channel_subsystem *channel_subsystems[__MAX_CSSID + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Cornelia Hucka28c6942006-01-06 00:19:23 -080033int css_characteristics_avail = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Heiko Carstens4d284ca2007-02-05 21:18:53 +010035int
Cornelia Huckf97a56f2006-01-06 00:19:22 -080036for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *data)
37{
38 struct subchannel_id schid;
39 int ret;
40
41 init_subchannel_id(&schid);
42 ret = -ENODEV;
43 do {
Cornelia Huckfb6958a2006-01-06 00:19:25 -080044 do {
45 ret = fn(schid, data);
46 if (ret)
47 break;
48 } while (schid.sch_no++ < __MAX_SUBCHANNEL);
49 schid.sch_no = 0;
50 } while (schid.ssid++ < max_ssid);
Cornelia Huckf97a56f2006-01-06 00:19:22 -080051 return ret;
52}
53
Peter Oberparleitere82a1562008-01-26 14:10:48 +010054struct cb_data {
55 void *data;
56 struct idset *set;
57 int (*fn_known_sch)(struct subchannel *, void *);
58 int (*fn_unknown_sch)(struct subchannel_id, void *);
59};
60
61static int call_fn_known_sch(struct device *dev, void *data)
62{
63 struct subchannel *sch = to_subchannel(dev);
64 struct cb_data *cb = data;
65 int rc = 0;
66
67 idset_sch_del(cb->set, sch->schid);
68 if (cb->fn_known_sch)
69 rc = cb->fn_known_sch(sch, cb->data);
70 return rc;
71}
72
73static int call_fn_unknown_sch(struct subchannel_id schid, void *data)
74{
75 struct cb_data *cb = data;
76 int rc = 0;
77
78 if (idset_sch_contains(cb->set, schid))
79 rc = cb->fn_unknown_sch(schid, cb->data);
80 return rc;
81}
82
83int for_each_subchannel_staged(int (*fn_known)(struct subchannel *, void *),
84 int (*fn_unknown)(struct subchannel_id,
85 void *), void *data)
86{
87 struct cb_data cb;
88 int rc;
89
90 cb.set = idset_sch_new();
91 if (!cb.set)
92 return -ENOMEM;
93 idset_fill(cb.set);
94 cb.data = data;
95 cb.fn_known_sch = fn_known;
96 cb.fn_unknown_sch = fn_unknown;
97 /* Process registered subchannels. */
98 rc = bus_for_each_dev(&css_bus_type, NULL, &cb, call_fn_known_sch);
99 if (rc)
100 goto out;
101 /* Process unregistered subchannels. */
102 if (fn_unknown)
103 rc = for_each_subchannel(call_fn_unknown_sch, &cb);
104out:
105 idset_free(cb.set);
106
107 return rc;
108}
109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110static struct subchannel *
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800111css_alloc_subchannel(struct subchannel_id schid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112{
113 struct subchannel *sch;
114 int ret;
115
116 sch = kmalloc (sizeof (*sch), GFP_KERNEL | GFP_DMA);
117 if (sch == NULL)
118 return ERR_PTR(-ENOMEM);
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800119 ret = cio_validate_subchannel (sch, schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 if (ret < 0) {
121 kfree(sch);
122 return ERR_PTR(ret);
123 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 return sch;
125}
126
127static void
128css_free_subchannel(struct subchannel *sch)
129{
130 if (sch) {
131 /* Reset intparm to zeroes. */
132 sch->schib.pmcw.intparm = 0;
133 cio_modify(sch);
Cornelia Huck2ec22982006-12-08 15:54:26 +0100134 kfree(sch->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 kfree(sch);
136 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137}
138
139static void
140css_subchannel_release(struct device *dev)
141{
142 struct subchannel *sch;
143
144 sch = to_subchannel(dev);
Cornelia Huck2ec22982006-12-08 15:54:26 +0100145 if (!cio_is_console(sch->schid)) {
146 kfree(sch->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 kfree(sch);
Cornelia Huck2ec22982006-12-08 15:54:26 +0100148 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149}
150
Cornelia Huck07c6a332007-07-27 12:29:10 +0200151static int css_sch_device_register(struct subchannel *sch)
Cornelia Huck6ab48792006-07-12 16:39:50 +0200152{
153 int ret;
154
155 mutex_lock(&sch->reg_mutex);
156 ret = device_register(&sch->dev);
157 mutex_unlock(&sch->reg_mutex);
158 return ret;
159}
160
161void css_sch_device_unregister(struct subchannel *sch)
162{
163 mutex_lock(&sch->reg_mutex);
164 device_unregister(&sch->dev);
165 mutex_unlock(&sch->reg_mutex);
166}
167
Peter Oberparleiter7ad6a242007-04-27 16:01:35 +0200168static void ssd_from_pmcw(struct chsc_ssd_info *ssd, struct pmcw *pmcw)
169{
170 int i;
171 int mask;
172
173 memset(ssd, 0, sizeof(struct chsc_ssd_info));
174 ssd->path_mask = pmcw->pim;
175 for (i = 0; i < 8; i++) {
176 mask = 0x80 >> i;
177 if (pmcw->pim & mask) {
178 chp_id_init(&ssd->chpid[i]);
179 ssd->chpid[i].id = pmcw->chpid[i];
180 }
181 }
182}
183
184static void ssd_register_chpids(struct chsc_ssd_info *ssd)
185{
186 int i;
187 int mask;
188
189 for (i = 0; i < 8; i++) {
190 mask = 0x80 >> i;
191 if (ssd->path_mask & mask)
192 if (!chp_is_registered(ssd->chpid[i]))
193 chp_new(ssd->chpid[i]);
194 }
195}
196
197void css_update_ssd_info(struct subchannel *sch)
198{
199 int ret;
200
201 if (cio_is_console(sch->schid)) {
202 /* Console is initialized too early for functions requiring
203 * memory allocation. */
204 ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
205 } else {
206 ret = chsc_get_ssd_info(sch->schid, &sch->ssd_info);
207 if (ret)
208 ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
209 ssd_register_chpids(&sch->ssd_info);
210 }
211}
212
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200213static ssize_t type_show(struct device *dev, struct device_attribute *attr,
214 char *buf)
215{
216 struct subchannel *sch = to_subchannel(dev);
217
218 return sprintf(buf, "%01x\n", sch->st);
219}
220
221static DEVICE_ATTR(type, 0444, type_show, NULL);
222
223static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
224 char *buf)
225{
226 struct subchannel *sch = to_subchannel(dev);
227
228 return sprintf(buf, "css:t%01X\n", sch->st);
229}
230
231static DEVICE_ATTR(modalias, 0444, modalias_show, NULL);
232
233static struct attribute *subch_attrs[] = {
234 &dev_attr_type.attr,
235 &dev_attr_modalias.attr,
236 NULL,
237};
238
239static struct attribute_group subch_attr_group = {
240 .attrs = subch_attrs,
241};
242
243static struct attribute_group *default_subch_attr_groups[] = {
244 &subch_attr_group,
245 NULL,
246};
247
Peter Oberparleiter7ad6a242007-04-27 16:01:35 +0200248static int css_register_subchannel(struct subchannel *sch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249{
250 int ret;
251
252 /* Initialize the subchannel structure */
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200253 sch->dev.parent = &channel_subsystems[0]->device;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 sch->dev.bus = &css_bus_type;
255 sch->dev.release = &css_subchannel_release;
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200256 sch->dev.groups = default_subch_attr_groups;
Cornelia Huck5bf04b22007-10-22 12:52:41 +0200257 /*
258 * We don't want to generate uevents for I/O subchannels that don't
259 * have a working ccw device behind them since they will be
260 * unregistered before they can be used anyway, so we delay the add
261 * uevent until after device recognition was successful.
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200262 * Note that we suppress the uevent for all subchannel types;
263 * the subchannel driver can decide itself when it wants to inform
264 * userspace of its existence.
Cornelia Huck5bf04b22007-10-22 12:52:41 +0200265 */
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200266 sch->dev.uevent_suppress = 1;
Peter Oberparleiter7ad6a242007-04-27 16:01:35 +0200267 css_update_ssd_info(sch);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 /* make it known to the system */
Cornelia Huck6ab48792006-07-12 16:39:50 +0200269 ret = css_sch_device_register(sch);
Cornelia Huck7674da72006-12-08 15:54:21 +0100270 if (ret) {
Cornelia Hucke556bbb2007-07-27 12:29:19 +0200271 CIO_MSG_EVENT(0, "Could not register sch 0.%x.%04x: %d\n",
272 sch->schid.ssid, sch->schid.sch_no, ret);
Cornelia Huck7674da72006-12-08 15:54:21 +0100273 return ret;
274 }
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200275 if (!sch->driver) {
276 /*
277 * No driver matched. Generate the uevent now so that
278 * a fitting driver module may be loaded based on the
279 * modalias.
280 */
281 sch->dev.uevent_suppress = 0;
282 kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
283 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 return ret;
285}
286
Cornelia Huckc820de32008-07-14 09:58:45 +0200287int css_probe_device(struct subchannel_id schid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
289 int ret;
290 struct subchannel *sch;
291
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800292 sch = css_alloc_subchannel(schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 if (IS_ERR(sch))
294 return PTR_ERR(sch);
295 ret = css_register_subchannel(sch);
296 if (ret)
297 css_free_subchannel(sch);
298 return ret;
299}
300
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700301static int
302check_subchannel(struct device * dev, void * data)
303{
304 struct subchannel *sch;
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800305 struct subchannel_id *schid = data;
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700306
307 sch = to_subchannel(dev);
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800308 return schid_equal(&sch->schid, schid);
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700309}
310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311struct subchannel *
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800312get_subchannel_by_schid(struct subchannel_id schid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 struct device *dev;
315
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700316 dev = bus_find_device(&css_bus_type, NULL,
Cornelia Huck12975ae2006-10-11 15:31:47 +0200317 &schid, check_subchannel);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700319 return dev ? to_subchannel(dev) : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320}
321
Cornelia Huckb279a4f2008-01-26 14:10:45 +0100322/**
323 * css_sch_is_valid() - check if a subchannel is valid
324 * @schib: subchannel information block for the subchannel
325 */
326int css_sch_is_valid(struct schib *schib)
327{
328 if ((schib->pmcw.st == SUBCHANNEL_TYPE_IO) && !schib->pmcw.dnv)
329 return 0;
330 return 1;
331}
332EXPORT_SYMBOL_GPL(css_sch_is_valid);
333
Peter Oberparleiter564337f2006-09-20 16:00:01 +0200334static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow)
335{
336 struct schib schib;
337
338 if (!slow) {
339 /* Will be done on the slow path. */
340 return -EAGAIN;
341 }
Cornelia Huckb279a4f2008-01-26 14:10:45 +0100342 if (stsch_err(schid, &schib) || !css_sch_is_valid(&schib)) {
Peter Oberparleiter564337f2006-09-20 16:00:01 +0200343 /* Unusable - ignore. */
344 return 0;
345 }
346 CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, unknown, "
347 "slow path.\n", schid.ssid, schid.sch_no, CIO_OPER);
348
349 return css_probe_device(schid);
350}
351
Cornelia Huckc820de32008-07-14 09:58:45 +0200352static int css_evaluate_known_subchannel(struct subchannel *sch, int slow)
353{
354 int ret = 0;
355
356 if (sch->driver) {
357 if (sch->driver->sch_event)
358 ret = sch->driver->sch_event(sch, slow);
359 else
360 dev_dbg(&sch->dev,
361 "Got subchannel machine check but "
362 "no sch_event handler provided.\n");
363 }
364 return ret;
365}
366
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200367static void css_evaluate_subchannel(struct subchannel_id schid, int slow)
Peter Oberparleiter564337f2006-09-20 16:00:01 +0200368{
369 struct subchannel *sch;
370 int ret;
371
372 sch = get_subchannel_by_schid(schid);
373 if (sch) {
374 ret = css_evaluate_known_subchannel(sch, slow);
375 put_device(&sch->dev);
376 } else
377 ret = css_evaluate_new_subchannel(schid, slow);
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200378 if (ret == -EAGAIN)
379 css_schedule_eval(schid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380}
381
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200382static struct idset *slow_subchannel_set;
383static spinlock_t slow_subchannel_lock;
384
385static int __init slow_subchannel_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386{
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200387 spin_lock_init(&slow_subchannel_lock);
388 slow_subchannel_set = idset_sch_new();
389 if (!slow_subchannel_set) {
Cornelia Hucke556bbb2007-07-27 12:29:19 +0200390 CIO_MSG_EVENT(0, "could not allocate slow subchannel set\n");
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200391 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200393 return 0;
394}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
Peter Oberparleitere82a1562008-01-26 14:10:48 +0100396static int slow_eval_known_fn(struct subchannel *sch, void *data)
397{
398 int eval;
399 int rc;
400
401 spin_lock_irq(&slow_subchannel_lock);
402 eval = idset_sch_contains(slow_subchannel_set, sch->schid);
403 idset_sch_del(slow_subchannel_set, sch->schid);
404 spin_unlock_irq(&slow_subchannel_lock);
405 if (eval) {
406 rc = css_evaluate_known_subchannel(sch, 1);
407 if (rc == -EAGAIN)
408 css_schedule_eval(sch->schid);
409 }
410 return 0;
411}
412
413static int slow_eval_unknown_fn(struct subchannel_id schid, void *data)
414{
415 int eval;
416 int rc = 0;
417
418 spin_lock_irq(&slow_subchannel_lock);
419 eval = idset_sch_contains(slow_subchannel_set, schid);
420 idset_sch_del(slow_subchannel_set, schid);
421 spin_unlock_irq(&slow_subchannel_lock);
422 if (eval) {
423 rc = css_evaluate_new_subchannel(schid, 1);
424 switch (rc) {
425 case -EAGAIN:
426 css_schedule_eval(schid);
427 rc = 0;
428 break;
429 case -ENXIO:
430 case -ENOMEM:
431 case -EIO:
432 /* These should abort looping */
433 break;
434 default:
435 rc = 0;
436 }
437 }
438 return rc;
439}
440
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200441static void css_slow_path_func(struct work_struct *unused)
442{
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200443 CIO_TRACE_EVENT(4, "slowpath");
Peter Oberparleitere82a1562008-01-26 14:10:48 +0100444 for_each_subchannel_staged(slow_eval_known_fn, slow_eval_unknown_fn,
445 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446}
447
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200448static DECLARE_WORK(slow_path_work, css_slow_path_func);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449struct workqueue_struct *slow_path_wq;
450
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200451void css_schedule_eval(struct subchannel_id schid)
452{
453 unsigned long flags;
454
455 spin_lock_irqsave(&slow_subchannel_lock, flags);
456 idset_sch_add(slow_subchannel_set, schid);
457 queue_work(slow_path_wq, &slow_path_work);
458 spin_unlock_irqrestore(&slow_subchannel_lock, flags);
459}
460
461void css_schedule_eval_all(void)
462{
463 unsigned long flags;
464
465 spin_lock_irqsave(&slow_subchannel_lock, flags);
466 idset_fill(slow_subchannel_set);
467 queue_work(slow_path_wq, &slow_path_work);
468 spin_unlock_irqrestore(&slow_subchannel_lock, flags);
469}
470
Cornelia Huck22806dc2008-04-17 07:45:59 +0200471void css_wait_for_slow_path(void)
472{
473 flush_workqueue(ccw_device_notify_work);
474 flush_workqueue(slow_path_wq);
475}
476
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200477/* Reprobe subchannel if unregistered. */
478static int reprobe_subchannel(struct subchannel_id schid, void *data)
479{
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200480 int ret;
481
Cornelia Hucke556bbb2007-07-27 12:29:19 +0200482 CIO_MSG_EVENT(6, "cio: reprobe 0.%x.%04x\n",
483 schid.ssid, schid.sch_no);
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200484 if (need_reprobe)
485 return -EAGAIN;
486
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200487 ret = css_probe_device(schid);
488 switch (ret) {
489 case 0:
490 break;
491 case -ENXIO:
492 case -ENOMEM:
Peter Oberparleiter671756162007-12-04 16:09:02 +0100493 case -EIO:
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200494 /* These should abort looping */
495 break;
496 default:
497 ret = 0;
498 }
499
500 return ret;
501}
502
503/* Work function used to reprobe all unregistered subchannels. */
Al Viro4927b3f2006-12-06 19:18:20 +0000504static void reprobe_all(struct work_struct *unused)
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200505{
506 int ret;
507
Michael Ernst139b83d2008-05-07 09:22:54 +0200508 CIO_MSG_EVENT(4, "reprobe start\n");
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200509
510 need_reprobe = 0;
511 /* Make sure initial subchannel scan is done. */
512 wait_event(ccw_device_init_wq,
513 atomic_read(&ccw_device_init_count) == 0);
Peter Oberparleitere82a1562008-01-26 14:10:48 +0100514 ret = for_each_subchannel_staged(NULL, reprobe_subchannel, NULL);
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200515
Michael Ernst139b83d2008-05-07 09:22:54 +0200516 CIO_MSG_EVENT(4, "reprobe done (rc=%d, need_reprobe=%d)\n", ret,
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200517 need_reprobe);
518}
519
Heiko Carstens2b67fc42007-02-05 21:16:47 +0100520static DECLARE_WORK(css_reprobe_work, reprobe_all);
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200521
522/* Schedule reprobing of all unregistered subchannels. */
523void css_schedule_reprobe(void)
524{
525 need_reprobe = 1;
Cornelia Huckc5d4a992007-11-20 11:13:41 +0100526 queue_work(slow_path_wq, &css_reprobe_work);
Peter Oberparleiter40154b82006-06-29 14:57:03 +0200527}
528
529EXPORT_SYMBOL_GPL(css_schedule_reprobe);
530
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 * Called from the machine check handler for subchannel report words.
533 */
Cornelia Huckc1156182008-07-14 09:58:46 +0200534static void css_process_crw(struct crw *crw0, struct crw *crw1, int overflow)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535{
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800536 struct subchannel_id mchk_schid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537
Cornelia Huckc1156182008-07-14 09:58:46 +0200538 if (overflow) {
539 css_schedule_eval_all();
540 return;
541 }
542 CIO_CRW_EVENT(2, "CRW0 reports slct=%d, oflw=%d, "
543 "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
544 crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc,
545 crw0->erc, crw0->rsid);
546 if (crw1)
547 CIO_CRW_EVENT(2, "CRW1 reports slct=%d, oflw=%d, "
548 "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
549 crw1->slct, crw1->oflw, crw1->chn, crw1->rsc,
550 crw1->anc, crw1->erc, crw1->rsid);
Cornelia Hucka8237fc2006-01-06 00:19:21 -0800551 init_subchannel_id(&mchk_schid);
Cornelia Huckc1156182008-07-14 09:58:46 +0200552 mchk_schid.sch_no = crw0->rsid;
553 if (crw1)
554 mchk_schid.ssid = (crw1->rsid >> 8) & 3;
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800555
Cornelia Huckc1156182008-07-14 09:58:46 +0200556 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 * Since we are always presented with IPI in the CRW, we have to
558 * use stsch() to find out if the subchannel in question has come
559 * or gone.
560 */
Peter Oberparleiter83b33702007-04-27 16:01:34 +0200561 css_evaluate_subchannel(mchk_schid, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562}
563
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800564static int __init
565__init_channel_subsystem(struct subchannel_id schid, void *data)
566{
567 struct subchannel *sch;
568 int ret;
569
570 if (cio_is_console(schid))
571 sch = cio_get_console_subchannel();
572 else {
573 sch = css_alloc_subchannel(schid);
574 if (IS_ERR(sch))
575 ret = PTR_ERR(sch);
576 else
577 ret = 0;
578 switch (ret) {
579 case 0:
580 break;
581 case -ENOMEM:
582 panic("Out of memory in init_channel_subsystem\n");
583 /* -ENXIO: no more subchannels. */
584 case -ENXIO:
585 return ret;
Greg Smithe843e282006-03-14 19:50:17 -0800586 /* -EIO: this subchannel set not supported. */
587 case -EIO:
588 return ret;
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800589 default:
590 return 0;
591 }
592 }
593 /*
594 * We register ALL valid subchannels in ioinfo, even those
595 * that have been present before init_channel_subsystem.
596 * These subchannels can't have been registered yet (kmalloc
597 * not working) so we do it now. This is true e.g. for the
598 * console subchannel.
599 */
600 css_register_subchannel(sch);
601 return 0;
602}
603
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604static void __init
Cornelia Hucka28c6942006-01-06 00:19:23 -0800605css_generate_pgid(struct channel_subsystem *css, u32 tod_high)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606{
Cornelia Hucka28c6942006-01-06 00:19:23 -0800607 if (css_characteristics_avail && css_general_characteristics.mcss) {
608 css->global_pgid.pgid_high.ext_cssid.version = 0x80;
609 css->global_pgid.pgid_high.ext_cssid.cssid = css->cssid;
610 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611#ifdef CONFIG_SMP
Cornelia Hucka28c6942006-01-06 00:19:23 -0800612 css->global_pgid.pgid_high.cpu_addr = hard_smp_processor_id();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613#else
Cornelia Hucka28c6942006-01-06 00:19:23 -0800614 css->global_pgid.pgid_high.cpu_addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615#endif
616 }
Cornelia Hucka28c6942006-01-06 00:19:23 -0800617 css->global_pgid.cpu_id = ((cpuid_t *) __LC_CPUID)->ident;
618 css->global_pgid.cpu_model = ((cpuid_t *) __LC_CPUID)->machine;
619 css->global_pgid.tod_high = tod_high;
620
621}
622
Cornelia Huck3b793062006-01-06 00:19:26 -0800623static void
624channel_subsystem_release(struct device *dev)
625{
626 struct channel_subsystem *css;
627
628 css = to_css(dev);
Cornelia Huck495a5b42006-03-24 03:15:14 -0800629 mutex_destroy(&css->mutex);
Cornelia Huck3b793062006-01-06 00:19:26 -0800630 kfree(css);
631}
632
Cornelia Huck495a5b42006-03-24 03:15:14 -0800633static ssize_t
634css_cm_enable_show(struct device *dev, struct device_attribute *attr,
635 char *buf)
636{
637 struct channel_subsystem *css = to_css(dev);
Michael Ernst8284fb192008-04-17 07:46:01 +0200638 int ret;
Cornelia Huck495a5b42006-03-24 03:15:14 -0800639
640 if (!css)
641 return 0;
Michael Ernst8284fb192008-04-17 07:46:01 +0200642 mutex_lock(&css->mutex);
643 ret = sprintf(buf, "%x\n", css->cm_enabled);
644 mutex_unlock(&css->mutex);
645 return ret;
Cornelia Huck495a5b42006-03-24 03:15:14 -0800646}
647
648static ssize_t
649css_cm_enable_store(struct device *dev, struct device_attribute *attr,
650 const char *buf, size_t count)
651{
652 struct channel_subsystem *css = to_css(dev);
653 int ret;
Cornelia Huck2f972202008-04-30 13:38:33 +0200654 unsigned long val;
Cornelia Huck495a5b42006-03-24 03:15:14 -0800655
Cornelia Huck2f972202008-04-30 13:38:33 +0200656 ret = strict_strtoul(buf, 16, &val);
657 if (ret)
658 return ret;
Michael Ernst8284fb192008-04-17 07:46:01 +0200659 mutex_lock(&css->mutex);
Cornelia Huck2f972202008-04-30 13:38:33 +0200660 switch (val) {
661 case 0:
Cornelia Huck495a5b42006-03-24 03:15:14 -0800662 ret = css->cm_enabled ? chsc_secm(css, 0) : 0;
663 break;
Cornelia Huck2f972202008-04-30 13:38:33 +0200664 case 1:
Cornelia Huck495a5b42006-03-24 03:15:14 -0800665 ret = css->cm_enabled ? 0 : chsc_secm(css, 1);
666 break;
667 default:
668 ret = -EINVAL;
669 }
Michael Ernst8284fb192008-04-17 07:46:01 +0200670 mutex_unlock(&css->mutex);
Cornelia Huck495a5b42006-03-24 03:15:14 -0800671 return ret < 0 ? ret : count;
672}
673
674static DEVICE_ATTR(cm_enable, 0644, css_cm_enable_show, css_cm_enable_store);
675
Heiko Carstens4d284ca2007-02-05 21:18:53 +0100676static int __init setup_css(int nr)
Cornelia Hucka28c6942006-01-06 00:19:23 -0800677{
678 u32 tod_high;
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100679 int ret;
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200680 struct channel_subsystem *css;
Cornelia Hucka28c6942006-01-06 00:19:23 -0800681
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200682 css = channel_subsystems[nr];
683 memset(css, 0, sizeof(struct channel_subsystem));
684 css->pseudo_subchannel =
685 kzalloc(sizeof(*css->pseudo_subchannel), GFP_KERNEL);
686 if (!css->pseudo_subchannel)
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100687 return -ENOMEM;
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200688 css->pseudo_subchannel->dev.parent = &css->device;
689 css->pseudo_subchannel->dev.release = css_subchannel_release;
690 sprintf(css->pseudo_subchannel->dev.bus_id, "defunct");
691 ret = cio_create_sch_lock(css->pseudo_subchannel);
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100692 if (ret) {
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200693 kfree(css->pseudo_subchannel);
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100694 return ret;
695 }
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200696 mutex_init(&css->mutex);
697 css->valid = 1;
698 css->cssid = nr;
699 sprintf(css->device.bus_id, "css%x", nr);
700 css->device.release = channel_subsystem_release;
Cornelia Hucka28c6942006-01-06 00:19:23 -0800701 tod_high = (u32) (get_clock() >> 32);
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200702 css_generate_pgid(css, tod_high);
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100703 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704}
705
Cornelia Hucka55360d2007-10-12 16:11:20 +0200706static int css_reboot_event(struct notifier_block *this,
707 unsigned long event,
708 void *ptr)
709{
710 int ret, i;
711
712 ret = NOTIFY_DONE;
713 for (i = 0; i <= __MAX_CSSID; i++) {
714 struct channel_subsystem *css;
715
716 css = channel_subsystems[i];
Michael Ernst8284fb192008-04-17 07:46:01 +0200717 mutex_lock(&css->mutex);
Cornelia Hucka55360d2007-10-12 16:11:20 +0200718 if (css->cm_enabled)
719 if (chsc_secm(css, 0))
720 ret = NOTIFY_BAD;
Michael Ernst8284fb192008-04-17 07:46:01 +0200721 mutex_unlock(&css->mutex);
Cornelia Hucka55360d2007-10-12 16:11:20 +0200722 }
723
724 return ret;
725}
726
727static struct notifier_block css_reboot_notifier = {
728 .notifier_call = css_reboot_event,
729};
730
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731/*
732 * Now that the driver core is running, we can setup our channel subsystem.
733 * The struct subchannel's are created during probing (except for the
734 * static console subchannel).
735 */
736static int __init
737init_channel_subsystem (void)
738{
Cornelia Hucka28c6942006-01-06 00:19:23 -0800739 int ret, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
Cornelia Huck4434a382007-07-27 12:29:21 +0200741 ret = chsc_determine_css_characteristics();
742 if (ret == -ENOMEM)
743 goto out; /* No need to continue. */
744 if (ret == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 css_characteristics_avail = 1;
746
Cornelia Huck4434a382007-07-27 12:29:21 +0200747 ret = chsc_alloc_sei_area();
748 if (ret)
749 goto out;
750
751 ret = slow_subchannel_init();
752 if (ret)
753 goto out;
754
Cornelia Huckc1156182008-07-14 09:58:46 +0200755 ret = s390_register_crw_handler(CRW_RSC_SCH, css_process_crw);
756 if (ret)
757 goto out;
758
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 if ((ret = bus_register(&css_bus_type)))
760 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800762 /* Try to enable MSS. */
763 ret = chsc_enable_facility(CHSC_SDA_OC_MSS);
764 switch (ret) {
765 case 0: /* Success. */
766 max_ssid = __MAX_SSID;
767 break;
768 case -ENOMEM:
769 goto out_bus;
770 default:
771 max_ssid = 0;
772 }
Cornelia Hucka28c6942006-01-06 00:19:23 -0800773 /* Setup css structure. */
774 for (i = 0; i <= __MAX_CSSID; i++) {
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200775 struct channel_subsystem *css;
776
777 css = kmalloc(sizeof(struct channel_subsystem), GFP_KERNEL);
778 if (!css) {
Cornelia Hucka28c6942006-01-06 00:19:23 -0800779 ret = -ENOMEM;
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800780 goto out_unregister;
Cornelia Hucka28c6942006-01-06 00:19:23 -0800781 }
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200782 channel_subsystems[i] = css;
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100783 ret = setup_css(i);
Cornelia Hucka28c6942006-01-06 00:19:23 -0800784 if (ret)
785 goto out_free;
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200786 ret = device_register(&css->device);
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100787 if (ret)
788 goto out_free_all;
Cornelia Huck7e560812006-07-12 16:40:19 +0200789 if (css_characteristics_avail &&
790 css_chsc_characteristics.secm) {
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200791 ret = device_create_file(&css->device,
Cornelia Huck7e560812006-07-12 16:40:19 +0200792 &dev_attr_cm_enable);
793 if (ret)
794 goto out_device;
795 }
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200796 ret = device_register(&css->pseudo_subchannel->dev);
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100797 if (ret)
798 goto out_file;
Cornelia Hucka28c6942006-01-06 00:19:23 -0800799 }
Cornelia Hucka55360d2007-10-12 16:11:20 +0200800 ret = register_reboot_notifier(&css_reboot_notifier);
801 if (ret)
802 goto out_pseudo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 css_init_done = 1;
804
805 ctl_set_bit(6, 28);
806
Cornelia Huckf97a56f2006-01-06 00:19:22 -0800807 for_each_subchannel(__init_channel_subsystem, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 return 0;
Cornelia Hucka55360d2007-10-12 16:11:20 +0200809out_pseudo:
810 device_unregister(&channel_subsystems[i]->pseudo_subchannel->dev);
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100811out_file:
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200812 device_remove_file(&channel_subsystems[i]->device,
813 &dev_attr_cm_enable);
Cornelia Huck7e560812006-07-12 16:40:19 +0200814out_device:
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200815 device_unregister(&channel_subsystems[i]->device);
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100816out_free_all:
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200817 kfree(channel_subsystems[i]->pseudo_subchannel->lock);
818 kfree(channel_subsystems[i]->pseudo_subchannel);
Cornelia Hucka28c6942006-01-06 00:19:23 -0800819out_free:
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200820 kfree(channel_subsystems[i]);
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800821out_unregister:
Cornelia Hucka28c6942006-01-06 00:19:23 -0800822 while (i > 0) {
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200823 struct channel_subsystem *css;
824
Cornelia Hucka28c6942006-01-06 00:19:23 -0800825 i--;
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200826 css = channel_subsystems[i];
827 device_unregister(&css->pseudo_subchannel->dev);
Cornelia Huck495a5b42006-03-24 03:15:14 -0800828 if (css_characteristics_avail && css_chsc_characteristics.secm)
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200829 device_remove_file(&css->device,
Cornelia Huck495a5b42006-03-24 03:15:14 -0800830 &dev_attr_cm_enable);
Cornelia Huck7c9f4e32007-10-12 16:11:13 +0200831 device_unregister(&css->device);
Cornelia Hucka28c6942006-01-06 00:19:23 -0800832 }
Cornelia Huckfb6958a2006-01-06 00:19:25 -0800833out_bus:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 bus_unregister(&css_bus_type);
835out:
Cornelia Huckc1156182008-07-14 09:58:46 +0200836 s390_unregister_crw_handler(CRW_RSC_CSS);
Cornelia Huck4434a382007-07-27 12:29:21 +0200837 chsc_free_sei_area();
838 kfree(slow_subchannel_set);
839 printk(KERN_WARNING"cio: failed to initialize css driver (%d)!\n",
840 ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 return ret;
842}
843
Cornelia Huckd7b5a4c92006-12-08 15:54:28 +0100844int sch_is_pseudo_sch(struct subchannel *sch)
845{
846 return sch == to_css(sch->dev.parent)->pseudo_subchannel;
847}
848
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849/*
850 * find a driver for a subchannel. They identify by the subchannel
851 * type with the exception that the console subchannel driver has its own
852 * subchannel type although the device is an i/o subchannel
853 */
854static int
855css_bus_match (struct device *dev, struct device_driver *drv)
856{
Cornelia Huck084325d2008-01-26 14:10:38 +0100857 struct subchannel *sch = to_subchannel(dev);
858 struct css_driver *driver = to_cssdriver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
860 if (sch->st == driver->subchannel_type)
861 return 1;
862
863 return 0;
864}
865
Cornelia Huck98c13c22008-01-26 14:10:40 +0100866static int css_probe(struct device *dev)
Cornelia Huck8bbace72006-01-11 10:56:22 +0100867{
868 struct subchannel *sch;
Cornelia Huck98c13c22008-01-26 14:10:40 +0100869 int ret;
Cornelia Huck8bbace72006-01-11 10:56:22 +0100870
871 sch = to_subchannel(dev);
Cornelia Huck084325d2008-01-26 14:10:38 +0100872 sch->driver = to_cssdriver(dev->driver);
Cornelia Huck98c13c22008-01-26 14:10:40 +0100873 ret = sch->driver->probe ? sch->driver->probe(sch) : 0;
874 if (ret)
875 sch->driver = NULL;
876 return ret;
Cornelia Huck8bbace72006-01-11 10:56:22 +0100877}
878
Cornelia Huck98c13c22008-01-26 14:10:40 +0100879static int css_remove(struct device *dev)
880{
881 struct subchannel *sch;
882 int ret;
883
884 sch = to_subchannel(dev);
885 ret = sch->driver->remove ? sch->driver->remove(sch) : 0;
886 sch->driver = NULL;
887 return ret;
888}
889
890static void css_shutdown(struct device *dev)
Cornelia Huck8bbace72006-01-11 10:56:22 +0100891{
892 struct subchannel *sch;
893
894 sch = to_subchannel(dev);
Cornelia Huck98c13c22008-01-26 14:10:40 +0100895 if (sch->driver && sch->driver->shutdown)
Cornelia Huck8bbace72006-01-11 10:56:22 +0100896 sch->driver->shutdown(sch);
897}
898
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200899static int css_uevent(struct device *dev, struct kobj_uevent_env *env)
900{
901 struct subchannel *sch = to_subchannel(dev);
902 int ret;
903
904 ret = add_uevent_var(env, "ST=%01X", sch->st);
905 if (ret)
906 return ret;
907 ret = add_uevent_var(env, "MODALIAS=css:t%01X", sch->st);
908 return ret;
909}
910
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911struct bus_type css_bus_type = {
Cornelia Huck8bbace72006-01-11 10:56:22 +0100912 .name = "css",
913 .match = css_bus_match,
914 .probe = css_probe,
915 .remove = css_remove,
916 .shutdown = css_shutdown,
Cornelia Huck7e9db9e2008-07-14 09:58:44 +0200917 .uevent = css_uevent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918};
919
Cornelia Huck25b7bb52008-01-26 14:10:41 +0100920/**
921 * css_driver_register - register a css driver
922 * @cdrv: css driver to register
923 *
924 * This is mainly a wrapper around driver_register that sets name
925 * and bus_type in the embedded struct device_driver correctly.
926 */
927int css_driver_register(struct css_driver *cdrv)
928{
929 cdrv->drv.name = cdrv->name;
930 cdrv->drv.bus = &css_bus_type;
Cornelia Huck4beee642008-01-26 14:10:47 +0100931 cdrv->drv.owner = cdrv->owner;
Cornelia Huck25b7bb52008-01-26 14:10:41 +0100932 return driver_register(&cdrv->drv);
933}
934EXPORT_SYMBOL_GPL(css_driver_register);
935
936/**
937 * css_driver_unregister - unregister a css driver
938 * @cdrv: css driver to unregister
939 *
940 * This is a wrapper around driver_unregister.
941 */
942void css_driver_unregister(struct css_driver *cdrv)
943{
944 driver_unregister(&cdrv->drv);
945}
946EXPORT_SYMBOL_GPL(css_driver_unregister);
947
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948subsys_initcall(init_channel_subsystem);
949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950MODULE_LICENSE("GPL");
951EXPORT_SYMBOL(css_bus_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952EXPORT_SYMBOL_GPL(css_characteristics_avail);