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(struct_size(module, interfaces, num_interfaces), 97 GFP_KERNEL); 98 if (!module) 99 return NULL; 100 101 module->hd = hd; 102 module->module_id = module_id; 103 module->num_interfaces = num_interfaces; 104 105 module->dev.parent = &hd->dev; 106 module->dev.bus = &greybus_bus_type; 107 module->dev.type = &greybus_module_type; 108 module->dev.groups = module_groups; 109 module->dev.dma_mask = hd->dev.dma_mask; 110 device_initialize(&module->dev); 111 dev_set_name(&module->dev, "%d-%u", hd->bus_id, module_id); 112 113 trace_gb_module_create(module); 114 115 for (i = 0; i < num_interfaces; ++i) { 116 intf = gb_interface_create(module, module_id + i); 117 if (!intf) { 118 dev_err(&module->dev, "failed to create interface %u\n", 119 module_id + i); 120 goto err_put_interfaces; 121 } 122 module->interfaces[i] = intf; 123 } 124 125 return module; 126 127 err_put_interfaces: 128 for (--i; i >= 0; --i) 129 gb_interface_put(module->interfaces[i]); 130 131 put_device(&module->dev); 132 133 return NULL; 134 } 135 136 /* 137 * Register and enable an interface after first attempting to activate it. 138 */ 139 static void gb_module_register_interface(struct gb_interface *intf) 140 { 141 struct gb_module *module = intf->module; 142 u8 intf_id = intf->interface_id; 143 int ret; 144 145 mutex_lock(&intf->mutex); 146 147 ret = gb_interface_activate(intf); 148 if (ret) { 149 if (intf->type != GB_INTERFACE_TYPE_DUMMY) { 150 dev_err(&module->dev, 151 "failed to activate interface %u: %d\n", 152 intf_id, ret); 153 } 154 155 gb_interface_add(intf); 156 goto err_unlock; 157 } 158 159 ret = gb_interface_add(intf); 160 if (ret) 161 goto err_interface_deactivate; 162 163 ret = gb_interface_enable(intf); 164 if (ret) { 165 dev_err(&module->dev, "failed to enable interface %u: %d\n", 166 intf_id, ret); 167 goto err_interface_deactivate; 168 } 169 170 mutex_unlock(&intf->mutex); 171 172 return; 173 174 err_interface_deactivate: 175 gb_interface_deactivate(intf); 176 err_unlock: 177 mutex_unlock(&intf->mutex); 178 } 179 180 static void gb_module_deregister_interface(struct gb_interface *intf) 181 { 182 /* Mark as disconnected to prevent I/O during disable. */ 183 if (intf->module->disconnected) 184 intf->disconnected = true; 185 186 mutex_lock(&intf->mutex); 187 intf->removed = true; 188 gb_interface_disable(intf); 189 gb_interface_deactivate(intf); 190 mutex_unlock(&intf->mutex); 191 192 gb_interface_del(intf); 193 } 194 195 /* Register a module and its interfaces. */ 196 int gb_module_add(struct gb_module *module) 197 { 198 size_t i; 199 int ret; 200 201 ret = device_add(&module->dev); 202 if (ret) { 203 dev_err(&module->dev, "failed to register module: %d\n", ret); 204 return ret; 205 } 206 207 trace_gb_module_add(module); 208 209 for (i = 0; i < module->num_interfaces; ++i) 210 gb_module_register_interface(module->interfaces[i]); 211 212 return 0; 213 } 214 215 /* Deregister a module and its interfaces. */ 216 void gb_module_del(struct gb_module *module) 217 { 218 size_t i; 219 220 for (i = 0; i < module->num_interfaces; ++i) 221 gb_module_deregister_interface(module->interfaces[i]); 222 223 trace_gb_module_del(module); 224 225 device_del(&module->dev); 226 } 227 228 void gb_module_put(struct gb_module *module) 229 { 230 size_t i; 231 232 for (i = 0; i < module->num_interfaces; ++i) 233 gb_interface_put(module->interfaces[i]); 234 235 put_device(&module->dev); 236 } 237