Commit | Line | Data |
---|---|---|
0f3a8c3f DB |
1 | /* |
2 | * The Industrial I/O core, software IIO devices functions | |
3 | * | |
4 | * Copyright (c) 2016 Intel Corporation | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify it | |
7 | * under the terms of the GNU General Public License version 2 as published by | |
8 | * the Free Software Foundation. | |
9 | */ | |
10 | ||
11 | #include <linux/module.h> | |
12 | #include <linux/init.h> | |
13 | #include <linux/kmod.h> | |
14 | #include <linux/list.h> | |
15 | #include <linux/slab.h> | |
16 | ||
17 | #include <linux/iio/sw_device.h> | |
18 | #include <linux/iio/configfs.h> | |
19 | #include <linux/configfs.h> | |
20 | ||
21 | static struct config_group *iio_devices_group; | |
22 | static struct config_item_type iio_device_type_group_type; | |
23 | ||
24 | static struct config_item_type iio_devices_group_type = { | |
25 | .ct_owner = THIS_MODULE, | |
26 | }; | |
27 | ||
28 | static LIST_HEAD(iio_device_types_list); | |
29 | static DEFINE_MUTEX(iio_device_types_lock); | |
30 | ||
31 | static | |
32 | struct iio_sw_device_type *__iio_find_sw_device_type(const char *name, | |
33 | unsigned len) | |
34 | { | |
35 | struct iio_sw_device_type *d = NULL, *iter; | |
36 | ||
37 | list_for_each_entry(iter, &iio_device_types_list, list) | |
38 | if (!strcmp(iter->name, name)) { | |
39 | d = iter; | |
40 | break; | |
41 | } | |
42 | ||
43 | return d; | |
44 | } | |
45 | ||
46 | int iio_register_sw_device_type(struct iio_sw_device_type *d) | |
47 | { | |
48 | struct iio_sw_device_type *iter; | |
49 | int ret = 0; | |
50 | ||
51 | mutex_lock(&iio_device_types_lock); | |
52 | iter = __iio_find_sw_device_type(d->name, strlen(d->name)); | |
53 | if (iter) | |
54 | ret = -EBUSY; | |
55 | else | |
56 | list_add_tail(&d->list, &iio_device_types_list); | |
57 | mutex_unlock(&iio_device_types_lock); | |
58 | ||
59 | if (ret) | |
60 | return ret; | |
61 | ||
62 | d->group = configfs_register_default_group(iio_devices_group, d->name, | |
63 | &iio_device_type_group_type); | |
64 | if (IS_ERR(d->group)) | |
65 | ret = PTR_ERR(d->group); | |
66 | ||
67 | return ret; | |
68 | } | |
69 | EXPORT_SYMBOL(iio_register_sw_device_type); | |
70 | ||
71 | void iio_unregister_sw_device_type(struct iio_sw_device_type *dt) | |
72 | { | |
73 | struct iio_sw_device_type *iter; | |
74 | ||
75 | mutex_lock(&iio_device_types_lock); | |
76 | iter = __iio_find_sw_device_type(dt->name, strlen(dt->name)); | |
77 | if (iter) | |
78 | list_del(&dt->list); | |
79 | mutex_unlock(&iio_device_types_lock); | |
80 | ||
81 | configfs_unregister_default_group(dt->group); | |
82 | } | |
83 | EXPORT_SYMBOL(iio_unregister_sw_device_type); | |
84 | ||
85 | static | |
86 | struct iio_sw_device_type *iio_get_sw_device_type(const char *name) | |
87 | { | |
88 | struct iio_sw_device_type *dt; | |
89 | ||
90 | mutex_lock(&iio_device_types_lock); | |
91 | dt = __iio_find_sw_device_type(name, strlen(name)); | |
92 | if (dt && !try_module_get(dt->owner)) | |
93 | dt = NULL; | |
94 | mutex_unlock(&iio_device_types_lock); | |
95 | ||
96 | return dt; | |
97 | } | |
98 | ||
99 | struct iio_sw_device *iio_sw_device_create(const char *type, const char *name) | |
100 | { | |
101 | struct iio_sw_device *d; | |
102 | struct iio_sw_device_type *dt; | |
103 | ||
104 | dt = iio_get_sw_device_type(type); | |
105 | if (!dt) { | |
106 | pr_err("Invalid device type: %s\n", type); | |
107 | return ERR_PTR(-EINVAL); | |
108 | } | |
109 | d = dt->ops->probe(name); | |
110 | if (IS_ERR(d)) | |
111 | goto out_module_put; | |
112 | ||
113 | d->device_type = dt; | |
114 | ||
115 | return d; | |
116 | out_module_put: | |
117 | module_put(dt->owner); | |
118 | return d; | |
119 | } | |
120 | EXPORT_SYMBOL(iio_sw_device_create); | |
121 | ||
122 | void iio_sw_device_destroy(struct iio_sw_device *d) | |
123 | { | |
124 | struct iio_sw_device_type *dt = d->device_type; | |
125 | ||
126 | dt->ops->remove(d); | |
127 | module_put(dt->owner); | |
128 | } | |
129 | EXPORT_SYMBOL(iio_sw_device_destroy); | |
130 | ||
131 | static struct config_group *device_make_group(struct config_group *group, | |
132 | const char *name) | |
133 | { | |
134 | struct iio_sw_device *d; | |
135 | ||
136 | d = iio_sw_device_create(group->cg_item.ci_name, name); | |
137 | if (IS_ERR(d)) | |
138 | return ERR_CAST(d); | |
139 | ||
140 | config_item_set_name(&d->group.cg_item, "%s", name); | |
141 | ||
142 | return &d->group; | |
143 | } | |
144 | ||
145 | static void device_drop_group(struct config_group *group, | |
146 | struct config_item *item) | |
147 | { | |
148 | struct iio_sw_device *d = to_iio_sw_device(item); | |
149 | ||
150 | iio_sw_device_destroy(d); | |
151 | config_item_put(item); | |
152 | } | |
153 | ||
154 | static struct configfs_group_operations device_ops = { | |
155 | .make_group = &device_make_group, | |
156 | .drop_item = &device_drop_group, | |
157 | }; | |
158 | ||
159 | static struct config_item_type iio_device_type_group_type = { | |
160 | .ct_group_ops = &device_ops, | |
161 | .ct_owner = THIS_MODULE, | |
162 | }; | |
163 | ||
164 | static int __init iio_sw_device_init(void) | |
165 | { | |
166 | iio_devices_group = | |
167 | configfs_register_default_group(&iio_configfs_subsys.su_group, | |
168 | "devices", | |
169 | &iio_devices_group_type); | |
170 | return PTR_ERR_OR_ZERO(iio_devices_group); | |
171 | } | |
172 | module_init(iio_sw_device_init); | |
173 | ||
174 | static void __exit iio_sw_device_exit(void) | |
175 | { | |
176 | configfs_unregister_default_group(iio_devices_group); | |
177 | } | |
178 | module_exit(iio_sw_device_exit); | |
179 | ||
180 | MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>"); | |
181 | MODULE_DESCRIPTION("Industrial I/O software devices support"); | |
182 | MODULE_LICENSE("GPL v2"); |