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 const struct config_item_type iio_device_type_group_type; 23 24 static const 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 const 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"); 183