2 * Greybus Bridged-Phy Bus driver
4 * Copyright 2014 Google Inc.
5 * Copyright 2014 Linaro Ltd.
7 * Released under the GPLv2 only.
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 #include <linux/types.h>
13 #include <linux/module.h>
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/device.h>
21 #define GB_GBPHY_AUTOSUSPEND_MS 3000
24 struct gb_bundle *bundle;
25 struct list_head devices;
28 static DEFINE_IDA(gbphy_id);
30 static ssize_t protocol_id_show(struct device *dev,
31 struct device_attribute *attr, char *buf)
33 struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
35 return sprintf(buf, "0x%02x\n", gbphy_dev->cport_desc->protocol_id);
37 static DEVICE_ATTR_RO(protocol_id);
39 static struct attribute *gbphy_dev_attrs[] = {
40 &dev_attr_protocol_id.attr,
44 ATTRIBUTE_GROUPS(gbphy_dev);
46 static void gbphy_dev_release(struct device *dev)
48 struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
50 ida_simple_remove(&gbphy_id, gbphy_dev->id);
55 static int gb_gbphy_idle(struct device *dev)
57 pm_runtime_mark_last_busy(dev);
58 pm_request_autosuspend(dev);
63 static const struct dev_pm_ops gb_gbphy_pm_ops = {
64 SET_RUNTIME_PM_OPS(pm_generic_runtime_suspend,
65 pm_generic_runtime_resume,
69 static const struct device_type greybus_gbphy_dev_type = {
70 .name = "gbphy_device",
71 .release = gbphy_dev_release,
72 .pm = &gb_gbphy_pm_ops,
75 static int gbphy_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
77 struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
78 struct greybus_descriptor_cport *cport_desc = gbphy_dev->cport_desc;
79 struct gb_bundle *bundle = gbphy_dev->bundle;
80 struct gb_interface *intf = bundle->intf;
81 struct gb_module *module = intf->module;
82 struct gb_host_device *hd = intf->hd;
84 if (add_uevent_var(env, "BUS=%u", hd->bus_id))
86 if (add_uevent_var(env, "MODULE=%u", module->module_id))
88 if (add_uevent_var(env, "INTERFACE=%u", intf->interface_id))
90 if (add_uevent_var(env, "GREYBUS_ID=%08x/%08x",
91 intf->vendor_id, intf->product_id))
93 if (add_uevent_var(env, "BUNDLE=%u", gbphy_dev->bundle->id))
95 if (add_uevent_var(env, "BUNDLE_CLASS=%02x", bundle->class))
97 if (add_uevent_var(env, "GBPHY=%u", gbphy_dev->id))
99 if (add_uevent_var(env, "PROTOCOL_ID=%02x", cport_desc->protocol_id))
105 static const struct gbphy_device_id *
106 gbphy_dev_match_id(struct gbphy_device *gbphy_dev,
107 struct gbphy_driver *gbphy_drv)
109 const struct gbphy_device_id *id = gbphy_drv->id_table;
114 for (; id->protocol_id; id++)
115 if (id->protocol_id == gbphy_dev->cport_desc->protocol_id)
121 static int gbphy_dev_match(struct device *dev, struct device_driver *drv)
123 struct gbphy_driver *gbphy_drv = to_gbphy_driver(drv);
124 struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
125 const struct gbphy_device_id *id;
127 id = gbphy_dev_match_id(gbphy_dev, gbphy_drv);
134 static int gbphy_dev_probe(struct device *dev)
136 struct gbphy_driver *gbphy_drv = to_gbphy_driver(dev->driver);
137 struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
138 const struct gbphy_device_id *id;
141 id = gbphy_dev_match_id(gbphy_dev, gbphy_drv);
145 /* for old kernels we need get_sync to resume parent devices */
146 ret = gb_pm_runtime_get_sync(gbphy_dev->bundle);
150 pm_runtime_set_autosuspend_delay(dev, GB_GBPHY_AUTOSUSPEND_MS);
151 pm_runtime_use_autosuspend(dev);
152 pm_runtime_get_noresume(dev);
153 pm_runtime_set_active(dev);
154 pm_runtime_enable(dev);
157 * Drivers should call put on the gbphy dev before returning
158 * from probe if they support runtime pm.
160 ret = gbphy_drv->probe(gbphy_dev, id);
162 pm_runtime_disable(dev);
163 pm_runtime_set_suspended(dev);
164 pm_runtime_put_noidle(dev);
165 pm_runtime_dont_use_autosuspend(dev);
168 gb_pm_runtime_put_autosuspend(gbphy_dev->bundle);
173 static int gbphy_dev_remove(struct device *dev)
175 struct gbphy_driver *gbphy_drv = to_gbphy_driver(dev->driver);
176 struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
178 gbphy_drv->remove(gbphy_dev);
180 pm_runtime_disable(dev);
181 pm_runtime_set_suspended(dev);
182 pm_runtime_put_noidle(dev);
183 pm_runtime_dont_use_autosuspend(dev);
188 static struct bus_type gbphy_bus_type = {
190 .match = gbphy_dev_match,
191 .probe = gbphy_dev_probe,
192 .remove = gbphy_dev_remove,
193 .uevent = gbphy_dev_uevent,
196 int gb_gbphy_register_driver(struct gbphy_driver *driver,
197 struct module *owner, const char *mod_name)
201 if (greybus_disabled())
204 driver->driver.bus = &gbphy_bus_type;
205 driver->driver.name = driver->name;
206 driver->driver.owner = owner;
207 driver->driver.mod_name = mod_name;
209 retval = driver_register(&driver->driver);
213 pr_info("registered new driver %s\n", driver->name);
216 EXPORT_SYMBOL_GPL(gb_gbphy_register_driver);
218 void gb_gbphy_deregister_driver(struct gbphy_driver *driver)
220 driver_unregister(&driver->driver);
222 EXPORT_SYMBOL_GPL(gb_gbphy_deregister_driver);
224 static struct gbphy_device *gb_gbphy_create_dev(struct gb_bundle *bundle,
225 struct greybus_descriptor_cport *cport_desc)
227 struct gbphy_device *gbphy_dev;
231 id = ida_simple_get(&gbphy_id, 1, 0, GFP_KERNEL);
235 gbphy_dev = kzalloc(sizeof(*gbphy_dev), GFP_KERNEL);
237 ida_simple_remove(&gbphy_id, id);
238 return ERR_PTR(-ENOMEM);
242 gbphy_dev->bundle = bundle;
243 gbphy_dev->cport_desc = cport_desc;
244 gbphy_dev->dev.parent = &bundle->dev;
245 gbphy_dev->dev.bus = &gbphy_bus_type;
246 gbphy_dev->dev.type = &greybus_gbphy_dev_type;
247 gbphy_dev->dev.groups = gbphy_dev_groups;
248 gbphy_dev->dev.dma_mask = bundle->dev.dma_mask;
249 dev_set_name(&gbphy_dev->dev, "gbphy%d", id);
251 retval = device_register(&gbphy_dev->dev);
253 put_device(&gbphy_dev->dev);
254 return ERR_PTR(retval);
260 static void gb_gbphy_disconnect(struct gb_bundle *bundle)
262 struct gbphy_host *gbphy_host = greybus_get_drvdata(bundle);
263 struct gbphy_device *gbphy_dev, *temp;
266 ret = gb_pm_runtime_get_sync(bundle);
268 gb_pm_runtime_get_noresume(bundle);
270 list_for_each_entry_safe(gbphy_dev, temp, &gbphy_host->devices, list) {
271 list_del(&gbphy_dev->list);
272 device_unregister(&gbphy_dev->dev);
278 static int gb_gbphy_probe(struct gb_bundle *bundle,
279 const struct greybus_bundle_id *id)
281 struct gbphy_host *gbphy_host;
282 struct gbphy_device *gbphy_dev;
285 if (bundle->num_cports == 0)
288 gbphy_host = kzalloc(sizeof(*gbphy_host), GFP_KERNEL);
292 gbphy_host->bundle = bundle;
293 INIT_LIST_HEAD(&gbphy_host->devices);
294 greybus_set_drvdata(bundle, gbphy_host);
297 * Create a bunch of children devices, one per cport, and bind the
298 * bridged phy drivers to them.
300 for (i = 0; i < bundle->num_cports; ++i) {
301 gbphy_dev = gb_gbphy_create_dev(bundle, &bundle->cport_desc[i]);
302 if (IS_ERR(gbphy_dev)) {
303 gb_gbphy_disconnect(bundle);
304 return PTR_ERR(gbphy_dev);
306 list_add(&gbphy_dev->list, &gbphy_host->devices);
309 gb_pm_runtime_put_autosuspend(bundle);
314 static const struct greybus_bundle_id gb_gbphy_id_table[] = {
315 { GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_BRIDGED_PHY) },
318 MODULE_DEVICE_TABLE(greybus, gb_gbphy_id_table);
320 static struct greybus_driver gb_gbphy_driver = {
322 .probe = gb_gbphy_probe,
323 .disconnect = gb_gbphy_disconnect,
324 .id_table = gb_gbphy_id_table,
327 static int __init gbphy_init(void)
331 retval = bus_register(&gbphy_bus_type);
333 pr_err("gbphy bus register failed (%d)\n", retval);
337 retval = greybus_register(&gb_gbphy_driver);
339 pr_err("error registering greybus driver\n");
346 bus_unregister(&gbphy_bus_type);
347 ida_destroy(&gbphy_id);
350 module_init(gbphy_init);
352 static void __exit gbphy_exit(void)
354 greybus_deregister(&gb_gbphy_driver);
355 bus_unregister(&gbphy_bus_type);
356 ida_destroy(&gbphy_id);
358 module_exit(gbphy_exit);
360 MODULE_LICENSE("GPL v2");