projects/linux·blob master · refs

235 lines · 4.9 KiB

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
12static 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}
47static DEVICE_ATTR_WO(eject);
48
49static 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}
56static DEVICE_ATTR_RO(module_id);
57
58static 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}
65static DEVICE_ATTR_RO(num_interfaces);
66
67static struct attribute *module_attrs[] = {
68 &dev_attr_eject.attr,
69 &dev_attr_module_id.attr,
70 &dev_attr_num_interfaces.attr,
71 NULL,
72};
73ATTRIBUTE_GROUPS(module);
74
75static 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
84const struct device_type greybus_module_type = {
85 .name = "greybus_module",
86 .release = gb_module_release,
87};
88
89struct 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);
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
126err_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 */
138static 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
173err_interface_deactivate:
174 gb_interface_deactivate(intf);
175err_unlock:
176 mutex_unlock(&intf->mutex);
177}
178
179static 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. */
195int 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. */
215void 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
227void 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}