![Greg Kroah-Hartman](/assets/img/avatar_default.png)
Now that the SPDX tag is in all greybus files, that identifies the license in a specific and legally-defined manner. So the extra GPL text wording can be removed as it is no longer needed at all. This is done on a quest to remove the 700+ different ways that files in the kernel describe the GPL license text. And there's unneeded stuff like the address (sometimes incorrect) for the FSF which is never needed. No copyright headers or other non-license-description text was removed. Cc: Vaibhav Hiremath <hvaibhav.linux@gmail.com> Reviewed-by: Alex Elder <elder@linaro.org> Acked-by: Vaibhav Agarwal <vaibhav.sr@gmail.com> Acked-by: David Lin <dtwlin@gmail.com> Acked-by: Johan Hovold <johan@kernel.org> Acked-by: Viresh Kumar <viresh.kumar@linaro.org> Acked-by: Mark Greer <mgreer@animalcreek.com> Acked-by: Rui Miguel Silva <rmfrfs@gmail.com> Acked-by: "Bryan O'Donoghue" <pure.logic@nexus-software.ie> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
360 lines
8.3 KiB
C
360 lines
8.3 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Greybus Bridged-Phy Bus driver
|
|
*
|
|
* Copyright 2014 Google Inc.
|
|
* Copyright 2014 Linaro Ltd.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/module.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/device.h>
|
|
|
|
#include "greybus.h"
|
|
#include "gbphy.h"
|
|
|
|
#define GB_GBPHY_AUTOSUSPEND_MS 3000
|
|
|
|
struct gbphy_host {
|
|
struct gb_bundle *bundle;
|
|
struct list_head devices;
|
|
};
|
|
|
|
static DEFINE_IDA(gbphy_id);
|
|
|
|
static ssize_t protocol_id_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
|
|
|
|
return sprintf(buf, "0x%02x\n", gbphy_dev->cport_desc->protocol_id);
|
|
}
|
|
static DEVICE_ATTR_RO(protocol_id);
|
|
|
|
static struct attribute *gbphy_dev_attrs[] = {
|
|
&dev_attr_protocol_id.attr,
|
|
NULL,
|
|
};
|
|
|
|
ATTRIBUTE_GROUPS(gbphy_dev);
|
|
|
|
static void gbphy_dev_release(struct device *dev)
|
|
{
|
|
struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
|
|
|
|
ida_simple_remove(&gbphy_id, gbphy_dev->id);
|
|
kfree(gbphy_dev);
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
static int gb_gbphy_idle(struct device *dev)
|
|
{
|
|
pm_runtime_mark_last_busy(dev);
|
|
pm_request_autosuspend(dev);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static const struct dev_pm_ops gb_gbphy_pm_ops = {
|
|
SET_RUNTIME_PM_OPS(pm_generic_runtime_suspend,
|
|
pm_generic_runtime_resume,
|
|
gb_gbphy_idle)
|
|
};
|
|
|
|
static const struct device_type greybus_gbphy_dev_type = {
|
|
.name = "gbphy_device",
|
|
.release = gbphy_dev_release,
|
|
.pm = &gb_gbphy_pm_ops,
|
|
};
|
|
|
|
static int gbphy_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|
{
|
|
struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
|
|
struct greybus_descriptor_cport *cport_desc = gbphy_dev->cport_desc;
|
|
struct gb_bundle *bundle = gbphy_dev->bundle;
|
|
struct gb_interface *intf = bundle->intf;
|
|
struct gb_module *module = intf->module;
|
|
struct gb_host_device *hd = intf->hd;
|
|
|
|
if (add_uevent_var(env, "BUS=%u", hd->bus_id))
|
|
return -ENOMEM;
|
|
if (add_uevent_var(env, "MODULE=%u", module->module_id))
|
|
return -ENOMEM;
|
|
if (add_uevent_var(env, "INTERFACE=%u", intf->interface_id))
|
|
return -ENOMEM;
|
|
if (add_uevent_var(env, "GREYBUS_ID=%08x/%08x",
|
|
intf->vendor_id, intf->product_id))
|
|
return -ENOMEM;
|
|
if (add_uevent_var(env, "BUNDLE=%u", gbphy_dev->bundle->id))
|
|
return -ENOMEM;
|
|
if (add_uevent_var(env, "BUNDLE_CLASS=%02x", bundle->class))
|
|
return -ENOMEM;
|
|
if (add_uevent_var(env, "GBPHY=%u", gbphy_dev->id))
|
|
return -ENOMEM;
|
|
if (add_uevent_var(env, "PROTOCOL_ID=%02x", cport_desc->protocol_id))
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct gbphy_device_id *
|
|
gbphy_dev_match_id(struct gbphy_device *gbphy_dev,
|
|
struct gbphy_driver *gbphy_drv)
|
|
{
|
|
const struct gbphy_device_id *id = gbphy_drv->id_table;
|
|
|
|
if (!id)
|
|
return NULL;
|
|
|
|
for (; id->protocol_id; id++)
|
|
if (id->protocol_id == gbphy_dev->cport_desc->protocol_id)
|
|
return id;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static int gbphy_dev_match(struct device *dev, struct device_driver *drv)
|
|
{
|
|
struct gbphy_driver *gbphy_drv = to_gbphy_driver(drv);
|
|
struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
|
|
const struct gbphy_device_id *id;
|
|
|
|
id = gbphy_dev_match_id(gbphy_dev, gbphy_drv);
|
|
if (id)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int gbphy_dev_probe(struct device *dev)
|
|
{
|
|
struct gbphy_driver *gbphy_drv = to_gbphy_driver(dev->driver);
|
|
struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
|
|
const struct gbphy_device_id *id;
|
|
int ret;
|
|
|
|
id = gbphy_dev_match_id(gbphy_dev, gbphy_drv);
|
|
if (!id)
|
|
return -ENODEV;
|
|
|
|
/* for old kernels we need get_sync to resume parent devices */
|
|
ret = gb_pm_runtime_get_sync(gbphy_dev->bundle);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
pm_runtime_set_autosuspend_delay(dev, GB_GBPHY_AUTOSUSPEND_MS);
|
|
pm_runtime_use_autosuspend(dev);
|
|
pm_runtime_get_noresume(dev);
|
|
pm_runtime_set_active(dev);
|
|
pm_runtime_enable(dev);
|
|
|
|
/*
|
|
* Drivers should call put on the gbphy dev before returning
|
|
* from probe if they support runtime pm.
|
|
*/
|
|
ret = gbphy_drv->probe(gbphy_dev, id);
|
|
if (ret) {
|
|
pm_runtime_disable(dev);
|
|
pm_runtime_set_suspended(dev);
|
|
pm_runtime_put_noidle(dev);
|
|
pm_runtime_dont_use_autosuspend(dev);
|
|
}
|
|
|
|
gb_pm_runtime_put_autosuspend(gbphy_dev->bundle);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int gbphy_dev_remove(struct device *dev)
|
|
{
|
|
struct gbphy_driver *gbphy_drv = to_gbphy_driver(dev->driver);
|
|
struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
|
|
|
|
gbphy_drv->remove(gbphy_dev);
|
|
|
|
pm_runtime_disable(dev);
|
|
pm_runtime_set_suspended(dev);
|
|
pm_runtime_put_noidle(dev);
|
|
pm_runtime_dont_use_autosuspend(dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct bus_type gbphy_bus_type = {
|
|
.name = "gbphy",
|
|
.match = gbphy_dev_match,
|
|
.probe = gbphy_dev_probe,
|
|
.remove = gbphy_dev_remove,
|
|
.uevent = gbphy_dev_uevent,
|
|
};
|
|
|
|
int gb_gbphy_register_driver(struct gbphy_driver *driver,
|
|
struct module *owner, const char *mod_name)
|
|
{
|
|
int retval;
|
|
|
|
if (greybus_disabled())
|
|
return -ENODEV;
|
|
|
|
driver->driver.bus = &gbphy_bus_type;
|
|
driver->driver.name = driver->name;
|
|
driver->driver.owner = owner;
|
|
driver->driver.mod_name = mod_name;
|
|
|
|
retval = driver_register(&driver->driver);
|
|
if (retval)
|
|
return retval;
|
|
|
|
pr_info("registered new driver %s\n", driver->name);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_gbphy_register_driver);
|
|
|
|
void gb_gbphy_deregister_driver(struct gbphy_driver *driver)
|
|
{
|
|
driver_unregister(&driver->driver);
|
|
}
|
|
EXPORT_SYMBOL_GPL(gb_gbphy_deregister_driver);
|
|
|
|
static struct gbphy_device *gb_gbphy_create_dev(struct gb_bundle *bundle,
|
|
struct greybus_descriptor_cport *cport_desc)
|
|
{
|
|
struct gbphy_device *gbphy_dev;
|
|
int retval;
|
|
int id;
|
|
|
|
id = ida_simple_get(&gbphy_id, 1, 0, GFP_KERNEL);
|
|
if (id < 0)
|
|
return ERR_PTR(id);
|
|
|
|
gbphy_dev = kzalloc(sizeof(*gbphy_dev), GFP_KERNEL);
|
|
if (!gbphy_dev) {
|
|
ida_simple_remove(&gbphy_id, id);
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
gbphy_dev->id = id;
|
|
gbphy_dev->bundle = bundle;
|
|
gbphy_dev->cport_desc = cport_desc;
|
|
gbphy_dev->dev.parent = &bundle->dev;
|
|
gbphy_dev->dev.bus = &gbphy_bus_type;
|
|
gbphy_dev->dev.type = &greybus_gbphy_dev_type;
|
|
gbphy_dev->dev.groups = gbphy_dev_groups;
|
|
gbphy_dev->dev.dma_mask = bundle->dev.dma_mask;
|
|
dev_set_name(&gbphy_dev->dev, "gbphy%d", id);
|
|
|
|
retval = device_register(&gbphy_dev->dev);
|
|
if (retval) {
|
|
put_device(&gbphy_dev->dev);
|
|
return ERR_PTR(retval);
|
|
}
|
|
|
|
return gbphy_dev;
|
|
}
|
|
|
|
static void gb_gbphy_disconnect(struct gb_bundle *bundle)
|
|
{
|
|
struct gbphy_host *gbphy_host = greybus_get_drvdata(bundle);
|
|
struct gbphy_device *gbphy_dev, *temp;
|
|
int ret;
|
|
|
|
ret = gb_pm_runtime_get_sync(bundle);
|
|
if (ret < 0)
|
|
gb_pm_runtime_get_noresume(bundle);
|
|
|
|
list_for_each_entry_safe(gbphy_dev, temp, &gbphy_host->devices, list) {
|
|
list_del(&gbphy_dev->list);
|
|
device_unregister(&gbphy_dev->dev);
|
|
}
|
|
|
|
kfree(gbphy_host);
|
|
}
|
|
|
|
static int gb_gbphy_probe(struct gb_bundle *bundle,
|
|
const struct greybus_bundle_id *id)
|
|
{
|
|
struct gbphy_host *gbphy_host;
|
|
struct gbphy_device *gbphy_dev;
|
|
int i;
|
|
|
|
if (bundle->num_cports == 0)
|
|
return -ENODEV;
|
|
|
|
gbphy_host = kzalloc(sizeof(*gbphy_host), GFP_KERNEL);
|
|
if (!gbphy_host)
|
|
return -ENOMEM;
|
|
|
|
gbphy_host->bundle = bundle;
|
|
INIT_LIST_HEAD(&gbphy_host->devices);
|
|
greybus_set_drvdata(bundle, gbphy_host);
|
|
|
|
/*
|
|
* Create a bunch of children devices, one per cport, and bind the
|
|
* bridged phy drivers to them.
|
|
*/
|
|
for (i = 0; i < bundle->num_cports; ++i) {
|
|
gbphy_dev = gb_gbphy_create_dev(bundle, &bundle->cport_desc[i]);
|
|
if (IS_ERR(gbphy_dev)) {
|
|
gb_gbphy_disconnect(bundle);
|
|
return PTR_ERR(gbphy_dev);
|
|
}
|
|
list_add(&gbphy_dev->list, &gbphy_host->devices);
|
|
}
|
|
|
|
gb_pm_runtime_put_autosuspend(bundle);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct greybus_bundle_id gb_gbphy_id_table[] = {
|
|
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_BRIDGED_PHY) },
|
|
{ },
|
|
};
|
|
MODULE_DEVICE_TABLE(greybus, gb_gbphy_id_table);
|
|
|
|
static struct greybus_driver gb_gbphy_driver = {
|
|
.name = "gbphy",
|
|
.probe = gb_gbphy_probe,
|
|
.disconnect = gb_gbphy_disconnect,
|
|
.id_table = gb_gbphy_id_table,
|
|
};
|
|
|
|
static int __init gbphy_init(void)
|
|
{
|
|
int retval;
|
|
|
|
retval = bus_register(&gbphy_bus_type);
|
|
if (retval) {
|
|
pr_err("gbphy bus register failed (%d)\n", retval);
|
|
return retval;
|
|
}
|
|
|
|
retval = greybus_register(&gb_gbphy_driver);
|
|
if (retval) {
|
|
pr_err("error registering greybus driver\n");
|
|
goto error_gbphy;
|
|
}
|
|
|
|
return 0;
|
|
|
|
error_gbphy:
|
|
bus_unregister(&gbphy_bus_type);
|
|
ida_destroy(&gbphy_id);
|
|
return retval;
|
|
}
|
|
module_init(gbphy_init);
|
|
|
|
static void __exit gbphy_exit(void)
|
|
{
|
|
greybus_deregister(&gb_gbphy_driver);
|
|
bus_unregister(&gbphy_bus_type);
|
|
ida_destroy(&gbphy_id);
|
|
}
|
|
module_exit(gbphy_exit);
|
|
|
|
MODULE_LICENSE("GPL v2");
|