1 // SPDX-License-Identifier: GPL-1.0+
3 * bus driver for ccw devices
5 * Copyright IBM Corp. 2002, 2008
6 * Author(s): Arnd Bergmann (arndb@de.ibm.com)
7 * Cornelia Huck (cornelia.huck@de.ibm.com)
8 * Martin Schwidefsky (schwidefsky@de.ibm.com)
11 #define KMSG_COMPONENT "cio"
12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
14 #include <linux/export.h>
15 #include <linux/init.h>
16 #include <linux/spinlock.h>
17 #include <linux/errno.h>
18 #include <linux/err.h>
19 #include <linux/slab.h>
20 #include <linux/list.h>
21 #include <linux/device.h>
22 #include <linux/workqueue.h>
23 #include <linux/delay.h>
24 #include <linux/timer.h>
25 #include <linux/kernel_stat.h>
26 #include <linux/sched/signal.h>
27 #include <linux/dma-mapping.h>
29 #include <asm/ccwdev.h>
31 #include <asm/param.h> /* HZ */
37 #include "cio_debug.h"
42 #include "blacklist.h"
45 static struct timer_list recovery_timer
;
46 static DEFINE_SPINLOCK(recovery_lock
);
47 static int recovery_phase
;
48 static const unsigned long recovery_delay
[] = { 3, 30, 300 };
50 static atomic_t ccw_device_init_count
= ATOMIC_INIT(0);
51 static DECLARE_WAIT_QUEUE_HEAD(ccw_device_init_wq
);
52 static struct bus_type ccw_bus_type
;
54 /******************* bus type handling ***********************/
56 /* The Linux driver model distinguishes between a bus type and
57 * the bus itself. Of course we only have one channel
58 * subsystem driver and one channel system per machine, but
59 * we still use the abstraction. T.R. says it's a good idea. */
61 ccw_bus_match (struct device
* dev
, struct device_driver
* drv
)
63 struct ccw_device
*cdev
= to_ccwdev(dev
);
64 struct ccw_driver
*cdrv
= to_ccwdrv(drv
);
65 const struct ccw_device_id
*ids
= cdrv
->ids
, *found
;
70 found
= ccw_device_id_match(ids
, &cdev
->id
);
74 cdev
->id
.driver_info
= found
->driver_info
;
79 /* Store modalias string delimited by prefix/suffix string into buffer with
80 * specified size. Return length of resulting string (excluding trailing '\0')
81 * even if string doesn't fit buffer (snprintf semantics). */
82 static int snprint_alias(char *buf
, size_t size
,
83 struct ccw_device_id
*id
, const char *suffix
)
87 len
= snprintf(buf
, size
, "ccw:t%04Xm%02X", id
->cu_type
, id
->cu_model
);
93 if (id
->dev_type
!= 0)
94 len
+= snprintf(buf
, size
, "dt%04Xdm%02X%s", id
->dev_type
,
95 id
->dev_model
, suffix
);
97 len
+= snprintf(buf
, size
, "dtdm%s", suffix
);
102 /* Set up environment variables for ccw device uevent. Return 0 on success,
103 * non-zero otherwise. */
104 static int ccw_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
106 struct ccw_device
*cdev
= to_ccwdev(dev
);
107 struct ccw_device_id
*id
= &(cdev
->id
);
109 char modalias_buf
[30];
112 ret
= add_uevent_var(env
, "CU_TYPE=%04X", id
->cu_type
);
117 ret
= add_uevent_var(env
, "CU_MODEL=%02X", id
->cu_model
);
121 /* The next two can be zero, that's ok for us */
123 ret
= add_uevent_var(env
, "DEV_TYPE=%04X", id
->dev_type
);
128 ret
= add_uevent_var(env
, "DEV_MODEL=%02X", id
->dev_model
);
133 snprint_alias(modalias_buf
, sizeof(modalias_buf
), id
, "");
134 ret
= add_uevent_var(env
, "MODALIAS=%s", modalias_buf
);
138 static void io_subchannel_irq(struct subchannel
*);
139 static int io_subchannel_probe(struct subchannel
*);
140 static void io_subchannel_remove(struct subchannel
*);
141 static void io_subchannel_shutdown(struct subchannel
*);
142 static int io_subchannel_sch_event(struct subchannel
*, int);
143 static int io_subchannel_chp_event(struct subchannel
*, struct chp_link
*,
145 static void recovery_func(struct timer_list
*unused
);
147 static struct css_device_id io_subchannel_ids
[] = {
148 { .match_flags
= 0x1, .type
= SUBCHANNEL_TYPE_IO
, },
149 { /* end of list */ },
152 static int io_subchannel_settle(void)
156 ret
= wait_event_interruptible(ccw_device_init_wq
,
157 atomic_read(&ccw_device_init_count
) == 0);
160 flush_workqueue(cio_work_q
);
164 static struct css_driver io_subchannel_driver
= {
166 .owner
= THIS_MODULE
,
167 .name
= "io_subchannel",
169 .subchannel_type
= io_subchannel_ids
,
170 .irq
= io_subchannel_irq
,
171 .sch_event
= io_subchannel_sch_event
,
172 .chp_event
= io_subchannel_chp_event
,
173 .probe
= io_subchannel_probe
,
174 .remove
= io_subchannel_remove
,
175 .shutdown
= io_subchannel_shutdown
,
176 .settle
= io_subchannel_settle
,
179 int __init
io_subchannel_init(void)
183 timer_setup(&recovery_timer
, recovery_func
, 0);
184 ret
= bus_register(&ccw_bus_type
);
187 ret
= css_driver_register(&io_subchannel_driver
);
189 bus_unregister(&ccw_bus_type
);
195 /************************ device handling **************************/
198 devtype_show (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
200 struct ccw_device
*cdev
= to_ccwdev(dev
);
201 struct ccw_device_id
*id
= &(cdev
->id
);
203 if (id
->dev_type
!= 0)
204 return sprintf(buf
, "%04x/%02x\n",
205 id
->dev_type
, id
->dev_model
);
207 return sprintf(buf
, "n/a\n");
211 cutype_show (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
213 struct ccw_device
*cdev
= to_ccwdev(dev
);
214 struct ccw_device_id
*id
= &(cdev
->id
);
216 return sprintf(buf
, "%04x/%02x\n",
217 id
->cu_type
, id
->cu_model
);
221 modalias_show (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
223 struct ccw_device
*cdev
= to_ccwdev(dev
);
224 struct ccw_device_id
*id
= &(cdev
->id
);
227 len
= snprint_alias(buf
, PAGE_SIZE
, id
, "\n");
229 return len
> PAGE_SIZE
? PAGE_SIZE
: len
;
233 online_show (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
235 struct ccw_device
*cdev
= to_ccwdev(dev
);
237 return sprintf(buf
, cdev
->online
? "1\n" : "0\n");
240 int ccw_device_is_orphan(struct ccw_device
*cdev
)
242 return sch_is_pseudo_sch(to_subchannel(cdev
->dev
.parent
));
245 static void ccw_device_unregister(struct ccw_device
*cdev
)
247 if (device_is_registered(&cdev
->dev
)) {
248 /* Undo device_add(). */
249 device_del(&cdev
->dev
);
251 if (cdev
->private->flags
.initialized
) {
252 cdev
->private->flags
.initialized
= 0;
253 /* Release reference from device_initialize(). */
254 put_device(&cdev
->dev
);
258 static void io_subchannel_quiesce(struct subchannel
*);
261 * ccw_device_set_offline() - disable a ccw device for I/O
262 * @cdev: target ccw device
264 * This function calls the driver's set_offline() function for @cdev, if
265 * given, and then disables @cdev.
267 * %0 on success and a negative error value on failure.
269 * enabled, ccw device lock not held
271 int ccw_device_set_offline(struct ccw_device
*cdev
)
273 struct subchannel
*sch
;
278 if (!cdev
->online
|| !cdev
->drv
)
281 if (cdev
->drv
->set_offline
) {
282 ret
= cdev
->drv
->set_offline(cdev
);
286 spin_lock_irq(cdev
->ccwlock
);
287 sch
= to_subchannel(cdev
->dev
.parent
);
289 /* Wait until a final state or DISCONNECTED is reached */
290 while (!dev_fsm_final_state(cdev
) &&
291 cdev
->private->state
!= DEV_STATE_DISCONNECTED
) {
292 spin_unlock_irq(cdev
->ccwlock
);
293 wait_event(cdev
->private->wait_q
, (dev_fsm_final_state(cdev
) ||
294 cdev
->private->state
== DEV_STATE_DISCONNECTED
));
295 spin_lock_irq(cdev
->ccwlock
);
298 ret
= ccw_device_offline(cdev
);
301 CIO_MSG_EVENT(0, "ccw_device_offline returned %d, device "
302 "0.%x.%04x\n", ret
, cdev
->private->dev_id
.ssid
,
303 cdev
->private->dev_id
.devno
);
306 state
= cdev
->private->state
;
307 spin_unlock_irq(cdev
->ccwlock
);
308 io_subchannel_quiesce(sch
);
309 spin_lock_irq(cdev
->ccwlock
);
310 cdev
->private->state
= state
;
311 } while (ret
== -EBUSY
);
312 spin_unlock_irq(cdev
->ccwlock
);
313 wait_event(cdev
->private->wait_q
, (dev_fsm_final_state(cdev
) ||
314 cdev
->private->state
== DEV_STATE_DISCONNECTED
));
315 /* Inform the user if set offline failed. */
316 if (cdev
->private->state
== DEV_STATE_BOXED
) {
317 pr_warn("%s: The device entered boxed state while being set offline\n",
318 dev_name(&cdev
->dev
));
319 } else if (cdev
->private->state
== DEV_STATE_NOT_OPER
) {
320 pr_warn("%s: The device stopped operating while being set offline\n",
321 dev_name(&cdev
->dev
));
323 /* Give up reference from ccw_device_set_online(). */
324 put_device(&cdev
->dev
);
328 cdev
->private->state
= DEV_STATE_OFFLINE
;
329 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
330 spin_unlock_irq(cdev
->ccwlock
);
331 /* Give up reference from ccw_device_set_online(). */
332 put_device(&cdev
->dev
);
337 * ccw_device_set_online() - enable a ccw device for I/O
338 * @cdev: target ccw device
340 * This function first enables @cdev and then calls the driver's set_online()
341 * function for @cdev, if given. If set_online() returns an error, @cdev is
344 * %0 on success and a negative error value on failure.
346 * enabled, ccw device lock not held
348 int ccw_device_set_online(struct ccw_device
*cdev
)
355 if (cdev
->online
|| !cdev
->drv
)
357 /* Hold on to an extra reference while device is online. */
358 if (!get_device(&cdev
->dev
))
361 spin_lock_irq(cdev
->ccwlock
);
362 ret
= ccw_device_online(cdev
);
363 spin_unlock_irq(cdev
->ccwlock
);
365 wait_event(cdev
->private->wait_q
, dev_fsm_final_state(cdev
));
367 CIO_MSG_EVENT(0, "ccw_device_online returned %d, "
368 "device 0.%x.%04x\n",
369 ret
, cdev
->private->dev_id
.ssid
,
370 cdev
->private->dev_id
.devno
);
371 /* Give up online reference since onlining failed. */
372 put_device(&cdev
->dev
);
375 spin_lock_irq(cdev
->ccwlock
);
376 /* Check if online processing was successful */
377 if ((cdev
->private->state
!= DEV_STATE_ONLINE
) &&
378 (cdev
->private->state
!= DEV_STATE_W4SENSE
)) {
379 spin_unlock_irq(cdev
->ccwlock
);
380 /* Inform the user that set online failed. */
381 if (cdev
->private->state
== DEV_STATE_BOXED
) {
382 pr_warn("%s: Setting the device online failed because it is boxed\n",
383 dev_name(&cdev
->dev
));
384 } else if (cdev
->private->state
== DEV_STATE_NOT_OPER
) {
385 pr_warn("%s: Setting the device online failed because it is not operational\n",
386 dev_name(&cdev
->dev
));
388 /* Give up online reference since onlining failed. */
389 put_device(&cdev
->dev
);
392 spin_unlock_irq(cdev
->ccwlock
);
393 if (cdev
->drv
->set_online
)
394 ret
= cdev
->drv
->set_online(cdev
);
398 spin_lock_irq(cdev
->ccwlock
);
400 spin_unlock_irq(cdev
->ccwlock
);
404 spin_lock_irq(cdev
->ccwlock
);
405 /* Wait until a final state or DISCONNECTED is reached */
406 while (!dev_fsm_final_state(cdev
) &&
407 cdev
->private->state
!= DEV_STATE_DISCONNECTED
) {
408 spin_unlock_irq(cdev
->ccwlock
);
409 wait_event(cdev
->private->wait_q
, (dev_fsm_final_state(cdev
) ||
410 cdev
->private->state
== DEV_STATE_DISCONNECTED
));
411 spin_lock_irq(cdev
->ccwlock
);
413 ret2
= ccw_device_offline(cdev
);
416 spin_unlock_irq(cdev
->ccwlock
);
417 wait_event(cdev
->private->wait_q
, (dev_fsm_final_state(cdev
) ||
418 cdev
->private->state
== DEV_STATE_DISCONNECTED
));
419 /* Give up online reference since onlining failed. */
420 put_device(&cdev
->dev
);
424 CIO_MSG_EVENT(0, "rollback ccw_device_offline returned %d, "
425 "device 0.%x.%04x\n",
426 ret2
, cdev
->private->dev_id
.ssid
,
427 cdev
->private->dev_id
.devno
);
428 cdev
->private->state
= DEV_STATE_OFFLINE
;
429 spin_unlock_irq(cdev
->ccwlock
);
430 /* Give up online reference since onlining failed. */
431 put_device(&cdev
->dev
);
435 static int online_store_handle_offline(struct ccw_device
*cdev
)
437 if (cdev
->private->state
== DEV_STATE_DISCONNECTED
) {
438 spin_lock_irq(cdev
->ccwlock
);
439 ccw_device_sched_todo(cdev
, CDEV_TODO_UNREG_EVAL
);
440 spin_unlock_irq(cdev
->ccwlock
);
443 if (cdev
->drv
&& cdev
->drv
->set_offline
)
444 return ccw_device_set_offline(cdev
);
448 static int online_store_recog_and_online(struct ccw_device
*cdev
)
450 /* Do device recognition, if needed. */
451 if (cdev
->private->state
== DEV_STATE_BOXED
) {
452 spin_lock_irq(cdev
->ccwlock
);
453 ccw_device_recognition(cdev
);
454 spin_unlock_irq(cdev
->ccwlock
);
455 wait_event(cdev
->private->wait_q
,
456 cdev
->private->flags
.recog_done
);
457 if (cdev
->private->state
!= DEV_STATE_OFFLINE
)
458 /* recognition failed */
461 if (cdev
->drv
&& cdev
->drv
->set_online
)
462 return ccw_device_set_online(cdev
);
466 static int online_store_handle_online(struct ccw_device
*cdev
, int force
)
470 ret
= online_store_recog_and_online(cdev
);
473 if (force
&& cdev
->private->state
== DEV_STATE_BOXED
) {
474 ret
= ccw_device_stlck(cdev
);
477 if (cdev
->id
.cu_type
== 0)
478 cdev
->private->state
= DEV_STATE_NOT_OPER
;
479 ret
= online_store_recog_and_online(cdev
);
486 static ssize_t
online_store (struct device
*dev
, struct device_attribute
*attr
,
487 const char *buf
, size_t count
)
489 struct ccw_device
*cdev
= to_ccwdev(dev
);
493 /* Prevent conflict between multiple on-/offline processing requests. */
494 if (atomic_cmpxchg(&cdev
->private->onoff
, 0, 1) != 0)
496 /* Prevent conflict between internal I/Os and on-/offline processing. */
497 if (!dev_fsm_final_state(cdev
) &&
498 cdev
->private->state
!= DEV_STATE_DISCONNECTED
) {
502 /* Prevent conflict between pending work and on-/offline processing.*/
503 if (work_pending(&cdev
->private->todo_work
)) {
507 if (!strncmp(buf
, "force\n", count
)) {
513 ret
= kstrtoul(buf
, 16, &i
);
521 ret
= online_store_handle_offline(cdev
);
524 ret
= online_store_handle_online(cdev
, force
);
532 atomic_set(&cdev
->private->onoff
, 0);
533 return (ret
< 0) ? ret
: count
;
537 available_show (struct device
*dev
, struct device_attribute
*attr
, char *buf
)
539 struct ccw_device
*cdev
= to_ccwdev(dev
);
540 struct subchannel
*sch
;
542 if (ccw_device_is_orphan(cdev
))
543 return sprintf(buf
, "no device\n");
544 switch (cdev
->private->state
) {
545 case DEV_STATE_BOXED
:
546 return sprintf(buf
, "boxed\n");
547 case DEV_STATE_DISCONNECTED
:
548 case DEV_STATE_DISCONNECTED_SENSE_ID
:
549 case DEV_STATE_NOT_OPER
:
550 sch
= to_subchannel(dev
->parent
);
552 return sprintf(buf
, "no path\n");
554 return sprintf(buf
, "no device\n");
556 /* All other states considered fine. */
557 return sprintf(buf
, "good\n");
562 initiate_logging(struct device
*dev
, struct device_attribute
*attr
,
563 const char *buf
, size_t count
)
565 struct subchannel
*sch
= to_subchannel(dev
);
568 rc
= chsc_siosl(sch
->schid
);
570 pr_warn("Logging for subchannel 0.%x.%04x failed with errno=%d\n",
571 sch
->schid
.ssid
, sch
->schid
.sch_no
, rc
);
574 pr_notice("Logging for subchannel 0.%x.%04x was triggered\n",
575 sch
->schid
.ssid
, sch
->schid
.sch_no
);
579 static ssize_t
vpm_show(struct device
*dev
, struct device_attribute
*attr
,
582 struct subchannel
*sch
= to_subchannel(dev
);
584 return sprintf(buf
, "%02x\n", sch
->vpm
);
587 static DEVICE_ATTR_RO(devtype
);
588 static DEVICE_ATTR_RO(cutype
);
589 static DEVICE_ATTR_RO(modalias
);
590 static DEVICE_ATTR_RW(online
);
591 static DEVICE_ATTR(availability
, 0444, available_show
, NULL
);
592 static DEVICE_ATTR(logging
, 0200, NULL
, initiate_logging
);
593 static DEVICE_ATTR_RO(vpm
);
595 static struct attribute
*io_subchannel_attrs
[] = {
596 &dev_attr_logging
.attr
,
601 static const struct attribute_group io_subchannel_attr_group
= {
602 .attrs
= io_subchannel_attrs
,
605 static struct attribute
* ccwdev_attrs
[] = {
606 &dev_attr_devtype
.attr
,
607 &dev_attr_cutype
.attr
,
608 &dev_attr_modalias
.attr
,
609 &dev_attr_online
.attr
,
610 &dev_attr_cmb_enable
.attr
,
611 &dev_attr_availability
.attr
,
615 static const struct attribute_group ccwdev_attr_group
= {
616 .attrs
= ccwdev_attrs
,
619 static const struct attribute_group
*ccwdev_attr_groups
[] = {
624 static int match_dev_id(struct device
*dev
, const void *data
)
626 struct ccw_device
*cdev
= to_ccwdev(dev
);
627 struct ccw_dev_id
*dev_id
= (void *)data
;
629 return ccw_dev_id_is_equal(&cdev
->private->dev_id
, dev_id
);
633 * get_ccwdev_by_dev_id() - obtain device from a ccw device id
634 * @dev_id: id of the device to be searched
636 * This function searches all devices attached to the ccw bus for a device
639 * If a device is found its reference count is increased and returned;
640 * else %NULL is returned.
642 struct ccw_device
*get_ccwdev_by_dev_id(struct ccw_dev_id
*dev_id
)
646 dev
= bus_find_device(&ccw_bus_type
, NULL
, dev_id
, match_dev_id
);
648 return dev
? to_ccwdev(dev
) : NULL
;
650 EXPORT_SYMBOL_GPL(get_ccwdev_by_dev_id
);
652 static void ccw_device_do_unbind_bind(struct ccw_device
*cdev
)
656 if (device_is_registered(&cdev
->dev
)) {
657 device_release_driver(&cdev
->dev
);
658 ret
= device_attach(&cdev
->dev
);
659 WARN_ON(ret
== -ENODEV
);
664 ccw_device_release(struct device
*dev
)
666 struct ccw_device
*cdev
;
668 cdev
= to_ccwdev(dev
);
669 cio_gp_dma_free(cdev
->private->dma_pool
, cdev
->private->dma_area
,
670 sizeof(*cdev
->private->dma_area
));
671 cio_gp_dma_destroy(cdev
->private->dma_pool
, &cdev
->dev
);
672 /* Release reference of parent subchannel. */
673 put_device(cdev
->dev
.parent
);
674 kfree(cdev
->private);
678 static struct ccw_device
* io_subchannel_allocate_dev(struct subchannel
*sch
)
680 struct ccw_device
*cdev
;
681 struct gen_pool
*dma_pool
;
684 cdev
= kzalloc(sizeof(*cdev
), GFP_KERNEL
);
689 cdev
->private = kzalloc(sizeof(struct ccw_device_private
),
690 GFP_KERNEL
| GFP_DMA
);
691 if (!cdev
->private) {
696 cdev
->dev
.dma_mask
= sch
->dev
.dma_mask
;
697 ret
= dma_set_coherent_mask(&cdev
->dev
, sch
->dev
.coherent_dma_mask
);
699 goto err_coherent_mask
;
701 dma_pool
= cio_gp_dma_create(&cdev
->dev
, 1);
706 cdev
->private->dma_pool
= dma_pool
;
707 cdev
->private->dma_area
= cio_gp_dma_zalloc(dma_pool
, &cdev
->dev
,
708 sizeof(*cdev
->private->dma_area
));
709 if (!cdev
->private->dma_area
) {
715 cio_gp_dma_destroy(dma_pool
, &cdev
->dev
);
718 kfree(cdev
->private);
725 static void ccw_device_todo(struct work_struct
*work
);
727 static int io_subchannel_initialize_dev(struct subchannel
*sch
,
728 struct ccw_device
*cdev
)
730 struct ccw_device_private
*priv
= cdev
->private;
734 priv
->int_class
= IRQIO_CIO
;
735 priv
->state
= DEV_STATE_NOT_OPER
;
736 priv
->dev_id
.devno
= sch
->schib
.pmcw
.dev
;
737 priv
->dev_id
.ssid
= sch
->schid
.ssid
;
739 INIT_WORK(&priv
->todo_work
, ccw_device_todo
);
740 INIT_LIST_HEAD(&priv
->cmb_list
);
741 init_waitqueue_head(&priv
->wait_q
);
742 timer_setup(&priv
->timer
, ccw_device_timeout
, 0);
744 atomic_set(&priv
->onoff
, 0);
745 cdev
->ccwlock
= sch
->lock
;
746 cdev
->dev
.parent
= &sch
->dev
;
747 cdev
->dev
.release
= ccw_device_release
;
748 cdev
->dev
.bus
= &ccw_bus_type
;
749 cdev
->dev
.groups
= ccwdev_attr_groups
;
750 /* Do first half of device_register. */
751 device_initialize(&cdev
->dev
);
752 ret
= dev_set_name(&cdev
->dev
, "0.%x.%04x", cdev
->private->dev_id
.ssid
,
753 cdev
->private->dev_id
.devno
);
756 if (!get_device(&sch
->dev
)) {
760 priv
->flags
.initialized
= 1;
761 spin_lock_irq(sch
->lock
);
762 sch_set_cdev(sch
, cdev
);
763 spin_unlock_irq(sch
->lock
);
767 /* Release reference from device_initialize(). */
768 put_device(&cdev
->dev
);
772 static struct ccw_device
* io_subchannel_create_ccwdev(struct subchannel
*sch
)
774 struct ccw_device
*cdev
;
777 cdev
= io_subchannel_allocate_dev(sch
);
779 ret
= io_subchannel_initialize_dev(sch
, cdev
);
786 static void io_subchannel_recog(struct ccw_device
*, struct subchannel
*);
788 static void sch_create_and_recog_new_device(struct subchannel
*sch
)
790 struct ccw_device
*cdev
;
792 /* Need to allocate a new ccw device. */
793 cdev
= io_subchannel_create_ccwdev(sch
);
795 /* OK, we did everything we could... */
796 css_sch_device_unregister(sch
);
799 /* Start recognition for the new ccw device. */
800 io_subchannel_recog(cdev
, sch
);
804 * Register recognized device.
806 static void io_subchannel_register(struct ccw_device
*cdev
)
808 struct subchannel
*sch
;
809 int ret
, adjust_init_count
= 1;
812 sch
= to_subchannel(cdev
->dev
.parent
);
814 * Check if subchannel is still registered. It may have become
815 * unregistered if a machine check hit us after finishing
816 * device recognition but before the register work could be
819 if (!device_is_registered(&sch
->dev
))
821 css_update_ssd_info(sch
);
823 * io_subchannel_register() will also be called after device
824 * recognition has been done for a boxed device (which will already
825 * be registered). We need to reprobe since we may now have sense id
828 if (device_is_registered(&cdev
->dev
)) {
830 ret
= device_reprobe(&cdev
->dev
);
832 /* We can't do much here. */
833 CIO_MSG_EVENT(0, "device_reprobe() returned"
834 " %d for 0.%x.%04x\n", ret
,
835 cdev
->private->dev_id
.ssid
,
836 cdev
->private->dev_id
.devno
);
838 adjust_init_count
= 0;
842 * Now we know this subchannel will stay, we can throw
843 * our delayed uevent.
845 if (dev_get_uevent_suppress(&sch
->dev
)) {
846 dev_set_uevent_suppress(&sch
->dev
, 0);
847 kobject_uevent(&sch
->dev
.kobj
, KOBJ_ADD
);
849 /* make it known to the system */
850 ret
= device_add(&cdev
->dev
);
852 CIO_MSG_EVENT(0, "Could not register ccw dev 0.%x.%04x: %d\n",
853 cdev
->private->dev_id
.ssid
,
854 cdev
->private->dev_id
.devno
, ret
);
855 spin_lock_irqsave(sch
->lock
, flags
);
856 sch_set_cdev(sch
, NULL
);
857 spin_unlock_irqrestore(sch
->lock
, flags
);
858 /* Release initial device reference. */
859 put_device(&cdev
->dev
);
863 cdev
->private->flags
.recog_done
= 1;
864 wake_up(&cdev
->private->wait_q
);
866 if (adjust_init_count
&& atomic_dec_and_test(&ccw_device_init_count
))
867 wake_up(&ccw_device_init_wq
);
871 * subchannel recognition done. Called from the state machine.
874 io_subchannel_recog_done(struct ccw_device
*cdev
)
876 if (css_init_done
== 0) {
877 cdev
->private->flags
.recog_done
= 1;
880 switch (cdev
->private->state
) {
881 case DEV_STATE_BOXED
:
882 /* Device did not respond in time. */
883 case DEV_STATE_NOT_OPER
:
884 cdev
->private->flags
.recog_done
= 1;
885 /* Remove device found not operational. */
886 ccw_device_sched_todo(cdev
, CDEV_TODO_UNREG
);
887 if (atomic_dec_and_test(&ccw_device_init_count
))
888 wake_up(&ccw_device_init_wq
);
890 case DEV_STATE_OFFLINE
:
892 * We can't register the device in interrupt context so
893 * we schedule a work item.
895 ccw_device_sched_todo(cdev
, CDEV_TODO_REGISTER
);
900 static void io_subchannel_recog(struct ccw_device
*cdev
, struct subchannel
*sch
)
902 /* Increase counter of devices currently in recognition. */
903 atomic_inc(&ccw_device_init_count
);
905 /* Start async. device sensing. */
906 spin_lock_irq(sch
->lock
);
907 ccw_device_recognition(cdev
);
908 spin_unlock_irq(sch
->lock
);
911 static int ccw_device_move_to_sch(struct ccw_device
*cdev
,
912 struct subchannel
*sch
)
914 struct subchannel
*old_sch
;
915 int rc
, old_enabled
= 0;
917 old_sch
= to_subchannel(cdev
->dev
.parent
);
918 /* Obtain child reference for new parent. */
919 if (!get_device(&sch
->dev
))
922 if (!sch_is_pseudo_sch(old_sch
)) {
923 spin_lock_irq(old_sch
->lock
);
924 old_enabled
= old_sch
->schib
.pmcw
.ena
;
927 rc
= cio_disable_subchannel(old_sch
);
928 spin_unlock_irq(old_sch
->lock
);
930 /* Release child reference for new parent. */
931 put_device(&sch
->dev
);
936 mutex_lock(&sch
->reg_mutex
);
937 rc
= device_move(&cdev
->dev
, &sch
->dev
, DPM_ORDER_PARENT_BEFORE_DEV
);
938 mutex_unlock(&sch
->reg_mutex
);
940 CIO_MSG_EVENT(0, "device_move(0.%x.%04x,0.%x.%04x)=%d\n",
941 cdev
->private->dev_id
.ssid
,
942 cdev
->private->dev_id
.devno
, sch
->schid
.ssid
,
943 sch
->schib
.pmcw
.dev
, rc
);
945 /* Try to reenable the old subchannel. */
946 spin_lock_irq(old_sch
->lock
);
947 cio_enable_subchannel(old_sch
, (u32
)(addr_t
)old_sch
);
948 spin_unlock_irq(old_sch
->lock
);
950 /* Release child reference for new parent. */
951 put_device(&sch
->dev
);
954 /* Clean up old subchannel. */
955 if (!sch_is_pseudo_sch(old_sch
)) {
956 spin_lock_irq(old_sch
->lock
);
957 sch_set_cdev(old_sch
, NULL
);
958 spin_unlock_irq(old_sch
->lock
);
959 css_schedule_eval(old_sch
->schid
);
961 /* Release child reference for old parent. */
962 put_device(&old_sch
->dev
);
963 /* Initialize new subchannel. */
964 spin_lock_irq(sch
->lock
);
965 cdev
->ccwlock
= sch
->lock
;
966 if (!sch_is_pseudo_sch(sch
))
967 sch_set_cdev(sch
, cdev
);
968 spin_unlock_irq(sch
->lock
);
969 if (!sch_is_pseudo_sch(sch
))
970 css_update_ssd_info(sch
);
974 static int ccw_device_move_to_orph(struct ccw_device
*cdev
)
976 struct subchannel
*sch
= to_subchannel(cdev
->dev
.parent
);
977 struct channel_subsystem
*css
= to_css(sch
->dev
.parent
);
979 return ccw_device_move_to_sch(cdev
, css
->pseudo_subchannel
);
982 static void io_subchannel_irq(struct subchannel
*sch
)
984 struct ccw_device
*cdev
;
986 cdev
= sch_get_cdev(sch
);
988 CIO_TRACE_EVENT(6, "IRQ");
989 CIO_TRACE_EVENT(6, dev_name(&sch
->dev
));
991 dev_fsm_event(cdev
, DEV_EVENT_INTERRUPT
);
993 inc_irq_stat(IRQIO_CIO
);
996 void io_subchannel_init_config(struct subchannel
*sch
)
998 memset(&sch
->config
, 0, sizeof(sch
->config
));
999 sch
->config
.csense
= 1;
1002 static void io_subchannel_init_fields(struct subchannel
*sch
)
1004 if (cio_is_console(sch
->schid
))
1007 sch
->opm
= chp_get_sch_opm(sch
);
1008 sch
->lpm
= sch
->schib
.pmcw
.pam
& sch
->opm
;
1009 sch
->isc
= cio_is_console(sch
->schid
) ? CONSOLE_ISC
: IO_SCH_ISC
;
1011 CIO_MSG_EVENT(6, "Detected device %04x on subchannel 0.%x.%04X"
1012 " - PIM = %02X, PAM = %02X, POM = %02X\n",
1013 sch
->schib
.pmcw
.dev
, sch
->schid
.ssid
,
1014 sch
->schid
.sch_no
, sch
->schib
.pmcw
.pim
,
1015 sch
->schib
.pmcw
.pam
, sch
->schib
.pmcw
.pom
);
1017 io_subchannel_init_config(sch
);
1021 * Note: We always return 0 so that we bind to the device even on error.
1022 * This is needed so that our remove function is called on unregister.
1024 static int io_subchannel_probe(struct subchannel
*sch
)
1026 struct io_subchannel_private
*io_priv
;
1027 struct ccw_device
*cdev
;
1030 if (cio_is_console(sch
->schid
)) {
1031 rc
= sysfs_create_group(&sch
->dev
.kobj
,
1032 &io_subchannel_attr_group
);
1034 CIO_MSG_EVENT(0, "Failed to create io subchannel "
1035 "attributes for subchannel "
1036 "0.%x.%04x (rc=%d)\n",
1037 sch
->schid
.ssid
, sch
->schid
.sch_no
, rc
);
1039 * The console subchannel already has an associated ccw_device.
1040 * Throw the delayed uevent for the subchannel, register
1041 * the ccw_device and exit.
1043 if (dev_get_uevent_suppress(&sch
->dev
)) {
1044 /* should always be the case for the console */
1045 dev_set_uevent_suppress(&sch
->dev
, 0);
1046 kobject_uevent(&sch
->dev
.kobj
, KOBJ_ADD
);
1048 cdev
= sch_get_cdev(sch
);
1049 rc
= device_add(&cdev
->dev
);
1051 /* Release online reference. */
1052 put_device(&cdev
->dev
);
1055 if (atomic_dec_and_test(&ccw_device_init_count
))
1056 wake_up(&ccw_device_init_wq
);
1059 io_subchannel_init_fields(sch
);
1060 rc
= cio_commit_config(sch
);
1063 rc
= sysfs_create_group(&sch
->dev
.kobj
,
1064 &io_subchannel_attr_group
);
1067 /* Allocate I/O subchannel private data. */
1068 io_priv
= kzalloc(sizeof(*io_priv
), GFP_KERNEL
| GFP_DMA
);
1072 io_priv
->dma_area
= dma_alloc_coherent(&sch
->dev
,
1073 sizeof(*io_priv
->dma_area
),
1074 &io_priv
->dma_area_dma
, GFP_KERNEL
);
1075 if (!io_priv
->dma_area
) {
1080 set_io_private(sch
, io_priv
);
1081 css_schedule_eval(sch
->schid
);
1085 spin_lock_irq(sch
->lock
);
1086 css_sched_sch_todo(sch
, SCH_TODO_UNREG
);
1087 spin_unlock_irq(sch
->lock
);
1091 static void io_subchannel_remove(struct subchannel
*sch
)
1093 struct io_subchannel_private
*io_priv
= to_io_private(sch
);
1094 struct ccw_device
*cdev
;
1096 cdev
= sch_get_cdev(sch
);
1100 ccw_device_unregister(cdev
);
1101 spin_lock_irq(sch
->lock
);
1102 sch_set_cdev(sch
, NULL
);
1103 set_io_private(sch
, NULL
);
1104 spin_unlock_irq(sch
->lock
);
1106 dma_free_coherent(&sch
->dev
, sizeof(*io_priv
->dma_area
),
1107 io_priv
->dma_area
, io_priv
->dma_area_dma
);
1109 sysfs_remove_group(&sch
->dev
.kobj
, &io_subchannel_attr_group
);
1112 static void io_subchannel_verify(struct subchannel
*sch
)
1114 struct ccw_device
*cdev
;
1116 cdev
= sch_get_cdev(sch
);
1118 dev_fsm_event(cdev
, DEV_EVENT_VERIFY
);
1121 static void io_subchannel_terminate_path(struct subchannel
*sch
, u8 mask
)
1123 struct ccw_device
*cdev
;
1125 cdev
= sch_get_cdev(sch
);
1128 if (cio_update_schib(sch
))
1130 /* Check for I/O on path. */
1131 if (scsw_actl(&sch
->schib
.scsw
) == 0 || sch
->schib
.pmcw
.lpum
!= mask
)
1133 if (cdev
->private->state
== DEV_STATE_ONLINE
) {
1134 ccw_device_kill_io(cdev
);
1140 /* Trigger path verification. */
1141 dev_fsm_event(cdev
, DEV_EVENT_VERIFY
);
1145 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
1148 static int io_subchannel_chp_event(struct subchannel
*sch
,
1149 struct chp_link
*link
, int event
)
1151 struct ccw_device
*cdev
= sch_get_cdev(sch
);
1152 int mask
, chpid
, valid_bit
;
1155 mask
= chp_ssd_get_mask(&sch
->ssd_info
, link
);
1163 cdev
->private->path_gone_mask
|= mask
;
1164 io_subchannel_terminate_path(sch
, mask
);
1170 cdev
->private->path_new_mask
|= mask
;
1171 io_subchannel_verify(sch
);
1174 if (cio_update_schib(sch
))
1177 cdev
->private->path_gone_mask
|= mask
;
1178 io_subchannel_terminate_path(sch
, mask
);
1181 if (cio_update_schib(sch
))
1183 sch
->lpm
|= mask
& sch
->opm
;
1185 cdev
->private->path_new_mask
|= mask
;
1186 io_subchannel_verify(sch
);
1188 case CHP_FCES_EVENT
:
1189 /* Forward Endpoint Security event */
1190 for (chpid
= 0, valid_bit
= 0x80; chpid
< 8; chpid
++,
1192 if (mask
& valid_bit
)
1193 path_event
[chpid
] = PE_PATH_FCES_EVENT
;
1195 path_event
[chpid
] = PE_NONE
;
1198 cdev
->drv
->path_event(cdev
, path_event
);
1204 static void io_subchannel_quiesce(struct subchannel
*sch
)
1206 struct ccw_device
*cdev
;
1209 spin_lock_irq(sch
->lock
);
1210 cdev
= sch_get_cdev(sch
);
1211 if (cio_is_console(sch
->schid
))
1213 if (!sch
->schib
.pmcw
.ena
)
1215 ret
= cio_disable_subchannel(sch
);
1219 cdev
->handler(cdev
, cdev
->private->intparm
, ERR_PTR(-EIO
));
1220 while (ret
== -EBUSY
) {
1221 cdev
->private->state
= DEV_STATE_QUIESCE
;
1222 cdev
->private->iretry
= 255;
1223 ret
= ccw_device_cancel_halt_clear(cdev
);
1224 if (ret
== -EBUSY
) {
1225 ccw_device_set_timeout(cdev
, HZ
/10);
1226 spin_unlock_irq(sch
->lock
);
1227 wait_event(cdev
->private->wait_q
,
1228 cdev
->private->state
!= DEV_STATE_QUIESCE
);
1229 spin_lock_irq(sch
->lock
);
1231 ret
= cio_disable_subchannel(sch
);
1234 spin_unlock_irq(sch
->lock
);
1237 static void io_subchannel_shutdown(struct subchannel
*sch
)
1239 io_subchannel_quiesce(sch
);
1242 static int device_is_disconnected(struct ccw_device
*cdev
)
1246 return (cdev
->private->state
== DEV_STATE_DISCONNECTED
||
1247 cdev
->private->state
== DEV_STATE_DISCONNECTED_SENSE_ID
);
1250 static int recovery_check(struct device
*dev
, void *data
)
1252 struct ccw_device
*cdev
= to_ccwdev(dev
);
1253 struct subchannel
*sch
;
1256 spin_lock_irq(cdev
->ccwlock
);
1257 switch (cdev
->private->state
) {
1258 case DEV_STATE_ONLINE
:
1259 sch
= to_subchannel(cdev
->dev
.parent
);
1260 if ((sch
->schib
.pmcw
.pam
& sch
->opm
) == sch
->vpm
)
1263 case DEV_STATE_DISCONNECTED
:
1264 CIO_MSG_EVENT(3, "recovery: trigger 0.%x.%04x\n",
1265 cdev
->private->dev_id
.ssid
,
1266 cdev
->private->dev_id
.devno
);
1267 dev_fsm_event(cdev
, DEV_EVENT_VERIFY
);
1270 case DEV_STATE_DISCONNECTED_SENSE_ID
:
1274 spin_unlock_irq(cdev
->ccwlock
);
1279 static void recovery_work_func(struct work_struct
*unused
)
1283 bus_for_each_dev(&ccw_bus_type
, NULL
, &redo
, recovery_check
);
1285 spin_lock_irq(&recovery_lock
);
1286 if (!timer_pending(&recovery_timer
)) {
1287 if (recovery_phase
< ARRAY_SIZE(recovery_delay
) - 1)
1289 mod_timer(&recovery_timer
, jiffies
+
1290 recovery_delay
[recovery_phase
] * HZ
);
1292 spin_unlock_irq(&recovery_lock
);
1294 CIO_MSG_EVENT(3, "recovery: end\n");
1297 static DECLARE_WORK(recovery_work
, recovery_work_func
);
1299 static void recovery_func(struct timer_list
*unused
)
1302 * We can't do our recovery in softirq context and it's not
1303 * performance critical, so we schedule it.
1305 schedule_work(&recovery_work
);
1308 void ccw_device_schedule_recovery(void)
1310 unsigned long flags
;
1312 CIO_MSG_EVENT(3, "recovery: schedule\n");
1313 spin_lock_irqsave(&recovery_lock
, flags
);
1314 if (!timer_pending(&recovery_timer
) || (recovery_phase
!= 0)) {
1316 mod_timer(&recovery_timer
, jiffies
+ recovery_delay
[0] * HZ
);
1318 spin_unlock_irqrestore(&recovery_lock
, flags
);
1321 static int purge_fn(struct device
*dev
, void *data
)
1323 struct ccw_device
*cdev
= to_ccwdev(dev
);
1324 struct ccw_dev_id
*id
= &cdev
->private->dev_id
;
1326 spin_lock_irq(cdev
->ccwlock
);
1327 if (is_blacklisted(id
->ssid
, id
->devno
) &&
1328 (cdev
->private->state
== DEV_STATE_OFFLINE
) &&
1329 (atomic_cmpxchg(&cdev
->private->onoff
, 0, 1) == 0)) {
1330 CIO_MSG_EVENT(3, "ccw: purging 0.%x.%04x\n", id
->ssid
,
1332 ccw_device_sched_todo(cdev
, CDEV_TODO_UNREG
);
1333 atomic_set(&cdev
->private->onoff
, 0);
1335 spin_unlock_irq(cdev
->ccwlock
);
1336 /* Abort loop in case of pending signal. */
1337 if (signal_pending(current
))
1344 * ccw_purge_blacklisted - purge unused, blacklisted devices
1346 * Unregister all ccw devices that are offline and on the blacklist.
1348 int ccw_purge_blacklisted(void)
1350 CIO_MSG_EVENT(2, "ccw: purging blacklisted devices\n");
1351 bus_for_each_dev(&ccw_bus_type
, NULL
, NULL
, purge_fn
);
1355 void ccw_device_set_disconnected(struct ccw_device
*cdev
)
1359 ccw_device_set_timeout(cdev
, 0);
1360 cdev
->private->flags
.fake_irb
= 0;
1361 cdev
->private->state
= DEV_STATE_DISCONNECTED
;
1363 ccw_device_schedule_recovery();
1366 void ccw_device_set_notoper(struct ccw_device
*cdev
)
1368 struct subchannel
*sch
= to_subchannel(cdev
->dev
.parent
);
1370 CIO_TRACE_EVENT(2, "notoper");
1371 CIO_TRACE_EVENT(2, dev_name(&sch
->dev
));
1372 ccw_device_set_timeout(cdev
, 0);
1373 cio_disable_subchannel(sch
);
1374 cdev
->private->state
= DEV_STATE_NOT_OPER
;
1377 enum io_sch_action
{
1381 IO_SCH_UNREG_ATTACH
,
1389 static enum io_sch_action
sch_get_action(struct subchannel
*sch
)
1391 struct ccw_device
*cdev
;
1393 cdev
= sch_get_cdev(sch
);
1394 if (cio_update_schib(sch
)) {
1395 /* Not operational. */
1397 return IO_SCH_UNREG
;
1398 if (ccw_device_notify(cdev
, CIO_GONE
) != NOTIFY_OK
)
1399 return IO_SCH_UNREG
;
1400 return IO_SCH_ORPH_UNREG
;
1404 return IO_SCH_ATTACH
;
1405 if (sch
->schib
.pmcw
.dev
!= cdev
->private->dev_id
.devno
) {
1406 if (ccw_device_notify(cdev
, CIO_GONE
) != NOTIFY_OK
)
1407 return IO_SCH_UNREG_ATTACH
;
1408 return IO_SCH_ORPH_ATTACH
;
1410 if ((sch
->schib
.pmcw
.pam
& sch
->opm
) == 0) {
1411 if (ccw_device_notify(cdev
, CIO_NO_PATH
) != NOTIFY_OK
)
1412 return IO_SCH_UNREG
;
1415 if (device_is_disconnected(cdev
))
1416 return IO_SCH_REPROBE
;
1418 return IO_SCH_VERIFY
;
1419 if (cdev
->private->state
== DEV_STATE_NOT_OPER
)
1420 return IO_SCH_UNREG_ATTACH
;
1425 * io_subchannel_sch_event - process subchannel event
1427 * @process: non-zero if function is called in process context
1429 * An unspecified event occurred for this subchannel. Adjust data according
1430 * to the current operational state of the subchannel and device. Return
1431 * zero when the event has been handled sufficiently or -EAGAIN when this
1432 * function should be called again in process context.
1434 static int io_subchannel_sch_event(struct subchannel
*sch
, int process
)
1436 unsigned long flags
;
1437 struct ccw_device
*cdev
;
1438 struct ccw_dev_id dev_id
;
1439 enum io_sch_action action
;
1442 spin_lock_irqsave(sch
->lock
, flags
);
1443 if (!device_is_registered(&sch
->dev
))
1445 if (work_pending(&sch
->todo_work
))
1447 cdev
= sch_get_cdev(sch
);
1448 if (cdev
&& work_pending(&cdev
->private->todo_work
))
1450 action
= sch_get_action(sch
);
1451 CIO_MSG_EVENT(2, "event: sch 0.%x.%04x, process=%d, action=%d\n",
1452 sch
->schid
.ssid
, sch
->schid
.sch_no
, process
,
1454 /* Perform immediate actions while holding the lock. */
1456 case IO_SCH_REPROBE
:
1457 /* Trigger device recognition. */
1458 ccw_device_trigger_reprobe(cdev
);
1462 /* Trigger path verification. */
1463 io_subchannel_verify(sch
);
1467 ccw_device_set_disconnected(cdev
);
1470 case IO_SCH_ORPH_UNREG
:
1471 case IO_SCH_ORPH_ATTACH
:
1472 ccw_device_set_disconnected(cdev
);
1474 case IO_SCH_UNREG_ATTACH
:
1478 if (cdev
->private->state
== DEV_STATE_SENSE_ID
) {
1480 * Note: delayed work triggered by this event
1481 * and repeated calls to sch_event are synchronized
1482 * by the above check for work_pending(cdev).
1484 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
1486 ccw_device_set_notoper(cdev
);
1494 spin_unlock_irqrestore(sch
->lock
, flags
);
1495 /* All other actions require process context. */
1498 /* Handle attached ccw device. */
1500 case IO_SCH_ORPH_UNREG
:
1501 case IO_SCH_ORPH_ATTACH
:
1502 /* Move ccw device to orphanage. */
1503 rc
= ccw_device_move_to_orph(cdev
);
1507 case IO_SCH_UNREG_ATTACH
:
1508 spin_lock_irqsave(sch
->lock
, flags
);
1509 sch_set_cdev(sch
, NULL
);
1510 spin_unlock_irqrestore(sch
->lock
, flags
);
1511 /* Unregister ccw device. */
1512 ccw_device_unregister(cdev
);
1517 /* Handle subchannel. */
1519 case IO_SCH_ORPH_UNREG
:
1521 css_sch_device_unregister(sch
);
1523 case IO_SCH_ORPH_ATTACH
:
1524 case IO_SCH_UNREG_ATTACH
:
1526 dev_id
.ssid
= sch
->schid
.ssid
;
1527 dev_id
.devno
= sch
->schib
.pmcw
.dev
;
1528 cdev
= get_ccwdev_by_dev_id(&dev_id
);
1530 sch_create_and_recog_new_device(sch
);
1533 rc
= ccw_device_move_to_sch(cdev
, sch
);
1535 /* Release reference from get_ccwdev_by_dev_id() */
1536 put_device(&cdev
->dev
);
1539 spin_lock_irqsave(sch
->lock
, flags
);
1540 ccw_device_trigger_reprobe(cdev
);
1541 spin_unlock_irqrestore(sch
->lock
, flags
);
1542 /* Release reference from get_ccwdev_by_dev_id() */
1543 put_device(&cdev
->dev
);
1551 spin_unlock_irqrestore(sch
->lock
, flags
);
1556 static void ccw_device_set_int_class(struct ccw_device
*cdev
)
1558 struct ccw_driver
*cdrv
= cdev
->drv
;
1560 /* Note: we interpret class 0 in this context as an uninitialized
1561 * field since it translates to a non-I/O interrupt class. */
1562 if (cdrv
->int_class
!= 0)
1563 cdev
->private->int_class
= cdrv
->int_class
;
1565 cdev
->private->int_class
= IRQIO_CIO
;
1568 #ifdef CONFIG_CCW_CONSOLE
1569 int __init
ccw_device_enable_console(struct ccw_device
*cdev
)
1571 struct subchannel
*sch
= to_subchannel(cdev
->dev
.parent
);
1574 if (!cdev
->drv
|| !cdev
->handler
)
1577 io_subchannel_init_fields(sch
);
1578 rc
= cio_commit_config(sch
);
1581 sch
->driver
= &io_subchannel_driver
;
1582 io_subchannel_recog(cdev
, sch
);
1583 /* Now wait for the async. recognition to come to an end. */
1584 spin_lock_irq(cdev
->ccwlock
);
1585 while (!dev_fsm_final_state(cdev
))
1586 ccw_device_wait_idle(cdev
);
1588 /* Hold on to an extra reference while device is online. */
1589 get_device(&cdev
->dev
);
1590 rc
= ccw_device_online(cdev
);
1594 while (!dev_fsm_final_state(cdev
))
1595 ccw_device_wait_idle(cdev
);
1597 if (cdev
->private->state
== DEV_STATE_ONLINE
)
1602 spin_unlock_irq(cdev
->ccwlock
);
1603 if (rc
) /* Give up online reference since onlining failed. */
1604 put_device(&cdev
->dev
);
1608 struct ccw_device
* __init
ccw_device_create_console(struct ccw_driver
*drv
)
1610 struct io_subchannel_private
*io_priv
;
1611 struct ccw_device
*cdev
;
1612 struct subchannel
*sch
;
1614 sch
= cio_probe_console();
1616 return ERR_CAST(sch
);
1618 io_priv
= kzalloc(sizeof(*io_priv
), GFP_KERNEL
| GFP_DMA
);
1621 io_priv
->dma_area
= dma_alloc_coherent(&sch
->dev
,
1622 sizeof(*io_priv
->dma_area
),
1623 &io_priv
->dma_area_dma
, GFP_KERNEL
);
1624 if (!io_priv
->dma_area
)
1626 set_io_private(sch
, io_priv
);
1627 cdev
= io_subchannel_create_ccwdev(sch
);
1629 dma_free_coherent(&sch
->dev
, sizeof(*io_priv
->dma_area
),
1630 io_priv
->dma_area
, io_priv
->dma_area_dma
);
1631 set_io_private(sch
, NULL
);
1632 put_device(&sch
->dev
);
1637 ccw_device_set_int_class(cdev
);
1643 put_device(&sch
->dev
);
1644 return ERR_PTR(-ENOMEM
);
1647 void __init
ccw_device_destroy_console(struct ccw_device
*cdev
)
1649 struct subchannel
*sch
= to_subchannel(cdev
->dev
.parent
);
1650 struct io_subchannel_private
*io_priv
= to_io_private(sch
);
1652 set_io_private(sch
, NULL
);
1653 dma_free_coherent(&sch
->dev
, sizeof(*io_priv
->dma_area
),
1654 io_priv
->dma_area
, io_priv
->dma_area_dma
);
1655 put_device(&sch
->dev
);
1656 put_device(&cdev
->dev
);
1661 * ccw_device_wait_idle() - busy wait for device to become idle
1664 * Poll until activity control is zero, that is, no function or data
1665 * transfer is pending/active.
1666 * Called with device lock being held.
1668 void ccw_device_wait_idle(struct ccw_device
*cdev
)
1670 struct subchannel
*sch
= to_subchannel(cdev
->dev
.parent
);
1674 if (sch
->schib
.scsw
.cmd
.actl
== 0)
1682 * get_ccwdev_by_busid() - obtain device from a bus id
1683 * @cdrv: driver the device is owned by
1684 * @bus_id: bus id of the device to be searched
1686 * This function searches all devices owned by @cdrv for a device with a bus
1687 * id matching @bus_id.
1689 * If a match is found, its reference count of the found device is increased
1690 * and it is returned; else %NULL is returned.
1692 struct ccw_device
*get_ccwdev_by_busid(struct ccw_driver
*cdrv
,
1697 dev
= driver_find_device_by_name(&cdrv
->driver
, bus_id
);
1699 return dev
? to_ccwdev(dev
) : NULL
;
1702 /************************** device driver handling ************************/
1704 /* This is the implementation of the ccw_driver class. The probe, remove
1705 * and release methods are initially very similar to the device_driver
1706 * implementations, with the difference that they have ccw_device
1709 * A ccw driver also contains the information that is needed for
1713 ccw_device_probe (struct device
*dev
)
1715 struct ccw_device
*cdev
= to_ccwdev(dev
);
1716 struct ccw_driver
*cdrv
= to_ccwdrv(dev
->driver
);
1719 cdev
->drv
= cdrv
; /* to let the driver call _set_online */
1720 ccw_device_set_int_class(cdev
);
1721 ret
= cdrv
->probe
? cdrv
->probe(cdev
) : -ENODEV
;
1724 cdev
->private->int_class
= IRQIO_CIO
;
1731 static void ccw_device_remove(struct device
*dev
)
1733 struct ccw_device
*cdev
= to_ccwdev(dev
);
1734 struct ccw_driver
*cdrv
= cdev
->drv
;
1735 struct subchannel
*sch
;
1741 spin_lock_irq(cdev
->ccwlock
);
1744 ret
= ccw_device_offline(cdev
);
1745 spin_unlock_irq(cdev
->ccwlock
);
1747 wait_event(cdev
->private->wait_q
,
1748 dev_fsm_final_state(cdev
));
1750 CIO_MSG_EVENT(0, "ccw_device_offline returned %d, "
1751 "device 0.%x.%04x\n",
1752 ret
, cdev
->private->dev_id
.ssid
,
1753 cdev
->private->dev_id
.devno
);
1754 /* Give up reference obtained in ccw_device_set_online(). */
1755 put_device(&cdev
->dev
);
1756 spin_lock_irq(cdev
->ccwlock
);
1758 ccw_device_set_timeout(cdev
, 0);
1760 cdev
->private->int_class
= IRQIO_CIO
;
1761 sch
= to_subchannel(cdev
->dev
.parent
);
1762 spin_unlock_irq(cdev
->ccwlock
);
1763 io_subchannel_quiesce(sch
);
1764 __disable_cmf(cdev
);
1767 static void ccw_device_shutdown(struct device
*dev
)
1769 struct ccw_device
*cdev
;
1771 cdev
= to_ccwdev(dev
);
1772 if (cdev
->drv
&& cdev
->drv
->shutdown
)
1773 cdev
->drv
->shutdown(cdev
);
1774 __disable_cmf(cdev
);
1777 static struct bus_type ccw_bus_type
= {
1779 .match
= ccw_bus_match
,
1780 .uevent
= ccw_uevent
,
1781 .probe
= ccw_device_probe
,
1782 .remove
= ccw_device_remove
,
1783 .shutdown
= ccw_device_shutdown
,
1787 * ccw_driver_register() - register a ccw driver
1788 * @cdriver: driver to be registered
1790 * This function is mainly a wrapper around driver_register().
1792 * %0 on success and a negative error value on failure.
1794 int ccw_driver_register(struct ccw_driver
*cdriver
)
1796 struct device_driver
*drv
= &cdriver
->driver
;
1798 drv
->bus
= &ccw_bus_type
;
1800 return driver_register(drv
);
1804 * ccw_driver_unregister() - deregister a ccw driver
1805 * @cdriver: driver to be deregistered
1807 * This function is mainly a wrapper around driver_unregister().
1809 void ccw_driver_unregister(struct ccw_driver
*cdriver
)
1811 driver_unregister(&cdriver
->driver
);
1814 static void ccw_device_todo(struct work_struct
*work
)
1816 struct ccw_device_private
*priv
;
1817 struct ccw_device
*cdev
;
1818 struct subchannel
*sch
;
1819 enum cdev_todo todo
;
1821 priv
= container_of(work
, struct ccw_device_private
, todo_work
);
1823 sch
= to_subchannel(cdev
->dev
.parent
);
1824 /* Find out todo. */
1825 spin_lock_irq(cdev
->ccwlock
);
1827 priv
->todo
= CDEV_TODO_NOTHING
;
1828 CIO_MSG_EVENT(4, "cdev_todo: cdev=0.%x.%04x todo=%d\n",
1829 priv
->dev_id
.ssid
, priv
->dev_id
.devno
, todo
);
1830 spin_unlock_irq(cdev
->ccwlock
);
1833 case CDEV_TODO_ENABLE_CMF
:
1836 case CDEV_TODO_REBIND
:
1837 ccw_device_do_unbind_bind(cdev
);
1839 case CDEV_TODO_REGISTER
:
1840 io_subchannel_register(cdev
);
1842 case CDEV_TODO_UNREG_EVAL
:
1843 if (!sch_is_pseudo_sch(sch
))
1844 css_schedule_eval(sch
->schid
);
1846 case CDEV_TODO_UNREG
:
1847 spin_lock_irq(sch
->lock
);
1848 sch_set_cdev(sch
, NULL
);
1849 spin_unlock_irq(sch
->lock
);
1850 ccw_device_unregister(cdev
);
1855 /* Release workqueue ref. */
1856 put_device(&cdev
->dev
);
1860 * ccw_device_sched_todo - schedule ccw device operation
1864 * Schedule the operation identified by @todo to be performed on the slow path
1865 * workqueue. Do nothing if another operation with higher priority is already
1866 * scheduled. Needs to be called with ccwdev lock held.
1868 void ccw_device_sched_todo(struct ccw_device
*cdev
, enum cdev_todo todo
)
1870 CIO_MSG_EVENT(4, "cdev_todo: sched cdev=0.%x.%04x todo=%d\n",
1871 cdev
->private->dev_id
.ssid
, cdev
->private->dev_id
.devno
,
1873 if (cdev
->private->todo
>= todo
)
1875 cdev
->private->todo
= todo
;
1876 /* Get workqueue ref. */
1877 if (!get_device(&cdev
->dev
))
1879 if (!queue_work(cio_work_q
, &cdev
->private->todo_work
)) {
1880 /* Already queued, release workqueue ref. */
1881 put_device(&cdev
->dev
);
1886 * ccw_device_siosl() - initiate logging
1889 * This function is used to invoke model-dependent logging within the channel
1892 int ccw_device_siosl(struct ccw_device
*cdev
)
1894 struct subchannel
*sch
= to_subchannel(cdev
->dev
.parent
);
1896 return chsc_siosl(sch
->schid
);
1898 EXPORT_SYMBOL_GPL(ccw_device_siosl
);
1900 EXPORT_SYMBOL(ccw_device_set_online
);
1901 EXPORT_SYMBOL(ccw_device_set_offline
);
1902 EXPORT_SYMBOL(ccw_driver_register
);
1903 EXPORT_SYMBOL(ccw_driver_unregister
);
1904 EXPORT_SYMBOL(get_ccwdev_by_busid
);