Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-10-31 17:21:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

[S390] ccwgroup: cleanup

Browse Source 
Fix coding style, remove forward declerations, simplify code.
Also remove a superfluous get_device/put_device pair in
ccwgroup_create_from_string.

Signed-off-by: Sebastian Ott <sebott@linux.vnet.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
This commit is contained in:
Sebastian Ott 2011-10-30 15:16:53 +01:00 committed by Martin Schwidefsky
parent dbdf1afcaa
commit dad572e370
1 changed files with 119 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

299
drivers/s390/cio/ccwgroup.c
View File

@ -29,31 +29,20 @@
/* a device matches a driver if all its slave devices match the same /* a device matches a driver if all its slave devices match the same
* entry of the driver */ * entry of the driver */
static int static int ccwgroup_bus_match(struct device *dev, struct device_driver * drv)
ccwgroup_bus_match (struct device * dev, struct device_driver * drv)
{ {
struct ccwgroup_device *gdev; struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
struct ccwgroup_driver *gdrv; struct ccwgroup_driver *gdrv = to_ccwgroupdrv(drv);
gdev = to_ccwgroupdev(dev);
gdrv = to_ccwgroupdrv(drv);
if (gdev->creator_id == gdrv->driver_id) if (gdev->creator_id == gdrv->driver_id)
return 1; return 1;
return 0; 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 struct bus_type ccwgroup_bus_type;
static void static void __ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
__ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
{ {
int i; int i;
char str[8]; char str[8];
@ -63,7 +52,6 @@ __ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
sysfs_remove_link(&gdev->dev.kobj, str); sysfs_remove_link(&gdev->dev.kobj, str);
sysfs_remove_link(&gdev->cdev[i]->dev.kobj, "group_device"); sysfs_remove_link(&gdev->cdev[i]->dev.kobj, "group_device");
} }
} }
/* /*
@ -87,12 +75,87 @@ static void __ccwgroup_remove_cdev_refs(struct ccwgroup_device *gdev)
} }
} }
static int ccwgroup_set_online(struct ccwgroup_device *gdev)
{
struct ccwgroup_driver *gdrv = to_ccwgroupdrv(gdev->dev.driver);
int ret = 0;
if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
return -EAGAIN;
if (gdev->state == CCWGROUP_ONLINE)
goto out;
if (gdrv->set_online)
ret = gdrv->set_online(gdev);
if (ret)
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 = to_ccwgroupdrv(gdev->dev.driver);
int ret = 0;
if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
return -EAGAIN;
if (gdev->state == CCWGROUP_OFFLINE)
goto out;
if (gdrv->set_offline)
ret = gdrv->set_offline(gdev);
if (ret)
goto out;
gdev->state = CCWGROUP_OFFLINE;
out:
atomic_set(&gdev->onoff, 0);
return ret;
}
static ssize_t ccwgroup_online_store(struct device *dev, static ssize_t ccwgroup_online_store(struct device *dev,
struct device_attribute *attr, struct device_attribute *attr,
const char *buf, size_t count); const char *buf, size_t count)
{
struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
struct ccwgroup_driver *gdrv = to_ccwgroupdrv(dev->driver);
unsigned long value;
int ret;
if (!dev->driver)
return -EINVAL;
if (!try_module_get(gdrv->driver.owner))
return -EINVAL;
ret = strict_strtoul(buf, 0, &value);
if (ret)
goto out;
if (value == 1)
ret = ccwgroup_set_online(gdev);
else if (value == 0)
ret = ccwgroup_set_offline(gdev);
else
ret = -EINVAL;
out:
module_put(gdrv->driver.owner);
return (ret == 0) ? count : ret;
}
static ssize_t ccwgroup_online_show(struct device *dev, static ssize_t ccwgroup_online_show(struct device *dev,
struct device_attribute *attr, struct device_attribute *attr,
char *buf); char *buf)
{
struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
int online;
online = (gdev->state == CCWGROUP_ONLINE) ? 1 : 0;
return scnprintf(buf, PAGE_SIZE, "%d\n", online);
}
/* /*
* Provide an 'ungroup' attribute so the user can remove group devices no * Provide an 'ungroup' attribute so the user can remove group devices no
* longer needed or accidentially created. Saves memory :) * longer needed or accidentially created. Saves memory :)
@ -110,14 +173,13 @@ static void ccwgroup_ungroup_callback(struct device *dev)
mutex_unlock(&gdev->reg_mutex); mutex_unlock(&gdev->reg_mutex);
} }
static ssize_t static ssize_t ccwgroup_ungroup_store(struct device *dev,
ccwgroup_ungroup_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) struct device_attribute *attr,
const char *buf, size_t count)
{ {
struct ccwgroup_device *gdev; struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
int rc; int rc;
gdev = to_ccwgroupdev(dev);
/* Prevent concurrent online/offline processing and ungrouping. */ /* Prevent concurrent online/offline processing and ungrouping. */
if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0) if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
return -EAGAIN; return -EAGAIN;
@ -138,7 +200,6 @@ out:
} }
return count; return count;
} }
static DEVICE_ATTR(ungroup, 0200, NULL, ccwgroup_ungroup_store); static DEVICE_ATTR(ungroup, 0200, NULL, ccwgroup_ungroup_store);
static DEVICE_ATTR(online, 0644, ccwgroup_online_show, ccwgroup_online_store); static DEVICE_ATTR(online, 0644, ccwgroup_online_show, ccwgroup_online_store);
@ -155,21 +216,19 @@ static const struct attribute_group *ccwgroup_attr_groups[] = {
NULL, NULL,
}; };
static void static void ccwgroup_release(struct device *dev)
ccwgroup_release (struct device *dev)
{ {
kfree(to_ccwgroupdev(dev)); kfree(to_ccwgroupdev(dev));
} }
static int static int __ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
__ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
{ {
char str[8]; char str[8];
int i, rc; int i, rc;
for (i = 0; i < gdev->count; i++) { for (i = 0; i < gdev->count; i++) {
rc = sysfs_create_link(&gdev->cdev[i]->dev.kobj, &gdev->dev.kobj, rc = sysfs_create_link(&gdev->cdev[i]->dev.kobj,
"group_device"); &gdev->dev.kobj, "group_device");
if (rc) { if (rc) {
for (--i; i >= 0; i--) for (--i; i >= 0; i--)
sysfs_remove_link(&gdev->cdev[i]->dev.kobj, sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
@ -179,8 +238,8 @@ __ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
} }
for (i = 0; i < gdev->count; i++) { for (i = 0; i < gdev->count; i++) {
sprintf(str, "cdev%d", i); sprintf(str, "cdev%d", i);
rc = sysfs_create_link(&gdev->dev.kobj, &gdev->cdev[i]->dev.kobj, rc = sysfs_create_link(&gdev->dev.kobj,
str); &gdev->cdev[i]->dev.kobj, str);
if (rc) { if (rc) {
for (--i; i >= 0; i--) { for (--i; i >= 0; i--) {
sprintf(str, "cdev%d", i); sprintf(str, "cdev%d", i);
@ -317,14 +376,13 @@ int ccwgroup_create_from_string(struct device *root, unsigned int creator_id,
rc = device_add(&gdev->dev); rc = device_add(&gdev->dev);
if (rc) if (rc)
goto error; goto error;
get_device(&gdev->dev);
rc = __ccwgroup_create_symlinks(gdev); rc = __ccwgroup_create_symlinks(gdev);
if (!rc) { if (rc) {
mutex_unlock(&gdev->reg_mutex); device_del(&gdev->dev);
put_device(&gdev->dev); goto error;
return 0;
} }
device_unregister(&gdev->dev); mutex_unlock(&gdev->reg_mutex);
return 0;
error: error:
for (i = 0; i < num_devices; i++) for (i = 0; i < num_devices; i++)
if (gdev->cdev[i]) { if (gdev->cdev[i]) {
@ -342,7 +400,15 @@ error:
EXPORT_SYMBOL(ccwgroup_create_from_string); EXPORT_SYMBOL(ccwgroup_create_from_string);
static int ccwgroup_notifier(struct notifier_block *nb, unsigned long action, static int ccwgroup_notifier(struct notifier_block *nb, unsigned long action,
void *data); void *data)
{
struct device *dev = data;
if (action == BUS_NOTIFY_UNBIND_DRIVER)
device_schedule_callback(dev, ccwgroup_ungroup_callback);
return NOTIFY_OK;
}
static struct notifier_block ccwgroup_nb = { static struct notifier_block ccwgroup_nb = {
.notifier_call = ccwgroup_notifier .notifier_call = ccwgroup_notifier
@ -374,128 +440,21 @@ module_exit(cleanup_ccwgroup);
/************************** driver stuff ******************************/ /************************** driver stuff ******************************/
static int static int ccwgroup_probe(struct device *dev)
ccwgroup_set_online(struct ccwgroup_device *gdev)
{ {
struct ccwgroup_driver *gdrv; struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
int ret; struct ccwgroup_driver *gdrv = to_ccwgroupdrv(dev->driver);
if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0) return gdrv->probe ? gdrv->probe(gdev) : -ENODEV;
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 static int ccwgroup_remove(struct device *dev)
ccwgroup_set_offline(struct ccwgroup_device *gdev)
{ {
struct ccwgroup_driver *gdrv; struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
int ret; struct ccwgroup_driver *gdrv = to_ccwgroupdrv(dev->driver);
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 long value;
int ret;
if (!dev->driver)
return -EINVAL;
gdev = to_ccwgroupdev(dev);
gdrv = to_ccwgroupdrv(dev->driver);
if (!try_module_get(gdrv->driver.owner))
return -EINVAL;
ret = strict_strtoul(buf, 0, &value);
if (ret)
goto out;
if (value == 1)
ret = ccwgroup_set_online(gdev);
else if (value == 0)
ret = ccwgroup_set_offline(gdev);
else
ret = -EINVAL;
out:
module_put(gdrv->driver.owner);
return (ret == 0) ? count : 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 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);
ret = gdrv->probe ? gdrv->probe(gdev) : -ENODEV;
return ret;
}
static int
ccwgroup_remove (struct device *dev)
{
struct ccwgroup_device *gdev;
struct ccwgroup_driver *gdrv;
if (!dev->driver) if (!dev->driver)
return 0; return 0;
gdev = to_ccwgroupdev(dev);
gdrv = to_ccwgroupdrv(dev->driver);
if (gdrv->remove) if (gdrv->remove)
gdrv->remove(gdev); gdrv->remove(gdev);
@ -504,15 +463,11 @@ ccwgroup_remove (struct device *dev)
static void ccwgroup_shutdown(struct device *dev) static void ccwgroup_shutdown(struct device *dev)
{ {
struct ccwgroup_device *gdev; struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
struct ccwgroup_driver *gdrv; struct ccwgroup_driver *gdrv = to_ccwgroupdrv(dev->driver);
if (!dev->driver) if (!dev->driver)
return; return;
gdev = to_ccwgroupdev(dev);
gdrv = to_ccwgroupdrv(dev->driver);
if (gdrv->shutdown) if (gdrv->shutdown)
gdrv->shutdown(gdev); gdrv->shutdown(gdev);
} }
@ -588,26 +543,12 @@ static const struct dev_pm_ops ccwgroup_pm_ops = {
static struct bus_type ccwgroup_bus_type = { static struct bus_type ccwgroup_bus_type = {
.name = "ccwgroup", .name = "ccwgroup",
.match = ccwgroup_bus_match, .match = ccwgroup_bus_match,
.uevent = ccwgroup_uevent,
.probe = ccwgroup_probe, .probe = ccwgroup_probe,
.remove = ccwgroup_remove, .remove = ccwgroup_remove,
.shutdown = ccwgroup_shutdown, .shutdown = ccwgroup_shutdown,
.pm = &ccwgroup_pm_ops, .pm = &ccwgroup_pm_ops,
}; };
static int ccwgroup_notifier(struct notifier_block *nb, unsigned long action,
void *data)
{
struct device *dev = data;
if (action == BUS_NOTIFY_UNBIND_DRIVER)
device_schedule_callback(dev, ccwgroup_ungroup_callback);
return NOTIFY_OK;
}
/** /**
* ccwgroup_driver_register() - register a ccw group driver * ccwgroup_driver_register() - register a ccw group driver
* @cdriver: driver to be registered * @cdriver: driver to be registered
@ -621,9 +562,9 @@ int ccwgroup_driver_register(struct ccwgroup_driver *cdriver)
return driver_register(&cdriver->driver); return driver_register(&cdriver->driver);
} }
EXPORT_SYMBOL(ccwgroup_driver_register);
static int static int __ccwgroup_match_all(struct device *dev, void *data)
__ccwgroup_match_all(struct device *dev, void *data)
{ {
return 1; return 1;
} }
@ -654,6 +595,7 @@ void ccwgroup_driver_unregister(struct ccwgroup_driver *cdriver)
put_driver(&cdriver->driver); put_driver(&cdriver->driver);
driver_unregister(&cdriver->driver); driver_unregister(&cdriver->driver);
} }
EXPORT_SYMBOL(ccwgroup_driver_unregister);
/** /**
* ccwgroup_probe_ccwdev() - probe function for slave devices * ccwgroup_probe_ccwdev() - probe function for slave devices
@ -668,6 +610,7 @@ int ccwgroup_probe_ccwdev(struct ccw_device *cdev)
{ {
return 0; return 0;
} }
EXPORT_SYMBOL(ccwgroup_probe_ccwdev);
/** /**
* ccwgroup_remove_ccwdev() - remove function for slave devices * ccwgroup_remove_ccwdev() - remove function for slave devices
@ -704,9 +647,5 @@ void ccwgroup_remove_ccwdev(struct ccw_device *cdev)
/* Release ccwgroup device reference for local processing. */ /* Release ccwgroup device reference for local processing. */
put_device(&gdev->dev); put_device(&gdev->dev);
} }
MODULE_LICENSE("GPL");
EXPORT_SYMBOL(ccwgroup_driver_register);
EXPORT_SYMBOL(ccwgroup_driver_unregister);
EXPORT_SYMBOL(ccwgroup_probe_ccwdev);
EXPORT_SYMBOL(ccwgroup_remove_ccwdev); EXPORT_SYMBOL(ccwgroup_remove_ccwdev);
MODULE_LICENSE("GPL");