1910 lines · c
1// SPDX-License-Identifier: GPL-1.0+2/*3 * bus driver for ccw devices4 *5 * Copyright IBM Corp. 2002, 20086 * Author(s): Arnd Bergmann (arndb@de.ibm.com)7 * Cornelia Huck (cornelia.huck@de.ibm.com)8 * Martin Schwidefsky (schwidefsky@de.ibm.com)9 */10 11#define KMSG_COMPONENT "cio"12#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt13 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>28 29#include <asm/ccwdev.h>30#include <asm/cio.h>31#include <asm/param.h> /* HZ */32#include <asm/cmb.h>33#include <asm/isc.h>34 35#include "chp.h"36#include "cio.h"37#include "cio_debug.h"38#include "css.h"39#include "device.h"40#include "ioasm.h"41#include "io_sch.h"42#include "blacklist.h"43#include "chsc.h"44 45static struct timer_list recovery_timer;46static DEFINE_SPINLOCK(recovery_lock);47static int recovery_phase;48static const unsigned long recovery_delay[] = { 3, 30, 300 };49 50static atomic_t ccw_device_init_count = ATOMIC_INIT(0);51static DECLARE_WAIT_QUEUE_HEAD(ccw_device_init_wq);52static const struct bus_type ccw_bus_type;53 54/******************* bus type handling ***********************/55 56/* The Linux driver model distinguishes between a bus type and57 * the bus itself. Of course we only have one channel58 * subsystem driver and one channel system per machine, but59 * we still use the abstraction. T.R. says it's a good idea. */60static int61ccw_bus_match (struct device * dev, const struct device_driver * drv)62{63 struct ccw_device *cdev = to_ccwdev(dev);64 const struct ccw_driver *cdrv = to_ccwdrv(drv);65 const struct ccw_device_id *ids = cdrv->ids, *found;66 67 if (!ids)68 return 0;69 70 found = ccw_device_id_match(ids, &cdev->id);71 if (!found)72 return 0;73 74 cdev->id.driver_info = found->driver_info;75 76 return 1;77}78 79/* Store modalias string delimited by prefix/suffix string into buffer with80 * specified size. Return length of resulting string (excluding trailing '\0')81 * even if string doesn't fit buffer (snprintf semantics). */82static int snprint_alias(char *buf, size_t size,83 const struct ccw_device_id *id, const char *suffix)84{85 int len;86 87 len = snprintf(buf, size, "ccw:t%04Xm%02X", id->cu_type, id->cu_model);88 if (len > size)89 return len;90 buf += len;91 size -= len;92 93 if (id->dev_type != 0)94 len += snprintf(buf, size, "dt%04Xdm%02X%s", id->dev_type,95 id->dev_model, suffix);96 else97 len += snprintf(buf, size, "dtdm%s", suffix);98 99 return len;100}101 102/* Set up environment variables for ccw device uevent. Return 0 on success,103 * non-zero otherwise. */104static int ccw_uevent(const struct device *dev, struct kobj_uevent_env *env)105{106 const struct ccw_device *cdev = to_ccwdev(dev);107 const struct ccw_device_id *id = &(cdev->id);108 int ret;109 char modalias_buf[30];110 111 /* CU_TYPE= */112 ret = add_uevent_var(env, "CU_TYPE=%04X", id->cu_type);113 if (ret)114 return ret;115 116 /* CU_MODEL= */117 ret = add_uevent_var(env, "CU_MODEL=%02X", id->cu_model);118 if (ret)119 return ret;120 121 /* The next two can be zero, that's ok for us */122 /* DEV_TYPE= */123 ret = add_uevent_var(env, "DEV_TYPE=%04X", id->dev_type);124 if (ret)125 return ret;126 127 /* DEV_MODEL= */128 ret = add_uevent_var(env, "DEV_MODEL=%02X", id->dev_model);129 if (ret)130 return ret;131 132 /* MODALIAS= */133 snprint_alias(modalias_buf, sizeof(modalias_buf), id, "");134 ret = add_uevent_var(env, "MODALIAS=%s", modalias_buf);135 return ret;136}137 138static void io_subchannel_irq(struct subchannel *);139static int io_subchannel_probe(struct subchannel *);140static void io_subchannel_remove(struct subchannel *);141static void io_subchannel_shutdown(struct subchannel *);142static int io_subchannel_sch_event(struct subchannel *, int);143static int io_subchannel_chp_event(struct subchannel *, struct chp_link *,144 int);145static void recovery_func(struct timer_list *unused);146 147static struct css_device_id io_subchannel_ids[] = {148 { .match_flags = 0x1, .type = SUBCHANNEL_TYPE_IO, },149 { /* end of list */ },150};151 152static int io_subchannel_settle(void)153{154 int ret;155 156 ret = wait_event_interruptible(ccw_device_init_wq,157 atomic_read(&ccw_device_init_count) == 0);158 if (ret)159 return -EINTR;160 flush_workqueue(cio_work_q);161 return 0;162}163 164static struct css_driver io_subchannel_driver = {165 .drv = {166 .owner = THIS_MODULE,167 .name = "io_subchannel",168 },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,177};178 179int __init io_subchannel_init(void)180{181 int ret;182 183 timer_setup(&recovery_timer, recovery_func, 0);184 ret = bus_register(&ccw_bus_type);185 if (ret)186 return ret;187 ret = css_driver_register(&io_subchannel_driver);188 if (ret)189 bus_unregister(&ccw_bus_type);190 191 return ret;192}193 194 195/************************ device handling **************************/196 197static ssize_t198devtype_show (struct device *dev, struct device_attribute *attr, char *buf)199{200 struct ccw_device *cdev = to_ccwdev(dev);201 struct ccw_device_id *id = &(cdev->id);202 203 if (id->dev_type != 0)204 return sprintf(buf, "%04x/%02x\n",205 id->dev_type, id->dev_model);206 else207 return sprintf(buf, "n/a\n");208}209 210static ssize_t211cutype_show (struct device *dev, struct device_attribute *attr, char *buf)212{213 struct ccw_device *cdev = to_ccwdev(dev);214 struct ccw_device_id *id = &(cdev->id);215 216 return sprintf(buf, "%04x/%02x\n",217 id->cu_type, id->cu_model);218}219 220static ssize_t221modalias_show (struct device *dev, struct device_attribute *attr, char *buf)222{223 struct ccw_device *cdev = to_ccwdev(dev);224 struct ccw_device_id *id = &(cdev->id);225 int len;226 227 len = snprint_alias(buf, PAGE_SIZE, id, "\n");228 229 return len > PAGE_SIZE ? PAGE_SIZE : len;230}231 232static ssize_t233online_show (struct device *dev, struct device_attribute *attr, char *buf)234{235 struct ccw_device *cdev = to_ccwdev(dev);236 237 return sprintf(buf, cdev->online ? "1\n" : "0\n");238}239 240int ccw_device_is_orphan(struct ccw_device *cdev)241{242 return sch_is_pseudo_sch(to_subchannel(cdev->dev.parent));243}244 245static void ccw_device_unregister(struct ccw_device *cdev)246{247 mutex_lock(&cdev->reg_mutex);248 if (device_is_registered(&cdev->dev)) {249 /* Undo device_add(). */250 device_del(&cdev->dev);251 }252 mutex_unlock(&cdev->reg_mutex);253 254 if (cdev->private->flags.initialized) {255 cdev->private->flags.initialized = 0;256 /* Release reference from device_initialize(). */257 put_device(&cdev->dev);258 }259}260 261static void io_subchannel_quiesce(struct subchannel *);262 263/**264 * ccw_device_set_offline() - disable a ccw device for I/O265 * @cdev: target ccw device266 *267 * This function calls the driver's set_offline() function for @cdev, if268 * given, and then disables @cdev.269 * Returns:270 * %0 on success and a negative error value on failure.271 * Context:272 * enabled, ccw device lock not held273 */274int ccw_device_set_offline(struct ccw_device *cdev)275{276 struct subchannel *sch;277 int ret, state;278 279 if (!cdev)280 return -ENODEV;281 if (!cdev->online || !cdev->drv)282 return -EINVAL;283 284 if (cdev->drv->set_offline) {285 ret = cdev->drv->set_offline(cdev);286 if (ret != 0)287 return ret;288 }289 spin_lock_irq(cdev->ccwlock);290 sch = to_subchannel(cdev->dev.parent);291 cdev->online = 0;292 /* Wait until a final state or DISCONNECTED is reached */293 while (!dev_fsm_final_state(cdev) &&294 cdev->private->state != DEV_STATE_DISCONNECTED) {295 spin_unlock_irq(cdev->ccwlock);296 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||297 cdev->private->state == DEV_STATE_DISCONNECTED));298 spin_lock_irq(cdev->ccwlock);299 }300 do {301 ret = ccw_device_offline(cdev);302 if (!ret)303 break;304 CIO_MSG_EVENT(0, "ccw_device_offline returned %d, device "305 "0.%x.%04x\n", ret, cdev->private->dev_id.ssid,306 cdev->private->dev_id.devno);307 if (ret != -EBUSY)308 goto error;309 state = cdev->private->state;310 spin_unlock_irq(cdev->ccwlock);311 io_subchannel_quiesce(sch);312 spin_lock_irq(cdev->ccwlock);313 cdev->private->state = state;314 } while (ret == -EBUSY);315 spin_unlock_irq(cdev->ccwlock);316 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||317 cdev->private->state == DEV_STATE_DISCONNECTED));318 /* Inform the user if set offline failed. */319 if (cdev->private->state == DEV_STATE_BOXED) {320 pr_warn("%s: The device entered boxed state while being set offline\n",321 dev_name(&cdev->dev));322 } else if (cdev->private->state == DEV_STATE_NOT_OPER) {323 pr_warn("%s: The device stopped operating while being set offline\n",324 dev_name(&cdev->dev));325 }326 /* Give up reference from ccw_device_set_online(). */327 put_device(&cdev->dev);328 return 0;329 330error:331 cdev->private->state = DEV_STATE_OFFLINE;332 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);333 spin_unlock_irq(cdev->ccwlock);334 /* Give up reference from ccw_device_set_online(). */335 put_device(&cdev->dev);336 return -ENODEV;337}338 339/**340 * ccw_device_set_online() - enable a ccw device for I/O341 * @cdev: target ccw device342 *343 * This function first enables @cdev and then calls the driver's set_online()344 * function for @cdev, if given. If set_online() returns an error, @cdev is345 * disabled again.346 * Returns:347 * %0 on success and a negative error value on failure.348 * Context:349 * enabled, ccw device lock not held350 */351int ccw_device_set_online(struct ccw_device *cdev)352{353 int ret;354 int ret2;355 356 if (!cdev)357 return -ENODEV;358 if (cdev->online || !cdev->drv)359 return -EINVAL;360 /* Hold on to an extra reference while device is online. */361 if (!get_device(&cdev->dev))362 return -ENODEV;363 364 spin_lock_irq(cdev->ccwlock);365 ret = ccw_device_online(cdev);366 if (ret) {367 spin_unlock_irq(cdev->ccwlock);368 CIO_MSG_EVENT(0, "ccw_device_online returned %d, "369 "device 0.%x.%04x\n",370 ret, cdev->private->dev_id.ssid,371 cdev->private->dev_id.devno);372 /* Give up online reference since onlining failed. */373 put_device(&cdev->dev);374 return ret;375 }376 /* Wait until a final state is reached */377 while (!dev_fsm_final_state(cdev)) {378 spin_unlock_irq(cdev->ccwlock);379 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev));380 spin_lock_irq(cdev->ccwlock);381 }382 /* Check if online processing was successful */383 if ((cdev->private->state != DEV_STATE_ONLINE) &&384 (cdev->private->state != DEV_STATE_W4SENSE)) {385 spin_unlock_irq(cdev->ccwlock);386 /* Inform the user that set online failed. */387 if (cdev->private->state == DEV_STATE_BOXED) {388 pr_warn("%s: Setting the device online failed because it is boxed\n",389 dev_name(&cdev->dev));390 } else if (cdev->private->state == DEV_STATE_NOT_OPER) {391 pr_warn("%s: Setting the device online failed because it is not operational\n",392 dev_name(&cdev->dev));393 }394 /* Give up online reference since onlining failed. */395 put_device(&cdev->dev);396 return -ENODEV;397 }398 spin_unlock_irq(cdev->ccwlock);399 if (cdev->drv->set_online)400 ret = cdev->drv->set_online(cdev);401 if (ret)402 goto rollback;403 404 spin_lock_irq(cdev->ccwlock);405 cdev->online = 1;406 spin_unlock_irq(cdev->ccwlock);407 return 0;408 409rollback:410 spin_lock_irq(cdev->ccwlock);411 /* Wait until a final state or DISCONNECTED is reached */412 while (!dev_fsm_final_state(cdev) &&413 cdev->private->state != DEV_STATE_DISCONNECTED) {414 spin_unlock_irq(cdev->ccwlock);415 wait_event(cdev->private->wait_q, (dev_fsm_final_state(cdev) ||416 cdev->private->state == DEV_STATE_DISCONNECTED));417 spin_lock_irq(cdev->ccwlock);418 }419 ret2 = ccw_device_offline(cdev);420 if (ret2)421 goto error;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 /* Give up online reference since onlining failed. */426 put_device(&cdev->dev);427 return ret;428 429error:430 CIO_MSG_EVENT(0, "rollback ccw_device_offline returned %d, "431 "device 0.%x.%04x\n",432 ret2, cdev->private->dev_id.ssid,433 cdev->private->dev_id.devno);434 cdev->private->state = DEV_STATE_OFFLINE;435 spin_unlock_irq(cdev->ccwlock);436 /* Give up online reference since onlining failed. */437 put_device(&cdev->dev);438 return ret;439}440 441static int online_store_handle_offline(struct ccw_device *cdev)442{443 if (cdev->private->state == DEV_STATE_DISCONNECTED) {444 spin_lock_irq(cdev->ccwlock);445 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG_EVAL);446 spin_unlock_irq(cdev->ccwlock);447 return 0;448 }449 if (cdev->drv && cdev->drv->set_offline)450 return ccw_device_set_offline(cdev);451 return -EINVAL;452}453 454static int online_store_recog_and_online(struct ccw_device *cdev)455{456 /* Do device recognition, if needed. */457 if (cdev->private->state == DEV_STATE_BOXED) {458 spin_lock_irq(cdev->ccwlock);459 ccw_device_recognition(cdev);460 spin_unlock_irq(cdev->ccwlock);461 wait_event(cdev->private->wait_q,462 cdev->private->flags.recog_done);463 if (cdev->private->state != DEV_STATE_OFFLINE)464 /* recognition failed */465 return -EAGAIN;466 }467 if (cdev->drv && cdev->drv->set_online)468 return ccw_device_set_online(cdev);469 return -EINVAL;470}471 472static int online_store_handle_online(struct ccw_device *cdev, int force)473{474 int ret;475 476 ret = online_store_recog_and_online(cdev);477 if (ret && !force)478 return ret;479 if (force && cdev->private->state == DEV_STATE_BOXED) {480 ret = ccw_device_stlck(cdev);481 if (ret)482 return ret;483 if (cdev->id.cu_type == 0)484 cdev->private->state = DEV_STATE_NOT_OPER;485 ret = online_store_recog_and_online(cdev);486 if (ret)487 return ret;488 }489 return 0;490}491 492static ssize_t online_store (struct device *dev, struct device_attribute *attr,493 const char *buf, size_t count)494{495 struct ccw_device *cdev = to_ccwdev(dev);496 int force, ret;497 unsigned long i;498 499 /* Prevent conflict between multiple on-/offline processing requests. */500 if (atomic_cmpxchg(&cdev->private->onoff, 0, 1) != 0)501 return -EAGAIN;502 /* Prevent conflict between internal I/Os and on-/offline processing. */503 if (!dev_fsm_final_state(cdev) &&504 cdev->private->state != DEV_STATE_DISCONNECTED) {505 ret = -EAGAIN;506 goto out;507 }508 /* Prevent conflict between pending work and on-/offline processing.*/509 if (work_pending(&cdev->private->todo_work)) {510 ret = -EAGAIN;511 goto out;512 }513 if (!strncmp(buf, "force\n", count)) {514 force = 1;515 i = 1;516 ret = 0;517 } else {518 force = 0;519 ret = kstrtoul(buf, 16, &i);520 }521 if (ret)522 goto out;523 524 device_lock(dev);525 switch (i) {526 case 0:527 ret = online_store_handle_offline(cdev);528 break;529 case 1:530 ret = online_store_handle_online(cdev, force);531 break;532 default:533 ret = -EINVAL;534 }535 device_unlock(dev);536 537out:538 atomic_set(&cdev->private->onoff, 0);539 return (ret < 0) ? ret : count;540}541 542static ssize_t543available_show (struct device *dev, struct device_attribute *attr, char *buf)544{545 struct ccw_device *cdev = to_ccwdev(dev);546 struct subchannel *sch;547 548 if (ccw_device_is_orphan(cdev))549 return sprintf(buf, "no device\n");550 switch (cdev->private->state) {551 case DEV_STATE_BOXED:552 return sprintf(buf, "boxed\n");553 case DEV_STATE_DISCONNECTED:554 case DEV_STATE_DISCONNECTED_SENSE_ID:555 case DEV_STATE_NOT_OPER:556 sch = to_subchannel(dev->parent);557 if (!sch->lpm)558 return sprintf(buf, "no path\n");559 else560 return sprintf(buf, "no device\n");561 default:562 /* All other states considered fine. */563 return sprintf(buf, "good\n");564 }565}566 567static ssize_t568initiate_logging(struct device *dev, struct device_attribute *attr,569 const char *buf, size_t count)570{571 struct subchannel *sch = to_subchannel(dev);572 int rc;573 574 rc = chsc_siosl(sch->schid);575 if (rc < 0) {576 pr_warn("Logging for subchannel 0.%x.%04x failed with errno=%d\n",577 sch->schid.ssid, sch->schid.sch_no, rc);578 return rc;579 }580 pr_notice("Logging for subchannel 0.%x.%04x was triggered\n",581 sch->schid.ssid, sch->schid.sch_no);582 return count;583}584 585static ssize_t vpm_show(struct device *dev, struct device_attribute *attr,586 char *buf)587{588 struct subchannel *sch = to_subchannel(dev);589 590 return sprintf(buf, "%02x\n", sch->vpm);591}592 593static DEVICE_ATTR_RO(devtype);594static DEVICE_ATTR_RO(cutype);595static DEVICE_ATTR_RO(modalias);596static DEVICE_ATTR_RW(online);597static DEVICE_ATTR(availability, 0444, available_show, NULL);598static DEVICE_ATTR(logging, 0200, NULL, initiate_logging);599static DEVICE_ATTR_RO(vpm);600 601static struct attribute *io_subchannel_attrs[] = {602 &dev_attr_logging.attr,603 &dev_attr_vpm.attr,604 NULL,605};606 607static const struct attribute_group io_subchannel_attr_group = {608 .attrs = io_subchannel_attrs,609};610 611static struct attribute * ccwdev_attrs[] = {612 &dev_attr_devtype.attr,613 &dev_attr_cutype.attr,614 &dev_attr_modalias.attr,615 &dev_attr_online.attr,616 &dev_attr_cmb_enable.attr,617 &dev_attr_availability.attr,618 NULL,619};620 621static const struct attribute_group ccwdev_attr_group = {622 .attrs = ccwdev_attrs,623};624 625static const struct attribute_group *ccwdev_attr_groups[] = {626 &ccwdev_attr_group,627 NULL,628};629 630static int match_dev_id(struct device *dev, const void *data)631{632 struct ccw_device *cdev = to_ccwdev(dev);633 struct ccw_dev_id *dev_id = (void *)data;634 635 return ccw_dev_id_is_equal(&cdev->private->dev_id, dev_id);636}637 638/**639 * get_ccwdev_by_dev_id() - obtain device from a ccw device id640 * @dev_id: id of the device to be searched641 *642 * This function searches all devices attached to the ccw bus for a device643 * matching @dev_id.644 * Returns:645 * If a device is found its reference count is increased and returned;646 * else %NULL is returned.647 */648struct ccw_device *get_ccwdev_by_dev_id(struct ccw_dev_id *dev_id)649{650 struct device *dev;651 652 dev = bus_find_device(&ccw_bus_type, NULL, dev_id, match_dev_id);653 654 return dev ? to_ccwdev(dev) : NULL;655}656EXPORT_SYMBOL_GPL(get_ccwdev_by_dev_id);657 658static void ccw_device_do_unbind_bind(struct ccw_device *cdev)659{660 int ret;661 662 mutex_lock(&cdev->reg_mutex);663 if (device_is_registered(&cdev->dev)) {664 device_release_driver(&cdev->dev);665 ret = device_attach(&cdev->dev);666 WARN_ON(ret == -ENODEV);667 }668 mutex_unlock(&cdev->reg_mutex);669}670 671static void672ccw_device_release(struct device *dev)673{674 struct ccw_device *cdev;675 676 cdev = to_ccwdev(dev);677 cio_gp_dma_free(cdev->private->dma_pool, cdev->private->dma_area,678 sizeof(*cdev->private->dma_area));679 cio_gp_dma_destroy(cdev->private->dma_pool, &cdev->dev);680 /* Release reference of parent subchannel. */681 put_device(cdev->dev.parent);682 kfree(cdev->private);683 kfree(cdev);684}685 686static struct ccw_device * io_subchannel_allocate_dev(struct subchannel *sch)687{688 struct ccw_device *cdev;689 struct gen_pool *dma_pool;690 int ret;691 692 cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);693 if (!cdev) {694 ret = -ENOMEM;695 goto err_cdev;696 }697 cdev->private = kzalloc(sizeof(struct ccw_device_private),698 GFP_KERNEL | GFP_DMA);699 if (!cdev->private) {700 ret = -ENOMEM;701 goto err_priv;702 }703 704 cdev->dev.dma_mask = sch->dev.dma_mask;705 ret = dma_set_coherent_mask(&cdev->dev, sch->dev.coherent_dma_mask);706 if (ret)707 goto err_coherent_mask;708 709 dma_pool = cio_gp_dma_create(&cdev->dev, 1);710 if (!dma_pool) {711 ret = -ENOMEM;712 goto err_dma_pool;713 }714 cdev->private->dma_pool = dma_pool;715 cdev->private->dma_area = cio_gp_dma_zalloc(dma_pool, &cdev->dev,716 sizeof(*cdev->private->dma_area));717 if (!cdev->private->dma_area) {718 ret = -ENOMEM;719 goto err_dma_area;720 }721 return cdev;722err_dma_area:723 cio_gp_dma_destroy(dma_pool, &cdev->dev);724err_dma_pool:725err_coherent_mask:726 kfree(cdev->private);727err_priv:728 kfree(cdev);729err_cdev:730 return ERR_PTR(ret);731}732 733static void ccw_device_todo(struct work_struct *work);734 735static int io_subchannel_initialize_dev(struct subchannel *sch,736 struct ccw_device *cdev)737{738 struct ccw_device_private *priv = cdev->private;739 int ret;740 741 priv->cdev = cdev;742 priv->int_class = IRQIO_CIO;743 priv->state = DEV_STATE_NOT_OPER;744 priv->dev_id.devno = sch->schib.pmcw.dev;745 priv->dev_id.ssid = sch->schid.ssid;746 747 INIT_WORK(&priv->todo_work, ccw_device_todo);748 INIT_LIST_HEAD(&priv->cmb_list);749 init_waitqueue_head(&priv->wait_q);750 timer_setup(&priv->timer, ccw_device_timeout, 0);751 mutex_init(&cdev->reg_mutex);752 753 atomic_set(&priv->onoff, 0);754 cdev->ccwlock = &sch->lock;755 cdev->dev.parent = &sch->dev;756 cdev->dev.release = ccw_device_release;757 cdev->dev.bus = &ccw_bus_type;758 cdev->dev.groups = ccwdev_attr_groups;759 /* Do first half of device_register. */760 device_initialize(&cdev->dev);761 ret = dev_set_name(&cdev->dev, "0.%x.%04x", cdev->private->dev_id.ssid,762 cdev->private->dev_id.devno);763 if (ret)764 goto out_put;765 if (!get_device(&sch->dev)) {766 ret = -ENODEV;767 goto out_put;768 }769 priv->flags.initialized = 1;770 spin_lock_irq(&sch->lock);771 sch_set_cdev(sch, cdev);772 spin_unlock_irq(&sch->lock);773 return 0;774 775out_put:776 /* Release reference from device_initialize(). */777 put_device(&cdev->dev);778 return ret;779}780 781static struct ccw_device * io_subchannel_create_ccwdev(struct subchannel *sch)782{783 struct ccw_device *cdev;784 int ret;785 786 cdev = io_subchannel_allocate_dev(sch);787 if (!IS_ERR(cdev)) {788 ret = io_subchannel_initialize_dev(sch, cdev);789 if (ret)790 cdev = ERR_PTR(ret);791 }792 return cdev;793}794 795static void io_subchannel_recog(struct ccw_device *, struct subchannel *);796 797static void sch_create_and_recog_new_device(struct subchannel *sch)798{799 struct ccw_device *cdev;800 801 /* Need to allocate a new ccw device. */802 cdev = io_subchannel_create_ccwdev(sch);803 if (IS_ERR(cdev)) {804 /* OK, we did everything we could... */805 css_sch_device_unregister(sch);806 return;807 }808 /* Start recognition for the new ccw device. */809 io_subchannel_recog(cdev, sch);810}811 812/*813 * Register recognized device.814 */815static void io_subchannel_register(struct ccw_device *cdev)816{817 struct subchannel *sch;818 int ret, adjust_init_count = 1;819 unsigned long flags;820 821 sch = to_subchannel(cdev->dev.parent);822 /*823 * Check if subchannel is still registered. It may have become824 * unregistered if a machine check hit us after finishing825 * device recognition but before the register work could be826 * queued.827 */828 if (!device_is_registered(&sch->dev))829 goto out_err;830 css_update_ssd_info(sch);831 /*832 * io_subchannel_register() will also be called after device833 * recognition has been done for a boxed device (which will already834 * be registered). We need to reprobe since we may now have sense id835 * information.836 */837 mutex_lock(&cdev->reg_mutex);838 if (device_is_registered(&cdev->dev)) {839 if (!cdev->drv) {840 ret = device_reprobe(&cdev->dev);841 if (ret)842 /* We can't do much here. */843 CIO_MSG_EVENT(0, "device_reprobe() returned"844 " %d for 0.%x.%04x\n", ret,845 cdev->private->dev_id.ssid,846 cdev->private->dev_id.devno);847 }848 adjust_init_count = 0;849 goto out;850 }851 /* make it known to the system */852 ret = device_add(&cdev->dev);853 if (ret) {854 CIO_MSG_EVENT(0, "Could not register ccw dev 0.%x.%04x: %d\n",855 cdev->private->dev_id.ssid,856 cdev->private->dev_id.devno, ret);857 spin_lock_irqsave(&sch->lock, flags);858 sch_set_cdev(sch, NULL);859 spin_unlock_irqrestore(&sch->lock, flags);860 mutex_unlock(&cdev->reg_mutex);861 /* Release initial device reference. */862 put_device(&cdev->dev);863 goto out_err;864 }865out:866 cdev->private->flags.recog_done = 1;867 mutex_unlock(&cdev->reg_mutex);868 wake_up(&cdev->private->wait_q);869out_err:870 if (adjust_init_count && atomic_dec_and_test(&ccw_device_init_count))871 wake_up(&ccw_device_init_wq);872}873 874/*875 * subchannel recognition done. Called from the state machine.876 */877void878io_subchannel_recog_done(struct ccw_device *cdev)879{880 if (css_init_done == 0) {881 cdev->private->flags.recog_done = 1;882 return;883 }884 switch (cdev->private->state) {885 case DEV_STATE_BOXED:886 /* Device did not respond in time. */887 case DEV_STATE_NOT_OPER:888 cdev->private->flags.recog_done = 1;889 /* Remove device found not operational. */890 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);891 if (atomic_dec_and_test(&ccw_device_init_count))892 wake_up(&ccw_device_init_wq);893 break;894 case DEV_STATE_OFFLINE:895 /*896 * We can't register the device in interrupt context so897 * we schedule a work item.898 */899 ccw_device_sched_todo(cdev, CDEV_TODO_REGISTER);900 break;901 }902}903 904static void io_subchannel_recog(struct ccw_device *cdev, struct subchannel *sch)905{906 /* Increase counter of devices currently in recognition. */907 atomic_inc(&ccw_device_init_count);908 909 /* Start async. device sensing. */910 spin_lock_irq(&sch->lock);911 ccw_device_recognition(cdev);912 spin_unlock_irq(&sch->lock);913}914 915static int ccw_device_move_to_sch(struct ccw_device *cdev,916 struct subchannel *sch)917{918 struct subchannel *old_sch;919 int rc, old_enabled = 0;920 921 old_sch = to_subchannel(cdev->dev.parent);922 /* Obtain child reference for new parent. */923 if (!get_device(&sch->dev))924 return -ENODEV;925 926 if (!sch_is_pseudo_sch(old_sch)) {927 spin_lock_irq(&old_sch->lock);928 old_enabled = old_sch->schib.pmcw.ena;929 rc = 0;930 if (old_enabled)931 rc = cio_disable_subchannel(old_sch);932 spin_unlock_irq(&old_sch->lock);933 if (rc == -EBUSY) {934 /* Release child reference for new parent. */935 put_device(&sch->dev);936 return rc;937 }938 }939 940 mutex_lock(&sch->reg_mutex);941 rc = device_move(&cdev->dev, &sch->dev, DPM_ORDER_PARENT_BEFORE_DEV);942 mutex_unlock(&sch->reg_mutex);943 if (rc) {944 CIO_MSG_EVENT(0, "device_move(0.%x.%04x,0.%x.%04x)=%d\n",945 cdev->private->dev_id.ssid,946 cdev->private->dev_id.devno, sch->schid.ssid,947 sch->schib.pmcw.dev, rc);948 if (old_enabled) {949 /* Try to re-enable the old subchannel. */950 spin_lock_irq(&old_sch->lock);951 cio_enable_subchannel(old_sch, (u32)virt_to_phys(old_sch));952 spin_unlock_irq(&old_sch->lock);953 }954 /* Release child reference for new parent. */955 put_device(&sch->dev);956 return rc;957 }958 /* Clean up old subchannel. */959 if (!sch_is_pseudo_sch(old_sch)) {960 spin_lock_irq(&old_sch->lock);961 sch_set_cdev(old_sch, NULL);962 spin_unlock_irq(&old_sch->lock);963 css_schedule_eval(old_sch->schid);964 }965 /* Release child reference for old parent. */966 put_device(&old_sch->dev);967 /* Initialize new subchannel. */968 spin_lock_irq(&sch->lock);969 cdev->ccwlock = &sch->lock;970 if (!sch_is_pseudo_sch(sch))971 sch_set_cdev(sch, cdev);972 spin_unlock_irq(&sch->lock);973 if (!sch_is_pseudo_sch(sch))974 css_update_ssd_info(sch);975 return 0;976}977 978static int ccw_device_move_to_orph(struct ccw_device *cdev)979{980 struct subchannel *sch = to_subchannel(cdev->dev.parent);981 struct channel_subsystem *css = to_css(sch->dev.parent);982 983 return ccw_device_move_to_sch(cdev, css->pseudo_subchannel);984}985 986static void io_subchannel_irq(struct subchannel *sch)987{988 struct ccw_device *cdev;989 990 cdev = sch_get_cdev(sch);991 992 CIO_TRACE_EVENT(6, "IRQ");993 CIO_TRACE_EVENT(6, dev_name(&sch->dev));994 if (cdev)995 dev_fsm_event(cdev, DEV_EVENT_INTERRUPT);996 else997 inc_irq_stat(IRQIO_CIO);998}999 1000void io_subchannel_init_config(struct subchannel *sch)1001{1002 memset(&sch->config, 0, sizeof(sch->config));1003 sch->config.csense = 1;1004}1005 1006static void io_subchannel_init_fields(struct subchannel *sch)1007{1008 if (cio_is_console(sch->schid))1009 sch->opm = 0xff;1010 else1011 sch->opm = chp_get_sch_opm(sch);1012 sch->lpm = sch->schib.pmcw.pam & sch->opm;1013 sch->isc = cio_is_console(sch->schid) ? CONSOLE_ISC : IO_SCH_ISC;1014 1015 CIO_MSG_EVENT(6, "Detected device %04x on subchannel 0.%x.%04X"1016 " - PIM = %02X, PAM = %02X, POM = %02X\n",1017 sch->schib.pmcw.dev, sch->schid.ssid,1018 sch->schid.sch_no, sch->schib.pmcw.pim,1019 sch->schib.pmcw.pam, sch->schib.pmcw.pom);1020 1021 io_subchannel_init_config(sch);1022}1023 1024/*1025 * Note: We always return 0 so that we bind to the device even on error.1026 * This is needed so that our remove function is called on unregister.1027 */1028static int io_subchannel_probe(struct subchannel *sch)1029{1030 struct io_subchannel_private *io_priv;1031 struct ccw_device *cdev;1032 int rc;1033 1034 if (cio_is_console(sch->schid)) {1035 rc = sysfs_create_group(&sch->dev.kobj,1036 &io_subchannel_attr_group);1037 if (rc)1038 CIO_MSG_EVENT(0, "Failed to create io subchannel "1039 "attributes for subchannel "1040 "0.%x.%04x (rc=%d)\n",1041 sch->schid.ssid, sch->schid.sch_no, rc);1042 /*1043 * The console subchannel already has an associated ccw_device.1044 * Register it and exit.1045 */1046 cdev = sch_get_cdev(sch);1047 rc = device_add(&cdev->dev);1048 if (rc) {1049 /* Release online reference. */1050 put_device(&cdev->dev);1051 goto out_schedule;1052 }1053 if (atomic_dec_and_test(&ccw_device_init_count))1054 wake_up(&ccw_device_init_wq);1055 return 0;1056 }1057 io_subchannel_init_fields(sch);1058 rc = cio_commit_config(sch);1059 if (rc)1060 goto out_schedule;1061 rc = sysfs_create_group(&sch->dev.kobj,1062 &io_subchannel_attr_group);1063 if (rc)1064 goto out_schedule;1065 /* Allocate I/O subchannel private data. */1066 io_priv = kzalloc(sizeof(*io_priv), GFP_KERNEL | GFP_DMA);1067 if (!io_priv)1068 goto out_schedule;1069 1070 io_priv->dma_area = dma_alloc_coherent(&sch->dev,1071 sizeof(*io_priv->dma_area),1072 &io_priv->dma_area_dma, GFP_KERNEL);1073 if (!io_priv->dma_area) {1074 kfree(io_priv);1075 goto out_schedule;1076 }1077 1078 set_io_private(sch, io_priv);1079 css_schedule_eval(sch->schid);1080 return 0;1081 1082out_schedule:1083 spin_lock_irq(&sch->lock);1084 css_sched_sch_todo(sch, SCH_TODO_UNREG);1085 spin_unlock_irq(&sch->lock);1086 return 0;1087}1088 1089static void io_subchannel_remove(struct subchannel *sch)1090{1091 struct io_subchannel_private *io_priv = to_io_private(sch);1092 struct ccw_device *cdev;1093 1094 cdev = sch_get_cdev(sch);1095 if (!cdev)1096 goto out_free;1097 1098 ccw_device_unregister(cdev);1099 spin_lock_irq(&sch->lock);1100 sch_set_cdev(sch, NULL);1101 set_io_private(sch, NULL);1102 spin_unlock_irq(&sch->lock);1103out_free:1104 dma_free_coherent(&sch->dev, sizeof(*io_priv->dma_area),1105 io_priv->dma_area, io_priv->dma_area_dma);1106 kfree(io_priv);1107 sysfs_remove_group(&sch->dev.kobj, &io_subchannel_attr_group);1108}1109 1110static void io_subchannel_verify(struct subchannel *sch)1111{1112 struct ccw_device *cdev;1113 1114 cdev = sch_get_cdev(sch);1115 if (cdev)1116 dev_fsm_event(cdev, DEV_EVENT_VERIFY);1117 else1118 css_schedule_eval(sch->schid);1119}1120 1121static void io_subchannel_terminate_path(struct subchannel *sch, u8 mask)1122{1123 struct ccw_device *cdev;1124 1125 cdev = sch_get_cdev(sch);1126 if (!cdev)1127 return;1128 if (cio_update_schib(sch))1129 goto err;1130 /* Check for I/O on path. */1131 if (scsw_actl(&sch->schib.scsw) == 0 || sch->schib.pmcw.lpum != mask)1132 goto out;1133 if (cdev->private->state == DEV_STATE_ONLINE) {1134 ccw_device_kill_io(cdev);1135 goto out;1136 }1137 if (cio_clear(sch))1138 goto err;1139out:1140 /* Trigger path verification. */1141 dev_fsm_event(cdev, DEV_EVENT_VERIFY);1142 return;1143 1144err:1145 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);1146}1147 1148static int io_subchannel_chp_event(struct subchannel *sch,1149 struct chp_link *link, int event)1150{1151 struct ccw_device *cdev = sch_get_cdev(sch);1152 int mask, chpid, valid_bit;1153 int path_event[8];1154 1155 mask = chp_ssd_get_mask(&sch->ssd_info, link);1156 if (!mask)1157 return 0;1158 switch (event) {1159 case CHP_VARY_OFF:1160 sch->opm &= ~mask;1161 sch->lpm &= ~mask;1162 if (cdev)1163 cdev->private->path_gone_mask |= mask;1164 io_subchannel_terminate_path(sch, mask);1165 break;1166 case CHP_VARY_ON:1167 sch->opm |= mask;1168 sch->lpm |= mask;1169 if (cdev)1170 cdev->private->path_new_mask |= mask;1171 io_subchannel_verify(sch);1172 break;1173 case CHP_OFFLINE:1174 if (cio_update_schib(sch))1175 return -ENODEV;1176 if (cdev)1177 cdev->private->path_gone_mask |= mask;1178 io_subchannel_terminate_path(sch, mask);1179 break;1180 case CHP_ONLINE:1181 if (cio_update_schib(sch))1182 return -ENODEV;1183 sch->lpm |= mask & sch->opm;1184 if (cdev)1185 cdev->private->path_new_mask |= mask;1186 io_subchannel_verify(sch);1187 break;1188 case CHP_FCES_EVENT:1189 /* Forward Endpoint Security event */1190 for (chpid = 0, valid_bit = 0x80; chpid < 8; chpid++,1191 valid_bit >>= 1) {1192 if (mask & valid_bit)1193 path_event[chpid] = PE_PATH_FCES_EVENT;1194 else1195 path_event[chpid] = PE_NONE;1196 }1197 if (cdev && cdev->drv && cdev->drv->path_event)1198 cdev->drv->path_event(cdev, path_event);1199 break;1200 }1201 return 0;1202}1203 1204static void io_subchannel_quiesce(struct subchannel *sch)1205{1206 struct ccw_device *cdev;1207 int ret;1208 1209 spin_lock_irq(&sch->lock);1210 cdev = sch_get_cdev(sch);1211 if (cio_is_console(sch->schid))1212 goto out_unlock;1213 if (!sch->schib.pmcw.ena)1214 goto out_unlock;1215 ret = cio_disable_subchannel(sch);1216 if (ret != -EBUSY)1217 goto out_unlock;1218 if (cdev->handler)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);1230 }1231 ret = cio_disable_subchannel(sch);1232 }1233out_unlock:1234 spin_unlock_irq(&sch->lock);1235}1236 1237static void io_subchannel_shutdown(struct subchannel *sch)1238{1239 io_subchannel_quiesce(sch);1240}1241 1242static int device_is_disconnected(struct ccw_device *cdev)1243{1244 if (!cdev)1245 return 0;1246 return (cdev->private->state == DEV_STATE_DISCONNECTED ||1247 cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID);1248}1249 1250static int recovery_check(struct device *dev, void *data)1251{1252 struct ccw_device *cdev = to_ccwdev(dev);1253 struct subchannel *sch;1254 int *redo = data;1255 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)1261 break;1262 fallthrough;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);1268 *redo = 1;1269 break;1270 case DEV_STATE_DISCONNECTED_SENSE_ID:1271 *redo = 1;1272 break;1273 }1274 spin_unlock_irq(cdev->ccwlock);1275 1276 return 0;1277}1278 1279static void recovery_work_func(struct work_struct *unused)1280{1281 int redo = 0;1282 1283 bus_for_each_dev(&ccw_bus_type, NULL, &redo, recovery_check);1284 if (redo) {1285 spin_lock_irq(&recovery_lock);1286 if (!timer_pending(&recovery_timer)) {1287 if (recovery_phase < ARRAY_SIZE(recovery_delay) - 1)1288 recovery_phase++;1289 mod_timer(&recovery_timer, jiffies +1290 recovery_delay[recovery_phase] * HZ);1291 }1292 spin_unlock_irq(&recovery_lock);1293 } else1294 CIO_MSG_EVENT(3, "recovery: end\n");1295}1296 1297static DECLARE_WORK(recovery_work, recovery_work_func);1298 1299static void recovery_func(struct timer_list *unused)1300{1301 /*1302 * We can't do our recovery in softirq context and it's not1303 * performance critical, so we schedule it.1304 */1305 schedule_work(&recovery_work);1306}1307 1308void ccw_device_schedule_recovery(void)1309{1310 unsigned long flags;1311 1312 CIO_MSG_EVENT(3, "recovery: schedule\n");1313 spin_lock_irqsave(&recovery_lock, flags);1314 if (!timer_pending(&recovery_timer) || (recovery_phase != 0)) {1315 recovery_phase = 0;1316 mod_timer(&recovery_timer, jiffies + recovery_delay[0] * HZ);1317 }1318 spin_unlock_irqrestore(&recovery_lock, flags);1319}1320 1321static int purge_fn(struct device *dev, void *data)1322{1323 struct ccw_device *cdev = to_ccwdev(dev);1324 struct ccw_dev_id *id = &cdev->private->dev_id;1325 struct subchannel *sch = to_subchannel(cdev->dev.parent);1326 1327 spin_lock_irq(cdev->ccwlock);1328 if (is_blacklisted(id->ssid, id->devno) &&1329 (cdev->private->state == DEV_STATE_OFFLINE) &&1330 (atomic_cmpxchg(&cdev->private->onoff, 0, 1) == 0)) {1331 CIO_MSG_EVENT(3, "ccw: purging 0.%x.%04x\n", id->ssid,1332 id->devno);1333 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);1334 css_sched_sch_todo(sch, SCH_TODO_UNREG);1335 atomic_set(&cdev->private->onoff, 0);1336 }1337 spin_unlock_irq(cdev->ccwlock);1338 /* Abort loop in case of pending signal. */1339 if (signal_pending(current))1340 return -EINTR;1341 1342 return 0;1343}1344 1345/**1346 * ccw_purge_blacklisted - purge unused, blacklisted devices1347 *1348 * Unregister all ccw devices that are offline and on the blacklist.1349 */1350int ccw_purge_blacklisted(void)1351{1352 CIO_MSG_EVENT(2, "ccw: purging blacklisted devices\n");1353 bus_for_each_dev(&ccw_bus_type, NULL, NULL, purge_fn);1354 return 0;1355}1356 1357void ccw_device_set_disconnected(struct ccw_device *cdev)1358{1359 if (!cdev)1360 return;1361 ccw_device_set_timeout(cdev, 0);1362 cdev->private->flags.fake_irb = 0;1363 cdev->private->state = DEV_STATE_DISCONNECTED;1364 if (cdev->online)1365 ccw_device_schedule_recovery();1366}1367 1368void ccw_device_set_notoper(struct ccw_device *cdev)1369{1370 struct subchannel *sch = to_subchannel(cdev->dev.parent);1371 1372 CIO_TRACE_EVENT(2, "notoper");1373 CIO_TRACE_EVENT(2, dev_name(&sch->dev));1374 ccw_device_set_timeout(cdev, 0);1375 cio_disable_subchannel(sch);1376 cdev->private->state = DEV_STATE_NOT_OPER;1377}1378 1379enum io_sch_action {1380 IO_SCH_UNREG,1381 IO_SCH_ORPH_UNREG,1382 IO_SCH_UNREG_CDEV,1383 IO_SCH_ATTACH,1384 IO_SCH_UNREG_ATTACH,1385 IO_SCH_ORPH_ATTACH,1386 IO_SCH_REPROBE,1387 IO_SCH_VERIFY,1388 IO_SCH_DISC,1389 IO_SCH_NOP,1390};1391 1392static enum io_sch_action sch_get_action(struct subchannel *sch)1393{1394 struct ccw_device *cdev;1395 1396 cdev = sch_get_cdev(sch);1397 if (cio_update_schib(sch)) {1398 /* Not operational. */1399 if (!cdev)1400 return IO_SCH_UNREG;1401 if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)1402 return IO_SCH_UNREG;1403 return IO_SCH_ORPH_UNREG;1404 }1405 /* Operational. */1406 if (!cdev)1407 return IO_SCH_ATTACH;1408 if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {1409 if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)1410 return IO_SCH_UNREG_ATTACH;1411 return IO_SCH_ORPH_ATTACH;1412 }1413 if ((sch->schib.pmcw.pam & sch->opm) == 0) {1414 if (ccw_device_notify(cdev, CIO_NO_PATH) != NOTIFY_OK)1415 return IO_SCH_UNREG_CDEV;1416 return IO_SCH_DISC;1417 }1418 if (device_is_disconnected(cdev))1419 return IO_SCH_REPROBE;1420 if (cdev->online)1421 return IO_SCH_VERIFY;1422 if (cdev->private->state == DEV_STATE_NOT_OPER)1423 return IO_SCH_UNREG_ATTACH;1424 return IO_SCH_NOP;1425}1426 1427/**1428 * io_subchannel_sch_event - process subchannel event1429 * @sch: subchannel1430 * @process: non-zero if function is called in process context1431 *1432 * An unspecified event occurred for this subchannel. Adjust data according1433 * to the current operational state of the subchannel and device. Return1434 * zero when the event has been handled sufficiently or -EAGAIN when this1435 * function should be called again in process context.1436 */1437static int io_subchannel_sch_event(struct subchannel *sch, int process)1438{1439 unsigned long flags;1440 struct ccw_device *cdev;1441 struct ccw_dev_id dev_id;1442 enum io_sch_action action;1443 int rc = -EAGAIN;1444 1445 spin_lock_irqsave(&sch->lock, flags);1446 if (!device_is_registered(&sch->dev))1447 goto out_unlock;1448 if (work_pending(&sch->todo_work))1449 goto out_unlock;1450 cdev = sch_get_cdev(sch);1451 if (cdev && work_pending(&cdev->private->todo_work))1452 goto out_unlock;1453 action = sch_get_action(sch);1454 CIO_MSG_EVENT(2, "event: sch 0.%x.%04x, process=%d, action=%d\n",1455 sch->schid.ssid, sch->schid.sch_no, process,1456 action);1457 /* Perform immediate actions while holding the lock. */1458 switch (action) {1459 case IO_SCH_REPROBE:1460 /* Trigger device recognition. */1461 ccw_device_trigger_reprobe(cdev);1462 rc = 0;1463 goto out_unlock;1464 case IO_SCH_VERIFY:1465 /* Trigger path verification. */1466 io_subchannel_verify(sch);1467 rc = 0;1468 goto out_unlock;1469 case IO_SCH_DISC:1470 ccw_device_set_disconnected(cdev);1471 rc = 0;1472 goto out_unlock;1473 case IO_SCH_ORPH_UNREG:1474 case IO_SCH_ORPH_ATTACH:1475 ccw_device_set_disconnected(cdev);1476 break;1477 case IO_SCH_UNREG_CDEV:1478 case IO_SCH_UNREG_ATTACH:1479 case IO_SCH_UNREG:1480 if (!cdev)1481 break;1482 if (cdev->private->state == DEV_STATE_SENSE_ID) {1483 /*1484 * Note: delayed work triggered by this event1485 * and repeated calls to sch_event are synchronized1486 * by the above check for work_pending(cdev).1487 */1488 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);1489 } else1490 ccw_device_set_notoper(cdev);1491 break;1492 case IO_SCH_NOP:1493 rc = 0;1494 goto out_unlock;1495 default:1496 break;1497 }1498 spin_unlock_irqrestore(&sch->lock, flags);1499 /* All other actions require process context. */1500 if (!process)1501 goto out;1502 /* Handle attached ccw device. */1503 switch (action) {1504 case IO_SCH_ORPH_UNREG:1505 case IO_SCH_ORPH_ATTACH:1506 /* Move ccw device to orphanage. */1507 rc = ccw_device_move_to_orph(cdev);1508 if (rc)1509 goto out;1510 break;1511 case IO_SCH_UNREG_CDEV:1512 case IO_SCH_UNREG_ATTACH:1513 spin_lock_irqsave(&sch->lock, flags);1514 sch_set_cdev(sch, NULL);1515 spin_unlock_irqrestore(&sch->lock, flags);1516 /* Unregister ccw device. */1517 ccw_device_unregister(cdev);1518 break;1519 default:1520 break;1521 }1522 /* Handle subchannel. */1523 switch (action) {1524 case IO_SCH_ORPH_UNREG:1525 case IO_SCH_UNREG:1526 css_sch_device_unregister(sch);1527 break;1528 case IO_SCH_ORPH_ATTACH:1529 case IO_SCH_UNREG_ATTACH:1530 case IO_SCH_ATTACH:1531 dev_id.ssid = sch->schid.ssid;1532 dev_id.devno = sch->schib.pmcw.dev;1533 cdev = get_ccwdev_by_dev_id(&dev_id);1534 if (!cdev) {1535 sch_create_and_recog_new_device(sch);1536 break;1537 }1538 rc = ccw_device_move_to_sch(cdev, sch);1539 if (rc) {1540 /* Release reference from get_ccwdev_by_dev_id() */1541 put_device(&cdev->dev);1542 goto out;1543 }1544 spin_lock_irqsave(&sch->lock, flags);1545 ccw_device_trigger_reprobe(cdev);1546 spin_unlock_irqrestore(&sch->lock, flags);1547 /* Release reference from get_ccwdev_by_dev_id() */1548 put_device(&cdev->dev);1549 break;1550 default:1551 break;1552 }1553 return 0;1554 1555out_unlock:1556 spin_unlock_irqrestore(&sch->lock, flags);1557out:1558 return rc;1559}1560 1561static void ccw_device_set_int_class(struct ccw_device *cdev)1562{1563 struct ccw_driver *cdrv = cdev->drv;1564 1565 /* Note: we interpret class 0 in this context as an uninitialized1566 * field since it translates to a non-I/O interrupt class. */1567 if (cdrv->int_class != 0)1568 cdev->private->int_class = cdrv->int_class;1569 else1570 cdev->private->int_class = IRQIO_CIO;1571}1572 1573#ifdef CONFIG_CCW_CONSOLE1574int __init ccw_device_enable_console(struct ccw_device *cdev)1575{1576 struct subchannel *sch = to_subchannel(cdev->dev.parent);1577 int rc;1578 1579 if (!cdev->drv || !cdev->handler)1580 return -EINVAL;1581 1582 io_subchannel_init_fields(sch);1583 rc = cio_commit_config(sch);1584 if (rc)1585 return rc;1586 sch->driver = &io_subchannel_driver;1587 io_subchannel_recog(cdev, sch);1588 /* Now wait for the async. recognition to come to an end. */1589 spin_lock_irq(cdev->ccwlock);1590 while (!dev_fsm_final_state(cdev))1591 ccw_device_wait_idle(cdev);1592 1593 /* Hold on to an extra reference while device is online. */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 else1605 rc = -EIO;1606out_unlock:1607 spin_unlock_irq(cdev->ccwlock);1608 if (rc) /* Give up online reference since onlining failed. */1609 put_device(&cdev->dev);1610 return rc;1611}1612 1613struct ccw_device * __init ccw_device_create_console(struct ccw_driver *drv)1614{1615 struct io_subchannel_private *io_priv;1616 struct ccw_device *cdev;1617 struct subchannel *sch;1618 1619 sch = cio_probe_console();1620 if (IS_ERR(sch))1621 return ERR_CAST(sch);1622 1623 io_priv = kzalloc(sizeof(*io_priv), GFP_KERNEL | GFP_DMA);1624 if (!io_priv)1625 goto err_priv;1626 io_priv->dma_area = dma_alloc_coherent(&sch->dev,1627 sizeof(*io_priv->dma_area),1628 &io_priv->dma_area_dma, GFP_KERNEL);1629 if (!io_priv->dma_area)1630 goto err_dma_area;1631 set_io_private(sch, io_priv);1632 cdev = io_subchannel_create_ccwdev(sch);1633 if (IS_ERR(cdev)) {1634 dma_free_coherent(&sch->dev, sizeof(*io_priv->dma_area),1635 io_priv->dma_area, io_priv->dma_area_dma);1636 set_io_private(sch, NULL);1637 put_device(&sch->dev);1638 kfree(io_priv);1639 return cdev;1640 }1641 cdev->drv = drv;1642 ccw_device_set_int_class(cdev);1643 return cdev;1644 1645err_dma_area:1646 kfree(io_priv);1647err_priv:1648 put_device(&sch->dev);1649 return ERR_PTR(-ENOMEM);1650}1651 1652void __init ccw_device_destroy_console(struct ccw_device *cdev)1653{1654 struct subchannel *sch = to_subchannel(cdev->dev.parent);1655 struct io_subchannel_private *io_priv = to_io_private(sch);1656 1657 set_io_private(sch, NULL);1658 dma_free_coherent(&sch->dev, sizeof(*io_priv->dma_area),1659 io_priv->dma_area, io_priv->dma_area_dma);1660 put_device(&sch->dev);1661 put_device(&cdev->dev);1662 kfree(io_priv);1663}1664 1665/**1666 * ccw_device_wait_idle() - busy wait for device to become idle1667 * @cdev: ccw device1668 *1669 * Poll until activity control is zero, that is, no function or data1670 * transfer is pending/active.1671 * Called with device lock being held.1672 */1673void ccw_device_wait_idle(struct ccw_device *cdev)1674{1675 struct subchannel *sch = to_subchannel(cdev->dev.parent);1676 1677 while (1) {1678 cio_tsch(sch);1679 if (sch->schib.scsw.cmd.actl == 0)1680 break;1681 udelay(100);1682 }1683}1684#endif1685 1686/**1687 * get_ccwdev_by_busid() - obtain device from a bus id1688 * @cdrv: driver the device is owned by1689 * @bus_id: bus id of the device to be searched1690 *1691 * This function searches all devices owned by @cdrv for a device with a bus1692 * id matching @bus_id.1693 * Returns:1694 * If a match is found, its reference count of the found device is increased1695 * and it is returned; else %NULL is returned.1696 */1697struct ccw_device *get_ccwdev_by_busid(struct ccw_driver *cdrv,1698 const char *bus_id)1699{1700 struct device *dev;1701 1702 dev = driver_find_device_by_name(&cdrv->driver, bus_id);1703 1704 return dev ? to_ccwdev(dev) : NULL;1705}1706 1707/************************** device driver handling ************************/1708 1709/* This is the implementation of the ccw_driver class. The probe, remove1710 * and release methods are initially very similar to the device_driver1711 * implementations, with the difference that they have ccw_device1712 * arguments.1713 *1714 * A ccw driver also contains the information that is needed for1715 * device matching.1716 */1717static int1718ccw_device_probe (struct device *dev)1719{1720 struct ccw_device *cdev = to_ccwdev(dev);1721 struct ccw_driver *cdrv = to_ccwdrv(dev->driver);1722 int ret;1723 1724 cdev->drv = cdrv; /* to let the driver call _set_online */1725 ccw_device_set_int_class(cdev);1726 ret = cdrv->probe ? cdrv->probe(cdev) : -ENODEV;1727 if (ret) {1728 cdev->drv = NULL;1729 cdev->private->int_class = IRQIO_CIO;1730 return ret;1731 }1732 1733 return 0;1734}1735 1736static void ccw_device_remove(struct device *dev)1737{1738 struct ccw_device *cdev = to_ccwdev(dev);1739 struct ccw_driver *cdrv = cdev->drv;1740 struct subchannel *sch;1741 int ret;1742 1743 if (cdrv->remove)1744 cdrv->remove(cdev);1745 1746 spin_lock_irq(cdev->ccwlock);1747 if (cdev->online) {1748 cdev->online = 0;1749 ret = ccw_device_offline(cdev);1750 spin_unlock_irq(cdev->ccwlock);1751 if (ret == 0)1752 wait_event(cdev->private->wait_q,1753 dev_fsm_final_state(cdev));1754 else1755 CIO_MSG_EVENT(0, "ccw_device_offline returned %d, "1756 "device 0.%x.%04x\n",1757 ret, cdev->private->dev_id.ssid,1758 cdev->private->dev_id.devno);1759 /* Give up reference obtained in ccw_device_set_online(). */1760 put_device(&cdev->dev);1761 spin_lock_irq(cdev->ccwlock);1762 }1763 ccw_device_set_timeout(cdev, 0);1764 cdev->drv = NULL;1765 cdev->private->int_class = IRQIO_CIO;1766 sch = to_subchannel(cdev->dev.parent);1767 spin_unlock_irq(cdev->ccwlock);1768 io_subchannel_quiesce(sch);1769 __disable_cmf(cdev);1770}1771 1772static void ccw_device_shutdown(struct device *dev)1773{1774 struct ccw_device *cdev;1775 1776 cdev = to_ccwdev(dev);1777 if (cdev->drv && cdev->drv->shutdown)1778 cdev->drv->shutdown(cdev);1779 __disable_cmf(cdev);1780}1781 1782static const struct bus_type ccw_bus_type = {1783 .name = "ccw",1784 .match = ccw_bus_match,1785 .uevent = ccw_uevent,1786 .probe = ccw_device_probe,1787 .remove = ccw_device_remove,1788 .shutdown = ccw_device_shutdown,1789};1790 1791/**1792 * ccw_driver_register() - register a ccw driver1793 * @cdriver: driver to be registered1794 *1795 * This function is mainly a wrapper around driver_register().1796 * Returns:1797 * %0 on success and a negative error value on failure.1798 */1799int ccw_driver_register(struct ccw_driver *cdriver)1800{1801 struct device_driver *drv = &cdriver->driver;1802 1803 drv->bus = &ccw_bus_type;1804 1805 return driver_register(drv);1806}1807 1808/**1809 * ccw_driver_unregister() - deregister a ccw driver1810 * @cdriver: driver to be deregistered1811 *1812 * This function is mainly a wrapper around driver_unregister().1813 */1814void ccw_driver_unregister(struct ccw_driver *cdriver)1815{1816 driver_unregister(&cdriver->driver);1817}1818 1819static void ccw_device_todo(struct work_struct *work)1820{1821 struct ccw_device_private *priv;1822 struct ccw_device *cdev;1823 struct subchannel *sch;1824 enum cdev_todo todo;1825 1826 priv = container_of(work, struct ccw_device_private, todo_work);1827 cdev = priv->cdev;1828 sch = to_subchannel(cdev->dev.parent);1829 /* Find out todo. */1830 spin_lock_irq(cdev->ccwlock);1831 todo = priv->todo;1832 priv->todo = CDEV_TODO_NOTHING;1833 CIO_MSG_EVENT(4, "cdev_todo: cdev=0.%x.%04x todo=%d\n",1834 priv->dev_id.ssid, priv->dev_id.devno, todo);1835 spin_unlock_irq(cdev->ccwlock);1836 /* Perform todo. */1837 switch (todo) {1838 case CDEV_TODO_ENABLE_CMF:1839 cmf_reenable(cdev);1840 break;1841 case CDEV_TODO_REBIND:1842 ccw_device_do_unbind_bind(cdev);1843 break;1844 case CDEV_TODO_REGISTER:1845 io_subchannel_register(cdev);1846 break;1847 case CDEV_TODO_UNREG_EVAL:1848 if (!sch_is_pseudo_sch(sch))1849 css_schedule_eval(sch->schid);1850 fallthrough;1851 case CDEV_TODO_UNREG:1852 spin_lock_irq(&sch->lock);1853 sch_set_cdev(sch, NULL);1854 spin_unlock_irq(&sch->lock);1855 ccw_device_unregister(cdev);1856 break;1857 default:1858 break;1859 }1860 /* Release workqueue ref. */1861 put_device(&cdev->dev);1862}1863 1864/**1865 * ccw_device_sched_todo - schedule ccw device operation1866 * @cdev: ccw device1867 * @todo: todo1868 *1869 * Schedule the operation identified by @todo to be performed on the slow path1870 * workqueue. Do nothing if another operation with higher priority is already1871 * scheduled. Needs to be called with ccwdev lock held.1872 */1873void ccw_device_sched_todo(struct ccw_device *cdev, enum cdev_todo todo)1874{1875 CIO_MSG_EVENT(4, "cdev_todo: sched cdev=0.%x.%04x todo=%d\n",1876 cdev->private->dev_id.ssid, cdev->private->dev_id.devno,1877 todo);1878 if (cdev->private->todo >= todo)1879 return;1880 cdev->private->todo = todo;1881 /* Get workqueue ref. */1882 if (!get_device(&cdev->dev))1883 return;1884 if (!queue_work(cio_work_q, &cdev->private->todo_work)) {1885 /* Already queued, release workqueue ref. */1886 put_device(&cdev->dev);1887 }1888}1889 1890/**1891 * ccw_device_siosl() - initiate logging1892 * @cdev: ccw device1893 *1894 * This function is used to invoke model-dependent logging within the channel1895 * subsystem.1896 */1897int ccw_device_siosl(struct ccw_device *cdev)1898{1899 struct subchannel *sch = to_subchannel(cdev->dev.parent);1900 1901 return chsc_siosl(sch->schid);1902}1903EXPORT_SYMBOL_GPL(ccw_device_siosl);1904 1905EXPORT_SYMBOL(ccw_device_set_online);1906EXPORT_SYMBOL(ccw_device_set_offline);1907EXPORT_SYMBOL(ccw_driver_register);1908EXPORT_SYMBOL(ccw_driver_unregister);1909EXPORT_SYMBOL(get_ccwdev_by_busid);1910