[linux-2.6-block.git] / drivers / s390 / cio / ccwgroup.c

/*
 *  drivers/s390/cio/ccwgroup.c
 *  bus driver for ccwgroup
 *
 *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
 *                       IBM Corporation
 *    Author(s): Arnd Bergmann (arndb@de.ibm.com)
 *               Cornelia Huck (cornelia.huck@de.ibm.com)
 */
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/ctype.h>
#include <linux/dcache.h>

#include <asm/semaphore.h>
#include <asm/ccwdev.h>
#include <asm/ccwgroup.h>

/* In Linux 2.4, we had a channel device layer called "chandev"
 * that did all sorts of obscure stuff for networking devices.
 * This is another driver that serves as a replacement for just
 * one of its functions, namely the translation of single subchannels
 * to devices that use multiple subchannels.
 */

/* a device matches a driver if all its slave devices match the same
 * entry of the driver */
static int
ccwgroup_bus_match (struct device * dev, struct device_driver * drv)
{
	struct ccwgroup_device *gdev;
	struct ccwgroup_driver *gdrv;

	gdev = container_of(dev, struct ccwgroup_device, dev);
	gdrv = container_of(drv, struct ccwgroup_driver, driver);

	if (gdev->creator_id == gdrv->driver_id)
		return 1;

	return 0;
}
static int
ccwgroup_uevent (struct device *dev, struct kobj_uevent_env *env)
{
	/* TODO */
	return 0;
}

static struct bus_type ccwgroup_bus_type;

static void
__ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
{
	int i;
	char str[8];

	for (i = 0; i < gdev->count; i++) {
		sprintf(str, "cdev%d", i);
		sysfs_remove_link(&gdev->dev.kobj, str);
		sysfs_remove_link(&gdev->cdev[i]->dev.kobj, "group_device");
	}
	
}

/*
 * Provide an 'ungroup' attribute so the user can remove group devices no
 * longer needed or accidentially created. Saves memory :)
 */
static void ccwgroup_ungroup_callback(struct device *dev)
{
	struct ccwgroup_device *gdev = to_ccwgroupdev(dev);

	mutex_lock(&gdev->reg_mutex);
	__ccwgroup_remove_symlinks(gdev);
	device_unregister(dev);
	mutex_unlock(&gdev->reg_mutex);
}

static ssize_t
ccwgroup_ungroup_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	struct ccwgroup_device *gdev;
	int rc;

	gdev = to_ccwgroupdev(dev);

	if (gdev->state != CCWGROUP_OFFLINE)
		return -EINVAL;

	/* Note that we cannot unregister the device from one of its
	 * attribute methods, so we have to use this roundabout approach.
	 */
	rc = device_schedule_callback(dev, ccwgroup_ungroup_callback);
	if (rc)
		count = rc;
	return count;
}

static DEVICE_ATTR(ungroup, 0200, NULL, ccwgroup_ungroup_store);

static void
ccwgroup_release (struct device *dev)
{
	struct ccwgroup_device *gdev;
	int i;

	gdev = to_ccwgroupdev(dev);

	for (i = 0; i < gdev->count; i++) {
		gdev->cdev[i]->dev.driver_data = NULL;
		put_device(&gdev->cdev[i]->dev);
	}
	kfree(gdev);
}

static int
__ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
{
	char str[8];
	int i, rc;

	for (i = 0; i < gdev->count; i++) {
		rc = sysfs_create_link(&gdev->cdev[i]->dev.kobj, &gdev->dev.kobj,
				       "group_device");
		if (rc) {
			for (--i; i >= 0; i--)
				sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
						  "group_device");
			return rc;
		}
	}
	for (i = 0; i < gdev->count; i++) {
		sprintf(str, "cdev%d", i);
		rc = sysfs_create_link(&gdev->dev.kobj, &gdev->cdev[i]->dev.kobj,
				       str);
		if (rc) {
			for (--i; i >= 0; i--) {
				sprintf(str, "cdev%d", i);
				sysfs_remove_link(&gdev->dev.kobj, str);
			}
			for (i = 0; i < gdev->count; i++)
				sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
						  "group_device");
			return rc;
		}
	}
	return 0;
}

/**
 * ccwgroup_create() - create and register a ccw group device
 * @root: parent device for the new device
 * @creator_id: identifier of creating driver
 * @cdrv: ccw driver of slave devices
 * @argc: number of slave devices
 * @argv: bus ids of slave devices
 *
 * Create and register a new ccw group device as a child of @root. Slave
 * devices are obtained from the list of bus ids given in @argv[] and must all
 * belong to @cdrv.
 * Returns:
 *  %0 on success and an error code on failure.
 * Context:
 *  non-atomic
 */
int ccwgroup_create(struct device *root, unsigned int creator_id,
		    struct ccw_driver *cdrv, int argc, char *argv[])
{
	struct ccwgroup_device *gdev;
	int i;
	int rc;

	if (argc > 256) /* disallow dumb users */
		return -EINVAL;

	gdev = kzalloc(sizeof(*gdev) + argc*sizeof(gdev->cdev[0]), GFP_KERNEL);
	if (!gdev)
		return -ENOMEM;

	atomic_set(&gdev->onoff, 0);
	mutex_init(&gdev->reg_mutex);
	mutex_lock(&gdev->reg_mutex);
	for (i = 0; i < argc; i++) {
		gdev->cdev[i] = get_ccwdev_by_busid(cdrv, argv[i]);

		/* all devices have to be of the same type in
		 * order to be grouped */
		if (!gdev->cdev[i]
		    || gdev->cdev[i]->id.driver_info !=
		    gdev->cdev[0]->id.driver_info) {
			rc = -EINVAL;
			goto error;
		}
		/* Don't allow a device to belong to more than one group. */
		if (gdev->cdev[i]->dev.driver_data) {
			rc = -EINVAL;
			goto error;
		}
		gdev->cdev[i]->dev.driver_data = gdev;
	}

	gdev->creator_id = creator_id;
	gdev->count = argc;
	gdev->dev.bus = &ccwgroup_bus_type;
	gdev->dev.parent = root;
	gdev->dev.release = ccwgroup_release;

	snprintf (gdev->dev.bus_id, BUS_ID_SIZE, "%s",
			gdev->cdev[0]->dev.bus_id);

	rc = device_register(&gdev->dev);
	if (rc)
		goto error;
	get_device(&gdev->dev);
	rc = device_create_file(&gdev->dev, &dev_attr_ungroup);

	if (rc) {
		device_unregister(&gdev->dev);
		goto error;
	}

	rc = __ccwgroup_create_symlinks(gdev);
	if (!rc) {
		mutex_unlock(&gdev->reg_mutex);
		put_device(&gdev->dev);
		return 0;
	}
	device_remove_file(&gdev->dev, &dev_attr_ungroup);
	device_unregister(&gdev->dev);
error:
	for (i = 0; i < argc; i++)
		if (gdev->cdev[i]) {
			if (gdev->cdev[i]->dev.driver_data == gdev)
				gdev->cdev[i]->dev.driver_data = NULL;
			put_device(&gdev->cdev[i]->dev);
		}
	mutex_unlock(&gdev->reg_mutex);
	put_device(&gdev->dev);
	return rc;
}

static int __init
init_ccwgroup (void)
{
	return bus_register (&ccwgroup_bus_type);
}

static void __exit
cleanup_ccwgroup (void)
{
	bus_unregister (&ccwgroup_bus_type);
}

module_init(init_ccwgroup);
module_exit(cleanup_ccwgroup);

/************************** driver stuff ******************************/

static int
ccwgroup_set_online(struct ccwgroup_device *gdev)
{
	struct ccwgroup_driver *gdrv;
	int ret;

	if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
		return -EAGAIN;
	if (gdev->state == CCWGROUP_ONLINE) {
		ret = 0;
		goto out;
	}
	if (!gdev->dev.driver) {
		ret = -EINVAL;
		goto out;
	}
	gdrv = to_ccwgroupdrv (gdev->dev.driver);
	if ((ret = gdrv->set_online ? gdrv->set_online(gdev) : 0))
		goto out;

	gdev->state = CCWGROUP_ONLINE;
 out:
	atomic_set(&gdev->onoff, 0);
	return ret;
}

static int
ccwgroup_set_offline(struct ccwgroup_device *gdev)
{
	struct ccwgroup_driver *gdrv;
	int ret;

	if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
		return -EAGAIN;
	if (gdev->state == CCWGROUP_OFFLINE) {
		ret = 0;
		goto out;
	}
	if (!gdev->dev.driver) {
		ret = -EINVAL;
		goto out;
	}
	gdrv = to_ccwgroupdrv (gdev->dev.driver);
	if ((ret = gdrv->set_offline ? gdrv->set_offline(gdev) : 0))
		goto out;

	gdev->state = CCWGROUP_OFFLINE;
 out:
	atomic_set(&gdev->onoff, 0);
	return ret;
}

static ssize_t
ccwgroup_online_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	struct ccwgroup_device *gdev;
	struct ccwgroup_driver *gdrv;
	unsigned int value;
	int ret;

	gdev = to_ccwgroupdev(dev);
	if (!dev->driver)
		return count;

	gdrv = to_ccwgroupdrv (gdev->dev.driver);
	if (!try_module_get(gdrv->owner))
		return -EINVAL;

	value = simple_strtoul(buf, NULL, 0);
	ret = count;
	if (value == 1)
		ccwgroup_set_online(gdev);
	else if (value == 0)
		ccwgroup_set_offline(gdev);
	else
		ret = -EINVAL;
	module_put(gdrv->owner);
	return ret;
}

static ssize_t
ccwgroup_online_show (struct device *dev, struct device_attribute *attr, char *buf)
{
	int online;

	online = (to_ccwgroupdev(dev)->state == CCWGROUP_ONLINE);

	return sprintf(buf, online ? "1\n" : "0\n");
}

static DEVICE_ATTR(online, 0644, ccwgroup_online_show, ccwgroup_online_store);

static int
ccwgroup_probe (struct device *dev)
{
	struct ccwgroup_device *gdev;
	struct ccwgroup_driver *gdrv;

	int ret;

	gdev = to_ccwgroupdev(dev);
	gdrv = to_ccwgroupdrv(dev->driver);

	if ((ret = device_create_file(dev, &dev_attr_online)))
		return ret;

	ret = gdrv->probe ? gdrv->probe(gdev) : -ENODEV;
	if (ret)
		device_remove_file(dev, &dev_attr_online);

	return ret;
}

static int
ccwgroup_remove (struct device *dev)
{
	struct ccwgroup_device *gdev;
	struct ccwgroup_driver *gdrv;

	gdev = to_ccwgroupdev(dev);
	gdrv = to_ccwgroupdrv(dev->driver);

	device_remove_file(dev, &dev_attr_online);

	if (gdrv && gdrv->remove)
		gdrv->remove(gdev);
	return 0;
}

static struct bus_type ccwgroup_bus_type = {
	.name   = "ccwgroup",
	.match  = ccwgroup_bus_match,
	.uevent = ccwgroup_uevent,
	.probe  = ccwgroup_probe,
	.remove = ccwgroup_remove,
};

/**
 * ccwgroup_driver_register() - register a ccw group driver
 * @cdriver: driver to be registered
 *
 * This function is mainly a wrapper around driver_register().
 */
int ccwgroup_driver_register(struct ccwgroup_driver *cdriver)
{
	/* register our new driver with the core */
	cdriver->driver.bus = &ccwgroup_bus_type;
	cdriver->driver.name = cdriver->name;

	return driver_register(&cdriver->driver);
}

static int
__ccwgroup_match_all(struct device *dev, void *data)
{
	return 1;
}

/**
 * ccwgroup_driver_unregister() - deregister a ccw group driver
 * @cdriver: driver to be deregistered
 *
 * This function is mainly a wrapper around driver_unregister().
 */
void ccwgroup_driver_unregister(struct ccwgroup_driver *cdriver)
{
	struct device *dev;

	/* We don't want ccwgroup devices to live longer than their driver. */
	get_driver(&cdriver->driver);
	while ((dev = driver_find_device(&cdriver->driver, NULL, NULL,
					 __ccwgroup_match_all))) {
		struct ccwgroup_device *gdev = to_ccwgroupdev(dev);

		mutex_lock(&gdev->reg_mutex);
		__ccwgroup_remove_symlinks(gdev);
		device_unregister(dev);
		mutex_unlock(&gdev->reg_mutex);
		put_device(dev);
	}
	put_driver(&cdriver->driver);
	driver_unregister(&cdriver->driver);
}

/**
 * ccwgroup_probe_ccwdev() - probe function for slave devices
 * @cdev: ccw device to be probed
 *
 * This is a dummy probe function for ccw devices that are slave devices in
 * a ccw group device.
 * Returns:
 *  always %0
 */
int ccwgroup_probe_ccwdev(struct ccw_device *cdev)
{
	return 0;
}

static struct ccwgroup_device *
__ccwgroup_get_gdev_by_cdev(struct ccw_device *cdev)
{
	struct ccwgroup_device *gdev;

	if (cdev->dev.driver_data) {
		gdev = (struct ccwgroup_device *)cdev->dev.driver_data;
		if (get_device(&gdev->dev)) {
			mutex_lock(&gdev->reg_mutex);
			if (device_is_registered(&gdev->dev))
				return gdev;
			mutex_unlock(&gdev->reg_mutex);
			put_device(&gdev->dev);
		}
		return NULL;
	}
	return NULL;
}

/**
 * ccwgroup_remove_ccwdev() - remove function for slave devices
 * @cdev: ccw device to be removed
 *
 * This is a remove function for ccw devices that are slave devices in a ccw
 * group device. It sets the ccw device offline and also deregisters the
 * embedding ccw group device.
 */
void ccwgroup_remove_ccwdev(struct ccw_device *cdev)
{
	struct ccwgroup_device *gdev;

	/* Ignore offlining errors, device is gone anyway. */
	ccw_device_set_offline(cdev);
	/* If one of its devices is gone, the whole group is done for. */
	gdev = __ccwgroup_get_gdev_by_cdev(cdev);
	if (gdev) {
		__ccwgroup_remove_symlinks(gdev);
		device_unregister(&gdev->dev);
		mutex_unlock(&gdev->reg_mutex);
		put_device(&gdev->dev);
	}
}

MODULE_LICENSE("GPL");
EXPORT_SYMBOL(ccwgroup_driver_register);
EXPORT_SYMBOL(ccwgroup_driver_unregister);
EXPORT_SYMBOL(ccwgroup_create);
EXPORT_SYMBOL(ccwgroup_probe_ccwdev);
EXPORT_SYMBOL(ccwgroup_remove_ccwdev);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* drivers/s390/cio/ccwgroup.c
	3	* bus driver for ccwgroup
1da177e4 LT	4	*
	5	* Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
	6	* IBM Corporation
	7	* Author(s): Arnd Bergmann (arndb@de.ibm.com)
4ce3b30c	8	* Cornelia Huck (cornelia.huck@de.ibm.com)
1da177e4 LT	9	*/
	10	#include <linux/module.h>
	11	#include <linux/errno.h>
	12	#include <linux/slab.h>
	13	#include <linux/list.h>
	14	#include <linux/device.h>
	15	#include <linux/init.h>
	16	#include <linux/ctype.h>
	17	#include <linux/dcache.h>
	18
	19	#include <asm/semaphore.h>
	20	#include <asm/ccwdev.h>
	21	#include <asm/ccwgroup.h>
	22
	23	/* In Linux 2.4, we had a channel device layer called "chandev"
	24	* that did all sorts of obscure stuff for networking devices.
	25	* This is another driver that serves as a replacement for just
	26	* one of its functions, namely the translation of single subchannels
	27	* to devices that use multiple subchannels.
	28	*/
	29
	30	/* a device matches a driver if all its slave devices match the same
	31	* entry of the driver */
	32	static int
	33	ccwgroup_bus_match (struct device * dev, struct device_driver * drv)
	34	{
	35	struct ccwgroup_device *gdev;
	36	struct ccwgroup_driver *gdrv;
	37
	38	gdev = container_of(dev, struct ccwgroup_device, dev);
	39	gdrv = container_of(drv, struct ccwgroup_driver, driver);
	40
	41	if (gdev->creator_id == gdrv->driver_id)
	42	return 1;
	43
	44	return 0;
	45	}
	46	static int
7eff2e7a	47	ccwgroup_uevent (struct device dev, struct kobj_uevent_env env)
1da177e4 LT	48	{
	49	/* TODO */
	50	return 0;
	51	}
	52
f9ccf456	53	static struct bus_type ccwgroup_bus_type;
1da177e4	54
4d284cac	55	static void
1da177e4 LT	56	__ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
	57	{
	58	int i;
	59	char str[8];
	60
	61	for (i = 0; i < gdev->count; i++) {
	62	sprintf(str, "cdev%d", i);
	63	sysfs_remove_link(&gdev->dev.kobj, str);
	64	sysfs_remove_link(&gdev->cdev[i]->dev.kobj, "group_device");
	65	}
	66
	67	}
	68
	69	/*
	70	* Provide an 'ungroup' attribute so the user can remove group devices no
	71	* longer needed or accidentially created. Saves memory :)
	72	*/
d9a9cdfb AS	73	static void ccwgroup_ungroup_callback(struct device *dev)
	74	{
	75	struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
	76
d76123eb	77	mutex_lock(&gdev->reg_mutex);
d9a9cdfb AS	78	__ccwgroup_remove_symlinks(gdev);
d9a9cdfb AS	79	device_unregister(dev);
d76123eb	80	mutex_unlock(&gdev->reg_mutex);
d9a9cdfb AS	81	}
d9a9cdfb AS	82
1da177e4	83	static ssize_t
3fd3c0a5	84	ccwgroup_ungroup_store(struct device dev, struct device_attribute attr, const char *buf, size_t count)
1da177e4 LT	85	{
1da177e4 LT	86	struct ccwgroup_device *gdev;
d9a9cdfb	87	int rc;
1da177e4 LT	88
	89	gdev = to_ccwgroupdev(dev);
	90
	91	if (gdev->state != CCWGROUP_OFFLINE)
	92	return -EINVAL;
	93
d9a9cdfb AS	94	/* Note that we cannot unregister the device from one of its
	95	* attribute methods, so we have to use this roundabout approach.
	96	*/
	97	rc = device_schedule_callback(dev, ccwgroup_ungroup_callback);
	98	if (rc)
	99	count = rc;
1da177e4 LT	100	return count;
	101	}
	102
	103	static DEVICE_ATTR(ungroup, 0200, NULL, ccwgroup_ungroup_store);
	104
	105	static void
	106	ccwgroup_release (struct device *dev)
	107	{
	108	struct ccwgroup_device *gdev;
	109	int i;
	110
	111	gdev = to_ccwgroupdev(dev);
	112
	113	for (i = 0; i < gdev->count; i++) {
	114	gdev->cdev[i]->dev.driver_data = NULL;
	115	put_device(&gdev->cdev[i]->dev);
	116	}
	117	kfree(gdev);
	118	}
	119
4d284cac	120	static int
1da177e4 LT	121	__ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
	122	{
	123	char str[8];
	124	int i, rc;
	125
	126	for (i = 0; i < gdev->count; i++) {
	127	rc = sysfs_create_link(&gdev->cdev[i]->dev.kobj, &gdev->dev.kobj,
	128	"group_device");
	129	if (rc) {
	130	for (--i; i >= 0; i--)
	131	sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
	132	"group_device");
	133	return rc;
	134	}
	135	}
	136	for (i = 0; i < gdev->count; i++) {
	137	sprintf(str, "cdev%d", i);
	138	rc = sysfs_create_link(&gdev->dev.kobj, &gdev->cdev[i]->dev.kobj,
	139	str);
	140	if (rc) {
	141	for (--i; i >= 0; i--) {
	142	sprintf(str, "cdev%d", i);
	143	sysfs_remove_link(&gdev->dev.kobj, str);
	144	}
	145	for (i = 0; i < gdev->count; i++)
	146	sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
	147	"group_device");
	148	return rc;
	149	}
	150	}
	151	return 0;
	152	}
	153
b2ffd8e9 CH	154	/**
	155	* ccwgroup_create() - create and register a ccw group device
	156	* @root: parent device for the new device
	157	* @creator_id: identifier of creating driver
	158	* @cdrv: ccw driver of slave devices
	159	* @argc: number of slave devices
	160	* @argv: bus ids of slave devices
	161	*
	162	* Create and register a new ccw group device as a child of @root. Slave
	163	* devices are obtained from the list of bus ids given in @argv[] and must all
	164	* belong to @cdrv.
	165	* Returns:
	166	* %0 on success and an error code on failure.
	167	* Context:
	168	* non-atomic
1da177e4	169	*/
b2ffd8e9 CH	170	int ccwgroup_create(struct device *root, unsigned int creator_id,
b2ffd8e9 CH	171	struct ccw_driver cdrv, int argc, char argv[])
1da177e4 LT	172	{
	173	struct ccwgroup_device *gdev;
	174	int i;
	175	int rc;
1da177e4 LT	176
	177	if (argc > 256) /* disallow dumb users */
	178	return -EINVAL;
	179
88abaab4	180	gdev = kzalloc(sizeof(gdev) + argcsizeof(gdev->cdev[0]), GFP_KERNEL);
1da177e4 LT	181	if (!gdev)
	182	return -ENOMEM;
	183
1da177e4	184	atomic_set(&gdev->onoff, 0);
d76123eb CH	185	mutex_init(&gdev->reg_mutex);
d76123eb CH	186	mutex_lock(&gdev->reg_mutex);
1da177e4 LT	187	for (i = 0; i < argc; i++) {
	188	gdev->cdev[i] = get_ccwdev_by_busid(cdrv, argv[i]);
	189
	190	/* all devices have to be of the same type in
	191	* order to be grouped */
	192	if (!gdev->cdev[i]
	193	\|\| gdev->cdev[i]->id.driver_info !=
	194	gdev->cdev[0]->id.driver_info) {
	195	rc = -EINVAL;
d76123eb	196	goto error;
1da177e4 LT	197	}
	198	/* Don't allow a device to belong to more than one group. */
	199	if (gdev->cdev[i]->dev.driver_data) {
	200	rc = -EINVAL;
d76123eb	201	goto error;
1da177e4	202	}
1da177e4	203	gdev->cdev[i]->dev.driver_data = gdev;
17088229	204	}
1da177e4 LT	205
	206	gdev->creator_id = creator_id;
	207	gdev->count = argc;
292888c8 HC	208	gdev->dev.bus = &ccwgroup_bus_type;
	209	gdev->dev.parent = root;
	210	gdev->dev.release = ccwgroup_release;
1da177e4 LT	211
	212	snprintf (gdev->dev.bus_id, BUS_ID_SIZE, "%s",
	213	gdev->cdev[0]->dev.bus_id);
	214
	215	rc = device_register(&gdev->dev);
1da177e4	216	if (rc)
d76123eb	217	goto error;
1da177e4 LT	218	get_device(&gdev->dev);
	219	rc = device_create_file(&gdev->dev, &dev_attr_ungroup);
	220
	221	if (rc) {
	222	device_unregister(&gdev->dev);
	223	goto error;
	224	}
	225
	226	rc = __ccwgroup_create_symlinks(gdev);
	227	if (!rc) {
d76123eb	228	mutex_unlock(&gdev->reg_mutex);
1da177e4 LT	229	put_device(&gdev->dev);
	230	return 0;
	231	}
	232	device_remove_file(&gdev->dev, &dev_attr_ungroup);
	233	device_unregister(&gdev->dev);
	234	error:
1da177e4 LT	235	for (i = 0; i < argc; i++)
1da177e4 LT	236	if (gdev->cdev[i]) {
17088229	237	if (gdev->cdev[i]->dev.driver_data == gdev)
1da177e4	238	gdev->cdev[i]->dev.driver_data = NULL;
17088229	239	put_device(&gdev->cdev[i]->dev);
1da177e4	240	}
d76123eb CH	241	mutex_unlock(&gdev->reg_mutex);
d76123eb CH	242	put_device(&gdev->dev);
1da177e4 LT	243	return rc;
	244	}
	245
	246	static int __init
	247	init_ccwgroup (void)
	248	{
	249	return bus_register (&ccwgroup_bus_type);
	250	}
	251
	252	static void __exit
	253	cleanup_ccwgroup (void)
	254	{
	255	bus_unregister (&ccwgroup_bus_type);
	256	}
	257
	258	module_init(init_ccwgroup);
	259	module_exit(cleanup_ccwgroup);
	260
	261	/************************ driver stuff ****************************/
	262
	263	static int
	264	ccwgroup_set_online(struct ccwgroup_device *gdev)
	265	{
	266	struct ccwgroup_driver *gdrv;
	267	int ret;
	268
973bd993	269	if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
1da177e4 LT	270	return -EAGAIN;
	271	if (gdev->state == CCWGROUP_ONLINE) {
	272	ret = 0;
	273	goto out;
	274	}
	275	if (!gdev->dev.driver) {
	276	ret = -EINVAL;
	277	goto out;
	278	}
	279	gdrv = to_ccwgroupdrv (gdev->dev.driver);
a0016408	280	if ((ret = gdrv->set_online ? gdrv->set_online(gdev) : 0))
1da177e4 LT	281	goto out;
	282
	283	gdev->state = CCWGROUP_ONLINE;
	284	out:
	285	atomic_set(&gdev->onoff, 0);
	286	return ret;
	287	}
	288
	289	static int
	290	ccwgroup_set_offline(struct ccwgroup_device *gdev)
	291	{
	292	struct ccwgroup_driver *gdrv;
	293	int ret;
	294
973bd993	295	if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
1da177e4 LT	296	return -EAGAIN;
	297	if (gdev->state == CCWGROUP_OFFLINE) {
	298	ret = 0;
	299	goto out;
	300	}
	301	if (!gdev->dev.driver) {
	302	ret = -EINVAL;
	303	goto out;
	304	}
	305	gdrv = to_ccwgroupdrv (gdev->dev.driver);
a0016408	306	if ((ret = gdrv->set_offline ? gdrv->set_offline(gdev) : 0))
1da177e4 LT	307	goto out;
	308
	309	gdev->state = CCWGROUP_OFFLINE;
	310	out:
	311	atomic_set(&gdev->onoff, 0);
	312	return ret;
	313	}
	314
	315	static ssize_t
3fd3c0a5	316	ccwgroup_online_store (struct device dev, struct device_attribute attr, const char *buf, size_t count)
1da177e4 LT	317	{
	318	struct ccwgroup_device *gdev;
	319	struct ccwgroup_driver *gdrv;
	320	unsigned int value;
	321	int ret;
	322
	323	gdev = to_ccwgroupdev(dev);
	324	if (!dev->driver)
	325	return count;
	326
	327	gdrv = to_ccwgroupdrv (gdev->dev.driver);
	328	if (!try_module_get(gdrv->owner))
	329	return -EINVAL;
	330
d2c993d8	331	value = simple_strtoul(buf, NULL, 0);
1da177e4 LT	332	ret = count;
	333	if (value == 1)
	334	ccwgroup_set_online(gdev);
	335	else if (value == 0)
	336	ccwgroup_set_offline(gdev);
	337	else
	338	ret = -EINVAL;
	339	module_put(gdrv->owner);
	340	return ret;
	341	}
	342
	343	static ssize_t
3fd3c0a5	344	ccwgroup_online_show (struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	345	{
	346	int online;
	347
	348	online = (to_ccwgroupdev(dev)->state == CCWGROUP_ONLINE);
	349
	350	return sprintf(buf, online ? "1\n" : "0\n");
	351	}
	352
	353	static DEVICE_ATTR(online, 0644, ccwgroup_online_show, ccwgroup_online_store);
	354
	355	static int
	356	ccwgroup_probe (struct device *dev)
	357	{
	358	struct ccwgroup_device *gdev;
	359	struct ccwgroup_driver *gdrv;
	360
	361	int ret;
	362
	363	gdev = to_ccwgroupdev(dev);
	364	gdrv = to_ccwgroupdrv(dev->driver);
	365
	366	if ((ret = device_create_file(dev, &dev_attr_online)))
	367	return ret;
	368
1da177e4 LT	369	ret = gdrv->probe ? gdrv->probe(gdev) : -ENODEV;
	370	if (ret)
	371	device_remove_file(dev, &dev_attr_online);
	372
	373	return ret;
	374	}
	375
	376	static int
	377	ccwgroup_remove (struct device *dev)
	378	{
	379	struct ccwgroup_device *gdev;
	380	struct ccwgroup_driver *gdrv;
	381
	382	gdev = to_ccwgroupdev(dev);
	383	gdrv = to_ccwgroupdrv(dev->driver);
	384
1da177e4 LT	385	device_remove_file(dev, &dev_attr_online);
	386
	387	if (gdrv && gdrv->remove)
	388	gdrv->remove(gdev);
	389	return 0;
	390	}
	391
f9ccf456 RK	392	static struct bus_type ccwgroup_bus_type = {
	393	.name = "ccwgroup",
	394	.match = ccwgroup_bus_match,
	395	.uevent = ccwgroup_uevent,
	396	.probe = ccwgroup_probe,
	397	.remove = ccwgroup_remove,
	398	};
	399
b2ffd8e9 CH	400	/**
	401	* ccwgroup_driver_register() - register a ccw group driver
	402	* @cdriver: driver to be registered
	403	*
	404	* This function is mainly a wrapper around driver_register().
	405	*/
	406	int ccwgroup_driver_register(struct ccwgroup_driver *cdriver)
1da177e4 LT	407	{
1da177e4 LT	408	/* register our new driver with the core */
292888c8 HC	409	cdriver->driver.bus = &ccwgroup_bus_type;
292888c8 HC	410	cdriver->driver.name = cdriver->name;
1da177e4 LT	411
	412	return driver_register(&cdriver->driver);
	413	}
	414
b0744bd2	415	static int
887ab599	416	__ccwgroup_match_all(struct device dev, void data)
1da177e4	417	{
887ab599	418	return 1;
1da177e4 LT	419	}
1da177e4 LT	420
b2ffd8e9 CH	421	/**
	422	* ccwgroup_driver_unregister() - deregister a ccw group driver
	423	* @cdriver: driver to be deregistered
	424	*
	425	* This function is mainly a wrapper around driver_unregister().
	426	*/
	427	void ccwgroup_driver_unregister(struct ccwgroup_driver *cdriver)
1da177e4	428	{
887ab599 CH	429	struct device *dev;
887ab599 CH	430
1da177e4 LT	431	/* We don't want ccwgroup devices to live longer than their driver. */
1da177e4 LT	432	get_driver(&cdriver->driver);
887ab599 CH	433	while ((dev = driver_find_device(&cdriver->driver, NULL, NULL,
887ab599 CH	434	__ccwgroup_match_all))) {
d76123eb CH	435	struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
	436
	437	mutex_lock(&gdev->reg_mutex);
	438	__ccwgroup_remove_symlinks(gdev);
887ab599	439	device_unregister(dev);
d76123eb	440	mutex_unlock(&gdev->reg_mutex);
887ab599 CH	441	put_device(dev);
887ab599 CH	442	}
1da177e4 LT	443	put_driver(&cdriver->driver);
	444	driver_unregister(&cdriver->driver);
	445	}
	446
b2ffd8e9 CH	447	/**
	448	* ccwgroup_probe_ccwdev() - probe function for slave devices
	449	* @cdev: ccw device to be probed
	450	*
	451	* This is a dummy probe function for ccw devices that are slave devices in
	452	* a ccw group device.
	453	* Returns:
	454	* always %0
	455	*/
	456	int ccwgroup_probe_ccwdev(struct ccw_device *cdev)
1da177e4 LT	457	{
	458	return 0;
	459	}
	460
4d284cac	461	static struct ccwgroup_device *
1da177e4 LT	462	__ccwgroup_get_gdev_by_cdev(struct ccw_device *cdev)
	463	{
	464	struct ccwgroup_device *gdev;
	465
	466	if (cdev->dev.driver_data) {
	467	gdev = (struct ccwgroup_device *)cdev->dev.driver_data;
	468	if (get_device(&gdev->dev)) {
d76123eb	469	mutex_lock(&gdev->reg_mutex);
d305ef5d	470	if (device_is_registered(&gdev->dev))
1da177e4	471	return gdev;
d76123eb	472	mutex_unlock(&gdev->reg_mutex);
1da177e4 LT	473	put_device(&gdev->dev);
	474	}
	475	return NULL;
	476	}
	477	return NULL;
	478	}
	479
b2ffd8e9 CH	480	/**
	481	* ccwgroup_remove_ccwdev() - remove function for slave devices
	482	* @cdev: ccw device to be removed
	483	*
	484	* This is a remove function for ccw devices that are slave devices in a ccw
	485	* group device. It sets the ccw device offline and also deregisters the
	486	* embedding ccw group device.
	487	*/
	488	void ccwgroup_remove_ccwdev(struct ccw_device *cdev)
1da177e4 LT	489	{
	490	struct ccwgroup_device *gdev;
	491
	492	/* Ignore offlining errors, device is gone anyway. */
	493	ccw_device_set_offline(cdev);
	494	/* If one of its devices is gone, the whole group is done for. */
	495	gdev = __ccwgroup_get_gdev_by_cdev(cdev);
	496	if (gdev) {
	497	__ccwgroup_remove_symlinks(gdev);
	498	device_unregister(&gdev->dev);
d76123eb	499	mutex_unlock(&gdev->reg_mutex);
1da177e4 LT	500	put_device(&gdev->dev);
	501	}
	502	}
	503
	504	MODULE_LICENSE("GPL");
	505	EXPORT_SYMBOL(ccwgroup_driver_register);
	506	EXPORT_SYMBOL(ccwgroup_driver_unregister);
	507	EXPORT_SYMBOL(ccwgroup_create);
	508	EXPORT_SYMBOL(ccwgroup_probe_ccwdev);
	509	EXPORT_SYMBOL(ccwgroup_remove_ccwdev);