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 cdev->online = 0;
337 spin_lock_irq(cdev->ccwlock);
338 sch = to_subchannel(cdev->dev.parent);
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 cdev->online = 1;
450 return 0;
451
452rollback:
453 spin_lock_irq(cdev->ccwlock);
454
455 while (!dev_fsm_final_state(cdev) &&
456 cdev->private->state != DEV_STATE_DISCONNECTED) {
457 spin_unlock_irq(cdev->ccwlock);
458 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
459 cdev->private->state == DEV_STATE_DISCONNECTED));
460 spin_lock_irq(cdev->ccwlock);
461 }
462 ret2 = ccw_device_offline(cdev);
463 if (ret2)
464 goto error;
465 spin_unlock_irq(cdev->ccwlock);
466 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
467 cdev->private->state == DEV_STATE_DISCONNECTED));
468
469 put_device(&cdev->dev);
470 return ret;
471
472error:
473 CIO_MSG_EVENT(0, "rollback ccw_device_offline returned %d, "
474 "device 0.%x.%04x\n",
475 ret2, cdev->private->dev_id.ssid,
476 cdev->private->dev_id.devno);
477 cdev->private->state = DEV_STATE_OFFLINE;
478 spin_unlock_irq(cdev->ccwlock);
479
480 put_device(&cdev->dev);
481 return ret;
482}
483
484static int online_store_handle_offline(struct ccw_device *cdev)
485{
486 if (cdev->private->state == DEV_STATE_DISCONNECTED) {
487 spin_lock_irq(cdev->ccwlock);
488 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG_EVAL);
489 spin_unlock_irq(cdev->ccwlock);
490 return 0;
491 }
492 if (cdev->drv && cdev->drv->set_offline)
493 return ccw_device_set_offline(cdev);
494 return -EINVAL;
495}
496
497static int online_store_recog_and_online(struct ccw_device *cdev)
498{
499
500 if (cdev->private->state == DEV_STATE_BOXED) {
501 spin_lock_irq(cdev->ccwlock);
502 ccw_device_recognition(cdev);
503 spin_unlock_irq(cdev->ccwlock);
504 wait_event(cdev->private->wait_q,
505 cdev->private->flags.recog_done);
506 if (cdev->private->state != DEV_STATE_OFFLINE)
507
508 return -EAGAIN;
509 }
510 if (cdev->drv && cdev->drv->set_online)
511 return ccw_device_set_online(cdev);
512 return -EINVAL;
513}
514
515static int online_store_handle_online(struct ccw_device *cdev, int force)
516{
517 int ret;
518
519 ret = online_store_recog_and_online(cdev);
520 if (ret && !force)
521 return ret;
522 if (force && cdev->private->state == DEV_STATE_BOXED) {
523 ret = ccw_device_stlck(cdev);
524 if (ret)
525 return ret;
526 if (cdev->id.cu_type == 0)
527 cdev->private->state = DEV_STATE_NOT_OPER;
528 ret = online_store_recog_and_online(cdev);
529 if (ret)
530 return ret;
531 }
532 return 0;
533}
534
535static ssize_t online_store (struct device *dev, struct device_attribute *attr,
536 const char *buf, size_t count)
537{
538 struct ccw_device *cdev = to_ccwdev(dev);
539 int force, ret;
540 unsigned long i;
541
542
543 if (atomic_cmpxchg(&cdev->private->onoff, 0, 1) != 0)
544 return -EAGAIN;
545
546 if (!dev_fsm_final_state(cdev) &&
547 cdev->private->state != DEV_STATE_DISCONNECTED) {
548 ret = -EAGAIN;
549 goto out_onoff;
550 }
551
552 if (work_pending(&cdev->private->todo_work)) {
553 ret = -EAGAIN;
554 goto out_onoff;
555 }
556
557 if (cdev->drv && !try_module_get(cdev->drv->driver.owner)) {
558 ret = -EINVAL;
559 goto out_onoff;
560 }
561 if (!strncmp(buf, "force\n", count)) {
562 force = 1;
563 i = 1;
564 ret = 0;
565 } else {
566 force = 0;
567 ret = strict_strtoul(buf, 16, &i);
568 }
569 if (ret)
570 goto out;
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 }
581out:
582 if (cdev->drv)
583 module_put(cdev->drv->driver.owner);
584out_onoff:
585 atomic_set(&cdev->private->onoff, 0);
586 return (ret < 0) ? ret : count;
587}
588
589static ssize_t
590available_show (struct device *dev, struct device_attribute *attr, char *buf)
591{
592 struct ccw_device *cdev = to_ccwdev(dev);
593 struct subchannel *sch;
594
595 if (ccw_device_is_orphan(cdev))
596 return sprintf(buf, "no device\n");
597 switch (cdev->private->state) {
598 case DEV_STATE_BOXED:
599 return sprintf(buf, "boxed\n");
600 case DEV_STATE_DISCONNECTED:
601 case DEV_STATE_DISCONNECTED_SENSE_ID:
602 case DEV_STATE_NOT_OPER:
603 sch = to_subchannel(dev->parent);
604 if (!sch->lpm)
605 return sprintf(buf, "no path\n");
606 else
607 return sprintf(buf, "no device\n");
608 default:
609
610 return sprintf(buf, "good\n");
611 }
612}
613
614static ssize_t
615initiate_logging(struct device *dev, struct device_attribute *attr,
616 const char *buf, size_t count)
617{
618 struct subchannel *sch = to_subchannel(dev);
619 int rc;
620
621 rc = chsc_siosl(sch->schid);
622 if (rc < 0) {
623 pr_warning("Logging for subchannel 0.%x.%04x failed with "
624 "errno=%d\n",
625 sch->schid.ssid, sch->schid.sch_no, rc);
626 return rc;
627 }
628 pr_notice("Logging for subchannel 0.%x.%04x was triggered\n",
629 sch->schid.ssid, sch->schid.sch_no);
630 return count;
631}
632
633static ssize_t vpm_show(struct device *dev, struct device_attribute *attr,
634 char *buf)
635{
636 struct subchannel *sch = to_subchannel(dev);
637
638 return sprintf(buf, "%02x\n", sch->vpm);
639}
640
641static DEVICE_ATTR(chpids, 0444, chpids_show, NULL);
642static DEVICE_ATTR(pimpampom, 0444, pimpampom_show, NULL);
643static DEVICE_ATTR(devtype, 0444, devtype_show, NULL);
644static DEVICE_ATTR(cutype, 0444, cutype_show, NULL);
645static DEVICE_ATTR(modalias, 0444, modalias_show, NULL);
646static DEVICE_ATTR(online, 0644, online_show, online_store);
647static DEVICE_ATTR(availability, 0444, available_show, NULL);
648static DEVICE_ATTR(logging, 0200, NULL, initiate_logging);
649static DEVICE_ATTR(vpm, 0444, vpm_show, NULL);
650
651static struct attribute *io_subchannel_attrs[] = {
652 &dev_attr_chpids.attr,
653 &dev_attr_pimpampom.attr,
654 &dev_attr_logging.attr,
655 &dev_attr_vpm.attr,
656 NULL,
657};
658
659static struct attribute_group io_subchannel_attr_group = {
660 .attrs = io_subchannel_attrs,
661};
662
663static struct attribute * ccwdev_attrs[] = {
664 &dev_attr_devtype.attr,
665 &dev_attr_cutype.attr,
666 &dev_attr_modalias.attr,
667 &dev_attr_online.attr,
668 &dev_attr_cmb_enable.attr,
669 &dev_attr_availability.attr,
670 NULL,
671};
672
673static struct attribute_group ccwdev_attr_group = {
674 .attrs = ccwdev_attrs,
675};
676
677static const struct attribute_group *ccwdev_attr_groups[] = {
678 &ccwdev_attr_group,
679 NULL,
680};
681
682
683
684static int ccw_device_register(struct ccw_device *cdev)
685{
686 struct device *dev = &cdev->dev;
687 int ret;
688
689 dev->bus = &ccw_bus_type;
690 ret = dev_set_name(&cdev->dev, "0.%x.%04x", cdev->private->dev_id.ssid,
691 cdev->private->dev_id.devno);
692 if (ret)
693 return ret;
694 return device_add(dev);
695}
696
697static int match_dev_id(struct device *dev, void *data)
698{
699 struct ccw_device *cdev = to_ccwdev(dev);
700 struct ccw_dev_id *dev_id = data;
701
702 return ccw_dev_id_is_equal(&cdev->private->dev_id, dev_id);
703}
704
705
706
707
708
709
710
711
712
713
714
715struct ccw_device *get_ccwdev_by_dev_id(struct ccw_dev_id *dev_id)
716{
717 struct device *dev;
718
719 dev = bus_find_device(&ccw_bus_type, NULL, dev_id, match_dev_id);
720
721 return dev ? to_ccwdev(dev) : NULL;
722}
723EXPORT_SYMBOL_GPL(get_ccwdev_by_dev_id);
724
725static void ccw_device_do_unbind_bind(struct ccw_device *cdev)
726{
727 int ret;
728
729 if (device_is_registered(&cdev->dev)) {
730 device_release_driver(&cdev->dev);
731 ret = device_attach(&cdev->dev);
732 WARN_ON(ret == -ENODEV);
733 }
734}
735
736static void
737ccw_device_release(struct device *dev)
738{
739 struct ccw_device *cdev;
740
741 cdev = to_ccwdev(dev);
742
743 put_device(cdev->dev.parent);
744 kfree(cdev->private);
745 kfree(cdev);
746}
747
748static struct ccw_device * io_subchannel_allocate_dev(struct subchannel *sch)
749{
750 struct ccw_device *cdev;
751
752 cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
753 if (cdev) {
754 cdev->private = kzalloc(sizeof(struct ccw_device_private),
755 GFP_KERNEL | GFP_DMA);
756 if (cdev->private)
757 return cdev;
758 }
759 kfree(cdev);
760 return ERR_PTR(-ENOMEM);
761}
762
763static void ccw_device_todo(struct work_struct *work);
764
765static int io_subchannel_initialize_dev(struct subchannel *sch,
766 struct ccw_device *cdev)
767{
768 cdev->private->cdev = cdev;
769 cdev->private->int_class = IRQIO_CIO;
770 atomic_set(&cdev->private->onoff, 0);
771 cdev->dev.parent = &sch->dev;
772 cdev->dev.release = ccw_device_release;
773 INIT_WORK(&cdev->private->todo_work, ccw_device_todo);
774 cdev->dev.groups = ccwdev_attr_groups;
775
776 device_initialize(&cdev->dev);
777 if (!get_device(&sch->dev)) {
778
779 put_device(&cdev->dev);
780 return -ENODEV;
781 }
782 cdev->private->flags.initialized = 1;
783 return 0;
784}
785
786static struct ccw_device * io_subchannel_create_ccwdev(struct subchannel *sch)
787{
788 struct ccw_device *cdev;
789 int ret;
790
791 cdev = io_subchannel_allocate_dev(sch);
792 if (!IS_ERR(cdev)) {
793 ret = io_subchannel_initialize_dev(sch, cdev);
794 if (ret)
795 cdev = ERR_PTR(ret);
796 }
797 return cdev;
798}
799
800static void io_subchannel_recog(struct ccw_device *, struct subchannel *);
801
802static void sch_create_and_recog_new_device(struct subchannel *sch)
803{
804 struct ccw_device *cdev;
805
806
807 cdev = io_subchannel_create_ccwdev(sch);
808 if (IS_ERR(cdev)) {
809
810 css_sch_device_unregister(sch);
811 return;
812 }
813
814 io_subchannel_recog(cdev, sch);
815}
816
817
818
819
820static void io_subchannel_register(struct ccw_device *cdev)
821{
822 struct subchannel *sch;
823 int ret, adjust_init_count = 1;
824 unsigned long flags;
825
826 sch = to_subchannel(cdev->dev.parent);
827
828
829
830
831
832
833 if (!device_is_registered(&sch->dev))
834 goto out_err;
835 css_update_ssd_info(sch);
836
837
838
839
840
841
842 if (device_is_registered(&cdev->dev)) {
843 if (!cdev->drv) {
844 ret = device_reprobe(&cdev->dev);
845 if (ret)
846
847 CIO_MSG_EVENT(0, "device_reprobe() returned"
848 " %d for 0.%x.%04x\n", ret,
849 cdev->private->dev_id.ssid,
850 cdev->private->dev_id.devno);
851 }
852 adjust_init_count = 0;
853 goto out;
854 }
855
856
857
858
859 dev_set_uevent_suppress(&sch->dev, 0);
860 kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
861
862 ret = ccw_device_register(cdev);
863 if (ret) {
864 CIO_MSG_EVENT(0, "Could not register ccw dev 0.%x.%04x: %d\n",
865 cdev->private->dev_id.ssid,
866 cdev->private->dev_id.devno, ret);
867 spin_lock_irqsave(sch->lock, flags);
868 sch_set_cdev(sch, NULL);
869 spin_unlock_irqrestore(sch->lock, flags);
870
871 put_device(&cdev->dev);
872 goto out_err;
873 }
874out:
875 cdev->private->flags.recog_done = 1;
876 wake_up(&cdev->private->wait_q);
877out_err:
878 if (adjust_init_count && atomic_dec_and_test(&ccw_device_init_count))
879 wake_up(&ccw_device_init_wq);
880}
881
882static void ccw_device_call_sch_unregister(struct ccw_device *cdev)
883{
884 struct subchannel *sch;
885
886
887 if (!get_device(cdev->dev.parent))
888 return;
889 sch = to_subchannel(cdev->dev.parent);
890 css_sch_device_unregister(sch);
891
892 put_device(&sch->dev);
893}
894
895
896
897
898void
899io_subchannel_recog_done(struct ccw_device *cdev)
900{
901 if (css_init_done == 0) {
902 cdev->private->flags.recog_done = 1;
903 return;
904 }
905 switch (cdev->private->state) {
906 case DEV_STATE_BOXED:
907
908 case DEV_STATE_NOT_OPER:
909 cdev->private->flags.recog_done = 1;
910
911 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
912 if (atomic_dec_and_test(&ccw_device_init_count))
913 wake_up(&ccw_device_init_wq);
914 break;
915 case DEV_STATE_OFFLINE:
916
917
918
919
920 ccw_device_sched_todo(cdev, CDEV_TODO_REGISTER);
921 break;
922 }
923}
924
925static void io_subchannel_recog(struct ccw_device *cdev, struct subchannel *sch)
926{
927 struct ccw_device_private *priv;
928
929 cdev->ccwlock = sch->lock;
930
931
932 priv = cdev->private;
933 priv->dev_id.devno = sch->schib.pmcw.dev;
934 priv->dev_id.ssid = sch->schid.ssid;
935 priv->schid = sch->schid;
936 priv->state = DEV_STATE_NOT_OPER;
937 INIT_LIST_HEAD(&priv->cmb_list);
938 init_waitqueue_head(&priv->wait_q);
939 init_timer(&priv->timer);
940
941
942 atomic_inc(&ccw_device_init_count);
943
944
945 spin_lock_irq(sch->lock);
946 sch_set_cdev(sch, cdev);
947 ccw_device_recognition(cdev);
948 spin_unlock_irq(sch->lock);
949}
950
951static int ccw_device_move_to_sch(struct ccw_device *cdev,
952 struct subchannel *sch)
953{
954 struct subchannel *old_sch;
955 int rc, old_enabled = 0;
956
957 old_sch = to_subchannel(cdev->dev.parent);
958
959 if (!get_device(&sch->dev))
960 return -ENODEV;
961
962 if (!sch_is_pseudo_sch(old_sch)) {
963 spin_lock_irq(old_sch->lock);
964 old_enabled = old_sch->schib.pmcw.ena;
965 rc = 0;
966 if (old_enabled)
967 rc = cio_disable_subchannel(old_sch);
968 spin_unlock_irq(old_sch->lock);
969 if (rc == -EBUSY) {
970
971 put_device(&sch->dev);
972 return rc;
973 }
974 }
975
976 mutex_lock(&sch->reg_mutex);
977 rc = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
978 mutex_unlock(&sch->reg_mutex);
979 if (rc) {
980 CIO_MSG_EVENT(0, "device_move(0.%x.%04x,0.%x.%04x)=%d\n",
981 cdev->private->dev_id.ssid,
982 cdev->private->dev_id.devno, sch->schid.ssid,
983 sch->schib.pmcw.dev, rc);
984 if (old_enabled) {
985
986 spin_lock_irq(old_sch->lock);
987 cio_enable_subchannel(old_sch, (u32)(addr_t)old_sch);
988 spin_unlock_irq(old_sch->lock);
989 }
990
991 put_device(&sch->dev);
992 return rc;
993 }
994
995 if (!sch_is_pseudo_sch(old_sch)) {
996 spin_lock_irq(old_sch->lock);
997 sch_set_cdev(old_sch, NULL);
998 spin_unlock_irq(old_sch->lock);
999 css_schedule_eval(old_sch->schid);
1000 }
1001
1002 put_device(&old_sch->dev);
1003
1004 spin_lock_irq(sch->lock);
1005 cdev->private->schid = sch->schid;
1006 cdev->ccwlock = sch->lock;
1007 if (!sch_is_pseudo_sch(sch))
1008 sch_set_cdev(sch, cdev);
1009 spin_unlock_irq(sch->lock);
1010 if (!sch_is_pseudo_sch(sch))
1011 css_update_ssd_info(sch);
1012 return 0;
1013}
1014
1015static int ccw_device_move_to_orph(struct ccw_device *cdev)
1016{
1017 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1018 struct channel_subsystem *css = to_css(sch->dev.parent);
1019
1020 return ccw_device_move_to_sch(cdev, css->pseudo_subchannel);
1021}
1022
1023static void io_subchannel_irq(struct subchannel *sch)
1024{
1025 struct ccw_device *cdev;
1026
1027 cdev = sch_get_cdev(sch);
1028
1029 CIO_TRACE_EVENT(6, "IRQ");
1030 CIO_TRACE_EVENT(6, dev_name(&sch->dev));
1031 if (cdev)
1032 dev_fsm_event(cdev, DEV_EVENT_INTERRUPT);
1033 else
1034 inc_irq_stat(IRQIO_CIO);
1035}
1036
1037void io_subchannel_init_config(struct subchannel *sch)
1038{
1039 memset(&sch->config, 0, sizeof(sch->config));
1040 sch->config.csense = 1;
1041}
1042
1043static void io_subchannel_init_fields(struct subchannel *sch)
1044{
1045 if (cio_is_console(sch->schid))
1046 sch->opm = 0xff;
1047 else
1048 sch->opm = chp_get_sch_opm(sch);
1049 sch->lpm = sch->schib.pmcw.pam & sch->opm;
1050 sch->isc = cio_is_console(sch->schid) ? CONSOLE_ISC : IO_SCH_ISC;
1051
1052 CIO_MSG_EVENT(6, "Detected device %04x on subchannel 0.%x.%04X"
1053 " - PIM = %02X, PAM = %02X, POM = %02X\n",
1054 sch->schib.pmcw.dev, sch->schid.ssid,
1055 sch->schid.sch_no, sch->schib.pmcw.pim,
1056 sch->schib.pmcw.pam, sch->schib.pmcw.pom);
1057
1058 io_subchannel_init_config(sch);
1059}
1060
1061
1062
1063
1064
1065static int io_subchannel_probe(struct subchannel *sch)
1066{
1067 struct io_subchannel_private *io_priv;
1068 struct ccw_device *cdev;
1069 int rc;
1070
1071 if (cio_is_console(sch->schid)) {
1072 rc = sysfs_create_group(&sch->dev.kobj,
1073 &io_subchannel_attr_group);
1074 if (rc)
1075 CIO_MSG_EVENT(0, "Failed to create io subchannel "
1076 "attributes for subchannel "
1077 "0.%x.%04x (rc=%d)\n",
1078 sch->schid.ssid, sch->schid.sch_no, rc);
1079
1080
1081
1082
1083
1084 dev_set_uevent_suppress(&sch->dev, 0);
1085 kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
1086 cdev = sch_get_cdev(sch);
1087 rc = ccw_device_register(cdev);
1088 if (rc) {
1089
1090 put_device(&cdev->dev);
1091 goto out_schedule;
1092 }
1093 if (atomic_dec_and_test(&ccw_device_init_count))
1094 wake_up(&ccw_device_init_wq);
1095 return 0;
1096 }
1097 io_subchannel_init_fields(sch);
1098 rc = cio_commit_config(sch);
1099 if (rc)
1100 goto out_schedule;
1101 rc = sysfs_create_group(&sch->dev.kobj,
1102 &io_subchannel_attr_group);
1103 if (rc)
1104 goto out_schedule;
1105
1106 io_priv = kzalloc(sizeof(*io_priv), GFP_KERNEL | GFP_DMA);
1107 if (!io_priv)
1108 goto out_schedule;
1109
1110 set_io_private(sch, io_priv);
1111 css_schedule_eval(sch->schid);
1112 return 0;
1113
1114out_schedule:
1115 spin_lock_irq(sch->lock);
1116 css_sched_sch_todo(sch, SCH_TODO_UNREG);
1117 spin_unlock_irq(sch->lock);
1118 return 0;
1119}
1120
1121static int
1122io_subchannel_remove (struct subchannel *sch)
1123{
1124 struct io_subchannel_private *io_priv = to_io_private(sch);
1125 struct ccw_device *cdev;
1126
1127 cdev = sch_get_cdev(sch);
1128 if (!cdev)
1129 goto out_free;
1130 io_subchannel_quiesce(sch);
1131
1132 spin_lock_irq(cdev->ccwlock);
1133 sch_set_cdev(sch, NULL);
1134 set_io_private(sch, NULL);
1135 cdev->private->state = DEV_STATE_NOT_OPER;
1136 spin_unlock_irq(cdev->ccwlock);
1137 ccw_device_unregister(cdev);
1138out_free:
1139 kfree(io_priv);
1140 sysfs_remove_group(&sch->dev.kobj, &io_subchannel_attr_group);
1141 return 0;
1142}
1143
1144static void io_subchannel_verify(struct subchannel *sch)
1145{
1146 struct ccw_device *cdev;
1147
1148 cdev = sch_get_cdev(sch);
1149 if (cdev)
1150 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
1151}
1152
1153static void io_subchannel_terminate_path(struct subchannel *sch, u8 mask)
1154{
1155 struct ccw_device *cdev;
1156
1157 cdev = sch_get_cdev(sch);
1158 if (!cdev)
1159 return;
1160 if (cio_update_schib(sch))
1161 goto err;
1162
1163 if (scsw_actl(&sch->schib.scsw) == 0 || sch->schib.pmcw.lpum != mask)
1164 goto out;
1165 if (cdev->private->state == DEV_STATE_ONLINE) {
1166 ccw_device_kill_io(cdev);
1167 goto out;
1168 }
1169 if (cio_clear(sch))
1170 goto err;
1171out:
1172
1173 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
1174 return;
1175
1176err:
1177 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
1178}
1179
1180static int io_subchannel_chp_event(struct subchannel *sch,
1181 struct chp_link *link, int event)
1182{
1183 struct ccw_device *cdev = sch_get_cdev(sch);
1184 int mask;
1185
1186 mask = chp_ssd_get_mask(&sch->ssd_info, link);
1187 if (!mask)
1188 return 0;
1189 switch (event) {
1190 case CHP_VARY_OFF:
1191 sch->opm &= ~mask;
1192 sch->lpm &= ~mask;
1193 if (cdev)
1194 cdev->private->path_gone_mask |= mask;
1195 io_subchannel_terminate_path(sch, mask);
1196 break;
1197 case CHP_VARY_ON:
1198 sch->opm |= mask;
1199 sch->lpm |= mask;
1200 if (cdev)
1201 cdev->private->path_new_mask |= mask;
1202 io_subchannel_verify(sch);
1203 break;
1204 case CHP_OFFLINE:
1205 if (cio_update_schib(sch))
1206 return -ENODEV;
1207 if (cdev)
1208 cdev->private->path_gone_mask |= mask;
1209 io_subchannel_terminate_path(sch, mask);
1210 break;
1211 case CHP_ONLINE:
1212 if (cio_update_schib(sch))
1213 return -ENODEV;
1214 sch->lpm |= mask & sch->opm;
1215 if (cdev)
1216 cdev->private->path_new_mask |= mask;
1217 io_subchannel_verify(sch);
1218 break;
1219 }
1220 return 0;
1221}
1222
1223static void io_subchannel_quiesce(struct subchannel *sch)
1224{
1225 struct ccw_device *cdev;
1226 int ret;
1227
1228 spin_lock_irq(sch->lock);
1229 cdev = sch_get_cdev(sch);
1230 if (cio_is_console(sch->schid))
1231 goto out_unlock;
1232 if (!sch->schib.pmcw.ena)
1233 goto out_unlock;
1234 ret = cio_disable_subchannel(sch);
1235 if (ret != -EBUSY)
1236 goto out_unlock;
1237 if (cdev->handler)
1238 cdev->handler(cdev, cdev->private->intparm, ERR_PTR(-EIO));
1239 while (ret == -EBUSY) {
1240 cdev->private->state = DEV_STATE_QUIESCE;
1241 cdev->private->iretry = 255;
1242 ret = ccw_device_cancel_halt_clear(cdev);
1243 if (ret == -EBUSY) {
1244 ccw_device_set_timeout(cdev, HZ/10);
1245 spin_unlock_irq(sch->lock);
1246 wait_event(cdev->private->wait_q,
1247 cdev->private->state != DEV_STATE_QUIESCE);
1248 spin_lock_irq(sch->lock);
1249 }
1250 ret = cio_disable_subchannel(sch);
1251 }
1252out_unlock:
1253 spin_unlock_irq(sch->lock);
1254}
1255
1256static void io_subchannel_shutdown(struct subchannel *sch)
1257{
1258 io_subchannel_quiesce(sch);
1259}
1260
1261static int device_is_disconnected(struct ccw_device *cdev)
1262{
1263 if (!cdev)
1264 return 0;
1265 return (cdev->private->state == DEV_STATE_DISCONNECTED ||
1266 cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID);
1267}
1268
1269static int recovery_check(struct device *dev, void *data)
1270{
1271 struct ccw_device *cdev = to_ccwdev(dev);
1272 int *redo = data;
1273
1274 spin_lock_irq(cdev->ccwlock);
1275 switch (cdev->private->state) {
1276 case DEV_STATE_DISCONNECTED:
1277 CIO_MSG_EVENT(3, "recovery: trigger 0.%x.%04x\n",
1278 cdev->private->dev_id.ssid,
1279 cdev->private->dev_id.devno);
1280 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
1281 *redo = 1;
1282 break;
1283 case DEV_STATE_DISCONNECTED_SENSE_ID:
1284 *redo = 1;
1285 break;
1286 }
1287 spin_unlock_irq(cdev->ccwlock);
1288
1289 return 0;
1290}
1291
1292static void recovery_work_func(struct work_struct *unused)
1293{
1294 int redo = 0;
1295
1296 bus_for_each_dev(&ccw_bus_type, NULL, &redo, recovery_check);
1297 if (redo) {
1298 spin_lock_irq(&recovery_lock);
1299 if (!timer_pending(&recovery_timer)) {
1300 if (recovery_phase < ARRAY_SIZE(recovery_delay) - 1)
1301 recovery_phase++;
1302 mod_timer(&recovery_timer, jiffies +
1303 recovery_delay[recovery_phase] * HZ);
1304 }
1305 spin_unlock_irq(&recovery_lock);
1306 } else
1307 CIO_MSG_EVENT(4, "recovery: end\n");
1308}
1309
1310static DECLARE_WORK(recovery_work, recovery_work_func);
1311
1312static void recovery_func(unsigned long data)
1313{
1314
1315
1316
1317
1318 schedule_work(&recovery_work);
1319}
1320
1321static void ccw_device_schedule_recovery(void)
1322{
1323 unsigned long flags;
1324
1325 CIO_MSG_EVENT(4, "recovery: schedule\n");
1326 spin_lock_irqsave(&recovery_lock, flags);
1327 if (!timer_pending(&recovery_timer) || (recovery_phase != 0)) {
1328 recovery_phase = 0;
1329 mod_timer(&recovery_timer, jiffies + recovery_delay[0] * HZ);
1330 }
1331 spin_unlock_irqrestore(&recovery_lock, flags);
1332}
1333
1334static int purge_fn(struct device *dev, void *data)
1335{
1336 struct ccw_device *cdev = to_ccwdev(dev);
1337 struct ccw_dev_id *id = &cdev->private->dev_id;
1338
1339 spin_lock_irq(cdev->ccwlock);
1340 if (is_blacklisted(id->ssid, id->devno) &&
1341 (cdev->private->state == DEV_STATE_OFFLINE) &&
1342 (atomic_cmpxchg(&cdev->private->onoff, 0, 1) == 0)) {
1343 CIO_MSG_EVENT(3, "ccw: purging 0.%x.%04x\n", id->ssid,
1344 id->devno);
1345 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
1346 atomic_set(&cdev->private->onoff, 0);
1347 }
1348 spin_unlock_irq(cdev->ccwlock);
1349
1350 if (signal_pending(current))
1351 return -EINTR;
1352
1353 return 0;
1354}
1355
1356
1357
1358
1359
1360
1361int ccw_purge_blacklisted(void)
1362{
1363 CIO_MSG_EVENT(2, "ccw: purging blacklisted devices\n");
1364 bus_for_each_dev(&ccw_bus_type, NULL, NULL, purge_fn);
1365 return 0;
1366}
1367
1368void ccw_device_set_disconnected(struct ccw_device *cdev)
1369{
1370 if (!cdev)
1371 return;
1372 ccw_device_set_timeout(cdev, 0);
1373 cdev->private->flags.fake_irb = 0;
1374 cdev->private->state = DEV_STATE_DISCONNECTED;
1375 if (cdev->online)
1376 ccw_device_schedule_recovery();
1377}
1378
1379void ccw_device_set_notoper(struct ccw_device *cdev)
1380{
1381 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1382
1383 CIO_TRACE_EVENT(2, "notoper");
1384 CIO_TRACE_EVENT(2, dev_name(&sch->dev));
1385 ccw_device_set_timeout(cdev, 0);
1386 cio_disable_subchannel(sch);
1387 cdev->private->state = DEV_STATE_NOT_OPER;
1388}
1389
1390enum io_sch_action {
1391 IO_SCH_UNREG,
1392 IO_SCH_ORPH_UNREG,
1393 IO_SCH_ATTACH,
1394 IO_SCH_UNREG_ATTACH,
1395 IO_SCH_ORPH_ATTACH,
1396 IO_SCH_REPROBE,
1397 IO_SCH_VERIFY,
1398 IO_SCH_DISC,
1399 IO_SCH_NOP,
1400};
1401
1402static enum io_sch_action sch_get_action(struct subchannel *sch)
1403{
1404 struct ccw_device *cdev;
1405
1406 cdev = sch_get_cdev(sch);
1407 if (cio_update_schib(sch)) {
1408
1409 if (!cdev)
1410 return IO_SCH_UNREG;
1411 if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
1412 return IO_SCH_UNREG;
1413 return IO_SCH_ORPH_UNREG;
1414 }
1415
1416 if (!cdev)
1417 return IO_SCH_ATTACH;
1418 if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
1419 if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
1420 return IO_SCH_UNREG_ATTACH;
1421 return IO_SCH_ORPH_ATTACH;
1422 }
1423 if ((sch->schib.pmcw.pam & sch->opm) == 0) {
1424 if (ccw_device_notify(cdev, CIO_NO_PATH) != NOTIFY_OK)
1425 return IO_SCH_UNREG;
1426 return IO_SCH_DISC;
1427 }
1428 if (device_is_disconnected(cdev))
1429 return IO_SCH_REPROBE;
1430 if (cdev->online && !cdev->private->flags.resuming)
1431 return IO_SCH_VERIFY;
1432 if (cdev->private->state == DEV_STATE_NOT_OPER)
1433 return IO_SCH_UNREG_ATTACH;
1434 return IO_SCH_NOP;
1435}
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447static int io_subchannel_sch_event(struct subchannel *sch, int process)
1448{
1449 unsigned long flags;
1450 struct ccw_device *cdev;
1451 struct ccw_dev_id dev_id;
1452 enum io_sch_action action;
1453 int rc = -EAGAIN;
1454
1455 spin_lock_irqsave(sch->lock, flags);
1456 if (!device_is_registered(&sch->dev))
1457 goto out_unlock;
1458 if (work_pending(&sch->todo_work))
1459 goto out_unlock;
1460 cdev = sch_get_cdev(sch);
1461 if (cdev && work_pending(&cdev->private->todo_work))
1462 goto out_unlock;
1463 action = sch_get_action(sch);
1464 CIO_MSG_EVENT(2, "event: sch 0.%x.%04x, process=%d, action=%d\n",
1465 sch->schid.ssid, sch->schid.sch_no, process,
1466 action);
1467
1468 switch (action) {
1469 case IO_SCH_REPROBE:
1470
1471 ccw_device_trigger_reprobe(cdev);
1472 rc = 0;
1473 goto out_unlock;
1474 case IO_SCH_VERIFY:
1475
1476 io_subchannel_verify(sch);
1477 rc = 0;
1478 goto out_unlock;
1479 case IO_SCH_DISC:
1480 ccw_device_set_disconnected(cdev);
1481 rc = 0;
1482 goto out_unlock;
1483 case IO_SCH_ORPH_UNREG:
1484 case IO_SCH_ORPH_ATTACH:
1485 ccw_device_set_disconnected(cdev);
1486 break;
1487 case IO_SCH_UNREG_ATTACH:
1488 case IO_SCH_UNREG:
1489 if (!cdev)
1490 break;
1491 if (cdev->private->state == DEV_STATE_SENSE_ID) {
1492
1493
1494
1495
1496
1497 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
1498 } else
1499 ccw_device_set_notoper(cdev);
1500 break;
1501 case IO_SCH_NOP:
1502 rc = 0;
1503 goto out_unlock;
1504 default:
1505 break;
1506 }
1507 spin_unlock_irqrestore(sch->lock, flags);
1508
1509 if (!process)
1510 goto out;
1511
1512 switch (action) {
1513 case IO_SCH_ORPH_UNREG:
1514 case IO_SCH_ORPH_ATTACH:
1515
1516 rc = ccw_device_move_to_orph(cdev);
1517 if (rc)
1518 goto out;
1519 break;
1520 case IO_SCH_UNREG_ATTACH:
1521 spin_lock_irqsave(sch->lock, flags);
1522 if (cdev->private->flags.resuming) {
1523
1524 rc = 0;
1525 goto out_unlock;
1526 }
1527 sch_set_cdev(sch, NULL);
1528 spin_unlock_irqrestore(sch->lock, flags);
1529
1530 ccw_device_unregister(cdev);
1531 break;
1532 default:
1533 break;
1534 }
1535
1536 switch (action) {
1537 case IO_SCH_ORPH_UNREG:
1538 case IO_SCH_UNREG:
1539 if (!cdev || !cdev->private->flags.resuming)
1540 css_sch_device_unregister(sch);
1541 break;
1542 case IO_SCH_ORPH_ATTACH:
1543 case IO_SCH_UNREG_ATTACH:
1544 case IO_SCH_ATTACH:
1545 dev_id.ssid = sch->schid.ssid;
1546 dev_id.devno = sch->schib.pmcw.dev;
1547 cdev = get_ccwdev_by_dev_id(&dev_id);
1548 if (!cdev) {
1549 sch_create_and_recog_new_device(sch);
1550 break;
1551 }
1552 rc = ccw_device_move_to_sch(cdev, sch);
1553 if (rc) {
1554
1555 put_device(&cdev->dev);
1556 goto out;
1557 }
1558 spin_lock_irqsave(sch->lock, flags);
1559 ccw_device_trigger_reprobe(cdev);
1560 spin_unlock_irqrestore(sch->lock, flags);
1561
1562 put_device(&cdev->dev);
1563 break;
1564 default:
1565 break;
1566 }
1567 return 0;
1568
1569out_unlock:
1570 spin_unlock_irqrestore(sch->lock, flags);
1571out:
1572 return rc;
1573}
1574
1575#ifdef CONFIG_CCW_CONSOLE
1576static int ccw_device_console_enable(struct ccw_device *cdev,
1577 struct subchannel *sch)
1578{
1579 int rc;
1580
1581 io_subchannel_init_fields(sch);
1582 rc = cio_commit_config(sch);
1583 if (rc)
1584 return rc;
1585 sch->driver = &io_subchannel_driver;
1586 sch_set_cdev(sch, cdev);
1587 io_subchannel_recog(cdev, sch);
1588
1589 spin_lock_irq(cdev->ccwlock);
1590 while (!dev_fsm_final_state(cdev))
1591 ccw_device_wait_idle(cdev);
1592
1593
1594 get_device(&cdev->dev);
1595 rc = ccw_device_online(cdev);
1596 if (rc)
1597 goto out_unlock;
1598
1599 while (!dev_fsm_final_state(cdev))
1600 ccw_device_wait_idle(cdev);
1601
1602 if (cdev->private->state == DEV_STATE_ONLINE)
1603 cdev->online = 1;
1604 else
1605 rc = -EIO;
1606out_unlock:
1607 spin_unlock_irq(cdev->ccwlock);
1608 if (rc)
1609 put_device(&cdev->dev);
1610 return rc;
1611}
1612
1613struct ccw_device *ccw_device_probe_console(void)
1614{
1615 struct io_subchannel_private *io_priv;
1616 struct ccw_device *cdev;
1617 struct subchannel *sch;
1618 int ret;
1619
1620 sch = cio_probe_console();
1621 if (IS_ERR(sch))
1622 return ERR_CAST(sch);
1623
1624 io_priv = kzalloc(sizeof(*io_priv), GFP_KERNEL | GFP_DMA);
1625 if (!io_priv) {
1626 put_device(&sch->dev);
1627 return ERR_PTR(-ENOMEM);
1628 }
1629 cdev = io_subchannel_create_ccwdev(sch);
1630 if (IS_ERR(cdev)) {
1631 put_device(&sch->dev);
1632 kfree(io_priv);
1633 return cdev;
1634 }
1635 set_io_private(sch, io_priv);
1636 ret = ccw_device_console_enable(cdev, sch);
1637 if (ret) {
1638 set_io_private(sch, NULL);
1639 put_device(&sch->dev);
1640 put_device(&cdev->dev);
1641 kfree(io_priv);
1642 return ERR_PTR(ret);
1643 }
1644 return cdev;
1645}
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655void ccw_device_wait_idle(struct ccw_device *cdev)
1656{
1657 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1658
1659 while (1) {
1660 cio_tsch(sch);
1661 if (sch->schib.scsw.cmd.actl == 0)
1662 break;
1663 udelay_simple(100);
1664 }
1665}
1666
1667static int ccw_device_pm_restore(struct device *dev);
1668
1669int ccw_device_force_console(struct ccw_device *cdev)
1670{
1671 return ccw_device_pm_restore(&cdev->dev);
1672}
1673EXPORT_SYMBOL_GPL(ccw_device_force_console);
1674#endif
1675
1676
1677
1678
1679static int
1680__ccwdev_check_busid(struct device *dev, void *id)
1681{
1682 char *bus_id;
1683
1684 bus_id = id;
1685
1686 return (strcmp(bus_id, dev_name(dev)) == 0);
1687}
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701struct ccw_device *get_ccwdev_by_busid(struct ccw_driver *cdrv,
1702 const char *bus_id)
1703{
1704 struct device *dev;
1705
1706 dev = driver_find_device(&cdrv->driver, NULL, (void *)bus_id,
1707 __ccwdev_check_busid);
1708
1709 return dev ? to_ccwdev(dev) : NULL;
1710}
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722static int
1723ccw_device_probe (struct device *dev)
1724{
1725 struct ccw_device *cdev = to_ccwdev(dev);
1726 struct ccw_driver *cdrv = to_ccwdrv(dev->driver);
1727 int ret;
1728
1729 cdev->drv = cdrv;
1730
1731
1732 if (cdrv->int_class != 0)
1733 cdev->private->int_class = cdrv->int_class;
1734 else
1735 cdev->private->int_class = IRQIO_CIO;
1736
1737 ret = cdrv->probe ? cdrv->probe(cdev) : -ENODEV;
1738
1739 if (ret) {
1740 cdev->drv = NULL;
1741 cdev->private->int_class = IRQIO_CIO;
1742 return ret;
1743 }
1744
1745 return 0;
1746}
1747
1748static int
1749ccw_device_remove (struct device *dev)
1750{
1751 struct ccw_device *cdev = to_ccwdev(dev);
1752 struct ccw_driver *cdrv = cdev->drv;
1753 int ret;
1754
1755 if (cdrv->remove)
1756 cdrv->remove(cdev);
1757 if (cdev->online) {
1758 cdev->online = 0;
1759 spin_lock_irq(cdev->ccwlock);
1760 ret = ccw_device_offline(cdev);
1761 spin_unlock_irq(cdev->ccwlock);
1762 if (ret == 0)
1763 wait_event(cdev->private->wait_q,
1764 dev_fsm_final_state(cdev));
1765 else
1766 CIO_MSG_EVENT(0, "ccw_device_offline returned %d, "
1767 "device 0.%x.%04x\n",
1768 ret, cdev->private->dev_id.ssid,
1769 cdev->private->dev_id.devno);
1770
1771 put_device(&cdev->dev);
1772 }
1773 ccw_device_set_timeout(cdev, 0);
1774 cdev->drv = NULL;
1775 cdev->private->int_class = IRQIO_CIO;
1776 return 0;
1777}
1778
1779static void ccw_device_shutdown(struct device *dev)
1780{
1781 struct ccw_device *cdev;
1782
1783 cdev = to_ccwdev(dev);
1784 if (cdev->drv && cdev->drv->shutdown)
1785 cdev->drv->shutdown(cdev);
1786 disable_cmf(cdev);
1787}
1788
1789static int ccw_device_pm_prepare(struct device *dev)
1790{
1791 struct ccw_device *cdev = to_ccwdev(dev);
1792
1793 if (work_pending(&cdev->private->todo_work))
1794 return -EAGAIN;
1795
1796 if (atomic_read(&cdev->private->onoff))
1797 return -EAGAIN;
1798
1799 if (cdev->online && cdev->drv && cdev->drv->prepare)
1800 return cdev->drv->prepare(cdev);
1801
1802 return 0;
1803}
1804
1805static void ccw_device_pm_complete(struct device *dev)
1806{
1807 struct ccw_device *cdev = to_ccwdev(dev);
1808
1809 if (cdev->online && cdev->drv && cdev->drv->complete)
1810 cdev->drv->complete(cdev);
1811}
1812
1813static int ccw_device_pm_freeze(struct device *dev)
1814{
1815 struct ccw_device *cdev = to_ccwdev(dev);
1816 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1817 int ret, cm_enabled;
1818
1819
1820 if (!dev_fsm_final_state(cdev))
1821 return -EAGAIN;
1822 if (!cdev->online)
1823 return 0;
1824 if (cdev->drv && cdev->drv->freeze) {
1825 ret = cdev->drv->freeze(cdev);
1826 if (ret)
1827 return ret;
1828 }
1829
1830 spin_lock_irq(sch->lock);
1831 cm_enabled = cdev->private->cmb != NULL;
1832 spin_unlock_irq(sch->lock);
1833 if (cm_enabled) {
1834
1835 ret = ccw_set_cmf(cdev, 0);
1836 if (ret)
1837 return ret;
1838 }
1839
1840 spin_lock_irq(sch->lock);
1841 ret = cio_disable_subchannel(sch);
1842 spin_unlock_irq(sch->lock);
1843
1844 return ret;
1845}
1846
1847static int ccw_device_pm_thaw(struct device *dev)
1848{
1849 struct ccw_device *cdev = to_ccwdev(dev);
1850 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1851 int ret, cm_enabled;
1852
1853 if (!cdev->online)
1854 return 0;
1855
1856 spin_lock_irq(sch->lock);
1857
1858 ret = cio_enable_subchannel(sch, (u32)(addr_t)sch);
1859 cm_enabled = cdev->private->cmb != NULL;
1860 spin_unlock_irq(sch->lock);
1861 if (ret)
1862 return ret;
1863
1864 if (cm_enabled) {
1865 ret = ccw_set_cmf(cdev, 1);
1866 if (ret)
1867 return ret;
1868 }
1869
1870 if (cdev->drv && cdev->drv->thaw)
1871 ret = cdev->drv->thaw(cdev);
1872
1873 return ret;
1874}
1875
1876static void __ccw_device_pm_restore(struct ccw_device *cdev)
1877{
1878 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1879
1880 spin_lock_irq(sch->lock);
1881 if (cio_is_console(sch->schid)) {
1882 cio_enable_subchannel(sch, (u32)(addr_t)sch);
1883 goto out_unlock;
1884 }
1885
1886
1887
1888
1889 cdev->private->flags.resuming = 1;
1890 cdev->private->path_new_mask = LPM_ANYPATH;
1891 css_sched_sch_todo(sch, SCH_TODO_EVAL);
1892 spin_unlock_irq(sch->lock);
1893 css_wait_for_slow_path();
1894
1895
1896 sch = to_subchannel(cdev->dev.parent);
1897 spin_lock_irq(sch->lock);
1898 if (cdev->private->state != DEV_STATE_ONLINE &&
1899 cdev->private->state != DEV_STATE_OFFLINE)
1900 goto out_unlock;
1901
1902 ccw_device_recognition(cdev);
1903 spin_unlock_irq(sch->lock);
1904 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev) ||
1905 cdev->private->state == DEV_STATE_DISCONNECTED);
1906 spin_lock_irq(sch->lock);
1907
1908out_unlock:
1909 cdev->private->flags.resuming = 0;
1910 spin_unlock_irq(sch->lock);
1911}
1912
1913static int resume_handle_boxed(struct ccw_device *cdev)
1914{
1915 cdev->private->state = DEV_STATE_BOXED;
1916 if (ccw_device_notify(cdev, CIO_BOXED) == NOTIFY_OK)
1917 return 0;
1918 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
1919 return -ENODEV;
1920}
1921
1922static int resume_handle_disc(struct ccw_device *cdev)
1923{
1924 cdev->private->state = DEV_STATE_DISCONNECTED;
1925 if (ccw_device_notify(cdev, CIO_GONE) == NOTIFY_OK)
1926 return 0;
1927 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
1928 return -ENODEV;
1929}
1930
1931static int ccw_device_pm_restore(struct device *dev)
1932{
1933 struct ccw_device *cdev = to_ccwdev(dev);
1934 struct subchannel *sch;
1935 int ret = 0;
1936
1937 __ccw_device_pm_restore(cdev);
1938 sch = to_subchannel(cdev->dev.parent);
1939 spin_lock_irq(sch->lock);
1940 if (cio_is_console(sch->schid))
1941 goto out_restore;
1942
1943
1944 switch (cdev->private->state) {
1945 case DEV_STATE_OFFLINE:
1946 case DEV_STATE_ONLINE:
1947 cdev->private->flags.donotify = 0;
1948 break;
1949 case DEV_STATE_BOXED:
1950 ret = resume_handle_boxed(cdev);
1951 if (ret)
1952 goto out_unlock;
1953 goto out_restore;
1954 default:
1955 ret = resume_handle_disc(cdev);
1956 if (ret)
1957 goto out_unlock;
1958 goto out_restore;
1959 }
1960
1961 if (!ccw_device_test_sense_data(cdev)) {
1962 ccw_device_update_sense_data(cdev);
1963 ccw_device_sched_todo(cdev, CDEV_TODO_REBIND);
1964 ret = -ENODEV;
1965 goto out_unlock;
1966 }
1967 if (!cdev->online)
1968 goto out_unlock;
1969
1970 if (ccw_device_online(cdev)) {
1971 ret = resume_handle_disc(cdev);
1972 if (ret)
1973 goto out_unlock;
1974 goto out_restore;
1975 }
1976 spin_unlock_irq(sch->lock);
1977 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));
1978 spin_lock_irq(sch->lock);
1979
1980 if (ccw_device_notify(cdev, CIO_OPER) == NOTIFY_BAD) {
1981 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
1982 ret = -ENODEV;
1983 goto out_unlock;
1984 }
1985
1986
1987 if (cdev->private->cmb) {
1988 spin_unlock_irq(sch->lock);
1989 ret = ccw_set_cmf(cdev, 1);
1990 spin_lock_irq(sch->lock);
1991 if (ret) {
1992 CIO_MSG_EVENT(2, "resume: cdev 0.%x.%04x: cmf failed "
1993 "(rc=%d)\n", cdev->private->dev_id.ssid,
1994 cdev->private->dev_id.devno, ret);
1995 ret = 0;
1996 }
1997 }
1998
1999out_restore:
2000 spin_unlock_irq(sch->lock);
2001 if (cdev->online && cdev->drv && cdev->drv->restore)
2002 ret = cdev->drv->restore(cdev);
2003 return ret;
2004
2005out_unlock:
2006 spin_unlock_irq(sch->lock);
2007 return ret;
2008}
2009
2010static const struct dev_pm_ops ccw_pm_ops = {
2011 .prepare = ccw_device_pm_prepare,
2012 .complete = ccw_device_pm_complete,
2013 .freeze = ccw_device_pm_freeze,
2014 .thaw = ccw_device_pm_thaw,
2015 .restore = ccw_device_pm_restore,
2016};
2017
2018static struct bus_type ccw_bus_type = {
2019 .name = "ccw",
2020 .match = ccw_bus_match,
2021 .uevent = ccw_uevent,
2022 .probe = ccw_device_probe,
2023 .remove = ccw_device_remove,
2024 .shutdown = ccw_device_shutdown,
2025 .pm = &ccw_pm_ops,
2026};
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036int ccw_driver_register(struct ccw_driver *cdriver)
2037{
2038 struct device_driver *drv = &cdriver->driver;
2039
2040 drv->bus = &ccw_bus_type;
2041
2042 return driver_register(drv);
2043}
2044
2045
2046
2047
2048
2049
2050
2051void ccw_driver_unregister(struct ccw_driver *cdriver)
2052{
2053 driver_unregister(&cdriver->driver);
2054}
2055
2056static void ccw_device_todo(struct work_struct *work)
2057{
2058 struct ccw_device_private *priv;
2059 struct ccw_device *cdev;
2060 struct subchannel *sch;
2061 enum cdev_todo todo;
2062
2063 priv = container_of(work, struct ccw_device_private, todo_work);
2064 cdev = priv->cdev;
2065 sch = to_subchannel(cdev->dev.parent);
2066
2067 spin_lock_irq(cdev->ccwlock);
2068 todo = priv->todo;
2069 priv->todo = CDEV_TODO_NOTHING;
2070 CIO_MSG_EVENT(4, "cdev_todo: cdev=0.%x.%04x todo=%d\n",
2071 priv->dev_id.ssid, priv->dev_id.devno, todo);
2072 spin_unlock_irq(cdev->ccwlock);
2073
2074 switch (todo) {
2075 case CDEV_TODO_ENABLE_CMF:
2076 cmf_reenable(cdev);
2077 break;
2078 case CDEV_TODO_REBIND:
2079 ccw_device_do_unbind_bind(cdev);
2080 break;
2081 case CDEV_TODO_REGISTER:
2082 io_subchannel_register(cdev);
2083 break;
2084 case CDEV_TODO_UNREG_EVAL:
2085 if (!sch_is_pseudo_sch(sch))
2086 css_schedule_eval(sch->schid);
2087
2088 case CDEV_TODO_UNREG:
2089 if (sch_is_pseudo_sch(sch))
2090 ccw_device_unregister(cdev);
2091 else
2092 ccw_device_call_sch_unregister(cdev);
2093 break;
2094 default:
2095 break;
2096 }
2097
2098 put_device(&cdev->dev);
2099}
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110void ccw_device_sched_todo(struct ccw_device *cdev, enum cdev_todo todo)
2111{
2112 CIO_MSG_EVENT(4, "cdev_todo: sched cdev=0.%x.%04x todo=%d\n",
2113 cdev->private->dev_id.ssid, cdev->private->dev_id.devno,
2114 todo);
2115 if (cdev->private->todo >= todo)
2116 return;
2117 cdev->private->todo = todo;
2118
2119 if (!get_device(&cdev->dev))
2120 return;
2121 if (!queue_work(cio_work_q, &cdev->private->todo_work)) {
2122
2123 put_device(&cdev->dev);
2124 }
2125}
2126
2127
2128
2129
2130
2131
2132
2133
2134int ccw_device_siosl(struct ccw_device *cdev)
2135{
2136 struct subchannel *sch = to_subchannel(cdev->dev.parent);
2137
2138 return chsc_siosl(sch->schid);
2139}
2140EXPORT_SYMBOL_GPL(ccw_device_siosl);
2141
2142MODULE_LICENSE("GPL");
2143EXPORT_SYMBOL(ccw_device_set_online);
2144EXPORT_SYMBOL(ccw_device_set_offline);
2145EXPORT_SYMBOL(ccw_driver_register);
2146EXPORT_SYMBOL(ccw_driver_unregister);
2147EXPORT_SYMBOL(get_ccwdev_by_busid);
2148