1724117b7SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * bus driver for ccwgroup
41da177e4SLinus Torvalds *
5f2962daeSSebastian Ott * Copyright IBM Corp. 2002, 2012
67e597a21SSebastian Ott *
71da177e4SLinus Torvalds * Author(s): Arnd Bergmann (arndb@de.ibm.com)
84ce3b30cSCornelia Huck * Cornelia Huck (cornelia.huck@de.ibm.com)
91da177e4SLinus Torvalds */
101da177e4SLinus Torvalds #include <linux/module.h>
111da177e4SLinus Torvalds #include <linux/errno.h>
121da177e4SLinus Torvalds #include <linux/slab.h>
131da177e4SLinus Torvalds #include <linux/list.h>
141da177e4SLinus Torvalds #include <linux/device.h>
151da177e4SLinus Torvalds #include <linux/init.h>
161da177e4SLinus Torvalds #include <linux/ctype.h>
171da177e4SLinus Torvalds #include <linux/dcache.h>
181da177e4SLinus Torvalds
19b7a610f7SSebastian Ott #include <asm/cio.h>
201da177e4SLinus Torvalds #include <asm/ccwdev.h>
211da177e4SLinus Torvalds #include <asm/ccwgroup.h>
221da177e4SLinus Torvalds
23b7a610f7SSebastian Ott #include "device.h"
24b7a610f7SSebastian Ott
25b7a610f7SSebastian Ott #define CCW_BUS_ID_SIZE 10
2698df67b3SKay Sievers
271da177e4SLinus Torvalds /* In Linux 2.4, we had a channel device layer called "chandev"
281da177e4SLinus Torvalds * that did all sorts of obscure stuff for networking devices.
291da177e4SLinus Torvalds * This is another driver that serves as a replacement for just
301da177e4SLinus Torvalds * one of its functions, namely the translation of single subchannels
311da177e4SLinus Torvalds * to devices that use multiple subchannels.
321da177e4SLinus Torvalds */
331da177e4SLinus Torvalds
34f9ccf456SRussell King static struct bus_type ccwgroup_bus_type;
351da177e4SLinus Torvalds
__ccwgroup_remove_symlinks(struct ccwgroup_device * gdev)36dad572e3SSebastian Ott static void __ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
371da177e4SLinus Torvalds {
381da177e4SLinus Torvalds int i;
392685df67SHeiko Carstens char str[16];
401da177e4SLinus Torvalds
411da177e4SLinus Torvalds for (i = 0; i < gdev->count; i++) {
421da177e4SLinus Torvalds sprintf(str, "cdev%d", i);
431da177e4SLinus Torvalds sysfs_remove_link(&gdev->dev.kobj, str);
441da177e4SLinus Torvalds sysfs_remove_link(&gdev->cdev[i]->dev.kobj, "group_device");
451da177e4SLinus Torvalds }
461da177e4SLinus Torvalds }
471da177e4SLinus Torvalds
48683c3dceSSebastian Ott /**
49683c3dceSSebastian Ott * ccwgroup_set_online() - enable a ccwgroup device
50683c3dceSSebastian Ott * @gdev: target ccwgroup device
51683c3dceSSebastian Ott *
52683c3dceSSebastian Ott * This function attempts to put the ccwgroup device into the online state.
53683c3dceSSebastian Ott * Returns:
54683c3dceSSebastian Ott * %0 on success and a negative error value on failure.
55683c3dceSSebastian Ott */
ccwgroup_set_online(struct ccwgroup_device * gdev)56683c3dceSSebastian Ott int ccwgroup_set_online(struct ccwgroup_device *gdev)
57dad572e3SSebastian Ott {
58dad572e3SSebastian Ott struct ccwgroup_driver *gdrv = to_ccwgroupdrv(gdev->dev.driver);
59cff97102SSebastian Ott int ret = -EINVAL;
60dad572e3SSebastian Ott
61dad572e3SSebastian Ott if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
62dad572e3SSebastian Ott return -EAGAIN;
63dad572e3SSebastian Ott if (gdev->state == CCWGROUP_ONLINE)
64dad572e3SSebastian Ott goto out;
65dad572e3SSebastian Ott if (gdrv->set_online)
66dad572e3SSebastian Ott ret = gdrv->set_online(gdev);
67dad572e3SSebastian Ott if (ret)
68dad572e3SSebastian Ott goto out;
69dad572e3SSebastian Ott
70dad572e3SSebastian Ott gdev->state = CCWGROUP_ONLINE;
71dad572e3SSebastian Ott out:
72dad572e3SSebastian Ott atomic_set(&gdev->onoff, 0);
73dad572e3SSebastian Ott return ret;
74dad572e3SSebastian Ott }
75683c3dceSSebastian Ott EXPORT_SYMBOL(ccwgroup_set_online);
76dad572e3SSebastian Ott
77683c3dceSSebastian Ott /**
78683c3dceSSebastian Ott * ccwgroup_set_offline() - disable a ccwgroup device
79683c3dceSSebastian Ott * @gdev: target ccwgroup device
80d2b59bd4SAlexandra Winter * @call_gdrv: Call the registered gdrv set_offline function
81683c3dceSSebastian Ott *
82683c3dceSSebastian Ott * This function attempts to put the ccwgroup device into the offline state.
83683c3dceSSebastian Ott * Returns:
84683c3dceSSebastian Ott * %0 on success and a negative error value on failure.
85683c3dceSSebastian Ott */
ccwgroup_set_offline(struct ccwgroup_device * gdev,bool call_gdrv)86d2b59bd4SAlexandra Winter int ccwgroup_set_offline(struct ccwgroup_device *gdev, bool call_gdrv)
87dad572e3SSebastian Ott {
88dad572e3SSebastian Ott struct ccwgroup_driver *gdrv = to_ccwgroupdrv(gdev->dev.driver);
89cff97102SSebastian Ott int ret = -EINVAL;
90dad572e3SSebastian Ott
91dad572e3SSebastian Ott if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
92dad572e3SSebastian Ott return -EAGAIN;
93dad572e3SSebastian Ott if (gdev->state == CCWGROUP_OFFLINE)
94dad572e3SSebastian Ott goto out;
95d2b59bd4SAlexandra Winter if (!call_gdrv) {
96d2b59bd4SAlexandra Winter ret = 0;
97d2b59bd4SAlexandra Winter goto offline;
98d2b59bd4SAlexandra Winter }
99dad572e3SSebastian Ott if (gdrv->set_offline)
100dad572e3SSebastian Ott ret = gdrv->set_offline(gdev);
101dad572e3SSebastian Ott if (ret)
102dad572e3SSebastian Ott goto out;
103dad572e3SSebastian Ott
104d2b59bd4SAlexandra Winter offline:
105dad572e3SSebastian Ott gdev->state = CCWGROUP_OFFLINE;
106dad572e3SSebastian Ott out:
107dad572e3SSebastian Ott atomic_set(&gdev->onoff, 0);
108dad572e3SSebastian Ott return ret;
109dad572e3SSebastian Ott }
110683c3dceSSebastian Ott EXPORT_SYMBOL(ccwgroup_set_offline);
111dad572e3SSebastian Ott
ccwgroup_online_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)112dbdf1afcSSebastian Ott static ssize_t ccwgroup_online_store(struct device *dev,
113dbdf1afcSSebastian Ott struct device_attribute *attr,
114dad572e3SSebastian Ott const char *buf, size_t count)
115dad572e3SSebastian Ott {
116dad572e3SSebastian Ott struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
117dad572e3SSebastian Ott unsigned long value;
118dad572e3SSebastian Ott int ret;
119dad572e3SSebastian Ott
120d5b877ffSSebastian Ott device_lock(dev);
121d5b877ffSSebastian Ott if (!dev->driver) {
122d5b877ffSSebastian Ott ret = -EINVAL;
123d5b877ffSSebastian Ott goto out;
124d5b877ffSSebastian Ott }
125dad572e3SSebastian Ott
1260178722bSJingoo Han ret = kstrtoul(buf, 0, &value);
127dad572e3SSebastian Ott if (ret)
128dad572e3SSebastian Ott goto out;
129dad572e3SSebastian Ott
130dad572e3SSebastian Ott if (value == 1)
131dad572e3SSebastian Ott ret = ccwgroup_set_online(gdev);
132dad572e3SSebastian Ott else if (value == 0)
133d2b59bd4SAlexandra Winter ret = ccwgroup_set_offline(gdev, true);
134dad572e3SSebastian Ott else
135dad572e3SSebastian Ott ret = -EINVAL;
136dad572e3SSebastian Ott out:
137d5b877ffSSebastian Ott device_unlock(dev);
138dad572e3SSebastian Ott return (ret == 0) ? count : ret;
139dad572e3SSebastian Ott }
140dad572e3SSebastian Ott
ccwgroup_online_show(struct device * dev,struct device_attribute * attr,char * buf)141dbdf1afcSSebastian Ott static ssize_t ccwgroup_online_show(struct device *dev,
142dbdf1afcSSebastian Ott struct device_attribute *attr,
143dad572e3SSebastian Ott char *buf)
144dad572e3SSebastian Ott {
145dad572e3SSebastian Ott struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
146dad572e3SSebastian Ott int online;
147dad572e3SSebastian Ott
148dad572e3SSebastian Ott online = (gdev->state == CCWGROUP_ONLINE) ? 1 : 0;
149dad572e3SSebastian Ott
150dad572e3SSebastian Ott return scnprintf(buf, PAGE_SIZE, "%d\n", online);
151dad572e3SSebastian Ott }
152dad572e3SSebastian Ott
153c0301754SPeter Oberparleiter /*
1541da177e4SLinus Torvalds * Provide an 'ungroup' attribute so the user can remove group devices no
155*cada938aSHeiko Carstens * longer needed or accidentally created. Saves memory :)
1561da177e4SLinus Torvalds */
ccwgroup_ungroup(struct ccwgroup_device * gdev)1570b60f9eaSTejun Heo static void ccwgroup_ungroup(struct ccwgroup_device *gdev)
158d9a9cdfbSAlan Stern {
159d76123ebSCornelia Huck mutex_lock(&gdev->reg_mutex);
1601a908c73SCornelia Huck if (device_is_registered(&gdev->dev)) {
161d9a9cdfbSAlan Stern __ccwgroup_remove_symlinks(gdev);
1620b60f9eaSTejun Heo device_unregister(&gdev->dev);
1631a908c73SCornelia Huck }
164d76123ebSCornelia Huck mutex_unlock(&gdev->reg_mutex);
165d9a9cdfbSAlan Stern }
166d9a9cdfbSAlan Stern
ccwgroup_ungroup_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)167dad572e3SSebastian Ott static ssize_t ccwgroup_ungroup_store(struct device *dev,
168dad572e3SSebastian Ott struct device_attribute *attr,
169dad572e3SSebastian Ott const char *buf, size_t count)
1701da177e4SLinus Torvalds {
171dad572e3SSebastian Ott struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
1720310c8b5SSebastian Ott int rc = 0;
1731da177e4SLinus Torvalds
174c619d422SPeter Oberparleiter /* Prevent concurrent online/offline processing and ungrouping. */
175c619d422SPeter Oberparleiter if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
176c619d422SPeter Oberparleiter return -EAGAIN;
177c619d422SPeter Oberparleiter if (gdev->state != CCWGROUP_OFFLINE) {
178c619d422SPeter Oberparleiter rc = -EINVAL;
179c619d422SPeter Oberparleiter goto out;
180c619d422SPeter Oberparleiter }
1810b60f9eaSTejun Heo
1820b60f9eaSTejun Heo if (device_remove_file_self(dev, attr))
1830b60f9eaSTejun Heo ccwgroup_ungroup(gdev);
1840310c8b5SSebastian Ott else
1850310c8b5SSebastian Ott rc = -ENODEV;
186c619d422SPeter Oberparleiter out:
187c619d422SPeter Oberparleiter if (rc) {
188c619d422SPeter Oberparleiter /* Release onoff "lock" when ungrouping failed. */
189c619d422SPeter Oberparleiter atomic_set(&gdev->onoff, 0);
190c619d422SPeter Oberparleiter return rc;
191c619d422SPeter Oberparleiter }
1921da177e4SLinus Torvalds return count;
1931da177e4SLinus Torvalds }
1941da177e4SLinus Torvalds static DEVICE_ATTR(ungroup, 0200, NULL, ccwgroup_ungroup_store);
195dbdf1afcSSebastian Ott static DEVICE_ATTR(online, 0644, ccwgroup_online_show, ccwgroup_online_store);
196dbdf1afcSSebastian Ott
19705066312SJulian Wiedmann static struct attribute *ccwgroup_dev_attrs[] = {
198dbdf1afcSSebastian Ott &dev_attr_online.attr,
199dbdf1afcSSebastian Ott &dev_attr_ungroup.attr,
200dbdf1afcSSebastian Ott NULL,
201dbdf1afcSSebastian Ott };
20205066312SJulian Wiedmann ATTRIBUTE_GROUPS(ccwgroup_dev);
2031da177e4SLinus Torvalds
ccwgroup_ungroup_workfn(struct work_struct * work)2040b60f9eaSTejun Heo static void ccwgroup_ungroup_workfn(struct work_struct *work)
2050b60f9eaSTejun Heo {
2060b60f9eaSTejun Heo struct ccwgroup_device *gdev =
2070b60f9eaSTejun Heo container_of(work, struct ccwgroup_device, ungroup_work);
2080b60f9eaSTejun Heo
2090b60f9eaSTejun Heo ccwgroup_ungroup(gdev);
2109280ddb1SSebastian Ott put_device(&gdev->dev);
2110b60f9eaSTejun Heo }
2120b60f9eaSTejun Heo
ccwgroup_release(struct device * dev)213dad572e3SSebastian Ott static void ccwgroup_release(struct device *dev)
2141da177e4SLinus Torvalds {
215197cec28SJulian Wiedmann struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
216197cec28SJulian Wiedmann unsigned int i;
217197cec28SJulian Wiedmann
218197cec28SJulian Wiedmann for (i = 0; i < gdev->count; i++) {
219197cec28SJulian Wiedmann struct ccw_device *cdev = gdev->cdev[i];
220197cec28SJulian Wiedmann unsigned long flags;
221197cec28SJulian Wiedmann
222197cec28SJulian Wiedmann if (cdev) {
223197cec28SJulian Wiedmann spin_lock_irqsave(cdev->ccwlock, flags);
224197cec28SJulian Wiedmann if (dev_get_drvdata(&cdev->dev) == gdev)
225197cec28SJulian Wiedmann dev_set_drvdata(&cdev->dev, NULL);
226197cec28SJulian Wiedmann spin_unlock_irqrestore(cdev->ccwlock, flags);
227197cec28SJulian Wiedmann put_device(&cdev->dev);
228197cec28SJulian Wiedmann }
229197cec28SJulian Wiedmann }
230197cec28SJulian Wiedmann
231197cec28SJulian Wiedmann kfree(gdev);
2321da177e4SLinus Torvalds }
2331da177e4SLinus Torvalds
__ccwgroup_create_symlinks(struct ccwgroup_device * gdev)234dad572e3SSebastian Ott static int __ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
2351da177e4SLinus Torvalds {
2362685df67SHeiko Carstens char str[16];
2371da177e4SLinus Torvalds int i, rc;
2381da177e4SLinus Torvalds
2391da177e4SLinus Torvalds for (i = 0; i < gdev->count; i++) {
240dad572e3SSebastian Ott rc = sysfs_create_link(&gdev->cdev[i]->dev.kobj,
241dad572e3SSebastian Ott &gdev->dev.kobj, "group_device");
2421da177e4SLinus Torvalds if (rc) {
2431da177e4SLinus Torvalds for (--i; i >= 0; i--)
2441da177e4SLinus Torvalds sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
2451da177e4SLinus Torvalds "group_device");
2461da177e4SLinus Torvalds return rc;
2471da177e4SLinus Torvalds }
2481da177e4SLinus Torvalds }
2491da177e4SLinus Torvalds for (i = 0; i < gdev->count; i++) {
2501da177e4SLinus Torvalds sprintf(str, "cdev%d", i);
251dad572e3SSebastian Ott rc = sysfs_create_link(&gdev->dev.kobj,
252dad572e3SSebastian Ott &gdev->cdev[i]->dev.kobj, str);
2531da177e4SLinus Torvalds if (rc) {
2541da177e4SLinus Torvalds for (--i; i >= 0; i--) {
2551da177e4SLinus Torvalds sprintf(str, "cdev%d", i);
2561da177e4SLinus Torvalds sysfs_remove_link(&gdev->dev.kobj, str);
2571da177e4SLinus Torvalds }
2581da177e4SLinus Torvalds for (i = 0; i < gdev->count; i++)
2591da177e4SLinus Torvalds sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
2601da177e4SLinus Torvalds "group_device");
2611da177e4SLinus Torvalds return rc;
2621da177e4SLinus Torvalds }
2631da177e4SLinus Torvalds }
2641da177e4SLinus Torvalds return 0;
2651da177e4SLinus Torvalds }
2661da177e4SLinus Torvalds
__get_next_id(const char ** buf,struct ccw_dev_id * id)267b7a610f7SSebastian Ott static int __get_next_id(const char **buf, struct ccw_dev_id *id)
268022b660aSUrsula Braun {
269b7a610f7SSebastian Ott unsigned int cssid, ssid, devno;
270b7a610f7SSebastian Ott int ret = 0, len;
271022b660aSUrsula Braun char *start, *end;
272022b660aSUrsula Braun
273022b660aSUrsula Braun start = (char *)*buf;
274022b660aSUrsula Braun end = strchr(start, ',');
275022b660aSUrsula Braun if (!end) {
276022b660aSUrsula Braun /* Last entry. Strip trailing newline, if applicable. */
277022b660aSUrsula Braun end = strchr(start, '\n');
278022b660aSUrsula Braun if (end)
279022b660aSUrsula Braun *end = '\0';
280022b660aSUrsula Braun len = strlen(start) + 1;
281022b660aSUrsula Braun } else {
282022b660aSUrsula Braun len = end - start + 1;
283022b660aSUrsula Braun end++;
284022b660aSUrsula Braun }
285b7a610f7SSebastian Ott if (len <= CCW_BUS_ID_SIZE) {
286b7a610f7SSebastian Ott if (sscanf(start, "%2x.%1x.%04x", &cssid, &ssid, &devno) != 3)
287b7a610f7SSebastian Ott ret = -EINVAL;
288022b660aSUrsula Braun } else
289b7a610f7SSebastian Ott ret = -EINVAL;
290b7a610f7SSebastian Ott
291b7a610f7SSebastian Ott if (!ret) {
292b7a610f7SSebastian Ott id->ssid = ssid;
293b7a610f7SSebastian Ott id->devno = devno;
294022b660aSUrsula Braun }
295b7a610f7SSebastian Ott *buf = end;
296b7a610f7SSebastian Ott return ret;
297022b660aSUrsula Braun }
298022b660aSUrsula Braun
299b2ffd8e9SCornelia Huck /**
300f2962daeSSebastian Ott * ccwgroup_create_dev() - create and register a ccw group device
301f2962daeSSebastian Ott * @parent: parent device for the new device
302f2962daeSSebastian Ott * @gdrv: driver for the new group device
303022b660aSUrsula Braun * @num_devices: number of slave devices
304022b660aSUrsula Braun * @buf: buffer containing comma separated bus ids of slave devices
305b2ffd8e9SCornelia Huck *
306f2962daeSSebastian Ott * Create and register a new ccw group device as a child of @parent. Slave
307b7a610f7SSebastian Ott * devices are obtained from the list of bus ids given in @buf.
308b2ffd8e9SCornelia Huck * Returns:
309b2ffd8e9SCornelia Huck * %0 on success and an error code on failure.
310b2ffd8e9SCornelia Huck * Context:
311b2ffd8e9SCornelia Huck * non-atomic
3121da177e4SLinus Torvalds */
ccwgroup_create_dev(struct device * parent,struct ccwgroup_driver * gdrv,int num_devices,const char * buf)3139814fdfbSSebastian Ott int ccwgroup_create_dev(struct device *parent, struct ccwgroup_driver *gdrv,
3149814fdfbSSebastian Ott int num_devices, const char *buf)
3151da177e4SLinus Torvalds {
3161da177e4SLinus Torvalds struct ccwgroup_device *gdev;
317b7a610f7SSebastian Ott struct ccw_dev_id dev_id;
318022b660aSUrsula Braun int rc, i;
3191da177e4SLinus Torvalds
320ab7efda4SJulian Wiedmann if (num_devices < 1)
321ab7efda4SJulian Wiedmann return -EINVAL;
322ab7efda4SJulian Wiedmann
323acafe7e3SKees Cook gdev = kzalloc(struct_size(gdev, cdev, num_devices), GFP_KERNEL);
3241da177e4SLinus Torvalds if (!gdev)
3251da177e4SLinus Torvalds return -ENOMEM;
3261da177e4SLinus Torvalds
3271da177e4SLinus Torvalds atomic_set(&gdev->onoff, 0);
328d76123ebSCornelia Huck mutex_init(&gdev->reg_mutex);
329d76123ebSCornelia Huck mutex_lock(&gdev->reg_mutex);
3300b60f9eaSTejun Heo INIT_WORK(&gdev->ungroup_work, ccwgroup_ungroup_workfn);
33116f7f956SPeter Oberparleiter gdev->count = num_devices;
33216f7f956SPeter Oberparleiter gdev->dev.bus = &ccwgroup_bus_type;
333f2962daeSSebastian Ott gdev->dev.parent = parent;
33416f7f956SPeter Oberparleiter gdev->dev.release = ccwgroup_release;
33516f7f956SPeter Oberparleiter device_initialize(&gdev->dev);
33616f7f956SPeter Oberparleiter
337b7a610f7SSebastian Ott for (i = 0; i < num_devices && buf; i++) {
338b7a610f7SSebastian Ott rc = __get_next_id(&buf, &dev_id);
339022b660aSUrsula Braun if (rc != 0)
340022b660aSUrsula Braun goto error;
341b7a610f7SSebastian Ott gdev->cdev[i] = get_ccwdev_by_dev_id(&dev_id);
342022b660aSUrsula Braun /*
343022b660aSUrsula Braun * All devices have to be of the same type in
344022b660aSUrsula Braun * order to be grouped.
345022b660aSUrsula Braun */
346b7a610f7SSebastian Ott if (!gdev->cdev[i] || !gdev->cdev[i]->drv ||
347b7a610f7SSebastian Ott gdev->cdev[i]->drv != gdev->cdev[0]->drv ||
348b7a610f7SSebastian Ott gdev->cdev[i]->id.driver_info !=
3491da177e4SLinus Torvalds gdev->cdev[0]->id.driver_info) {
3501da177e4SLinus Torvalds rc = -EINVAL;
351d76123ebSCornelia Huck goto error;
3521da177e4SLinus Torvalds }
3531da177e4SLinus Torvalds /* Don't allow a device to belong to more than one group. */
354c560d105SSebastian Ott spin_lock_irq(gdev->cdev[i]->ccwlock);
355db6a6423SCornelia Huck if (dev_get_drvdata(&gdev->cdev[i]->dev)) {
356c560d105SSebastian Ott spin_unlock_irq(gdev->cdev[i]->ccwlock);
3571da177e4SLinus Torvalds rc = -EINVAL;
358d76123ebSCornelia Huck goto error;
3591da177e4SLinus Torvalds }
360db6a6423SCornelia Huck dev_set_drvdata(&gdev->cdev[i]->dev, gdev);
361c560d105SSebastian Ott spin_unlock_irq(gdev->cdev[i]->ccwlock);
36217088229SCornelia Huck }
363022b660aSUrsula Braun /* Check for sufficient number of bus ids. */
364b7a610f7SSebastian Ott if (i < num_devices) {
365022b660aSUrsula Braun rc = -EINVAL;
366022b660aSUrsula Braun goto error;
367022b660aSUrsula Braun }
368022b660aSUrsula Braun /* Check for trailing stuff. */
369ea298e6eSVasily Gorbik if (i == num_devices && buf && strlen(buf) > 0) {
370022b660aSUrsula Braun rc = -EINVAL;
371022b660aSUrsula Braun goto error;
372022b660aSUrsula Braun }
373f9a5d70cSJulian Wiedmann /* Check if the devices are bound to the required ccw driver. */
374ab7efda4SJulian Wiedmann if (gdrv && gdrv->ccw_driver &&
375f9a5d70cSJulian Wiedmann gdev->cdev[0]->drv != gdrv->ccw_driver) {
376f9a5d70cSJulian Wiedmann rc = -EINVAL;
377f9a5d70cSJulian Wiedmann goto error;
378f9a5d70cSJulian Wiedmann }
3791da177e4SLinus Torvalds
3801bf5b285SCornelia Huck dev_set_name(&gdev->dev, "%s", dev_name(&gdev->cdev[0]->dev));
381f2962daeSSebastian Ott
382f2962daeSSebastian Ott if (gdrv) {
383f2962daeSSebastian Ott gdev->dev.driver = &gdrv->driver;
384f2962daeSSebastian Ott rc = gdrv->setup ? gdrv->setup(gdev) : 0;
385f2962daeSSebastian Ott if (rc)
386f2962daeSSebastian Ott goto error;
387f2962daeSSebastian Ott }
38816f7f956SPeter Oberparleiter rc = device_add(&gdev->dev);
3891da177e4SLinus Torvalds if (rc)
390d76123ebSCornelia Huck goto error;
3911da177e4SLinus Torvalds rc = __ccwgroup_create_symlinks(gdev);
392dad572e3SSebastian Ott if (rc) {
393dad572e3SSebastian Ott device_del(&gdev->dev);
394dad572e3SSebastian Ott goto error;
3951da177e4SLinus Torvalds }
396dad572e3SSebastian Ott mutex_unlock(&gdev->reg_mutex);
397dad572e3SSebastian Ott return 0;
3981da177e4SLinus Torvalds error:
399d76123ebSCornelia Huck mutex_unlock(&gdev->reg_mutex);
400d76123ebSCornelia Huck put_device(&gdev->dev);
4011da177e4SLinus Torvalds return rc;
4021da177e4SLinus Torvalds }
403f2962daeSSebastian Ott EXPORT_SYMBOL(ccwgroup_create_dev);
404f2962daeSSebastian Ott
ccwgroup_notifier(struct notifier_block * nb,unsigned long action,void * data)405e909074bSSebastian Ott static int ccwgroup_notifier(struct notifier_block *nb, unsigned long action,
406dad572e3SSebastian Ott void *data)
407dad572e3SSebastian Ott {
4080b60f9eaSTejun Heo struct ccwgroup_device *gdev = to_ccwgroupdev(data);
409dad572e3SSebastian Ott
41017c0b86eSJulian Wiedmann if (action == BUS_NOTIFY_UNBOUND_DRIVER) {
4119280ddb1SSebastian Ott get_device(&gdev->dev);
4120b60f9eaSTejun Heo schedule_work(&gdev->ungroup_work);
4139280ddb1SSebastian Ott }
414dad572e3SSebastian Ott
415dad572e3SSebastian Ott return NOTIFY_OK;
416dad572e3SSebastian Ott }
417e909074bSSebastian Ott
418e909074bSSebastian Ott static struct notifier_block ccwgroup_nb = {
419e909074bSSebastian Ott .notifier_call = ccwgroup_notifier
420e909074bSSebastian Ott };
421e909074bSSebastian Ott
init_ccwgroup(void)422e909074bSSebastian Ott static int __init init_ccwgroup(void)
4231da177e4SLinus Torvalds {
424e909074bSSebastian Ott int ret;
425e909074bSSebastian Ott
426e909074bSSebastian Ott ret = bus_register(&ccwgroup_bus_type);
427e909074bSSebastian Ott if (ret)
428e909074bSSebastian Ott return ret;
429e909074bSSebastian Ott
430e909074bSSebastian Ott ret = bus_register_notifier(&ccwgroup_bus_type, &ccwgroup_nb);
431e909074bSSebastian Ott if (ret)
432e909074bSSebastian Ott bus_unregister(&ccwgroup_bus_type);
433e909074bSSebastian Ott
434e909074bSSebastian Ott return ret;
4351da177e4SLinus Torvalds }
4361da177e4SLinus Torvalds
cleanup_ccwgroup(void)437e909074bSSebastian Ott static void __exit cleanup_ccwgroup(void)
4381da177e4SLinus Torvalds {
439e909074bSSebastian Ott bus_unregister_notifier(&ccwgroup_bus_type, &ccwgroup_nb);
4401da177e4SLinus Torvalds bus_unregister(&ccwgroup_bus_type);
4411da177e4SLinus Torvalds }
4421da177e4SLinus Torvalds
4431da177e4SLinus Torvalds module_init(init_ccwgroup);
4441da177e4SLinus Torvalds module_exit(cleanup_ccwgroup);
4451da177e4SLinus Torvalds
4461da177e4SLinus Torvalds /************************** driver stuff ******************************/
4471da177e4SLinus Torvalds
ccwgroup_remove(struct device * dev)448fc7a6209SUwe Kleine-König static void ccwgroup_remove(struct device *dev)
4491da177e4SLinus Torvalds {
450dad572e3SSebastian Ott struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
451dad572e3SSebastian Ott struct ccwgroup_driver *gdrv = to_ccwgroupdrv(dev->driver);
4521da177e4SLinus Torvalds
45350f15483SSebastian Ott if (gdrv->remove)
4541da177e4SLinus Torvalds gdrv->remove(gdev);
4551da177e4SLinus Torvalds }
4561da177e4SLinus Torvalds
ccwgroup_shutdown(struct device * dev)45701bc8ad1SCornelia Huck static void ccwgroup_shutdown(struct device *dev)
45801bc8ad1SCornelia Huck {
459dad572e3SSebastian Ott struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
460dad572e3SSebastian Ott struct ccwgroup_driver *gdrv = to_ccwgroupdrv(dev->driver);
46101bc8ad1SCornelia Huck
46250f15483SSebastian Ott if (!dev->driver)
46350f15483SSebastian Ott return;
46450f15483SSebastian Ott if (gdrv->shutdown)
46501bc8ad1SCornelia Huck gdrv->shutdown(gdev);
46601bc8ad1SCornelia Huck }
46701bc8ad1SCornelia Huck
468f9ccf456SRussell King static struct bus_type ccwgroup_bus_type = {
469f9ccf456SRussell King .name = "ccwgroup",
47005066312SJulian Wiedmann .dev_groups = ccwgroup_dev_groups,
471f9ccf456SRussell King .remove = ccwgroup_remove,
47201bc8ad1SCornelia Huck .shutdown = ccwgroup_shutdown,
473f9ccf456SRussell King };
474f9ccf456SRussell King
dev_is_ccwgroup(struct device * dev)475a166c368SSebastian Ott bool dev_is_ccwgroup(struct device *dev)
476a166c368SSebastian Ott {
477a166c368SSebastian Ott return dev->bus == &ccwgroup_bus_type;
478a166c368SSebastian Ott }
479a166c368SSebastian Ott EXPORT_SYMBOL(dev_is_ccwgroup);
480a166c368SSebastian Ott
481b2ffd8e9SCornelia Huck /**
482b2ffd8e9SCornelia Huck * ccwgroup_driver_register() - register a ccw group driver
483b2ffd8e9SCornelia Huck * @cdriver: driver to be registered
484b2ffd8e9SCornelia Huck *
485b2ffd8e9SCornelia Huck * This function is mainly a wrapper around driver_register().
486b2ffd8e9SCornelia Huck */
ccwgroup_driver_register(struct ccwgroup_driver * cdriver)487b2ffd8e9SCornelia Huck int ccwgroup_driver_register(struct ccwgroup_driver *cdriver)
4881da177e4SLinus Torvalds {
4891da177e4SLinus Torvalds /* register our new driver with the core */
490292888c8SHeiko Carstens cdriver->driver.bus = &ccwgroup_bus_type;
4911da177e4SLinus Torvalds
4921da177e4SLinus Torvalds return driver_register(&cdriver->driver);
4931da177e4SLinus Torvalds }
494dad572e3SSebastian Ott EXPORT_SYMBOL(ccwgroup_driver_register);
4951da177e4SLinus Torvalds
496b2ffd8e9SCornelia Huck /**
497b2ffd8e9SCornelia Huck * ccwgroup_driver_unregister() - deregister a ccw group driver
498b2ffd8e9SCornelia Huck * @cdriver: driver to be deregistered
499b2ffd8e9SCornelia Huck *
500b2ffd8e9SCornelia Huck * This function is mainly a wrapper around driver_unregister().
501b2ffd8e9SCornelia Huck */
ccwgroup_driver_unregister(struct ccwgroup_driver * cdriver)502b2ffd8e9SCornelia Huck void ccwgroup_driver_unregister(struct ccwgroup_driver *cdriver)
5031da177e4SLinus Torvalds {
5041da177e4SLinus Torvalds driver_unregister(&cdriver->driver);
5051da177e4SLinus Torvalds }
506dad572e3SSebastian Ott EXPORT_SYMBOL(ccwgroup_driver_unregister);
5071da177e4SLinus Torvalds
508346e485dSJulian Wiedmann /**
509b2ffd8e9SCornelia Huck * ccwgroup_probe_ccwdev() - probe function for slave devices
510b2ffd8e9SCornelia Huck * @cdev: ccw device to be probed
511b2ffd8e9SCornelia Huck *
512b2ffd8e9SCornelia Huck * This is a dummy probe function for ccw devices that are slave devices in
513b2ffd8e9SCornelia Huck * a ccw group device.
514b2ffd8e9SCornelia Huck * Returns:
515b2ffd8e9SCornelia Huck * always %0
516b2ffd8e9SCornelia Huck */
ccwgroup_probe_ccwdev(struct ccw_device * cdev)517b2ffd8e9SCornelia Huck int ccwgroup_probe_ccwdev(struct ccw_device *cdev)
5181da177e4SLinus Torvalds {
5191da177e4SLinus Torvalds return 0;
5201da177e4SLinus Torvalds }
521dad572e3SSebastian Ott EXPORT_SYMBOL(ccwgroup_probe_ccwdev);
5221da177e4SLinus Torvalds
523b2ffd8e9SCornelia Huck /**
524b2ffd8e9SCornelia Huck * ccwgroup_remove_ccwdev() - remove function for slave devices
525b2ffd8e9SCornelia Huck * @cdev: ccw device to be removed
526b2ffd8e9SCornelia Huck *
527b2ffd8e9SCornelia Huck * This is a remove function for ccw devices that are slave devices in a ccw
528b2ffd8e9SCornelia Huck * group device. It sets the ccw device offline and also deregisters the
529b2ffd8e9SCornelia Huck * embedding ccw group device.
530b2ffd8e9SCornelia Huck */
ccwgroup_remove_ccwdev(struct ccw_device * cdev)531b2ffd8e9SCornelia Huck void ccwgroup_remove_ccwdev(struct ccw_device *cdev)
5321da177e4SLinus Torvalds {
5331da177e4SLinus Torvalds struct ccwgroup_device *gdev;
5341da177e4SLinus Torvalds
5351da177e4SLinus Torvalds /* Ignore offlining errors, device is gone anyway. */
5361da177e4SLinus Torvalds ccw_device_set_offline(cdev);
5371da177e4SLinus Torvalds /* If one of its devices is gone, the whole group is done for. */
538c0301754SPeter Oberparleiter spin_lock_irq(cdev->ccwlock);
539c0301754SPeter Oberparleiter gdev = dev_get_drvdata(&cdev->dev);
540c0301754SPeter Oberparleiter if (!gdev) {
541c0301754SPeter Oberparleiter spin_unlock_irq(cdev->ccwlock);
542c0301754SPeter Oberparleiter return;
543c0301754SPeter Oberparleiter }
544c0301754SPeter Oberparleiter /* Get ccwgroup device reference for local processing. */
545c0301754SPeter Oberparleiter get_device(&gdev->dev);
546c0301754SPeter Oberparleiter spin_unlock_irq(cdev->ccwlock);
547c0301754SPeter Oberparleiter /* Unregister group device. */
548fa73eb47SSebastian Ott ccwgroup_ungroup(gdev);
549c0301754SPeter Oberparleiter /* Release ccwgroup device reference for local processing. */
550c0301754SPeter Oberparleiter put_device(&gdev->dev);
5511da177e4SLinus Torvalds }
5521da177e4SLinus Torvalds EXPORT_SYMBOL(ccwgroup_remove_ccwdev);
553dad572e3SSebastian Ott MODULE_LICENSE("GPL");
554