Lines Matching refs:cdev
63 struct ccw_device *cdev = to_ccwdev(dev);
70 found = ccw_device_id_match(ids, &cdev->id);
74 cdev->id.driver_info = found->driver_info;
106 struct ccw_device *cdev = to_ccwdev(dev);
107 struct ccw_device_id *id = &(cdev->id);
154 struct ccw_device *cdev;
159 cdev = sch_get_cdev(sch);
160 if (cdev && !device_is_registered(&cdev->dev))
214 struct ccw_device *cdev = to_ccwdev(dev);
215 struct ccw_device_id *id = &(cdev->id);
227 struct ccw_device *cdev = to_ccwdev(dev);
228 struct ccw_device_id *id = &(cdev->id);
237 struct ccw_device *cdev = to_ccwdev(dev);
238 struct ccw_device_id *id = &(cdev->id);
249 struct ccw_device *cdev = to_ccwdev(dev);
251 return sprintf(buf, cdev->online ? "1\n" : "0\n");
254 int ccw_device_is_orphan(struct ccw_device *cdev)
256 return sch_is_pseudo_sch(to_subchannel(cdev->dev.parent));
259 static void ccw_device_unregister(struct ccw_device *cdev)
261 if (device_is_registered(&cdev->dev)) {
263 device_del(&cdev->dev);
265 if (cdev->private->flags.initialized) {
266 cdev->private->flags.initialized = 0;
268 put_device(&cdev->dev);
276 * @cdev: target ccw device
278 * This function calls the driver's set_offline() function for @cdev, if
279 * given, and then disables @cdev.
285 int ccw_device_set_offline(struct ccw_device *cdev)
290 if (!cdev)
292 if (!cdev->online || !cdev->drv)
295 if (cdev->drv->set_offline) {
296 ret = cdev->drv->set_offline(cdev);
300 spin_lock_irq(cdev->ccwlock);
301 sch = to_subchannel(cdev->dev.parent);
302 cdev->online = 0;
304 while (!dev_fsm_final_state(cdev) &&
305 cdev->private->state != DEV_STATE_DISCONNECTED) {
306 spin_unlock_irq(cdev->ccwlock);
307 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
308 cdev->private->state == DEV_STATE_DISCONNECTED));
309 spin_lock_irq(cdev->ccwlock);
312 ret = ccw_device_offline(cdev);
316 "0.%x.%04x\n", ret, cdev->private->dev_id.ssid,
317 cdev->private->dev_id.devno);
320 state = cdev->private->state;
321 spin_unlock_irq(cdev->ccwlock);
323 spin_lock_irq(cdev->ccwlock);
324 cdev->private->state = state;
326 spin_unlock_irq(cdev->ccwlock);
327 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
328 cdev->private->state == DEV_STATE_DISCONNECTED));
330 if (cdev->private->state == DEV_STATE_BOXED) {
332 dev_name(&cdev->dev));
333 } else if (cdev->private->state == DEV_STATE_NOT_OPER) {
335 dev_name(&cdev->dev));
338 put_device(&cdev->dev);
342 cdev->private->state = DEV_STATE_OFFLINE;
343 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
344 spin_unlock_irq(cdev->ccwlock);
346 put_device(&cdev->dev);
352 * @cdev: target ccw device
354 * This function first enables @cdev and then calls the driver's set_online()
355 * function for @cdev, if given. If set_online() returns an error, @cdev is
362 int ccw_device_set_online(struct ccw_device *cdev)
367 if (!cdev)
369 if (cdev->online || !cdev->drv)
372 if (!get_device(&cdev->dev))
375 spin_lock_irq(cdev->ccwlock);
376 ret = ccw_device_online(cdev);
377 spin_unlock_irq(cdev->ccwlock);
379 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));
383 ret, cdev->private->dev_id.ssid,
384 cdev->private->dev_id.devno);
386 put_device(&cdev->dev);
389 spin_lock_irq(cdev->ccwlock);
391 if ((cdev->private->state != DEV_STATE_ONLINE) &&
392 (cdev->private->state != DEV_STATE_W4SENSE)) {
393 spin_unlock_irq(cdev->ccwlock);
395 if (cdev->private->state == DEV_STATE_BOXED) {
397 dev_name(&cdev->dev));
398 } else if (cdev->private->state == DEV_STATE_NOT_OPER) {
400 dev_name(&cdev->dev));
403 put_device(&cdev->dev);
406 spin_unlock_irq(cdev->ccwlock);
407 if (cdev->drv->set_online)
408 ret = cdev->drv->set_online(cdev);
412 spin_lock_irq(cdev->ccwlock);
413 cdev->online = 1;
414 spin_unlock_irq(cdev->ccwlock);
418 spin_lock_irq(cdev->ccwlock);
420 while (!dev_fsm_final_state(cdev) &&
421 cdev->private->state != DEV_STATE_DISCONNECTED) {
422 spin_unlock_irq(cdev->ccwlock);
423 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
424 cdev->private->state == DEV_STATE_DISCONNECTED));
425 spin_lock_irq(cdev->ccwlock);
427 ret2 = ccw_device_offline(cdev);
430 spin_unlock_irq(cdev->ccwlock);
431 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||
432 cdev->private->state == DEV_STATE_DISCONNECTED));
434 put_device(&cdev->dev);
440 ret2, cdev->private->dev_id.ssid,
441 cdev->private->dev_id.devno);
442 cdev->private->state = DEV_STATE_OFFLINE;
443 spin_unlock_irq(cdev->ccwlock);
445 put_device(&cdev->dev);
449 static int online_store_handle_offline(struct ccw_device *cdev)
451 if (cdev->private->state == DEV_STATE_DISCONNECTED) {
452 spin_lock_irq(cdev->ccwlock);
453 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG_EVAL);
454 spin_unlock_irq(cdev->ccwlock);
457 if (cdev->drv && cdev->drv->set_offline)
458 return ccw_device_set_offline(cdev);
462 static int online_store_recog_and_online(struct ccw_device *cdev)
465 if (cdev->private->state == DEV_STATE_BOXED) {
466 spin_lock_irq(cdev->ccwlock);
467 ccw_device_recognition(cdev);
468 spin_unlock_irq(cdev->ccwlock);
469 wait_event(cdev->private->wait_q,
470 cdev->private->flags.recog_done);
471 if (cdev->private->state != DEV_STATE_OFFLINE)
475 if (cdev->drv && cdev->drv->set_online)
476 return ccw_device_set_online(cdev);
480 static int online_store_handle_online(struct ccw_device *cdev, int force)
484 ret = online_store_recog_and_online(cdev);
487 if (force && cdev->private->state == DEV_STATE_BOXED) {
488 ret = ccw_device_stlck(cdev);
491 if (cdev->id.cu_type == 0)
492 cdev->private->state = DEV_STATE_NOT_OPER;
493 ret = online_store_recog_and_online(cdev);
503 struct ccw_device *cdev = to_ccwdev(dev);
508 if (atomic_cmpxchg(&cdev->private->onoff, 0, 1) != 0)
511 if (!dev_fsm_final_state(cdev) &&
512 cdev->private->state != DEV_STATE_DISCONNECTED) {
517 if (work_pending(&cdev->private->todo_work)) {
535 ret = online_store_handle_offline(cdev);
538 ret = online_store_handle_online(cdev, force);
546 atomic_set(&cdev->private->onoff, 0);
553 struct ccw_device *cdev = to_ccwdev(dev);
556 if (ccw_device_is_orphan(cdev))
558 switch (cdev->private->state) {
638 static int ccw_device_add(struct ccw_device *cdev)
640 struct device *dev = &cdev->dev;
648 struct ccw_device *cdev = to_ccwdev(dev);
651 return ccw_dev_id_is_equal(&cdev->private->dev_id, dev_id);
674 static void ccw_device_do_unbind_bind(struct ccw_device *cdev)
678 if (device_is_registered(&cdev->dev)) {
679 device_release_driver(&cdev->dev);
680 ret = device_attach(&cdev->dev);
688 struct ccw_device *cdev;
690 cdev = to_ccwdev(dev);
691 cio_gp_dma_free(cdev->private->dma_pool, cdev->private->dma_area,
692 sizeof(*cdev->private->dma_area));
693 cio_gp_dma_destroy(cdev->private->dma_pool, &cdev->dev);
695 put_device(cdev->dev.parent);
696 kfree(cdev->private);
697 kfree(cdev);
702 struct ccw_device *cdev;
705 cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
706 if (!cdev)
708 cdev->private = kzalloc(sizeof(struct ccw_device_private),
710 if (!cdev->private)
712 cdev->dev.coherent_dma_mask = sch->dev.coherent_dma_mask;
713 cdev->dev.dma_mask = sch->dev.dma_mask;
714 dma_pool = cio_gp_dma_create(&cdev->dev, 1);
717 cdev->private->dma_pool = dma_pool;
718 cdev->private->dma_area = cio_gp_dma_zalloc(dma_pool, &cdev->dev,
719 sizeof(*cdev->private->dma_area));
720 if (!cdev->private->dma_area)
722 return cdev;
724 cio_gp_dma_destroy(dma_pool, &cdev->dev);
726 kfree(cdev->private);
728 kfree(cdev);
736 struct ccw_device *cdev)
738 struct ccw_device_private *priv = cdev->private;
741 priv->cdev = cdev;
753 cdev->ccwlock = sch->lock;
754 cdev->dev.parent = &sch->dev;
755 cdev->dev.release = ccw_device_release;
756 cdev->dev.groups = ccwdev_attr_groups;
758 device_initialize(&cdev->dev);
759 ret = dev_set_name(&cdev->dev, "0.%x.%04x", cdev->private->dev_id.ssid,
760 cdev->private->dev_id.devno);
769 sch_set_cdev(sch, cdev);
775 put_device(&cdev->dev);
781 struct ccw_device *cdev;
784 cdev = io_subchannel_allocate_dev(sch);
785 if (!IS_ERR(cdev)) {
786 ret = io_subchannel_initialize_dev(sch, cdev);
788 cdev = ERR_PTR(ret);
790 return cdev;
797 struct ccw_device *cdev;
800 cdev = io_subchannel_create_ccwdev(sch);
801 if (IS_ERR(cdev)) {
807 io_subchannel_recog(cdev, sch);
813 static void io_subchannel_register(struct ccw_device *cdev)
819 sch = to_subchannel(cdev->dev.parent);
835 if (device_is_registered(&cdev->dev)) {
836 if (!cdev->drv) {
837 ret = device_reprobe(&cdev->dev);
842 cdev->private->dev_id.ssid,
843 cdev->private->dev_id.devno);
857 ret = ccw_device_add(cdev);
860 cdev->private->dev_id.ssid,
861 cdev->private->dev_id.devno, ret);
866 put_device(&cdev->dev);
870 cdev->private->flags.recog_done = 1;
871 wake_up(&cdev->private->wait_q);
877 static void ccw_device_call_sch_unregister(struct ccw_device *cdev)
882 if (!get_device(cdev->dev.parent))
884 sch = to_subchannel(cdev->dev.parent);
894 io_subchannel_recog_done(struct ccw_device *cdev)
897 cdev->private->flags.recog_done = 1;
900 switch (cdev->private->state) {
904 cdev->private->flags.recog_done = 1;
906 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
915 ccw_device_sched_todo(cdev, CDEV_TODO_REGISTER);
920 static void io_subchannel_recog(struct ccw_device *cdev, struct subchannel *sch)
927 ccw_device_recognition(cdev);
931 static int ccw_device_move_to_sch(struct ccw_device *cdev,
937 old_sch = to_subchannel(cdev->dev.parent);
957 rc = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);
961 cdev->private->dev_id.ssid,
962 cdev->private->dev_id.devno, sch->schid.ssid,
985 cdev->ccwlock = sch->lock;
987 sch_set_cdev(sch, cdev);
994 static int ccw_device_move_to_orph(struct ccw_device *cdev)
996 struct subchannel *sch = to_subchannel(cdev->dev.parent);
999 return ccw_device_move_to_sch(cdev, css->pseudo_subchannel);
1004 struct ccw_device *cdev;
1006 cdev = sch_get_cdev(sch);
1010 if (cdev)
1011 dev_fsm_event(cdev, DEV_EVENT_INTERRUPT);
1047 struct ccw_device *cdev;
1068 cdev = sch_get_cdev(sch);
1069 rc = ccw_device_add(cdev);
1072 put_device(&cdev->dev);
1114 struct ccw_device *cdev;
1116 cdev = sch_get_cdev(sch);
1117 if (!cdev)
1120 ccw_device_unregister(cdev);
1135 struct ccw_device *cdev;
1137 cdev = sch_get_cdev(sch);
1138 if (cdev)
1139 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
1144 struct ccw_device *cdev;
1146 cdev = sch_get_cdev(sch);
1147 if (!cdev)
1154 if (cdev->private->state == DEV_STATE_ONLINE) {
1155 ccw_device_kill_io(cdev);
1162 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
1166 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
1172 struct ccw_device *cdev = sch_get_cdev(sch);
1182 if (cdev)
1183 cdev->private->path_gone_mask |= mask;
1189 if (cdev)
1190 cdev->private->path_new_mask |= mask;
1196 if (cdev)
1197 cdev->private->path_gone_mask |= mask;
1204 if (cdev)
1205 cdev->private->path_new_mask |= mask;
1214 struct ccw_device *cdev;
1218 cdev = sch_get_cdev(sch);
1226 if (cdev->handler)
1227 cdev->handler(cdev, cdev->private->intparm, ERR_PTR(-EIO));
1229 cdev->private->state = DEV_STATE_QUIESCE;
1230 cdev->private->iretry = 255;
1231 ret = ccw_device_cancel_halt_clear(cdev);
1233 ccw_device_set_timeout(cdev, HZ/10);
1235 wait_event(cdev->private->wait_q,
1236 cdev->private->state != DEV_STATE_QUIESCE);
1250 static int device_is_disconnected(struct ccw_device *cdev)
1252 if (!cdev)
1254 return (cdev->private->state == DEV_STATE_DISCONNECTED ||
1255 cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID);
1260 struct ccw_device *cdev = to_ccwdev(dev);
1264 spin_lock_irq(cdev->ccwlock);
1265 switch (cdev->private->state) {
1267 sch = to_subchannel(cdev->dev.parent);
1273 cdev->private->dev_id.ssid,
1274 cdev->private->dev_id.devno);
1275 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
1282 spin_unlock_irq(cdev->ccwlock);
1331 struct ccw_device *cdev = to_ccwdev(dev);
1332 struct ccw_dev_id *id = &cdev->private->dev_id;
1334 spin_lock_irq(cdev->ccwlock);
1336 (cdev->private->state == DEV_STATE_OFFLINE) &&
1337 (atomic_cmpxchg(&cdev->private->onoff, 0, 1) == 0)) {
1340 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
1341 atomic_set(&cdev->private->onoff, 0);
1343 spin_unlock_irq(cdev->ccwlock);
1363 void ccw_device_set_disconnected(struct ccw_device *cdev)
1365 if (!cdev)
1367 ccw_device_set_timeout(cdev, 0);
1368 cdev->private->flags.fake_irb = 0;
1369 cdev->private->state = DEV_STATE_DISCONNECTED;
1370 if (cdev->online)
1374 void ccw_device_set_notoper(struct ccw_device *cdev)
1376 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1380 ccw_device_set_timeout(cdev, 0);
1382 cdev->private->state = DEV_STATE_NOT_OPER;
1400 struct ccw_device *cdev;
1402 cdev = sch_get_cdev(sch);
1405 if (!cdev)
1407 if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
1412 if (!cdev)
1414 if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
1415 if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
1420 if (ccw_device_notify(cdev, CIO_NO_PATH) != NOTIFY_OK)
1424 if (device_is_disconnected(cdev))
1426 if (cdev->online && !cdev->private->flags.resuming)
1428 if (cdev->private->state == DEV_STATE_NOT_OPER)
1446 struct ccw_device *cdev;
1456 cdev = sch_get_cdev(sch);
1457 if (cdev && work_pending(&cdev->private->todo_work))
1467 ccw_device_trigger_reprobe(cdev);
1476 ccw_device_set_disconnected(cdev);
1481 ccw_device_set_disconnected(cdev);
1486 if (!cdev)
1488 if (cdev->private->state == DEV_STATE_SENSE_ID) {
1492 * by the above check for work_pending(cdev).
1494 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
1496 ccw_device_set_notoper(cdev);
1513 rc = ccw_device_move_to_orph(cdev);
1520 if (cdev->private->flags.resuming) {
1528 ccw_device_unregister(cdev);
1537 if (!cdev || !cdev->private->flags.resuming)
1545 cdev = get_ccwdev_by_dev_id(&dev_id);
1546 if (!cdev) {
1550 rc = ccw_device_move_to_sch(cdev, sch);
1553 put_device(&cdev->dev);
1557 ccw_device_trigger_reprobe(cdev);
1560 put_device(&cdev->dev);
1573 static void ccw_device_set_int_class(struct ccw_device *cdev)
1575 struct ccw_driver *cdrv = cdev->drv;
1580 cdev->private->int_class = cdrv->int_class;
1582 cdev->private->int_class = IRQIO_CIO;
1586 int __init ccw_device_enable_console(struct ccw_device *cdev)
1588 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1591 if (!cdev->drv || !cdev->handler)
1599 io_subchannel_recog(cdev, sch);
1601 spin_lock_irq(cdev->ccwlock);
1602 while (!dev_fsm_final_state(cdev))
1603 ccw_device_wait_idle(cdev);
1606 get_device(&cdev->dev);
1607 rc = ccw_device_online(cdev);
1611 while (!dev_fsm_final_state(cdev))
1612 ccw_device_wait_idle(cdev);
1614 if (cdev->private->state == DEV_STATE_ONLINE)
1615 cdev->online = 1;
1619 spin_unlock_irq(cdev->ccwlock);
1621 put_device(&cdev->dev);
1628 struct ccw_device *cdev;
1644 cdev = io_subchannel_create_ccwdev(sch);
1645 if (IS_ERR(cdev)) {
1651 return cdev;
1653 cdev->drv = drv;
1654 ccw_device_set_int_class(cdev);
1655 return cdev;
1664 void __init ccw_device_destroy_console(struct ccw_device *cdev)
1666 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1673 put_device(&cdev->dev);
1679 * @cdev: ccw device
1685 void ccw_device_wait_idle(struct ccw_device *cdev)
1687 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1699 int ccw_device_force_console(struct ccw_device *cdev)
1701 return ccw_device_pm_restore(&cdev->dev);
1740 struct ccw_device *cdev = to_ccwdev(dev);
1744 cdev->drv = cdrv; /* to let the driver call _set_online */
1745 ccw_device_set_int_class(cdev);
1746 ret = cdrv->probe ? cdrv->probe(cdev) : -ENODEV;
1748 cdev->drv = NULL;
1749 cdev->private->int_class = IRQIO_CIO;
1758 struct ccw_device *cdev = to_ccwdev(dev);
1759 struct ccw_driver *cdrv = cdev->drv;
1764 cdrv->remove(cdev);
1766 spin_lock_irq(cdev->ccwlock);
1767 if (cdev->online) {
1768 cdev->online = 0;
1769 ret = ccw_device_offline(cdev);
1770 spin_unlock_irq(cdev->ccwlock);
1772 wait_event(cdev->private->wait_q,
1773 dev_fsm_final_state(cdev));
1777 ret, cdev->private->dev_id.ssid,
1778 cdev->private->dev_id.devno);
1780 put_device(&cdev->dev);
1781 spin_lock_irq(cdev->ccwlock);
1783 ccw_device_set_timeout(cdev, 0);
1784 cdev->drv = NULL;
1785 cdev->private->int_class = IRQIO_CIO;
1786 sch = to_subchannel(cdev->dev.parent);
1787 spin_unlock_irq(cdev->ccwlock);
1789 __disable_cmf(cdev);
1796 struct ccw_device *cdev;
1798 cdev = to_ccwdev(dev);
1799 if (cdev->drv && cdev->drv->shutdown)
1800 cdev->drv->shutdown(cdev);
1801 __disable_cmf(cdev);
1806 struct ccw_device *cdev = to_ccwdev(dev);
1808 if (work_pending(&cdev->private->todo_work))
1811 if (atomic_read(&cdev->private->onoff))
1814 if (cdev->online && cdev->drv && cdev->drv->prepare)
1815 return cdev->drv->prepare(cdev);
1822 struct ccw_device *cdev = to_ccwdev(dev);
1824 if (cdev->online && cdev->drv && cdev->drv->complete)
1825 cdev->drv->complete(cdev);
1830 struct ccw_device *cdev = to_ccwdev(dev);
1831 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1835 if (!dev_fsm_final_state(cdev))
1837 if (!cdev->online)
1839 if (cdev->drv && cdev->drv->freeze) {
1840 ret = cdev->drv->freeze(cdev);
1846 cm_enabled = cdev->private->cmb != NULL;
1850 ret = ccw_set_cmf(cdev, 0);
1864 struct ccw_device *cdev = to_ccwdev(dev);
1865 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1868 if (!cdev->online)
1874 cm_enabled = cdev->private->cmb != NULL;
1880 ret = ccw_set_cmf(cdev, 1);
1885 if (cdev->drv && cdev->drv->thaw)
1886 ret = cdev->drv->thaw(cdev);
1891 static void __ccw_device_pm_restore(struct ccw_device *cdev)
1893 struct subchannel *sch = to_subchannel(cdev->dev.parent);
1904 cdev->private->flags.resuming = 1;
1905 cdev->private->path_new_mask = LPM_ANYPATH;
1910 /* cdev may have been moved to a different subchannel. */
1911 sch = to_subchannel(cdev->dev.parent);
1913 if (cdev->private->state != DEV_STATE_ONLINE &&
1914 cdev->private->state != DEV_STATE_OFFLINE)
1917 ccw_device_recognition(cdev);
1919 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev) ||
1920 cdev->private->state == DEV_STATE_DISCONNECTED);
1924 cdev->private->flags.resuming = 0;
1928 static int resume_handle_boxed(struct ccw_device *cdev)
1930 cdev->private->state = DEV_STATE_BOXED;
1931 if (ccw_device_notify(cdev, CIO_BOXED) == NOTIFY_OK)
1933 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
1937 static int resume_handle_disc(struct ccw_device *cdev)
1939 cdev->private->state = DEV_STATE_DISCONNECTED;
1940 if (ccw_device_notify(cdev, CIO_GONE) == NOTIFY_OK)
1942 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
1948 struct ccw_device *cdev = to_ccwdev(dev);
1952 __ccw_device_pm_restore(cdev);
1953 sch = to_subchannel(cdev->dev.parent);
1959 switch (cdev->private->state) {
1962 cdev->private->flags.donotify = 0;
1965 ret = resume_handle_boxed(cdev);
1970 ret = resume_handle_disc(cdev);
1976 if (!ccw_device_test_sense_data(cdev)) {
1977 ccw_device_update_sense_data(cdev);
1978 ccw_device_sched_todo(cdev, CDEV_TODO_REBIND);
1982 if (!cdev->online)
1985 if (ccw_device_online(cdev)) {
1986 ret = resume_handle_disc(cdev);
1992 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));
1995 if (ccw_device_notify(cdev, CIO_OPER) == NOTIFY_BAD) {
1996 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
2002 if (cdev->private->cmb) {
2004 ret = ccw_set_cmf(cdev, 1);
2007 CIO_MSG_EVENT(2, "resume: cdev 0.%x.%04x: cmf failed "
2008 "(rc=%d)\n", cdev->private->dev_id.ssid,
2009 cdev->private->dev_id.devno, ret);
2016 if (cdev->online && cdev->drv && cdev->drv->restore)
2017 ret = cdev->drv->restore(cdev);
2074 struct ccw_device *cdev;
2079 cdev = priv->cdev;
2080 sch = to_subchannel(cdev->dev.parent);
2082 spin_lock_irq(cdev->ccwlock);
2085 CIO_MSG_EVENT(4, "cdev_todo: cdev=0.%x.%04x todo=%d\n",
2087 spin_unlock_irq(cdev->ccwlock);
2091 cmf_reenable(cdev);
2094 ccw_device_do_unbind_bind(cdev);
2097 io_subchannel_register(cdev);
2105 ccw_device_unregister(cdev);
2107 ccw_device_call_sch_unregister(cdev);
2113 put_device(&cdev->dev);
2118 * @cdev: ccw device
2125 void ccw_device_sched_todo(struct ccw_device *cdev, enum cdev_todo todo)
2127 CIO_MSG_EVENT(4, "cdev_todo: sched cdev=0.%x.%04x todo=%d\n",
2128 cdev->private->dev_id.ssid, cdev->private->dev_id.devno,
2130 if (cdev->private->todo >= todo)
2132 cdev->private->todo = todo;
2134 if (!get_device(&cdev->dev))
2136 if (!queue_work(cio_work_q, &cdev->private->todo_work)) {
2138 put_device(&cdev->dev);
2144 * @cdev: ccw device
2149 int ccw_device_siosl(struct ccw_device *cdev)
2151 struct subchannel *sch = to_subchannel(cdev->dev.parent);