[GitHub/mt8127/android_kernel_alcatel_ttab.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, char **envp, int num_envp, char *buffer,
		  int buffer_size)
{
	/* TODO */
	return 0;
}

static struct bus_type ccwgroup_bus_type;

static inline 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 ssize_t
ccwgroup_ungroup_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	struct ccwgroup_device *gdev;

	gdev = to_ccwgroupdev(dev);

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

	__ccwgroup_remove_symlinks(gdev);
	device_unregister(dev);

	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 inline 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;
}

/*
 * try to add a new ccwgroup device for one driver
 * argc and argv[] are a list of bus_id's of devices
 * belonging to the driver.
 */
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;
	int del_drvdata;

	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);

	del_drvdata = 0;
	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 free_dev;
		}
		/* Don't allow a device to belong to more than one group. */
		if (gdev->cdev[i]->dev.driver_data) {
			rc = -EINVAL;
			goto free_dev;
		}
	}
	for (i = 0; i < argc; i++)
		gdev->cdev[i]->dev.driver_data = gdev;
	del_drvdata = 1;

	gdev->creator_id = creator_id;
	gdev->count = argc;
	gdev->dev = (struct device ) {
		.bus = &ccwgroup_bus_type,
		.parent = root,
		.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 free_dev;
	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) {
		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]) {
			put_device(&gdev->cdev[i]->dev);
			gdev->cdev[i]->dev.driver_data = NULL;
		}
	put_device(&gdev->dev);
	return rc;
free_dev:
	for (i = 0; i < argc; i++)
		if (gdev->cdev[i]) {
			put_device(&gdev->cdev[i]->dev);
			if (del_drvdata)
				gdev->cdev[i]->dev.driver_data = NULL;
		}
	kfree(gdev);
	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;

	pr_debug("%s: device %s\n", __func__, gdev->dev.bus_id);
	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);

	pr_debug("%s: device %s\n", __func__, gdev->dev.bus_id);

	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,
};

int
ccwgroup_driver_register (struct ccwgroup_driver *cdriver)
{
	/* register our new driver with the core */
	cdriver->driver = (struct device_driver) {
		.bus = &ccwgroup_bus_type,
		.name = cdriver->name,
	};

	return driver_register(&cdriver->driver);
}

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

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))) {
		__ccwgroup_remove_symlinks(to_ccwgroupdev(dev));
		device_unregister(dev);
		put_device(dev);
	}
	put_driver(&cdriver->driver);
	driver_unregister(&cdriver->driver);
}

int
ccwgroup_probe_ccwdev(struct ccw_device *cdev)
{
	return 0;
}

static inline 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)) {
			if (device_is_registered(&gdev->dev))
				return gdev;
			put_device(&gdev->dev);
		}
		return NULL;
	}
	return NULL;
}

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);
		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
6d20b035	47	ccwgroup_uevent (struct device dev, char envp, int num_envp, char buffer,
1da177e4 LT	48	int buffer_size)
	49	{
	50	/* TODO */
	51	return 0;
	52	}
	53
f9ccf456	54	static struct bus_type ccwgroup_bus_type;
1da177e4 LT	55
	56	static inline void
	57	__ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
	58	{
	59	int i;
	60	char str[8];
	61
	62	for (i = 0; i < gdev->count; i++) {
	63	sprintf(str, "cdev%d", i);
	64	sysfs_remove_link(&gdev->dev.kobj, str);
	65	sysfs_remove_link(&gdev->cdev[i]->dev.kobj, "group_device");
	66	}
	67
	68	}
	69
	70	/*
	71	* Provide an 'ungroup' attribute so the user can remove group devices no
	72	* longer needed or accidentially created. Saves memory :)
	73	*/
	74	static ssize_t
3fd3c0a5	75	ccwgroup_ungroup_store(struct device dev, struct device_attribute attr, const char *buf, size_t count)
1da177e4 LT	76	{
	77	struct ccwgroup_device *gdev;
	78
	79	gdev = to_ccwgroupdev(dev);
	80
	81	if (gdev->state != CCWGROUP_OFFLINE)
	82	return -EINVAL;
	83
	84	__ccwgroup_remove_symlinks(gdev);
	85	device_unregister(dev);
	86
	87	return count;
	88	}
	89
	90	static DEVICE_ATTR(ungroup, 0200, NULL, ccwgroup_ungroup_store);
	91
	92	static void
	93	ccwgroup_release (struct device *dev)
	94	{
	95	struct ccwgroup_device *gdev;
	96	int i;
	97
	98	gdev = to_ccwgroupdev(dev);
	99
	100	for (i = 0; i < gdev->count; i++) {
	101	gdev->cdev[i]->dev.driver_data = NULL;
	102	put_device(&gdev->cdev[i]->dev);
	103	}
	104	kfree(gdev);
	105	}
	106
	107	static inline int
	108	__ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
	109	{
	110	char str[8];
	111	int i, rc;
	112
	113	for (i = 0; i < gdev->count; i++) {
	114	rc = sysfs_create_link(&gdev->cdev[i]->dev.kobj, &gdev->dev.kobj,
	115	"group_device");
	116	if (rc) {
	117	for (--i; i >= 0; i--)
	118	sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
	119	"group_device");
	120	return rc;
	121	}
	122	}
	123	for (i = 0; i < gdev->count; i++) {
	124	sprintf(str, "cdev%d", i);
	125	rc = sysfs_create_link(&gdev->dev.kobj, &gdev->cdev[i]->dev.kobj,
	126	str);
	127	if (rc) {
	128	for (--i; i >= 0; i--) {
	129	sprintf(str, "cdev%d", i);
	130	sysfs_remove_link(&gdev->dev.kobj, str);
	131	}
	132	for (i = 0; i < gdev->count; i++)
	133	sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
	134	"group_device");
	135	return rc;
	136	}
	137	}
	138	return 0;
	139	}
140
141	/*
142	* try to add a new ccwgroup device for one driver
143	* argc and argv[] are a list of bus_id's of devices
144	* belonging to the driver.
145	*/
146	int
147	ccwgroup_create(struct device *root,
148	unsigned int creator_id,
149	struct ccw_driver *cdrv,
150	int argc, char *argv[])
151	{
152	struct ccwgroup_device *gdev;
153	int i;
154	int rc;
155	int del_drvdata;
156
157	if (argc > 256) /* disallow dumb users */
158	return -EINVAL;
159
88abaab4	160	gdev = kzalloc(sizeof(gdev) + argcsizeof(gdev->cdev[0]), GFP_KERNEL);
1da177e4 LT	161	if (!gdev)
	162	return -ENOMEM;
	163
1da177e4 LT	164	atomic_set(&gdev->onoff, 0);
	165
	166	del_drvdata = 0;
	167	for (i = 0; i < argc; i++) {
	168	gdev->cdev[i] = get_ccwdev_by_busid(cdrv, argv[i]);
	169
	170	/* all devices have to be of the same type in
	171	* order to be grouped */
	172	if (!gdev->cdev[i]
	173	\|\| gdev->cdev[i]->id.driver_info !=
	174	gdev->cdev[0]->id.driver_info) {
	175	rc = -EINVAL;
	176	goto free_dev;
	177	}
	178	/* Don't allow a device to belong to more than one group. */
	179	if (gdev->cdev[i]->dev.driver_data) {
	180	rc = -EINVAL;
	181	goto free_dev;
	182	}
	183	}
	184	for (i = 0; i < argc; i++)
	185	gdev->cdev[i]->dev.driver_data = gdev;
	186	del_drvdata = 1;
	187
	188	gdev->creator_id = creator_id;
	189	gdev->count = argc;
	190	gdev->dev = (struct device ) {
	191	.bus = &ccwgroup_bus_type,
	192	.parent = root,
	193	.release = ccwgroup_release,
	194	};
	195
	196	snprintf (gdev->dev.bus_id, BUS_ID_SIZE, "%s",
	197	gdev->cdev[0]->dev.bus_id);
	198
	199	rc = device_register(&gdev->dev);
	200
	201	if (rc)
	202	goto free_dev;
	203	get_device(&gdev->dev);
	204	rc = device_create_file(&gdev->dev, &dev_attr_ungroup);
	205
	206	if (rc) {
	207	device_unregister(&gdev->dev);
	208	goto error;
	209	}
	210
	211	rc = __ccwgroup_create_symlinks(gdev);
	212	if (!rc) {
	213	put_device(&gdev->dev);
	214	return 0;
	215	}
	216	device_remove_file(&gdev->dev, &dev_attr_ungroup);
	217	device_unregister(&gdev->dev);
	218	error:
	219	for (i = 0; i < argc; i++)
	220	if (gdev->cdev[i]) {
	221	put_device(&gdev->cdev[i]->dev);
	222	gdev->cdev[i]->dev.driver_data = NULL;
	223	}
	224	put_device(&gdev->dev);
	225	return rc;
	226	free_dev:
	227	for (i = 0; i < argc; i++)
228	if (gdev->cdev[i]) {
229	put_device(&gdev->cdev[i]->dev);
230	if (del_drvdata)
231	gdev->cdev[i]->dev.driver_data = NULL;
232	}
233	kfree(gdev);
234	return rc;
235	}
236
237	static int __init
238	init_ccwgroup (void)
239	{
240	return bus_register (&ccwgroup_bus_type);
241	}
242
243	static void __exit
244	cleanup_ccwgroup (void)
245	{
246	bus_unregister (&ccwgroup_bus_type);
247	}
248
249	module_init(init_ccwgroup);
250	module_exit(cleanup_ccwgroup);
251
252	/************************ driver stuff ****************************/
253
254	static int
255	ccwgroup_set_online(struct ccwgroup_device *gdev)
256	{
257	struct ccwgroup_driver *gdrv;
258	int ret;
259
973bd993	260	if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
1da177e4 LT	261	return -EAGAIN;
	262	if (gdev->state == CCWGROUP_ONLINE) {
	263	ret = 0;
	264	goto out;
	265	}
	266	if (!gdev->dev.driver) {
	267	ret = -EINVAL;
	268	goto out;
	269	}
	270	gdrv = to_ccwgroupdrv (gdev->dev.driver);
a0016408	271	if ((ret = gdrv->set_online ? gdrv->set_online(gdev) : 0))
1da177e4 LT	272	goto out;
	273
	274	gdev->state = CCWGROUP_ONLINE;
	275	out:
	276	atomic_set(&gdev->onoff, 0);
	277	return ret;
	278	}
	279
	280	static int
	281	ccwgroup_set_offline(struct ccwgroup_device *gdev)
	282	{
	283	struct ccwgroup_driver *gdrv;
	284	int ret;
	285
973bd993	286	if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
1da177e4 LT	287	return -EAGAIN;
	288	if (gdev->state == CCWGROUP_OFFLINE) {
	289	ret = 0;
	290	goto out;
	291	}
	292	if (!gdev->dev.driver) {
	293	ret = -EINVAL;
	294	goto out;
	295	}
	296	gdrv = to_ccwgroupdrv (gdev->dev.driver);
a0016408	297	if ((ret = gdrv->set_offline ? gdrv->set_offline(gdev) : 0))
1da177e4 LT	298	goto out;
	299
	300	gdev->state = CCWGROUP_OFFLINE;
	301	out:
	302	atomic_set(&gdev->onoff, 0);
	303	return ret;
	304	}
	305
	306	static ssize_t
3fd3c0a5	307	ccwgroup_online_store (struct device dev, struct device_attribute attr, const char *buf, size_t count)
1da177e4 LT	308	{
	309	struct ccwgroup_device *gdev;
	310	struct ccwgroup_driver *gdrv;
	311	unsigned int value;
	312	int ret;
	313
	314	gdev = to_ccwgroupdev(dev);
	315	if (!dev->driver)
	316	return count;
	317
	318	gdrv = to_ccwgroupdrv (gdev->dev.driver);
	319	if (!try_module_get(gdrv->owner))
	320	return -EINVAL;
	321
d2c993d8	322	value = simple_strtoul(buf, NULL, 0);
1da177e4 LT	323	ret = count;
	324	if (value == 1)
	325	ccwgroup_set_online(gdev);
	326	else if (value == 0)
	327	ccwgroup_set_offline(gdev);
	328	else
	329	ret = -EINVAL;
	330	module_put(gdrv->owner);
	331	return ret;
	332	}
	333
	334	static ssize_t
3fd3c0a5	335	ccwgroup_online_show (struct device dev, struct device_attribute attr, char *buf)
1da177e4 LT	336	{
	337	int online;
	338
	339	online = (to_ccwgroupdev(dev)->state == CCWGROUP_ONLINE);
	340
	341	return sprintf(buf, online ? "1\n" : "0\n");
	342	}
	343
	344	static DEVICE_ATTR(online, 0644, ccwgroup_online_show, ccwgroup_online_store);
	345
	346	static int
	347	ccwgroup_probe (struct device *dev)
	348	{
	349	struct ccwgroup_device *gdev;
	350	struct ccwgroup_driver *gdrv;
	351
	352	int ret;
	353
	354	gdev = to_ccwgroupdev(dev);
	355	gdrv = to_ccwgroupdrv(dev->driver);
	356
	357	if ((ret = device_create_file(dev, &dev_attr_online)))
	358	return ret;
	359
	360	pr_debug("%s: device %s\n", __func__, gdev->dev.bus_id);
	361	ret = gdrv->probe ? gdrv->probe(gdev) : -ENODEV;
	362	if (ret)
	363	device_remove_file(dev, &dev_attr_online);
	364
	365	return ret;
	366	}
	367
	368	static int
	369	ccwgroup_remove (struct device *dev)
	370	{
	371	struct ccwgroup_device *gdev;
	372	struct ccwgroup_driver *gdrv;
	373
	374	gdev = to_ccwgroupdev(dev);
	375	gdrv = to_ccwgroupdrv(dev->driver);
	376
	377	pr_debug("%s: device %s\n", __func__, gdev->dev.bus_id);
	378
	379	device_remove_file(dev, &dev_attr_online);
	380
	381	if (gdrv && gdrv->remove)
	382	gdrv->remove(gdev);
	383	return 0;
	384	}
	385
f9ccf456 RK	386	static struct bus_type ccwgroup_bus_type = {
	387	.name = "ccwgroup",
	388	.match = ccwgroup_bus_match,
	389	.uevent = ccwgroup_uevent,
	390	.probe = ccwgroup_probe,
	391	.remove = ccwgroup_remove,
	392	};
	393
1da177e4 LT	394	int
	395	ccwgroup_driver_register (struct ccwgroup_driver *cdriver)
	396	{
	397	/* register our new driver with the core */
	398	cdriver->driver = (struct device_driver) {
	399	.bus = &ccwgroup_bus_type,
	400	.name = cdriver->name,
1da177e4 LT	401	};
	402
	403	return driver_register(&cdriver->driver);
	404	}
	405
b0744bd2	406	static int
887ab599	407	__ccwgroup_match_all(struct device dev, void data)
1da177e4	408	{
887ab599	409	return 1;
1da177e4 LT	410	}
	411
	412	void
	413	ccwgroup_driver_unregister (struct ccwgroup_driver *cdriver)
	414	{
887ab599 CH	415	struct device *dev;
887ab599 CH	416
1da177e4 LT	417	/* We don't want ccwgroup devices to live longer than their driver. */
1da177e4 LT	418	get_driver(&cdriver->driver);
887ab599 CH	419	while ((dev = driver_find_device(&cdriver->driver, NULL, NULL,
	420	__ccwgroup_match_all))) {
	421	__ccwgroup_remove_symlinks(to_ccwgroupdev(dev));
	422	device_unregister(dev);
	423	put_device(dev);
	424	}
1da177e4 LT	425	put_driver(&cdriver->driver);
	426	driver_unregister(&cdriver->driver);
	427	}
	428
	429	int
	430	ccwgroup_probe_ccwdev(struct ccw_device *cdev)
	431	{
	432	return 0;
	433	}
	434
	435	static inline struct ccwgroup_device *
	436	__ccwgroup_get_gdev_by_cdev(struct ccw_device *cdev)
	437	{
	438	struct ccwgroup_device *gdev;
	439
	440	if (cdev->dev.driver_data) {
	441	gdev = (struct ccwgroup_device *)cdev->dev.driver_data;
	442	if (get_device(&gdev->dev)) {
d305ef5d	443	if (device_is_registered(&gdev->dev))
1da177e4 LT	444	return gdev;
	445	put_device(&gdev->dev);
	446	}
	447	return NULL;
	448	}
	449	return NULL;
	450	}
	451
	452	void
	453	ccwgroup_remove_ccwdev(struct ccw_device *cdev)
	454	{
	455	struct ccwgroup_device *gdev;
	456
	457	/* Ignore offlining errors, device is gone anyway. */
	458	ccw_device_set_offline(cdev);
	459	/* If one of its devices is gone, the whole group is done for. */
	460	gdev = __ccwgroup_get_gdev_by_cdev(cdev);
	461	if (gdev) {
	462	__ccwgroup_remove_symlinks(gdev);
	463	device_unregister(&gdev->dev);
	464	put_device(&gdev->dev);
	465	}
	466	}
	467
	468	MODULE_LICENSE("GPL");
	469	EXPORT_SYMBOL(ccwgroup_driver_register);
	470	EXPORT_SYMBOL(ccwgroup_driver_unregister);
	471	EXPORT_SYMBOL(ccwgroup_create);
	472	EXPORT_SYMBOL(ccwgroup_probe_ccwdev);
	473	EXPORT_SYMBOL(ccwgroup_remove_ccwdev);