1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Greybus Module code 4 * 5 * Copyright 2016 Google Inc. 6 * Copyright 2016 Linaro Ltd. 7 */ 8 9 #include <linux/greybus.h> 10 #include "greybus_trace.h" 11 12 static ssize_t eject_store(struct device *dev, 13 struct device_attribute *attr, 14 const char *buf, size_t len) 15 { 16 struct gb_module *module = to_gb_module(dev); 17 struct gb_interface *intf; 18 size_t i; 19 long val; 20 int ret; 21 22 ret = kstrtol(buf, 0, &val); 23 if (ret) 24 return ret; 25 26 if (!val) 27 return len; 28 29 for (i = 0; i < module->num_interfaces; ++i) { 30 intf = module->interfaces[i]; 31 32 mutex_lock(&intf->mutex); 33 /* Set flag to prevent concurrent activation. */ 34 intf->ejected = true; 35 gb_interface_disable(intf); 36 gb_interface_deactivate(intf); 37 mutex_unlock(&intf->mutex); 38 } 39 40 /* Tell the SVC to eject the primary interface. */ 41 ret = gb_svc_intf_eject(module->hd->svc, module->module_id); 42 if (ret) 43 return ret; 44 45 return len; 46 } 47 static DEVICE_ATTR_WO(eject); 48 49 static ssize_t module_id_show(struct device *dev, 50 struct device_attribute *attr, char *buf) 51 { 52 struct gb_module *module = to_gb_module(dev); 53 54 return sprintf(buf, "%u\n", module->module_id); 55 } 56 static DEVICE_ATTR_RO(module_id); 57 58 static ssize_t num_interfaces_show(struct device *dev, 59 struct device_attribute *attr, char *buf) 60 { 61 struct gb_module *module = to_gb_module(dev); 62 63 return sprintf(buf, "%zu\n", module->num_interfaces); 64 } 65 static DEVICE_ATTR_RO(num_interfaces); 66 67 static struct attribute *module_attrs[] = { 68 &dev_attr_eject.attr, 69 &dev_attr_module_id.attr, 70 &dev_attr_num_interfaces.attr, 71 NULL, 72 }; 73 ATTRIBUTE_GROUPS(module); 74 75 static void gb_module_release(struct device *dev) 76 { 77 struct gb_module *module = to_gb_module(dev); 78 79 trace_gb_module_release(module); 80 81 kfree(module); 82 } 83 84 const struct device_type greybus_module_type = { 85 .name = "greybus_module", 86 .release = gb_module_release, 87 }; 88 89 struct gb_module *gb_module_create(struct gb_host_device *hd, u8 module_id, 90 size_t num_interfaces) 91 { 92 struct gb_interface *intf; 93 struct gb_module *module; 94 int i; 95 96 module = kzalloc_flex(*module, interfaces, num_interfaces, GFP_KERNEL); 97 if (!module) 98 return NULL; 99 100 module->hd = hd; 101 module->module_id = module_id; 102 module->num_interfaces = num_interfaces; 103 104 module->dev.parent = &hd->dev; 105 module->dev.bus = &greybus_bus_type; 106 module->dev.type = &greybus_module_type; 107 module->dev.groups = module_groups; 108 module->dev.dma_mask = hd->dev.dma_mask; 109 device_initialize(&module->dev); 110 dev_set_name(&module->dev, "%d-%u", hd->bus_id, module_id); 111 112 trace_gb_module_create(module); 113 114 for (i = 0; i < num_interfaces; ++i) { 115 intf = gb_interface_create(module, module_id + i); 116 if (!intf) { 117 dev_err(&module->dev, "failed to create interface %u\n", 118 module_id + i); 119 goto err_put_interfaces; 120 } 121 module->interfaces[i] = intf; 122 } 123 124 return module; 125 126 err_put_interfaces: 127 for (--i; i >= 0; --i) 128 gb_interface_put(module->interfaces[i]); 129 130 put_device(&module->dev); 131 132 return NULL; 133 } 134 135 /* 136 * Register and enable an interface after first attempting to activate it. 137 */ 138 static void gb_module_register_interface(struct gb_interface *intf) 139 { 140 struct gb_module *module = intf->module; 141 u8 intf_id = intf->interface_id; 142 int ret; 143 144 mutex_lock(&intf->mutex); 145 146 ret = gb_interface_activate(intf); 147 if (ret) { 148 if (intf->type != GB_INTERFACE_TYPE_DUMMY) { 149 dev_err(&module->dev, 150 "failed to activate interface %u: %d\n", 151 intf_id, ret); 152 } 153 154 gb_interface_add(intf); 155 goto err_unlock; 156 } 157 158 ret = gb_interface_add(intf); 159 if (ret) 160 goto err_interface_deactivate; 161 162 ret = gb_interface_enable(intf); 163 if (ret) { 164 dev_err(&module->dev, "failed to enable interface %u: %d\n", 165 intf_id, ret); 166 goto err_interface_deactivate; 167 } 168 169 mutex_unlock(&intf->mutex); 170 171 return; 172 173 err_interface_deactivate: 174 gb_interface_deactivate(intf); 175 err_unlock: 176 mutex_unlock(&intf->mutex); 177 } 178 179 static void gb_module_deregister_interface(struct gb_interface *intf) 180 { 181 /* Mark as disconnected to prevent I/O during disable. */ 182 if (intf->module->disconnected) 183 intf->disconnected = true; 184 185 mutex_lock(&intf->mutex); 186 intf->removed = true; 187 gb_interface_disable(intf); 188 gb_interface_deactivate(intf); 189 mutex_unlock(&intf->mutex); 190 191 gb_interface_del(intf); 192 } 193 194 /* Register a module and its interfaces. */ 195 int gb_module_add(struct gb_module *module) 196 { 197 size_t i; 198 int ret; 199 200 ret = device_add(&module->dev); 201 if (ret) { 202 dev_err(&module->dev, "failed to register module: %d\n", ret); 203 return ret; 204 } 205 206 trace_gb_module_add(module); 207 208 for (i = 0; i < module->num_interfaces; ++i) 209 gb_module_register_interface(module->interfaces[i]); 210 211 return 0; 212 } 213 214 /* Deregister a module and its interfaces. */ 215 void gb_module_del(struct gb_module *module) 216 { 217 size_t i; 218 219 for (i = 0; i < module->num_interfaces; ++i) 220 gb_module_deregister_interface(module->interfaces[i]); 221 222 trace_gb_module_del(module); 223 224 device_del(&module->dev); 225 } 226 227 void gb_module_put(struct gb_module *module) 228 { 229 size_t i; 230 231 for (i = 0; i < module->num_interfaces; ++i) 232 gb_interface_put(module->interfaces[i]); 233 234 put_device(&module->dev); 235 } 236