[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / s390 / cio / ccwgroup.c

/*
 *  drivers/s390/cio/ccwgroup.c
 *  bus driver for ccwgroup
 *   $Revision: 1.33 $
 *
 *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
 *                       IBM Corporation
 *    Author(s): Arnd Bergmann (arndb@de.ibm.com)
 *               Cornelia Huck (cohuck@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 = {
	.name    = "ccwgroup",
	.match   = ccwgroup_bus_match,
	.uevent = ccwgroup_uevent,
};

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 = kmalloc(sizeof(*gdev) + argc*sizeof(gdev->cdev[0]), GFP_KERNEL);
	if (!gdev)
		return -ENOMEM;

	memset(gdev, 0, sizeof(*gdev) + argc*sizeof(gdev->cdev[0]));
	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, 0, 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;
}

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,
		.probe = ccwgroup_probe,
		.remove = ccwgroup_remove,
	};

	return driver_register(&cdriver->driver);
}

static int
__ccwgroup_driver_unregister_device(struct device *dev, void *data)
{
	__ccwgroup_remove_symlinks(to_ccwgroupdev(dev));
	device_unregister(dev);
	put_device(dev);
	return 0;
}

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