1
2
3
4
5
6
7
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/spinlock.h>
16#include <linux/errno.h>
17#include <linux/err.h>
18#include <linux/slab.h>
19#include <linux/list.h>
20#include <linux/device.h>
21#include <linux/workqueue.h>
22#include <linux/delay.h>
23#include <linux/timer.h>
24#include <linux/kernel_stat.h>
25
26#include <asm/ccwdev.h>
27#include <asm/cio.h>
28#include <asm/param.h>
29#include <asm/cmb.h>
30#include <asm/isc.h>
31
32#include "chp.h"
33#include "cio.h"
34#include "cio_debug.h"
35#include "css.h"
36#include "device.h"
37#include "ioasm.h"
38#include "io_sch.h"
39#include "blacklist.h"
40#include "chsc.h"
41
42static struct timer_list recovery_timer;
43static DEFINE_SPINLOCK(recovery_lock);
44static int recovery_phase;
45static const unsigned long recovery_delay[] = { 3, 30, 300 };
46
47static atomic_t ccw_device_init_count = ATOMIC_INIT(0);
48static DECLARE_WAIT_QUEUE_HEAD(ccw_device_init_wq);
49static struct bus_type ccw_bus_type;
50
51
52
53
54
55
56
57static int
58ccw_bus_match (struct device * dev, struct device_driver * drv)
59{
60 struct ccw_device *cdev = to_ccwdev(dev);
61 struct ccw_driver *cdrv = to_ccwdrv(drv);
62 const struct ccw_device_id *ids = cdrv->ids, *found;
63
64 if (!ids)
65 return 0;
66
67 found = ccw_device_id_match(ids, &cdev->id);
68 if (!found)
69 return 0;
70
71 cdev->id.driver_info = found->driver_info;
72
73 return 1;
74}
75
76
77
78
79static int snprint_alias(char *buf, size_t size,
80 struct ccw_device_id *id, const char *suffix)
81{
82 int len;
83
84 len = snprintf(buf, size, "ccw:t%04Xm%02X", id->cu_type, id->cu_model);
85 if (len > size)
86 return len;
87 buf += len;
88 size -= len;
89
90 if (id->dev_type != 0)
91 len += snprintf(buf, size, "dt%04Xdm%02X%s", id->dev_type,
92 id->dev_model, suffix);
93 else
94 len += snprintf(buf, size, "dtdm%s", suffix);
95
96 return len;
97}
98
99
100
101static int ccw_uevent(struct device *dev, struct kobj_uevent_env *env)
102{
103 struct ccw_device *cdev = to_ccwdev(dev);
104 struct ccw_device_id *id = &(cdev->id);
105 int ret;
106 char modalias_buf[30];
107
108
109 ret = add_uevent_var(env, "CU_TYPE=%04X", id->cu_type);
110 if (ret)
111 return ret;
112
113
114 ret = add_uevent_var(env, "CU_MODEL=%02X", id->cu_model);
115 if (ret)
116 return ret;
117
118
119
120 ret = add_uevent_var(env, "DEV_TYPE=%04X", id->dev_type);
121 if (ret)
122 return ret;
123
124
125 ret = add_uevent_var(env, "DEV_MODEL=%02X", id->dev_model);
126 if (ret)
127 return ret;
128
129
130 snprint_alias(modalias_buf, sizeof(modalias_buf), id, "");
131 ret = add_uevent_var(env, "MODALIAS=%s", modalias_buf);
132 return ret;
133}
134
135static void io_subchannel_irq(struct subchannel *);
136static int io_subchannel_probe(struct subchannel *);
137static int io_subchannel_remove(struct subchannel *);
138static void io_subchannel_shutdown(struct subchannel *);
139static int io_subchannel_sch_event(struct subchannel *, int);
140static int io_subchannel_chp_event(struct subchannel *, struct chp_link *,
141 int);
142static void recovery_func(unsigned long data);
143
144static struct css_device_id io_subchannel_ids[] = {
145 { .match_flags = 0x1, .type = SUBCHANNEL_TYPE_IO, },
146 { },
147};
148MODULE_DEVICE_TABLE(css, io_subchannel_ids);
149
150static int io_subchannel_prepare(struct subchannel *sch)
151{
152 struct ccw_device *cdev;
153
154
155
156
157 cdev = sch_get_cdev(sch);
158 if (cdev && !device_is_registered(&cdev->dev))
159 return -EAGAIN;
160 return 0;
161}
162
163static int io_subchannel_settle(void)
164{
165 int ret;
166
167 ret = wait_event_interruptible(ccw_device_init_wq,
168 atomic_read(&ccw_device_init_count) == 0);
169 if (ret)
170 return -EINTR;
171 flush_workqueue(cio_work_q);
172 return 0;
173}
174
175static struct css_driver io_subchannel_driver = {
176 .drv = {
177 .owner = THIS_MODULE,
178 .name = "io_subchannel",
179 },
180 .subchannel_type = io_subchannel_ids,
181 .irq = io_subchannel_irq,
182 .sch_event = io_subchannel_sch_event,
183 .chp_event = io_subchannel_chp_event,
184 .probe = io_subchannel_probe,
185 .remove = io_subchannel_remove,
186 .shutdown = io_subchannel_shutdown,
187 .prepare = io_subchannel_prepare,
188 .settle = io_subchannel_settle,
189};
190
191int __init io_subchannel_init(void)
192{
193 int ret;
194
195 setup_timer(&recovery_timer, recovery_func, 0);
196 ret = bus_register(&ccw_bus_type);
197 if (ret)
198 return ret;
199 ret = css_driver_register(&io_subchannel_driver);
200 if (ret)
201 bus_unregister(&ccw_bus_type);
202
203 return ret;
204}
205
206
207
208
209
210
211
212
213
214
215
216
217static ssize_t
218chpids_show (struct device * dev, struct device_attribute *attr, char * buf)
219{
220 struct subchannel *sch = to_subchannel(dev);
221 struct chsc_ssd_info *ssd = &sch->ssd_info;
222 ssize_t ret = 0;
223 int chp;
224 int mask;
225
226 for (chp = 0; chp < 8; chp++) {
227 mask = 0x80 >> chp;
228 if (ssd->path_mask & mask)
229 ret += sprintf(buf + ret, "%02x ", ssd->chpid[chp].id);
230 else
231 ret += sprintf(buf + ret, "00 ");
232 }
233 ret += sprintf (buf+ret, "\n");
234 return min((ssize_t)PAGE_SIZE, ret);
235}
236
237static ssize_t
238pimpampom_show (struct device * dev, struct device_attribute *attr, char * buf)
239{
240 struct subchannel *sch = to_subchannel(dev);
241 struct pmcw *pmcw = &sch->schib.pmcw;
242
243 return sprintf (buf, "%02x %02x %02x\n",
244 pmcw->pim, pmcw->pam, pmcw->pom);
245}
246
247static ssize_t
248devtype_show (struct device *dev, struct device_attribute *attr, char *buf)
249{
250 struct ccw_device *cdev = to_ccwdev(dev);
251 struct ccw_device_id *id = &(cdev->id);
252
253 if (id->dev_type != 0)
254 return sprintf(buf, "%04x/%02x\n",
255 id->dev_type, id->dev_model);
256 else
257 return sprintf(buf, "n/a\n");
258}
259
260static ssize_t
261cutype_show (struct device *dev, struct device_attribute *attr, char *buf)
262{
263 struct ccw_device *cdev = to_ccwdev(dev);
264 struct ccw_device_id *id = &(cdev->id);
265
266 return sprintf(buf, "%04x/%02x\n",
267 id->cu_type, id->cu_model);
268}
269
270static ssize_t
271modalias_show (struct device *dev, struct device_attribute *attr, char *buf)
272{
273 struct ccw_device *cdev = to_ccwdev(dev);
274 struct ccw_device_id *id = &(cdev->id);
275 int len;
276
277 len = snprint_alias(buf, PAGE_SIZE, id, "\n");
278
279 return len > PAGE_SIZE ? PAGE_SIZE : len;
280}
281
282static ssize_t
283online_show (struct device *dev, struct device_attribute *attr, char *buf)
284{
285 struct ccw_device *cdev = to_ccwdev(dev);
286
287 return sprintf(buf, cdev->online ? "1\n" : "0\n");
288}
289
290int ccw_device_is_orphan(struct ccw_device *cdev)
291{
292 return sch_is_pseudo_sch(to_subchannel(cdev->dev.parent));
293}
294
295static void ccw_device_unregister(struct ccw_device *cdev)
296{
297 if (device_is_registered(&cdev->dev)) {
298
299 device_del(&cdev->dev);
300 }
301 if (cdev->private->flags.initialized) {
302 cdev->private->flags.initialized = 0;
303
304 put_device(&cdev->dev);
305 }
306}
307
308static void io_subchannel_quiesce(struct subchannel *);
309
310
311
312
313
314
315
316
317
318
319
320
321int ccw_device_set_offline(struct ccw_device *cdev)
322{
323 struct subchannel *sch;
324 int ret, state;
325
326 if (!cdev)
327 return -ENODEV;
328 if (!cdev->online || !cdev->drv)
329 return -EINVAL;
330
331 if (cdev->drv->set_offline) {
332 ret = cdev->drv->set_offline(cdev);
333 if (ret != 0)
334 return ret;
335 }
336 spin_lock_irq(cdev->ccwlock);
337 sch = to_subchannel(cdev->dev.parent);
338 cdev->online = 0;
339
340 while (!dev_fsm_final_state(cdev) &&
341 cdev->private->state != DEV_STATE_DISCONNECTED) {
342 spin_unlock_irq(cdev->ccwlock);
343 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
344 cdev->private->state == DEV_STATE_DISCONNECTED));
345 spin_lock_irq(cdev->ccwlock);
346 }
347 do {
348 ret = ccw_device_offline(cdev);
349 if (!ret)
350 break;
351 CIO_MSG_EVENT(0, "ccw_device_offline returned %d, device "
352 "0.%x.%04x\n", ret, cdev->private->dev_id.ssid,
353 cdev->private->dev_id.devno);
354 if (ret != -EBUSY)
355 goto error;
356 state = cdev->private->state;
357 spin_unlock_irq(cdev->ccwlock);
358 io_subchannel_quiesce(sch);
359 spin_lock_irq(cdev->ccwlock);
360 cdev->private->state = state;
361 } while (ret == -EBUSY);
362 spin_unlock_irq(cdev->ccwlock);
363 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
364 cdev->private->state == DEV_STATE_DISCONNECTED));
365
366 if (cdev->private->state == DEV_STATE_BOXED) {
367 pr_warning("%s: The device entered boxed state while "
368 "being set offline\n", dev_name(&cdev->dev));
369 } else if (cdev->private->state == DEV_STATE_NOT_OPER) {
370 pr_warning("%s: The device stopped operating while "
371 "being set offline\n", dev_name(&cdev->dev));
372 }
373
374 put_device(&cdev->dev);
375 return 0;
376
377error:
378 cdev->private->state = DEV_STATE_OFFLINE;
379 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
380 spin_unlock_irq(cdev->ccwlock);
381
382 put_device(&cdev->dev);
383 return -ENODEV;
384}
385
386
387
388
389
390
391
392
393
394
395
396
397
398int ccw_device_set_online(struct ccw_device *cdev)
399{
400 int ret;
401 int ret2;
402
403 if (!cdev)
404 return -ENODEV;
405 if (cdev->online || !cdev->drv)
406 return -EINVAL;
407
408 if (!get_device(&cdev->dev))
409 return -ENODEV;
410
411 spin_lock_irq(cdev->ccwlock);
412 ret = ccw_device_online(cdev);
413 spin_unlock_irq(cdev->ccwlock);
414 if (ret == 0)
415 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));
416 else {
417 CIO_MSG_EVENT(0, "ccw_device_online returned %d, "
418 "device 0.%x.%04x\n",
419 ret, cdev->private->dev_id.ssid,
420 cdev->private->dev_id.devno);
421
422 put_device(&cdev->dev);
423 return ret;
424 }
425 spin_lock_irq(cdev->ccwlock);
426
427 if ((cdev->private->state != DEV_STATE_ONLINE) &&
428 (cdev->private->state != DEV_STATE_W4SENSE)) {
429 spin_unlock_irq(cdev->ccwlock);
430
431 if (cdev->private->state == DEV_STATE_BOXED) {
432 pr_warning("%s: Setting the device online failed "
433 "because it is boxed\n",
434 dev_name(&cdev->dev));
435 } else if (cdev->private->state == DEV_STATE_NOT_OPER) {
436 pr_warning("%s: Setting the device online failed "
437 "because it is not operational\n",
438 dev_name(&cdev->dev));
439 }
440
441 put_device(&cdev->dev);
442 return -ENODEV;
443 }
444 spin_unlock_irq(cdev->ccwlock);
445 if (cdev->drv->set_online)
446 ret = cdev->drv->set_online(cdev);
447 if (ret)
448 goto rollback;
449
450 spin_lock_irq(cdev->ccwlock);
451 cdev->online = 1;
452 spin_unlock_irq(cdev->ccwlock);
453 return 0;
454
455rollback:
456 spin_lock_irq(cdev->ccwlock);
457
458 while (!dev_fsm_final_state(cdev) &&
459 cdev->private->state != DEV_STATE_DISCONNECTED) {
460 spin_unlock_irq(cdev->ccwlock);
461 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
462 cdev->private->state == DEV_STATE_DISCONNECTED));
463 spin_lock_irq(cdev->ccwlock);
464 }
465 ret2 = ccw_device_offline(cdev);
466 if (ret2)
467 goto error;
468 spin_unlock_irq(cdev->ccwlock);
469 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
470 cdev->private->state == DEV_STATE_DISCONNECTED));
471
472 put_device(&cdev->dev);
473 return ret;
474
475error:
476 CIO_MSG_EVENT(0, "rollback ccw_device_offline returned %d, "
477 "device 0.%x.%04x\n",
478 ret2, cdev->private->dev_id.ssid,
479 cdev->private->dev_id.devno);
480 cdev->private->state = DEV_STATE_OFFLINE;
481 spin_unlock_irq(cdev->ccwlock);
482
483 put_device(&cdev->dev);
484 return ret;
485}
486
487static int online_store_handle_offline(struct ccw_device *cdev)
488{
489 if (cdev->private->state == DEV_STATE_DISCONNECTED) {
490 spin_lock_irq(cdev->ccwlock);
491 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG_EVAL);
492 spin_unlock_irq(cdev->ccwlock);
493 return 0;
494 }
495 if (cdev->drv && cdev->drv->set_offline)
496 return ccw_device_set_offline(cdev);
497 return -EINVAL;
498}
499
500static int online_store_recog_and_online(struct ccw_device *cdev)
501{
502
503 if (cdev->private->state == DEV_STATE_BOXED) {
504 spin_lock_irq(cdev->ccwlock);
505 ccw_device_recognition(cdev);
506 spin_unlock_irq(cdev->ccwlock);
507 wait_event(cdev->private->wait_q,
508 cdev->private->flags.recog_done);
509 if (cdev->private->state != DEV_STATE_OFFLINE)
510
511 return -EAGAIN;
512 }
513 if (cdev->drv && cdev->drv->set_online)
514 return ccw_device_set_online(cdev);
515 return -EINVAL;
516}
517
518static int online_store_handle_online(struct ccw_device *cdev, int force)
519{
520 int ret;
521
522 ret = online_store_recog_and_online(cdev);
523 if (ret && !force)
524 return ret;
525 if (force && cdev->private->state == DEV_STATE_BOXED) {
526 ret = ccw_device_stlck(cdev);
527 if (ret)
528 return ret;
529 if (cdev->id.cu_type == 0)
530 cdev->private->state = DEV_STATE_NOT_OPER;
531 ret = online_store_recog_and_online(cdev);
532 if (ret)
533 return ret;
534 }
535 return 0;
536}
537
538static ssize_t online_store (struct device *dev, struct device_attribute *attr,
539 const char *buf, size_t count)
540{
541 struct ccw_device *cdev = to_ccwdev(dev);
542 int force, ret;
543 unsigned long i;
544
545
546 if (atomic_cmpxchg(&cdev->private->onoff, 0, 1) != 0)
547 return -EAGAIN;
548
549 if (!dev_fsm_final_state(cdev) &&
550 cdev->private->state != DEV_STATE_DISCONNECTED) {
551 ret = -EAGAIN;
552 goto out;
553 }
554
555 if (work_pending(&cdev->private->todo_work)) {
556 ret = -EAGAIN;
557 goto out;
558 }
559 if (!strncmp(buf, "force\n", count)) {
560 force = 1;
561 i = 1;
562 ret = 0;
563 } else {
564 force = 0;
565 ret = kstrtoul(buf, 16, &i);
566 }
567 if (ret)
568 goto out;
569
570 device_lock(dev);
571 switch (i) {
572 case 0:
573 ret = online_store_handle_offline(cdev);
574 break;
575 case 1:
576 ret = online_store_handle_online(cdev, force);
577 break;
578 default:
579 ret = -EINVAL;
580 }
581 device_unlock(dev);
582
583out:
584 atomic_set(&cdev->private->onoff, 0);
585 return (ret < 0) ? ret : count;
586}
587
588static ssize_t
589available_show (struct device *dev, struct device_attribute *attr, char *buf)
590{
591 struct ccw_device *cdev = to_ccwdev(dev);
592 struct subchannel *sch;
593
594 if (ccw_device_is_orphan(cdev))
595 return sprintf(buf, "no device\n");
596 switch (cdev->private->state) {
597 case DEV_STATE_BOXED:
598 return sprintf(buf, "boxed\n");
599 case DEV_STATE_DISCONNECTED:
600 case DEV_STATE_DISCONNECTED_SENSE_ID:
601 case DEV_STATE_NOT_OPER:
602 sch = to_subchannel(dev->parent);
603 if (!sch->lpm)
604 return sprintf(buf, "no path\n");
605 else
606 return sprintf(buf, "no device\n");
607 default:
608
609 return sprintf(buf, "good\n");
610 }
611}
612
613static ssize_t
614initiate_logging(struct device *dev, struct device_attribute *attr,
615 const char *buf, size_t count)
616{
617 struct subchannel *sch = to_subchannel(dev);
618 int rc;
619
620 rc = chsc_siosl(sch->schid);
621 if (rc < 0) {
622 pr_warning("Logging for subchannel 0.%x.%04x failed with "
623 "errno=%d\n",
624 sch->schid.ssid, sch->schid.sch_no, rc);
625 return rc;
626 }
627 pr_notice("Logging for subchannel 0.%x.%04x was triggered\n",
628 sch->schid.ssid, sch->schid.sch_no);
629 return count;
630}
631
632static ssize_t vpm_show(struct device *dev, struct device_attribute *attr,
633 char *buf)
634{
635 struct subchannel *sch = to_subchannel(dev);
636
637 return sprintf(buf, "%02x\n", sch->vpm);
638}
639
640static DEVICE_ATTR(chpids, 0444, chpids_show, NULL);
641static DEVICE_ATTR(pimpampom, 0444, pimpampom_show, NULL);
642static DEVICE_ATTR(devtype, 0444, devtype_show, NULL);
643static DEVICE_ATTR(cutype, 0444, cutype_show, NULL);
644static DEVICE_ATTR(modalias, 0444, modalias_show, NULL);
645static DEVICE_ATTR(online, 0644, online_show, online_store);
646static DEVICE_ATTR(availability, 0444, available_show, NULL);
647static DEVICE_ATTR(logging, 0200, NULL, initiate_logging);
648static DEVICE_ATTR(vpm, 0444, vpm_show, NULL);
649
650static struct attribute *io_subchannel_attrs[] = {
651 &dev_attr_chpids.attr,
652 &dev_attr_pimpampom.attr,
653 &dev_attr_logging.attr,
654 &dev_attr_vpm.attr,
655 NULL,
656};
657
658static struct attribute_group io_subchannel_attr_group = {
659 .attrs = io_subchannel_attrs,
660};
661
662static struct attribute * ccwdev_attrs[] = {
663 &dev_attr_devtype.attr,
664 &dev_attr_cutype.attr,
665 &dev_attr_modalias.attr,
666 &dev_attr_online.attr,
667 &dev_attr_cmb_enable.attr,
668 &dev_attr_availability.attr,
669 NULL,
670};
671
672static struct attribute_group ccwdev_attr_group = {
673 .attrs = ccwdev_attrs,
674};
675
676static const struct attribute_group *ccwdev_attr_groups[] = {
677 &ccwdev_attr_group,
678 NULL,
679};
680
681static int ccw_device_add(struct ccw_device *cdev)
682{
683 struct device *dev = &cdev->dev;
684
685 dev->bus = &ccw_bus_type;
686 return device_add(dev);
687}
688
689static int match_dev_id(struct device *dev, void *data)
690{
691 struct ccw_device *cdev = to_ccwdev(dev);
692 struct ccw_dev_id *dev_id = data;
693
694 return ccw_dev_id_is_equal(&cdev->private->dev_id, dev_id);
695}
696
697
698
699
700
701
702
703
704
705
706
707struct ccw_device *get_ccwdev_by_dev_id(struct ccw_dev_id *dev_id)
708{
709 struct device *dev;
710
711 dev = bus_find_device(&ccw_bus_type, NULL, dev_id, match_dev_id);
712
713 return dev ? to_ccwdev(dev) : NULL;
714}
715EXPORT_SYMBOL_GPL(get_ccwdev_by_dev_id);
716
717static void ccw_device_do_unbind_bind(struct ccw_device *cdev)
718{
719 int ret;
720
721 if (device_is_registered(&cdev->dev)) {
722 device_release_driver(&cdev->dev);
723 ret = device_attach(&cdev->dev);
724 WARN_ON(ret == -ENODEV);
725 }
726}
727
728static void
729ccw_device_release(struct device *dev)
730{
731 struct ccw_device *cdev;
732
733 cdev = to_ccwdev(dev);
734
735 put_device(cdev->dev.parent);
736 kfree(cdev->private);
737 kfree(cdev);
738}
739
740static struct ccw_device * io_subchannel_allocate_dev(struct subchannel *sch)
741{
742 struct ccw_device *cdev;
743
744 cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
745 if (cdev) {
746 cdev->private = kzalloc(sizeof(struct ccw_device_private),
747 GFP_KERNEL | GFP_DMA);
748 if (cdev->private)
749 return cdev;
750 }
751 kfree(cdev);
752 return ERR_PTR(-ENOMEM);
753}
754
755static void ccw_device_todo(struct work_struct *work);
756
757static int io_subchannel_initialize_dev(struct subchannel *sch,
758 struct ccw_device *cdev)
759{
760 struct ccw_device_private *priv = cdev->private;
761 int ret;
762
763 priv->cdev = cdev;
764 priv->int_class = IRQIO_CIO;
765 priv->state = DEV_STATE_NOT_OPER;
766 priv->dev_id.devno = sch->schib.pmcw.dev;
767 priv->dev_id.ssid = sch->schid.ssid;
768 priv->schid = sch->schid;
769
770 INIT_WORK(&priv->todo_work, ccw_device_todo);
771 INIT_LIST_HEAD(&priv->cmb_list);
772 init_waitqueue_head(&priv->wait_q);
773 init_timer(&priv->timer);
774
775 atomic_set(&priv->onoff, 0);
776 cdev->ccwlock = sch->lock;
777 cdev->dev.parent = &sch->dev;
778 cdev->dev.release = ccw_device_release;
779 cdev->dev.groups = ccwdev_attr_groups;
780
781 device_initialize(&cdev->dev);
782 ret = dev_set_name(&cdev->dev, "0.%x.%04x", cdev->private->dev_id.ssid,
783 cdev->private->dev_id.devno);
784 if (ret)
785 goto out_put;
786 if (!get_device(&sch->dev)) {
787 ret = -ENODEV;
788 goto out_put;
789 }
790 priv->flags.initialized = 1;
791 spin_lock_irq(sch->lock);
792 sch_set_cdev(sch, cdev);
793 spin_unlock_irq(sch->lock);
794 return 0;
795
796out_put:
797
798 put_device(&cdev->dev);
799 return ret;
800}
801
802static struct ccw_device * io_subchannel_create_ccwdev(struct subchannel *sch)
803{
804 struct ccw_device *cdev;
805 int ret;
806
807 cdev = io_subchannel_allocate_dev(sch);
808 if (!IS_ERR(cdev)) {
809 ret = io_subchannel_initialize_dev(sch, cdev);
810 if (ret)
811 cdev = ERR_PTR(ret);
812 }
813 return cdev;
814}
815
816static void io_subchannel_recog(struct ccw_device *, struct subchannel *);
817
818static void sch_create_and_recog_new_device(struct subchannel *sch)
819{
820 struct ccw_device *cdev;
821
822
823 cdev = io_subchannel_create_ccwdev(sch);
824 if (IS_ERR(cdev)) {
825
826 css_sch_device_unregister(sch);
827 return;
828 }
829
830 io_subchannel_recog(cdev, sch);
831}
832
833
834
835
836static void io_subchannel_register(struct ccw_device *cdev)
837{
838 struct subchannel *sch;
839 int ret, adjust_init_count = 1;
840 unsigned long flags;
841
842 sch = to_subchannel(cdev->dev.parent);
843
844
845
846
847
848
849 if (!device_is_registered(&sch->dev))
850 goto out_err;
851 css_update_ssd_info(sch);
852
853
854
855
856
857
858 if (device_is_registered(&cdev->dev)) {
859 if (!cdev->drv) {
860 ret = device_reprobe(&cdev->dev);
861 if (ret)
862
863 CIO_MSG_EVENT(0, "device_reprobe() returned"
864 " %d for 0.%x.%04x\n", ret,
865 cdev->private->dev_id.ssid,
866 cdev->private->dev_id.devno);
867 }
868 adjust_init_count = 0;
869 goto out;
870 }
871
872
873
874
875 dev_set_uevent_suppress(&sch->dev, 0);
876 kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
877
878 ret = ccw_device_add(cdev);
879 if (ret) {
880 CIO_MSG_EVENT(0, "Could not register ccw dev 0.%x.%04x: %d\n",
881 cdev->private->dev_id.ssid,
882 cdev->private->dev_id.devno, ret);
883 spin_lock_irqsave(sch->lock, flags);
884 sch_set_cdev(sch, NULL);
885 spin_unlock_irqrestore(sch->lock, flags);
886
887 put_device(&cdev->dev);
888 goto out_err;
889 }
890out:
891 cdev->private->flags.recog_done = 1;
892 wake_up(&cdev->private->wait_q);
893out_err:
894 if (adjust_init_count && atomic_dec_and_test(&ccw_device_init_count))
895 wake_up(&ccw_device_init_wq);
896}
897
898static void ccw_device_call_sch_unregister(struct ccw_device *cdev)
899{
900 struct subchannel *sch;
901
902
903 if (!get_device(cdev->dev.parent))
904 return;
905 sch = to_subchannel(cdev->dev.parent);
906 css_sch_device_unregister(sch);
907
908 put_device(&sch->dev);
909}
910
911
912
913
914void
915io_subchannel_recog_done(struct ccw_device *cdev)
916{
917 if (css_init_done == 0) {
918 cdev->private->flags.recog_done = 1;
919 return;
920 }
921 switch (cdev->private->state) {
922 case DEV_STATE_BOXED:
923
924 case DEV_STATE_NOT_OPER:
925 cdev->private->flags.recog_done = 1;
926
927 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
928 if (atomic_dec_and_test(&ccw_device_init_count))
929 wake_up(&ccw_device_init_wq);
930 break;
931 case DEV_STATE_OFFLINE:
932
933
934
935
936 ccw_device_sched_todo(cdev, CDEV_TODO_REGISTER);
937 break;
938 }
939}
940
941static void io_subchannel_recog(struct ccw_device *cdev, struct subchannel *sch)
942{
943
944 atomic_inc(&ccw_device_init_count);
945
946
947 spin_lock_irq(sch->lock);
948 ccw_device_recognition(cdev);
949 spin_unlock_irq(sch->lock);
950}
951
952static int ccw_device_move_to_sch(struct ccw_device *cdev,
953 struct subchannel *sch)
954{
955 struct subchannel *old_sch;
956 int rc, old_enabled = 0;
957
958 old_sch = to_subchannel(cdev->dev.parent);
959
960 if (!get_device(&sch->dev))
961 return -ENODEV;
962
963 if (!sch_is_pseudo_sch(old_sch)) {
964 spin_lock_irq(old_sch->lock);
965 old_enabled = old_sch->schib.pmcw.ena;
966 rc = 0;
967 if (old_enabled)
968 rc = cio_disable_subchannel(old_sch);
969 spin_unlock_irq(old_sch->lock);
970 if (rc == -EBUSY) {
971
972 put_device(&sch->dev);
973 return rc;
974 }
975 }
976
977 mutex_lock(&sch->reg_mutex);
978 rc = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
979 mutex_unlock(&sch->reg_mutex);
980 if (rc) {
981 CIO_MSG_EVENT(0, "device_move(0.%x.%04x,0.%x.%04x)=%d\n",
982 cdev->private->dev_id.ssid,
983 cdev->private->dev_id.devno, sch->schid.ssid,
984 sch->schib.pmcw.dev, rc);
985 if (old_enabled) {
986
987 spin_lock_irq(old_sch->lock);
988 cio_enable_subchannel(old_sch, (u32)(addr_t)old_sch);
989 spin_unlock_irq(old_sch->lock);
990 }
991
992 put_device(&sch->dev);
993 return rc;
994 }
995
996 if (!sch_is_pseudo_sch(old_sch)) {
997 spin_lock_irq(old_sch->lock);
998 sch_set_cdev(old_sch, NULL);
999 spin_unlock_irq(old_sch->lock);
1000 css_schedule_eval(old_sch->schid);
1001 }
1002
1003 put_device(&old_sch->dev);
1004
1005 spin_lock_irq(sch->lock);
1006 cdev->private->schid = sch->schid;
1007 cdev->ccwlock = sch->lock;
1008 if (!sch_is_pseudo_sch(sch))
1009 sch_set_cdev(sch, cdev);
1010 spin_unlock_irq(sch->lock);
1011 if (!sch_is_pseudo_sch(sch))
1012 css_update_ssd_info(sch);
1013 return 0;
1014}
1015
1016static int ccw_device_move_to_orph(struct ccw_device *cdev)
1017{
1018 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1019 struct channel_subsystem *css = to_css(sch->dev.parent);
1020
1021 return ccw_device_move_to_sch(cdev, css->pseudo_subchannel);
1022}
1023
1024static void io_subchannel_irq(struct subchannel *sch)
1025{
1026 struct ccw_device *cdev;
1027
1028 cdev = sch_get_cdev(sch);
1029
1030 CIO_TRACE_EVENT(6, "IRQ");
1031 CIO_TRACE_EVENT(6, dev_name(&sch->dev));
1032 if (cdev)
1033 dev_fsm_event(cdev, DEV_EVENT_INTERRUPT);
1034 else
1035 inc_irq_stat(IRQIO_CIO);
1036}
1037
1038void io_subchannel_init_config(struct subchannel *sch)
1039{
1040 memset(&sch->config, 0, sizeof(sch->config));
1041 sch->config.csense = 1;
1042}
1043
1044static void io_subchannel_init_fields(struct subchannel *sch)
1045{
1046 if (cio_is_console(sch->schid))
1047 sch->opm = 0xff;
1048 else
1049 sch->opm = chp_get_sch_opm(sch);
1050 sch->lpm = sch->schib.pmcw.pam & sch->opm;
1051 sch->isc = cio_is_console(sch->schid) ? CONSOLE_ISC : IO_SCH_ISC;
1052
1053 CIO_MSG_EVENT(6, "Detected device %04x on subchannel 0.%x.%04X"
1054 " - PIM = %02X, PAM = %02X, POM = %02X\n",
1055 sch->schib.pmcw.dev, sch->schid.ssid,
1056 sch->schid.sch_no, sch->schib.pmcw.pim,
1057 sch->schib.pmcw.pam, sch->schib.pmcw.pom);
1058
1059 io_subchannel_init_config(sch);
1060}
1061
1062
1063
1064
1065
1066static int io_subchannel_probe(struct subchannel *sch)
1067{
1068 struct io_subchannel_private *io_priv;
1069 struct ccw_device *cdev;
1070 int rc;
1071
1072 if (cio_is_console(sch->schid)) {
1073 rc = sysfs_create_group(&sch->dev.kobj,
1074 &io_subchannel_attr_group);
1075 if (rc)
1076 CIO_MSG_EVENT(0, "Failed to create io subchannel "
1077 "attributes for subchannel "
1078 "0.%x.%04x (rc=%d)\n",
1079 sch->schid.ssid, sch->schid.sch_no, rc);
1080
1081
1082
1083
1084
1085 dev_set_uevent_suppress(&sch->dev, 0);
1086 kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
1087 cdev = sch_get_cdev(sch);
1088 rc = ccw_device_add(cdev);
1089 if (rc) {
1090
1091 put_device(&cdev->dev);
1092 goto out_schedule;
1093 }
1094 if (atomic_dec_and_test(&ccw_device_init_count))
1095 wake_up(&ccw_device_init_wq);
1096 return 0;
1097 }
1098 io_subchannel_init_fields(sch);
1099 rc = cio_commit_config(sch);
1100 if (rc)
1101 goto out_schedule;
1102 rc = sysfs_create_group(&sch->dev.kobj,
1103 &io_subchannel_attr_group);
1104 if (rc)
1105 goto out_schedule;
1106
1107 io_priv = kzalloc(sizeof(*io_priv), GFP_KERNEL | GFP_DMA);
1108 if (!io_priv)
1109 goto out_schedule;
1110
1111 set_io_private(sch, io_priv);
1112 css_schedule_eval(sch->schid);
1113 return 0;
1114
1115out_schedule:
1116 spin_lock_irq(sch->lock);
1117 css_sched_sch_todo(sch, SCH_TODO_UNREG);
1118 spin_unlock_irq(sch->lock);
1119 return 0;
1120}
1121
1122static int
1123io_subchannel_remove (struct subchannel *sch)
1124{
1125 struct io_subchannel_private *io_priv = to_io_private(sch);
1126 struct ccw_device *cdev;
1127
1128 cdev = sch_get_cdev(sch);
1129 if (!cdev)
1130 goto out_free;
1131 io_subchannel_quiesce(sch);
1132
1133 spin_lock_irq(cdev->ccwlock);
1134 sch_set_cdev(sch, NULL);
1135 set_io_private(sch, NULL);
1136 cdev->private->state = DEV_STATE_NOT_OPER;
1137 spin_unlock_irq(cdev->ccwlock);
1138 ccw_device_unregister(cdev);
1139out_free:
1140 kfree(io_priv);
1141 sysfs_remove_group(&sch->dev.kobj, &io_subchannel_attr_group);
1142 return 0;
1143}
1144
1145static void io_subchannel_verify(struct subchannel *sch)
1146{
1147 struct ccw_device *cdev;
1148
1149 cdev = sch_get_cdev(sch);
1150 if (cdev)
1151 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
1152}
1153
1154static void io_subchannel_terminate_path(struct subchannel *sch, u8 mask)
1155{
1156 struct ccw_device *cdev;
1157
1158 cdev = sch_get_cdev(sch);
1159 if (!cdev)
1160 return;
1161 if (cio_update_schib(sch))
1162 goto err;
1163
1164 if (scsw_actl(&sch->schib.scsw) == 0 || sch->schib.pmcw.lpum != mask)
1165 goto out;
1166 if (cdev->private->state == DEV_STATE_ONLINE) {
1167 ccw_device_kill_io(cdev);
1168 goto out;
1169 }
1170 if (cio_clear(sch))
1171 goto err;
1172out:
1173
1174 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
1175 return;
1176
1177err:
1178 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
1179}
1180
1181static int io_subchannel_chp_event(struct subchannel *sch,
1182 struct chp_link *link, int event)
1183{
1184 struct ccw_device *cdev = sch_get_cdev(sch);
1185 int mask;
1186
1187 mask = chp_ssd_get_mask(&sch->ssd_info, link);
1188 if (!mask)
1189 return 0;
1190 switch (event) {
1191 case CHP_VARY_OFF:
1192 sch->opm &= ~mask;
1193 sch->lpm &= ~mask;
1194 if (cdev)
1195 cdev->private->path_gone_mask |= mask;
1196 io_subchannel_terminate_path(sch, mask);
1197 break;
1198 case CHP_VARY_ON:
1199 sch->opm |= mask;
1200 sch->lpm |= mask;
1201 if (cdev)
1202 cdev->private->path_new_mask |= mask;
1203 io_subchannel_verify(sch);
1204 break;
1205 case CHP_OFFLINE:
1206 if (cio_update_schib(sch))
1207 return -ENODEV;
1208 if (cdev)
1209 cdev->private->path_gone_mask |= mask;
1210 io_subchannel_terminate_path(sch, mask);
1211 break;
1212 case CHP_ONLINE:
1213 if (cio_update_schib(sch))
1214 return -ENODEV;
1215 sch->lpm |= mask & sch->opm;
1216 if (cdev)
1217 cdev->private->path_new_mask |= mask;
1218 io_subchannel_verify(sch);
1219 break;
1220 }
1221 return 0;
1222}
1223
1224static void io_subchannel_quiesce(struct subchannel *sch)
1225{
1226 struct ccw_device *cdev;
1227 int ret;
1228
1229 spin_lock_irq(sch->lock);
1230 cdev = sch_get_cdev(sch);
1231 if (cio_is_console(sch->schid))
1232 goto out_unlock;
1233 if (!sch->schib.pmcw.ena)
1234 goto out_unlock;
1235 ret = cio_disable_subchannel(sch);
1236 if (ret != -EBUSY)
1237 goto out_unlock;
1238 if (cdev->handler)
1239 cdev->handler(cdev, cdev->private->intparm, ERR_PTR(-EIO));
1240 while (ret == -EBUSY) {
1241 cdev->private->state = DEV_STATE_QUIESCE;
1242 cdev->private->iretry = 255;
1243 ret = ccw_device_cancel_halt_clear(cdev);
1244 if (ret == -EBUSY) {
1245 ccw_device_set_timeout(cdev, HZ/10);
1246 spin_unlock_irq(sch->lock);
1247 wait_event(cdev->private->wait_q,
1248 cdev->private->state != DEV_STATE_QUIESCE);
1249 spin_lock_irq(sch->lock);
1250 }
1251 ret = cio_disable_subchannel(sch);
1252 }
1253out_unlock:
1254 spin_unlock_irq(sch->lock);
1255}
1256
1257static void io_subchannel_shutdown(struct subchannel *sch)
1258{
1259 io_subchannel_quiesce(sch);
1260}
1261
1262static int device_is_disconnected(struct ccw_device *cdev)
1263{
1264 if (!cdev)
1265 return 0;
1266 return (cdev->private->state == DEV_STATE_DISCONNECTED ||
1267 cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID);
1268}
1269
1270static int recovery_check(struct device *dev, void *data)
1271{
1272 struct ccw_device *cdev = to_ccwdev(dev);
1273 int *redo = data;
1274
1275 spin_lock_irq(cdev->ccwlock);
1276 switch (cdev->private->state) {
1277 case DEV_STATE_DISCONNECTED:
1278 CIO_MSG_EVENT(3, "recovery: trigger 0.%x.%04x\n",
1279 cdev->private->dev_id.ssid,
1280 cdev->private->dev_id.devno);
1281 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
1282 *redo = 1;
1283 break;
1284 case DEV_STATE_DISCONNECTED_SENSE_ID:
1285 *redo = 1;
1286 break;
1287 }
1288 spin_unlock_irq(cdev->ccwlock);
1289
1290 return 0;
1291}
1292
1293static void recovery_work_func(struct work_struct *unused)
1294{
1295 int redo = 0;
1296
1297 bus_for_each_dev(&ccw_bus_type, NULL, &redo, recovery_check);
1298 if (redo) {
1299 spin_lock_irq(&recovery_lock);
1300 if (!timer_pending(&recovery_timer)) {
1301 if (recovery_phase < ARRAY_SIZE(recovery_delay) - 1)
1302 recovery_phase++;
1303 mod_timer(&recovery_timer, jiffies +
1304 recovery_delay[recovery_phase] * HZ);
1305 }
1306 spin_unlock_irq(&recovery_lock);
1307 } else
1308 CIO_MSG_EVENT(4, "recovery: end\n");
1309}
1310
1311static DECLARE_WORK(recovery_work, recovery_work_func);
1312
1313static void recovery_func(unsigned long data)
1314{
1315
1316
1317
1318
1319 schedule_work(&recovery_work);
1320}
1321
1322static void ccw_device_schedule_recovery(void)
1323{
1324 unsigned long flags;
1325
1326 CIO_MSG_EVENT(4, "recovery: schedule\n");
1327 spin_lock_irqsave(&recovery_lock, flags);
1328 if (!timer_pending(&recovery_timer) || (recovery_phase != 0)) {
1329 recovery_phase = 0;
1330 mod_timer(&recovery_timer, jiffies + recovery_delay[0] * HZ);
1331 }
1332 spin_unlock_irqrestore(&recovery_lock, flags);
1333}
1334
1335static int purge_fn(struct device *dev, void *data)
1336{
1337 struct ccw_device *cdev = to_ccwdev(dev);
1338 struct ccw_dev_id *id = &cdev->private->dev_id;
1339
1340 spin_lock_irq(cdev->ccwlock);
1341 if (is_blacklisted(id->ssid, id->devno) &&
1342 (cdev->private->state == DEV_STATE_OFFLINE) &&
1343 (atomic_cmpxchg(&cdev->private->onoff, 0, 1) == 0)) {
1344 CIO_MSG_EVENT(3, "ccw: purging 0.%x.%04x\n", id->ssid,
1345 id->devno);
1346 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
1347 atomic_set(&cdev->private->onoff, 0);
1348 }
1349 spin_unlock_irq(cdev->ccwlock);
1350
1351 if (signal_pending(current))
1352 return -EINTR;
1353
1354 return 0;
1355}
1356
1357
1358
1359
1360
1361
1362int ccw_purge_blacklisted(void)
1363{
1364 CIO_MSG_EVENT(2, "ccw: purging blacklisted devices\n");
1365 bus_for_each_dev(&ccw_bus_type, NULL, NULL, purge_fn);
1366 return 0;
1367}
1368
1369void ccw_device_set_disconnected(struct ccw_device *cdev)
1370{
1371 if (!cdev)
1372 return;
1373 ccw_device_set_timeout(cdev, 0);
1374 cdev->private->flags.fake_irb = 0;
1375 cdev->private->state = DEV_STATE_DISCONNECTED;
1376 if (cdev->online)
1377 ccw_device_schedule_recovery();
1378}
1379
1380void ccw_device_set_notoper(struct ccw_device *cdev)
1381{
1382 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1383
1384 CIO_TRACE_EVENT(2, "notoper");
1385 CIO_TRACE_EVENT(2, dev_name(&sch->dev));
1386 ccw_device_set_timeout(cdev, 0);
1387 cio_disable_subchannel(sch);
1388 cdev->private->state = DEV_STATE_NOT_OPER;
1389}
1390
1391enum io_sch_action {
1392 IO_SCH_UNREG,
1393 IO_SCH_ORPH_UNREG,
1394 IO_SCH_ATTACH,
1395 IO_SCH_UNREG_ATTACH,
1396 IO_SCH_ORPH_ATTACH,
1397 IO_SCH_REPROBE,
1398 IO_SCH_VERIFY,
1399 IO_SCH_DISC,
1400 IO_SCH_NOP,
1401};
1402
1403static enum io_sch_action sch_get_action(struct subchannel *sch)
1404{
1405 struct ccw_device *cdev;
1406
1407 cdev = sch_get_cdev(sch);
1408 if (cio_update_schib(sch)) {
1409
1410 if (!cdev)
1411 return IO_SCH_UNREG;
1412 if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
1413 return IO_SCH_UNREG;
1414 return IO_SCH_ORPH_UNREG;
1415 }
1416
1417 if (!cdev)
1418 return IO_SCH_ATTACH;
1419 if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
1420 if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
1421 return IO_SCH_UNREG_ATTACH;
1422 return IO_SCH_ORPH_ATTACH;
1423 }
1424 if ((sch->schib.pmcw.pam & sch->opm) == 0) {
1425 if (ccw_device_notify(cdev, CIO_NO_PATH) != NOTIFY_OK)
1426 return IO_SCH_UNREG;
1427 return IO_SCH_DISC;
1428 }
1429 if (device_is_disconnected(cdev))
1430 return IO_SCH_REPROBE;
1431 if (cdev->online && !cdev->private->flags.resuming)
1432 return IO_SCH_VERIFY;
1433 if (cdev->private->state == DEV_STATE_NOT_OPER)
1434 return IO_SCH_UNREG_ATTACH;
1435 return IO_SCH_NOP;
1436}
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448static int io_subchannel_sch_event(struct subchannel *sch, int process)
1449{
1450 unsigned long flags;
1451 struct ccw_device *cdev;
1452 struct ccw_dev_id dev_id;
1453 enum io_sch_action action;
1454 int rc = -EAGAIN;
1455
1456 spin_lock_irqsave(sch->lock, flags);
1457 if (!device_is_registered(&sch->dev))
1458 goto out_unlock;
1459 if (work_pending(&sch->todo_work))
1460 goto out_unlock;
1461 cdev = sch_get_cdev(sch);
1462 if (cdev && work_pending(&cdev->private->todo_work))
1463 goto out_unlock;
1464 action = sch_get_action(sch);
1465 CIO_MSG_EVENT(2, "event: sch 0.%x.%04x, process=%d, action=%d\n",
1466 sch->schid.ssid, sch->schid.sch_no, process,
1467 action);
1468
1469 switch (action) {
1470 case IO_SCH_REPROBE:
1471
1472 ccw_device_trigger_reprobe(cdev);
1473 rc = 0;
1474 goto out_unlock;
1475 case IO_SCH_VERIFY:
1476
1477 io_subchannel_verify(sch);
1478 rc = 0;
1479 goto out_unlock;
1480 case IO_SCH_DISC:
1481 ccw_device_set_disconnected(cdev);
1482 rc = 0;
1483 goto out_unlock;
1484 case IO_SCH_ORPH_UNREG:
1485 case IO_SCH_ORPH_ATTACH:
1486 ccw_device_set_disconnected(cdev);
1487 break;
1488 case IO_SCH_UNREG_ATTACH:
1489 case IO_SCH_UNREG:
1490 if (!cdev)
1491 break;
1492 if (cdev->private->state == DEV_STATE_SENSE_ID) {
1493
1494
1495
1496
1497
1498 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
1499 } else
1500 ccw_device_set_notoper(cdev);
1501 break;
1502 case IO_SCH_NOP:
1503 rc = 0;
1504 goto out_unlock;
1505 default:
1506 break;
1507 }
1508 spin_unlock_irqrestore(sch->lock, flags);
1509
1510 if (!process)
1511 goto out;
1512
1513 switch (action) {
1514 case IO_SCH_ORPH_UNREG:
1515 case IO_SCH_ORPH_ATTACH:
1516
1517 rc = ccw_device_move_to_orph(cdev);
1518 if (rc)
1519 goto out;
1520 break;
1521 case IO_SCH_UNREG_ATTACH:
1522 spin_lock_irqsave(sch->lock, flags);
1523 if (cdev->private->flags.resuming) {
1524
1525 rc = 0;
1526 goto out_unlock;
1527 }
1528 sch_set_cdev(sch, NULL);
1529 spin_unlock_irqrestore(sch->lock, flags);
1530
1531 ccw_device_unregister(cdev);
1532 break;
1533 default:
1534 break;
1535 }
1536
1537 switch (action) {
1538 case IO_SCH_ORPH_UNREG:
1539 case IO_SCH_UNREG:
1540 if (!cdev || !cdev->private->flags.resuming)
1541 css_sch_device_unregister(sch);
1542 break;
1543 case IO_SCH_ORPH_ATTACH:
1544 case IO_SCH_UNREG_ATTACH:
1545 case IO_SCH_ATTACH:
1546 dev_id.ssid = sch->schid.ssid;
1547 dev_id.devno = sch->schib.pmcw.dev;
1548 cdev = get_ccwdev_by_dev_id(&dev_id);
1549 if (!cdev) {
1550 sch_create_and_recog_new_device(sch);
1551 break;
1552 }
1553 rc = ccw_device_move_to_sch(cdev, sch);
1554 if (rc) {
1555
1556 put_device(&cdev->dev);
1557 goto out;
1558 }
1559 spin_lock_irqsave(sch->lock, flags);
1560 ccw_device_trigger_reprobe(cdev);
1561 spin_unlock_irqrestore(sch->lock, flags);
1562
1563 put_device(&cdev->dev);
1564 break;
1565 default:
1566 break;
1567 }
1568 return 0;
1569
1570out_unlock:
1571 spin_unlock_irqrestore(sch->lock, flags);
1572out:
1573 return rc;
1574}
1575
1576static void ccw_device_set_int_class(struct ccw_device *cdev)
1577{
1578 struct ccw_driver *cdrv = cdev->drv;
1579
1580
1581
1582 if (cdrv->int_class != 0)
1583 cdev->private->int_class = cdrv->int_class;
1584 else
1585 cdev->private->int_class = IRQIO_CIO;
1586}
1587
1588#ifdef CONFIG_CCW_CONSOLE
1589int __init ccw_device_enable_console(struct ccw_device *cdev)
1590{
1591 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1592 int rc;
1593
1594 if (!cdev->drv || !cdev->handler)
1595 return -EINVAL;
1596
1597 io_subchannel_init_fields(sch);
1598 rc = cio_commit_config(sch);
1599 if (rc)
1600 return rc;
1601 sch->driver = &io_subchannel_driver;
1602 io_subchannel_recog(cdev, sch);
1603
1604 spin_lock_irq(cdev->ccwlock);
1605 while (!dev_fsm_final_state(cdev))
1606 ccw_device_wait_idle(cdev);
1607
1608
1609 get_device(&cdev->dev);
1610 rc = ccw_device_online(cdev);
1611 if (rc)
1612 goto out_unlock;
1613
1614 while (!dev_fsm_final_state(cdev))
1615 ccw_device_wait_idle(cdev);
1616
1617 if (cdev->private->state == DEV_STATE_ONLINE)
1618 cdev->online = 1;
1619 else
1620 rc = -EIO;
1621out_unlock:
1622 spin_unlock_irq(cdev->ccwlock);
1623 if (rc)
1624 put_device(&cdev->dev);
1625 return rc;
1626}
1627
1628struct ccw_device * __init ccw_device_create_console(struct ccw_driver *drv)
1629{
1630 struct io_subchannel_private *io_priv;
1631 struct ccw_device *cdev;
1632 struct subchannel *sch;
1633
1634 sch = cio_probe_console();
1635 if (IS_ERR(sch))
1636 return ERR_CAST(sch);
1637
1638 io_priv = kzalloc(sizeof(*io_priv), GFP_KERNEL | GFP_DMA);
1639 if (!io_priv) {
1640 put_device(&sch->dev);
1641 return ERR_PTR(-ENOMEM);
1642 }
1643 set_io_private(sch, io_priv);
1644 cdev = io_subchannel_create_ccwdev(sch);
1645 if (IS_ERR(cdev)) {
1646 put_device(&sch->dev);
1647 kfree(io_priv);
1648 return cdev;
1649 }
1650 cdev->drv = drv;
1651 ccw_device_set_int_class(cdev);
1652 return cdev;
1653}
1654
1655void __init ccw_device_destroy_console(struct ccw_device *cdev)
1656{
1657 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1658 struct io_subchannel_private *io_priv = to_io_private(sch);
1659
1660 set_io_private(sch, NULL);
1661 put_device(&sch->dev);
1662 put_device(&cdev->dev);
1663 kfree(io_priv);
1664}
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674void ccw_device_wait_idle(struct ccw_device *cdev)
1675{
1676 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1677
1678 while (1) {
1679 cio_tsch(sch);
1680 if (sch->schib.scsw.cmd.actl == 0)
1681 break;
1682 udelay_simple(100);
1683 }
1684}
1685
1686static int ccw_device_pm_restore(struct device *dev);
1687
1688int ccw_device_force_console(struct ccw_device *cdev)
1689{
1690 return ccw_device_pm_restore(&cdev->dev);
1691}
1692EXPORT_SYMBOL_GPL(ccw_device_force_console);
1693#endif
1694
1695
1696
1697
1698static int
1699__ccwdev_check_busid(struct device *dev, void *id)
1700{
1701 char *bus_id;
1702
1703 bus_id = id;
1704
1705 return (strcmp(bus_id, dev_name(dev)) == 0);
1706}
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720struct ccw_device *get_ccwdev_by_busid(struct ccw_driver *cdrv,
1721 const char *bus_id)
1722{
1723 struct device *dev;
1724
1725 dev = driver_find_device(&cdrv->driver, NULL, (void *)bus_id,
1726 __ccwdev_check_busid);
1727
1728 return dev ? to_ccwdev(dev) : NULL;
1729}
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741static int
1742ccw_device_probe (struct device *dev)
1743{
1744 struct ccw_device *cdev = to_ccwdev(dev);
1745 struct ccw_driver *cdrv = to_ccwdrv(dev->driver);
1746 int ret;
1747
1748 cdev->drv = cdrv;
1749 ccw_device_set_int_class(cdev);
1750 ret = cdrv->probe ? cdrv->probe(cdev) : -ENODEV;
1751 if (ret) {
1752 cdev->drv = NULL;
1753 cdev->private->int_class = IRQIO_CIO;
1754 return ret;
1755 }
1756
1757 return 0;
1758}
1759
1760static int ccw_device_remove(struct device *dev)
1761{
1762 struct ccw_device *cdev = to_ccwdev(dev);
1763 struct ccw_driver *cdrv = cdev->drv;
1764 int ret;
1765
1766 if (cdrv->remove)
1767 cdrv->remove(cdev);
1768
1769 spin_lock_irq(cdev->ccwlock);
1770 if (cdev->online) {
1771 cdev->online = 0;
1772 ret = ccw_device_offline(cdev);
1773 spin_unlock_irq(cdev->ccwlock);
1774 if (ret == 0)
1775 wait_event(cdev->private->wait_q,
1776 dev_fsm_final_state(cdev));
1777 else
1778 CIO_MSG_EVENT(0, "ccw_device_offline returned %d, "
1779 "device 0.%x.%04x\n",
1780 ret, cdev->private->dev_id.ssid,
1781 cdev->private->dev_id.devno);
1782
1783 put_device(&cdev->dev);
1784 spin_lock_irq(cdev->ccwlock);
1785 }
1786 ccw_device_set_timeout(cdev, 0);
1787 cdev->drv = NULL;
1788 cdev->private->int_class = IRQIO_CIO;
1789 spin_unlock_irq(cdev->ccwlock);
1790 return 0;
1791}
1792
1793static void ccw_device_shutdown(struct device *dev)
1794{
1795 struct ccw_device *cdev;
1796
1797 cdev = to_ccwdev(dev);
1798 if (cdev->drv && cdev->drv->shutdown)
1799 cdev->drv->shutdown(cdev);
1800 disable_cmf(cdev);
1801}
1802
1803static int ccw_device_pm_prepare(struct device *dev)
1804{
1805 struct ccw_device *cdev = to_ccwdev(dev);
1806
1807 if (work_pending(&cdev->private->todo_work))
1808 return -EAGAIN;
1809
1810 if (atomic_read(&cdev->private->onoff))
1811 return -EAGAIN;
1812
1813 if (cdev->online && cdev->drv && cdev->drv->prepare)
1814 return cdev->drv->prepare(cdev);
1815
1816 return 0;
1817}
1818
1819static void ccw_device_pm_complete(struct device *dev)
1820{
1821 struct ccw_device *cdev = to_ccwdev(dev);
1822
1823 if (cdev->online && cdev->drv && cdev->drv->complete)
1824 cdev->drv->complete(cdev);
1825}
1826
1827static int ccw_device_pm_freeze(struct device *dev)
1828{
1829 struct ccw_device *cdev = to_ccwdev(dev);
1830 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1831 int ret, cm_enabled;
1832
1833
1834 if (!dev_fsm_final_state(cdev))
1835 return -EAGAIN;
1836 if (!cdev->online)
1837 return 0;
1838 if (cdev->drv && cdev->drv->freeze) {
1839 ret = cdev->drv->freeze(cdev);
1840 if (ret)
1841 return ret;
1842 }
1843
1844 spin_lock_irq(sch->lock);
1845 cm_enabled = cdev->private->cmb != NULL;
1846 spin_unlock_irq(sch->lock);
1847 if (cm_enabled) {
1848
1849 ret = ccw_set_cmf(cdev, 0);
1850 if (ret)
1851 return ret;
1852 }
1853
1854 spin_lock_irq(sch->lock);
1855 ret = cio_disable_subchannel(sch);
1856 spin_unlock_irq(sch->lock);
1857
1858 return ret;
1859}
1860
1861static int ccw_device_pm_thaw(struct device *dev)
1862{
1863 struct ccw_device *cdev = to_ccwdev(dev);
1864 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1865 int ret, cm_enabled;
1866
1867 if (!cdev->online)
1868 return 0;
1869
1870 spin_lock_irq(sch->lock);
1871
1872 ret = cio_enable_subchannel(sch, (u32)(addr_t)sch);
1873 cm_enabled = cdev->private->cmb != NULL;
1874 spin_unlock_irq(sch->lock);
1875 if (ret)
1876 return ret;
1877
1878 if (cm_enabled) {
1879 ret = ccw_set_cmf(cdev, 1);
1880 if (ret)
1881 return ret;
1882 }
1883
1884 if (cdev->drv && cdev->drv->thaw)
1885 ret = cdev->drv->thaw(cdev);
1886
1887 return ret;
1888}
1889
1890static void __ccw_device_pm_restore(struct ccw_device *cdev)
1891{
1892 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1893
1894 spin_lock_irq(sch->lock);
1895 if (cio_is_console(sch->schid)) {
1896 cio_enable_subchannel(sch, (u32)(addr_t)sch);
1897 goto out_unlock;
1898 }
1899
1900
1901
1902
1903 cdev->private->flags.resuming = 1;
1904 cdev->private->path_new_mask = LPM_ANYPATH;
1905 css_sched_sch_todo(sch, SCH_TODO_EVAL);
1906 spin_unlock_irq(sch->lock);
1907 css_wait_for_slow_path();
1908
1909
1910 sch = to_subchannel(cdev->dev.parent);
1911 spin_lock_irq(sch->lock);
1912 if (cdev->private->state != DEV_STATE_ONLINE &&
1913 cdev->private->state != DEV_STATE_OFFLINE)
1914 goto out_unlock;
1915
1916 ccw_device_recognition(cdev);
1917 spin_unlock_irq(sch->lock);
1918 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev) ||
1919 cdev->private->state == DEV_STATE_DISCONNECTED);
1920 spin_lock_irq(sch->lock);
1921
1922out_unlock:
1923 cdev->private->flags.resuming = 0;
1924 spin_unlock_irq(sch->lock);
1925}
1926
1927static int resume_handle_boxed(struct ccw_device *cdev)
1928{
1929 cdev->private->state = DEV_STATE_BOXED;
1930 if (ccw_device_notify(cdev, CIO_BOXED) == NOTIFY_OK)
1931 return 0;
1932 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
1933 return -ENODEV;
1934}
1935
1936static int resume_handle_disc(struct ccw_device *cdev)
1937{
1938 cdev->private->state = DEV_STATE_DISCONNECTED;
1939 if (ccw_device_notify(cdev, CIO_GONE) == NOTIFY_OK)
1940 return 0;
1941 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
1942 return -ENODEV;
1943}
1944
1945static int ccw_device_pm_restore(struct device *dev)
1946{
1947 struct ccw_device *cdev = to_ccwdev(dev);
1948 struct subchannel *sch;
1949 int ret = 0;
1950
1951 __ccw_device_pm_restore(cdev);
1952 sch = to_subchannel(cdev->dev.parent);
1953 spin_lock_irq(sch->lock);
1954 if (cio_is_console(sch->schid))
1955 goto out_restore;
1956
1957
1958 switch (cdev->private->state) {
1959 case DEV_STATE_OFFLINE:
1960 case DEV_STATE_ONLINE:
1961 cdev->private->flags.donotify = 0;
1962 break;
1963 case DEV_STATE_BOXED:
1964 ret = resume_handle_boxed(cdev);
1965 if (ret)
1966 goto out_unlock;
1967 goto out_restore;
1968 default:
1969 ret = resume_handle_disc(cdev);
1970 if (ret)
1971 goto out_unlock;
1972 goto out_restore;
1973 }
1974
1975 if (!ccw_device_test_sense_data(cdev)) {
1976 ccw_device_update_sense_data(cdev);
1977 ccw_device_sched_todo(cdev, CDEV_TODO_REBIND);
1978 ret = -ENODEV;
1979 goto out_unlock;
1980 }
1981 if (!cdev->online)
1982 goto out_unlock;
1983
1984 if (ccw_device_online(cdev)) {
1985 ret = resume_handle_disc(cdev);
1986 if (ret)
1987 goto out_unlock;
1988 goto out_restore;
1989 }
1990 spin_unlock_irq(sch->lock);
1991 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));
1992 spin_lock_irq(sch->lock);
1993
1994 if (ccw_device_notify(cdev, CIO_OPER) == NOTIFY_BAD) {
1995 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
1996 ret = -ENODEV;
1997 goto out_unlock;
1998 }
1999
2000
2001 if (cdev->private->cmb) {
2002 spin_unlock_irq(sch->lock);
2003 ret = ccw_set_cmf(cdev, 1);
2004 spin_lock_irq(sch->lock);
2005 if (ret) {
2006 CIO_MSG_EVENT(2, "resume: cdev 0.%x.%04x: cmf failed "
2007 "(rc=%d)\n", cdev->private->dev_id.ssid,
2008 cdev->private->dev_id.devno, ret);
2009 ret = 0;
2010 }
2011 }
2012
2013out_restore:
2014 spin_unlock_irq(sch->lock);
2015 if (cdev->online && cdev->drv && cdev->drv->restore)
2016 ret = cdev->drv->restore(cdev);
2017 return ret;
2018
2019out_unlock:
2020 spin_unlock_irq(sch->lock);
2021 return ret;
2022}
2023
2024static const struct dev_pm_ops ccw_pm_ops = {
2025 .prepare = ccw_device_pm_prepare,
2026 .complete = ccw_device_pm_complete,
2027 .freeze = ccw_device_pm_freeze,
2028 .thaw = ccw_device_pm_thaw,
2029 .restore = ccw_device_pm_restore,
2030};
2031
2032static struct bus_type ccw_bus_type = {
2033 .name = "ccw",
2034 .match = ccw_bus_match,
2035 .uevent = ccw_uevent,
2036 .probe = ccw_device_probe,
2037 .remove = ccw_device_remove,
2038 .shutdown = ccw_device_shutdown,
2039 .pm = &ccw_pm_ops,
2040};
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050int ccw_driver_register(struct ccw_driver *cdriver)
2051{
2052 struct device_driver *drv = &cdriver->driver;
2053
2054 drv->bus = &ccw_bus_type;
2055
2056 return driver_register(drv);
2057}
2058
2059
2060
2061
2062
2063
2064
2065void ccw_driver_unregister(struct ccw_driver *cdriver)
2066{
2067 driver_unregister(&cdriver->driver);
2068}
2069
2070static void ccw_device_todo(struct work_struct *work)
2071{
2072 struct ccw_device_private *priv;
2073 struct ccw_device *cdev;
2074 struct subchannel *sch;
2075 enum cdev_todo todo;
2076
2077 priv = container_of(work, struct ccw_device_private, todo_work);
2078 cdev = priv->cdev;
2079 sch = to_subchannel(cdev->dev.parent);
2080
2081 spin_lock_irq(cdev->ccwlock);
2082 todo = priv->todo;
2083 priv->todo = CDEV_TODO_NOTHING;
2084 CIO_MSG_EVENT(4, "cdev_todo: cdev=0.%x.%04x todo=%d\n",
2085 priv->dev_id.ssid, priv->dev_id.devno, todo);
2086 spin_unlock_irq(cdev->ccwlock);
2087
2088 switch (todo) {
2089 case CDEV_TODO_ENABLE_CMF:
2090 cmf_reenable(cdev);
2091 break;
2092 case CDEV_TODO_REBIND:
2093 ccw_device_do_unbind_bind(cdev);
2094 break;
2095 case CDEV_TODO_REGISTER:
2096 io_subchannel_register(cdev);
2097 break;
2098 case CDEV_TODO_UNREG_EVAL:
2099 if (!sch_is_pseudo_sch(sch))
2100 css_schedule_eval(sch->schid);
2101
2102 case CDEV_TODO_UNREG:
2103 if (sch_is_pseudo_sch(sch))
2104 ccw_device_unregister(cdev);
2105 else
2106 ccw_device_call_sch_unregister(cdev);
2107 break;
2108 default:
2109 break;
2110 }
2111
2112 put_device(&cdev->dev);
2113}
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124void ccw_device_sched_todo(struct ccw_device *cdev, enum cdev_todo todo)
2125{
2126 CIO_MSG_EVENT(4, "cdev_todo: sched cdev=0.%x.%04x todo=%d\n",
2127 cdev->private->dev_id.ssid, cdev->private->dev_id.devno,
2128 todo);
2129 if (cdev->private->todo >= todo)
2130 return;
2131 cdev->private->todo = todo;
2132
2133 if (!get_device(&cdev->dev))
2134 return;
2135 if (!queue_work(cio_work_q, &cdev->private->todo_work)) {
2136
2137 put_device(&cdev->dev);
2138 }
2139}
2140
2141
2142
2143
2144
2145
2146
2147
2148int ccw_device_siosl(struct ccw_device *cdev)
2149{
2150 struct subchannel *sch = to_subchannel(cdev->dev.parent);
2151
2152 return chsc_siosl(sch->schid);
2153}
2154EXPORT_SYMBOL_GPL(ccw_device_siosl);
2155
2156MODULE_LICENSE("GPL");
2157EXPORT_SYMBOL(ccw_device_set_online);
2158EXPORT_SYMBOL(ccw_device_set_offline);
2159EXPORT_SYMBOL(ccw_driver_register);
2160EXPORT_SYMBOL(ccw_driver_unregister);
2161EXPORT_SYMBOL(get_ccwdev_by_busid);
2162