2014-10-02 04:54:12 +02:00
|
|
|
/*
|
|
|
|
* Greybus interfaces
|
|
|
|
*
|
|
|
|
* Copyright 2014 Google Inc.
|
2014-12-12 19:08:42 +01:00
|
|
|
* Copyright 2014 Linaro Ltd.
|
2014-10-02 04:54:12 +02:00
|
|
|
*
|
|
|
|
* Released under the GPLv2 only.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "greybus.h"
|
|
|
|
|
2014-10-24 11:34:46 +02:00
|
|
|
static ssize_t device_id_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct gb_interface *interface = to_gb_interface(dev);
|
|
|
|
|
|
|
|
return sprintf(buf, "%d", interface->device_id);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR_RO(device_id);
|
|
|
|
|
|
|
|
static struct attribute *interface_attrs[] = {
|
|
|
|
&dev_attr_device_id.attr,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
ATTRIBUTE_GROUPS(interface);
|
|
|
|
|
|
|
|
static void gb_interface_release(struct device *dev)
|
|
|
|
{
|
|
|
|
struct gb_interface *interface = to_gb_interface(dev);
|
|
|
|
|
|
|
|
kfree(interface);
|
|
|
|
}
|
|
|
|
|
2014-11-15 21:12:16 +01:00
|
|
|
struct device_type greybus_interface_type = {
|
2014-10-24 11:34:46 +02:00
|
|
|
.name = "greybus_interface",
|
|
|
|
.release = gb_interface_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2014-10-02 04:54:12 +02:00
|
|
|
/* XXX This could be per-host device or per-module */
|
|
|
|
static DEFINE_SPINLOCK(gb_interfaces_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A Greybus interface represents a UniPro device present on a
|
|
|
|
* module. For Project Ara, each active Interface Block on a module
|
|
|
|
* implements a UniPro device, and therefore a Greybus interface. A
|
|
|
|
* Greybus module has at least one interface, but can have two (or
|
|
|
|
* even more).
|
|
|
|
*
|
|
|
|
* Create a gb_interface structure to represent a discovered
|
|
|
|
* interface. Returns a pointer to the new interface or a null
|
|
|
|
* pointer if a failure occurs due to memory exhaustion.
|
|
|
|
*/
|
|
|
|
struct gb_interface *
|
2014-12-11 23:10:56 +01:00
|
|
|
gb_interface_create(struct gb_interface_block *gb_ib, u8 interface_id)
|
2014-10-02 04:54:12 +02:00
|
|
|
{
|
|
|
|
struct gb_interface *interface;
|
2014-10-24 11:34:46 +02:00
|
|
|
int retval;
|
2014-10-02 04:54:12 +02:00
|
|
|
|
|
|
|
interface = kzalloc(sizeof(*interface), GFP_KERNEL);
|
|
|
|
if (!interface)
|
|
|
|
return NULL;
|
|
|
|
|
2014-12-11 23:10:56 +01:00
|
|
|
interface->gb_ib = gb_ib;
|
2014-10-02 19:30:02 +02:00
|
|
|
interface->id = interface_id;
|
2014-10-24 11:34:46 +02:00
|
|
|
interface->device_id = 0xff; /* Invalid device id to start with */
|
2014-10-03 21:14:22 +02:00
|
|
|
INIT_LIST_HEAD(&interface->connections);
|
2014-10-02 04:54:12 +02:00
|
|
|
|
2014-10-24 11:34:46 +02:00
|
|
|
/* Build up the interface device structures and register it with the
|
|
|
|
* driver core */
|
2014-12-11 23:10:56 +01:00
|
|
|
interface->dev.parent = &gb_ib->dev;
|
2014-10-24 11:34:46 +02:00
|
|
|
interface->dev.bus = &greybus_bus_type;
|
|
|
|
interface->dev.type = &greybus_interface_type;
|
|
|
|
interface->dev.groups = interface_groups;
|
|
|
|
device_initialize(&interface->dev);
|
2014-12-11 23:10:56 +01:00
|
|
|
dev_set_name(&interface->dev, "%d:%d", gb_ib->module_id, interface_id);
|
2014-10-24 11:34:46 +02:00
|
|
|
|
|
|
|
retval = device_add(&interface->dev);
|
|
|
|
if (retval) {
|
2014-11-05 23:03:12 +01:00
|
|
|
pr_err("failed to add interface device for id 0x%02hhx\n",
|
|
|
|
interface_id);
|
2014-11-13 13:44:38 +01:00
|
|
|
put_device(&interface->dev);
|
2014-10-24 11:34:46 +02:00
|
|
|
kfree(interface);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-10-02 04:54:12 +02:00
|
|
|
spin_lock_irq(&gb_interfaces_lock);
|
2014-12-11 23:10:56 +01:00
|
|
|
list_add_tail(&interface->links, &gb_ib->interfaces);
|
2014-10-02 04:54:12 +02:00
|
|
|
spin_unlock_irq(&gb_interfaces_lock);
|
|
|
|
|
|
|
|
return interface;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Tear down a previously set up interface.
|
|
|
|
*/
|
2014-12-11 23:10:56 +01:00
|
|
|
void gb_interface_destroy(struct gb_interface_block *gb_ib)
|
2014-10-02 04:54:12 +02:00
|
|
|
{
|
2014-10-24 11:34:46 +02:00
|
|
|
struct gb_interface *interface;
|
|
|
|
struct gb_interface *temp;
|
|
|
|
|
2014-12-11 23:10:56 +01:00
|
|
|
if (WARN_ON(!gb_ib))
|
2014-10-02 04:54:12 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
spin_lock_irq(&gb_interfaces_lock);
|
2014-12-11 23:10:56 +01:00
|
|
|
list_for_each_entry_safe(interface, temp, &gb_ib->interfaces, links) {
|
2014-10-24 11:34:46 +02:00
|
|
|
list_del(&interface->links);
|
|
|
|
gb_interface_connections_exit(interface);
|
|
|
|
device_del(&interface->dev);
|
|
|
|
}
|
2014-10-02 04:54:12 +02:00
|
|
|
spin_unlock_irq(&gb_interfaces_lock);
|
|
|
|
}
|
2014-10-16 13:35:35 +02:00
|
|
|
|
2014-12-11 23:10:56 +01:00
|
|
|
int gb_interface_init(struct gb_interface_block *gb_ib, u8 interface_id, u8 device_id)
|
2014-11-14 12:55:08 +01:00
|
|
|
{
|
|
|
|
struct gb_interface *interface;
|
|
|
|
int ret;
|
|
|
|
|
2014-12-11 23:10:56 +01:00
|
|
|
interface = gb_interface_find(gb_ib, interface_id);
|
2014-11-14 12:55:08 +01:00
|
|
|
if (!interface) {
|
2014-12-11 23:10:56 +01:00
|
|
|
dev_err(gb_ib->hd->parent, "module %hhu not found\n",
|
2014-11-14 12:55:08 +01:00
|
|
|
interface_id);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
interface->device_id = device_id;
|
|
|
|
|
2014-12-11 23:10:56 +01:00
|
|
|
ret = svc_set_route_send(interface, gb_ib->hd);
|
2014-11-14 12:55:08 +01:00
|
|
|
if (ret) {
|
2014-12-11 23:10:56 +01:00
|
|
|
dev_err(gb_ib->hd->parent, "failed to set route (%d)\n", ret);
|
2014-11-14 12:55:08 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = gb_interface_connections_init(interface);
|
|
|
|
if (ret) {
|
2014-12-11 23:10:56 +01:00
|
|
|
dev_err(gb_ib->hd->parent, "module interface init error %d\n",
|
2014-11-14 12:55:08 +01:00
|
|
|
ret);
|
|
|
|
/* XXX clear route */
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-11 23:10:56 +01:00
|
|
|
struct gb_interface *gb_interface_find(struct gb_interface_block *gb_ib,
|
2014-10-22 04:43:30 +02:00
|
|
|
u8 interface_id)
|
|
|
|
{
|
|
|
|
struct gb_interface *interface;
|
|
|
|
|
2014-10-24 11:34:46 +02:00
|
|
|
spin_lock_irq(&gb_interfaces_lock);
|
2014-12-11 23:10:56 +01:00
|
|
|
list_for_each_entry(interface, &gb_ib->interfaces, links)
|
2014-10-24 11:34:46 +02:00
|
|
|
if (interface->id == interface_id) {
|
|
|
|
spin_unlock_irq(&gb_interfaces_lock);
|
2014-10-22 04:43:30 +02:00
|
|
|
return interface;
|
2014-10-24 11:34:46 +02:00
|
|
|
}
|
|
|
|
spin_unlock_irq(&gb_interfaces_lock);
|
2014-10-22 04:43:30 +02:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-10-16 13:35:35 +02:00
|
|
|
int gb_interface_connections_init(struct gb_interface *interface)
|
|
|
|
{
|
|
|
|
struct gb_connection *connection;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
list_for_each_entry(connection, &interface->connections,
|
|
|
|
interface_links) {
|
|
|
|
ret = gb_connection_init(connection);
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2014-10-21 06:01:04 +02:00
|
|
|
|
|
|
|
void gb_interface_connections_exit(struct gb_interface *interface)
|
|
|
|
{
|
|
|
|
struct gb_connection *connection;
|
|
|
|
struct gb_connection *next;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(connection, next, &interface->connections,
|
|
|
|
interface_links) {
|
|
|
|
gb_connection_exit(connection);
|
|
|
|
gb_connection_destroy(connection);
|
|
|
|
}
|
|
|
|
}
|