This source file includes following definitions.
- protocol_id_show
- gbphy_dev_release
- gb_gbphy_idle
- gbphy_dev_uevent
- gbphy_dev_match_id
- gbphy_dev_match
- gbphy_dev_probe
- gbphy_dev_remove
- gb_gbphy_register_driver
- gb_gbphy_deregister_driver
- gb_gbphy_create_dev
- gb_gbphy_disconnect
- gb_gbphy_probe
- gbphy_init
- gbphy_exit
1
2
3
4
5
6
7
8
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11 #include <linux/types.h>
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/slab.h>
15 #include <linux/device.h>
16 #include <linux/greybus.h>
17
18 #include "gbphy.h"
19
20 #define GB_GBPHY_AUTOSUSPEND_MS 3000
21
22 struct gbphy_host {
23 struct gb_bundle *bundle;
24 struct list_head devices;
25 };
26
27 static DEFINE_IDA(gbphy_id);
28
29 static ssize_t protocol_id_show(struct device *dev,
30 struct device_attribute *attr, char *buf)
31 {
32 struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
33
34 return sprintf(buf, "0x%02x\n", gbphy_dev->cport_desc->protocol_id);
35 }
36 static DEVICE_ATTR_RO(protocol_id);
37
38 static struct attribute *gbphy_dev_attrs[] = {
39 &dev_attr_protocol_id.attr,
40 NULL,
41 };
42
43 ATTRIBUTE_GROUPS(gbphy_dev);
44
45 static void gbphy_dev_release(struct device *dev)
46 {
47 struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
48
49 ida_simple_remove(&gbphy_id, gbphy_dev->id);
50 kfree(gbphy_dev);
51 }
52
53 #ifdef CONFIG_PM
54 static int gb_gbphy_idle(struct device *dev)
55 {
56 pm_runtime_mark_last_busy(dev);
57 pm_request_autosuspend(dev);
58 return 0;
59 }
60 #endif
61
62 static const struct dev_pm_ops gb_gbphy_pm_ops = {
63 SET_RUNTIME_PM_OPS(pm_generic_runtime_suspend,
64 pm_generic_runtime_resume,
65 gb_gbphy_idle)
66 };
67
68 static const struct device_type greybus_gbphy_dev_type = {
69 .name = "gbphy_device",
70 .release = gbphy_dev_release,
71 .pm = &gb_gbphy_pm_ops,
72 };
73
74 static int gbphy_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
75 {
76 struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
77 struct greybus_descriptor_cport *cport_desc = gbphy_dev->cport_desc;
78 struct gb_bundle *bundle = gbphy_dev->bundle;
79 struct gb_interface *intf = bundle->intf;
80 struct gb_module *module = intf->module;
81 struct gb_host_device *hd = intf->hd;
82
83 if (add_uevent_var(env, "BUS=%u", hd->bus_id))
84 return -ENOMEM;
85 if (add_uevent_var(env, "MODULE=%u", module->module_id))
86 return -ENOMEM;
87 if (add_uevent_var(env, "INTERFACE=%u", intf->interface_id))
88 return -ENOMEM;
89 if (add_uevent_var(env, "GREYBUS_ID=%08x/%08x",
90 intf->vendor_id, intf->product_id))
91 return -ENOMEM;
92 if (add_uevent_var(env, "BUNDLE=%u", gbphy_dev->bundle->id))
93 return -ENOMEM;
94 if (add_uevent_var(env, "BUNDLE_CLASS=%02x", bundle->class))
95 return -ENOMEM;
96 if (add_uevent_var(env, "GBPHY=%u", gbphy_dev->id))
97 return -ENOMEM;
98 if (add_uevent_var(env, "PROTOCOL_ID=%02x", cport_desc->protocol_id))
99 return -ENOMEM;
100
101 return 0;
102 }
103
104 static const struct gbphy_device_id *
105 gbphy_dev_match_id(struct gbphy_device *gbphy_dev,
106 struct gbphy_driver *gbphy_drv)
107 {
108 const struct gbphy_device_id *id = gbphy_drv->id_table;
109
110 if (!id)
111 return NULL;
112
113 for (; id->protocol_id; id++)
114 if (id->protocol_id == gbphy_dev->cport_desc->protocol_id)
115 return id;
116
117 return NULL;
118 }
119
120 static int gbphy_dev_match(struct device *dev, struct device_driver *drv)
121 {
122 struct gbphy_driver *gbphy_drv = to_gbphy_driver(drv);
123 struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
124 const struct gbphy_device_id *id;
125
126 id = gbphy_dev_match_id(gbphy_dev, gbphy_drv);
127 if (id)
128 return 1;
129
130 return 0;
131 }
132
133 static int gbphy_dev_probe(struct device *dev)
134 {
135 struct gbphy_driver *gbphy_drv = to_gbphy_driver(dev->driver);
136 struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
137 const struct gbphy_device_id *id;
138 int ret;
139
140 id = gbphy_dev_match_id(gbphy_dev, gbphy_drv);
141 if (!id)
142 return -ENODEV;
143
144
145 ret = gb_pm_runtime_get_sync(gbphy_dev->bundle);
146 if (ret < 0)
147 return ret;
148
149 pm_runtime_set_autosuspend_delay(dev, GB_GBPHY_AUTOSUSPEND_MS);
150 pm_runtime_use_autosuspend(dev);
151 pm_runtime_get_noresume(dev);
152 pm_runtime_set_active(dev);
153 pm_runtime_enable(dev);
154
155
156
157
158
159 ret = gbphy_drv->probe(gbphy_dev, id);
160 if (ret) {
161 pm_runtime_disable(dev);
162 pm_runtime_set_suspended(dev);
163 pm_runtime_put_noidle(dev);
164 pm_runtime_dont_use_autosuspend(dev);
165 }
166
167 gb_pm_runtime_put_autosuspend(gbphy_dev->bundle);
168
169 return ret;
170 }
171
172 static int gbphy_dev_remove(struct device *dev)
173 {
174 struct gbphy_driver *gbphy_drv = to_gbphy_driver(dev->driver);
175 struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
176
177 gbphy_drv->remove(gbphy_dev);
178
179 pm_runtime_disable(dev);
180 pm_runtime_set_suspended(dev);
181 pm_runtime_put_noidle(dev);
182 pm_runtime_dont_use_autosuspend(dev);
183
184 return 0;
185 }
186
187 static struct bus_type gbphy_bus_type = {
188 .name = "gbphy",
189 .match = gbphy_dev_match,
190 .probe = gbphy_dev_probe,
191 .remove = gbphy_dev_remove,
192 .uevent = gbphy_dev_uevent,
193 };
194
195 int gb_gbphy_register_driver(struct gbphy_driver *driver,
196 struct module *owner, const char *mod_name)
197 {
198 int retval;
199
200 if (greybus_disabled())
201 return -ENODEV;
202
203 driver->driver.bus = &gbphy_bus_type;
204 driver->driver.name = driver->name;
205 driver->driver.owner = owner;
206 driver->driver.mod_name = mod_name;
207
208 retval = driver_register(&driver->driver);
209 if (retval)
210 return retval;
211
212 pr_info("registered new driver %s\n", driver->name);
213 return 0;
214 }
215 EXPORT_SYMBOL_GPL(gb_gbphy_register_driver);
216
217 void gb_gbphy_deregister_driver(struct gbphy_driver *driver)
218 {
219 driver_unregister(&driver->driver);
220 }
221 EXPORT_SYMBOL_GPL(gb_gbphy_deregister_driver);
222
223 static struct gbphy_device *gb_gbphy_create_dev(struct gb_bundle *bundle,
224 struct greybus_descriptor_cport *cport_desc)
225 {
226 struct gbphy_device *gbphy_dev;
227 int retval;
228 int id;
229
230 id = ida_simple_get(&gbphy_id, 1, 0, GFP_KERNEL);
231 if (id < 0)
232 return ERR_PTR(id);
233
234 gbphy_dev = kzalloc(sizeof(*gbphy_dev), GFP_KERNEL);
235 if (!gbphy_dev) {
236 ida_simple_remove(&gbphy_id, id);
237 return ERR_PTR(-ENOMEM);
238 }
239
240 gbphy_dev->id = id;
241 gbphy_dev->bundle = bundle;
242 gbphy_dev->cport_desc = cport_desc;
243 gbphy_dev->dev.parent = &bundle->dev;
244 gbphy_dev->dev.bus = &gbphy_bus_type;
245 gbphy_dev->dev.type = &greybus_gbphy_dev_type;
246 gbphy_dev->dev.groups = gbphy_dev_groups;
247 gbphy_dev->dev.dma_mask = bundle->dev.dma_mask;
248 dev_set_name(&gbphy_dev->dev, "gbphy%d", id);
249
250 retval = device_register(&gbphy_dev->dev);
251 if (retval) {
252 put_device(&gbphy_dev->dev);
253 return ERR_PTR(retval);
254 }
255
256 return gbphy_dev;
257 }
258
259 static void gb_gbphy_disconnect(struct gb_bundle *bundle)
260 {
261 struct gbphy_host *gbphy_host = greybus_get_drvdata(bundle);
262 struct gbphy_device *gbphy_dev, *temp;
263 int ret;
264
265 ret = gb_pm_runtime_get_sync(bundle);
266 if (ret < 0)
267 gb_pm_runtime_get_noresume(bundle);
268
269 list_for_each_entry_safe(gbphy_dev, temp, &gbphy_host->devices, list) {
270 list_del(&gbphy_dev->list);
271 device_unregister(&gbphy_dev->dev);
272 }
273
274 kfree(gbphy_host);
275 }
276
277 static int gb_gbphy_probe(struct gb_bundle *bundle,
278 const struct greybus_bundle_id *id)
279 {
280 struct gbphy_host *gbphy_host;
281 struct gbphy_device *gbphy_dev;
282 int i;
283
284 if (bundle->num_cports == 0)
285 return -ENODEV;
286
287 gbphy_host = kzalloc(sizeof(*gbphy_host), GFP_KERNEL);
288 if (!gbphy_host)
289 return -ENOMEM;
290
291 gbphy_host->bundle = bundle;
292 INIT_LIST_HEAD(&gbphy_host->devices);
293 greybus_set_drvdata(bundle, gbphy_host);
294
295
296
297
298
299 for (i = 0; i < bundle->num_cports; ++i) {
300 gbphy_dev = gb_gbphy_create_dev(bundle, &bundle->cport_desc[i]);
301 if (IS_ERR(gbphy_dev)) {
302 gb_gbphy_disconnect(bundle);
303 return PTR_ERR(gbphy_dev);
304 }
305 list_add(&gbphy_dev->list, &gbphy_host->devices);
306 }
307
308 gb_pm_runtime_put_autosuspend(bundle);
309
310 return 0;
311 }
312
313 static const struct greybus_bundle_id gb_gbphy_id_table[] = {
314 { GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_BRIDGED_PHY) },
315 { },
316 };
317 MODULE_DEVICE_TABLE(greybus, gb_gbphy_id_table);
318
319 static struct greybus_driver gb_gbphy_driver = {
320 .name = "gbphy",
321 .probe = gb_gbphy_probe,
322 .disconnect = gb_gbphy_disconnect,
323 .id_table = gb_gbphy_id_table,
324 };
325
326 static int __init gbphy_init(void)
327 {
328 int retval;
329
330 retval = bus_register(&gbphy_bus_type);
331 if (retval) {
332 pr_err("gbphy bus register failed (%d)\n", retval);
333 return retval;
334 }
335
336 retval = greybus_register(&gb_gbphy_driver);
337 if (retval) {
338 pr_err("error registering greybus driver\n");
339 goto error_gbphy;
340 }
341
342 return 0;
343
344 error_gbphy:
345 bus_unregister(&gbphy_bus_type);
346 ida_destroy(&gbphy_id);
347 return retval;
348 }
349 module_init(gbphy_init);
350
351 static void __exit gbphy_exit(void)
352 {
353 greybus_deregister(&gb_gbphy_driver);
354 bus_unregister(&gbphy_bus_type);
355 ida_destroy(&gbphy_id);
356 }
357 module_exit(gbphy_exit);
358
359 MODULE_LICENSE("GPL v2");