mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-10-06 16:49:22 +00:00
Code Issues Releases Wiki Activity

greybus: kill the endo

Browse source 
Remove the now unused endo and module code.

Note that the never-implemented serial and version attributes of the
endo can be implemented as svc attributes if needed.

Signed-off-by: Johan Hovold <johan@hovoldconsulting.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Johan Hovold 2015-11-25 15:59:21 +01:00 committed by Greg Kroah-Hartman
parent dc3da5db28
commit 0f37860de9
10 changed files with 0 additions and 840 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
drivers/staging/greybus/Makefile
View file

@ -2,8 +2,6 @@ greybus-y := core.o \
debugfs.o \
hd.o \
manifest.o \
endo.o \
module.o \
interface.o \
bundle.o \
connection.o \

20
drivers/staging/greybus/core.c
View file

@ -78,23 +78,12 @@ static int greybus_module_match(struct device *dev, struct device_driver *drv)
static int greybus_uevent(struct device *dev, struct kobj_uevent_env *env)
{
struct gb_host_device *hd = NULL;
struct gb_module *module = NULL;
struct gb_interface *intf = NULL;
struct gb_bundle *bundle = NULL;
struct gb_svc *svc = NULL;
if (is_gb_endo(dev)) {
/*
* Not much to do for an endo, just fall through, as the
* "default" attributes are good enough for us.
*/
return 0;
}
if (is_gb_host_device(dev)) {
hd = to_gb_host_device(dev);
} else if (is_gb_module(dev)) {
module = to_gb_module(dev);
} else if (is_gb_interface(dev)) {
intf = to_gb_interface(dev);
} else if (is_gb_bundle(dev)) {
@ -214,12 +203,6 @@ static int __init gb_init(void)
goto error_operation;
}
retval = gb_endo_init();
if (retval) {
pr_err("gb_endo_init failed (%d)\n", retval);
goto error_endo;
}
retval = gb_control_protocol_init();
if (retval) {
pr_err("gb_control_protocol_init failed\n");
@ -245,8 +228,6 @@ static int __init gb_init(void)
error_svc:
gb_control_protocol_exit();
error_control:
gb_endo_exit();
error_endo:
gb_operation_exit();
error_operation:
gb_hd_exit();
@ -264,7 +245,6 @@ static void __exit gb_exit(void)
gb_firmware_protocol_exit();
gb_svc_protocol_exit();
gb_control_protocol_exit();
gb_endo_exit();
gb_operation_exit();
gb_hd_exit();
bus_unregister(&greybus_bus_type);

520
drivers/staging/greybus/endo.c
View file

@ -1,520 +0,0 @@
/*
* Greybus endo code
*
* Copyright 2014-2015 Google Inc.
* Copyright 2014-2015 Linaro Ltd.
*
* Released under the GPLv2 only.
*/
#include "greybus.h"
/* Endo ID (16 bits long) Masks */
#define ENDO_ID_MASK 0xFFFF
#define ENDO_LARGE_MASK 0x1000
#define ENDO_MEDIUM_MASK 0x0400
#define ENDO_MINI_MASK 0x0100
#define ENDO_FRONT_MASK(id) ((id) >> 13)
#define ENDO_BACK_SIDE_RIBS_MASK(ribs) ((1 << (ribs)) - 1)
/*
* endo_is_medium() should be used only if endo isn't large. And endo_is_mini()
* should be used only if endo isn't large or medium.
*/
#define endo_is_large(id) ((id) & ENDO_LARGE_MASK)
#define endo_is_medium(id) ((id) & ENDO_MEDIUM_MASK)
#define endo_is_mini(id) ((id) & ENDO_MINI_MASK)
#define endo_back_left_ribs(id, ribs) (((id) >> (ribs)) & ENDO_BACK_SIDE_RIBS_MASK(ribs))
#define endo_back_right_ribs(id, ribs) ((id) & ENDO_BACK_SIDE_RIBS_MASK(ribs))
/*
* An Endo has interface block positions on the front and back.
* Each has numeric ID, starting with 1 (interface 0 represents
* the SVC within the Endo itself). The maximum interface ID is the
* also the number of non-SVC interfaces possible on the endo.
*
* Total number of interfaces:
* - Front: 4
* - Back left: max_ribs + 1
* - Back right: max_ribs + 1
*/
#define max_endo_interface_id(endo_layout) \
(4 + ((endo_layout)->max_ribs + 1) * 2)
static struct ida greybus_endo_id_map;
/* endo sysfs attributes */
static ssize_t serial_number_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct gb_endo *endo = to_gb_endo(dev);
return sprintf(buf, "%s\n", &endo->svc_info.serial_number[0]);
}
static DEVICE_ATTR_RO(serial_number);
static ssize_t version_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct gb_endo *endo = to_gb_endo(dev);
return sprintf(buf, "%s\n", &endo->svc_info.version[0]);
}
static DEVICE_ATTR_RO(version);
static struct attribute *svc_attrs[] = {
&dev_attr_serial_number.attr,
&dev_attr_version.attr,
NULL,
};
static const struct attribute_group svc_group = {
.attrs = svc_attrs,
.name = "svc",
};
static const struct attribute_group *endo_groups[] = {
&svc_group,
NULL,
};
static void gb_endo_release(struct device *dev)
{
struct gb_endo *endo = to_gb_endo(dev);
ida_simple_remove(&greybus_endo_id_map, endo->dev_id);
kfree(endo);
}
struct device_type greybus_endo_type = {
.name = "greybus_endo",
.release = gb_endo_release,
};
/* Validate Endo ID */
/*
* The maximum module height is 2 units. This means any adjacent pair of bits
* in the left or right mask must have at least one bit set.
*/
static inline bool modules_oversized(unsigned int count, unsigned int mask)
{
int i;
for (i = 0; i < count - 1; i++)
if (!(mask & (0x3 << i)))
return true;
return false;
}
/* Reverse a number of least significant bits in a value */
static u8 reverse_bits(unsigned int value, unsigned int bits)
{
u8 result = 0;
u8 result_mask = 1 << (bits - 1);
u8 value_mask = 1;
while (value && result_mask) {
if (value & value_mask) {
result |= result_mask;
value ^= value_mask;
}
value_mask <<= 1;
result_mask >>= 1;
}
return result;
}
/*
* An Endo can have at most one instance of a single rib spanning its whole
* width. That is, the left and right bit masks representing the rib positions
* must have at most one bit set in both masks.
*/
static bool single_cross_rib(u8 left_ribs, u8 right_ribs)
{
u8 span_ribs = left_ribs & right_ribs;
/* Power of 2 ? */
if (span_ribs & (span_ribs - 1))
return false;
return true;
}
/*
* Each Endo size has its own set of front module configurations. For most, the
* resulting rib mask is the same regardless of the Endo size. The mini Endo
* has a few differences though.
*
* Endo front has 4 interface blocks and 3 rib positions. A maximum of 2 ribs
* are allowed to be present for any endo type.
*
* This routine validates front mask and sets 'front_ribs', its 3 least
* significant bits represent front ribs mask, other are 0. The front values
* should be within range (1..6).
*
* front_ribs bitmask:
* - Bit 0: 1st rib location from top, i.e. between interface 1 and 2.
* - Bit 1: 2nd rib location from top, i.e. between interface 2 and 3.
* - Bit 2: 3rd rib location from top, i.e. between interface 3 and 4.
*/
static bool validate_front_ribs(struct gb_host_device *hd,
struct endo_layout *layout, bool mini,
u16 endo_id)
{
u8 front_mask = ENDO_FRONT_MASK(endo_id);
/* Verify front endo mask is in valid range, i.e. 1-6 */
switch (front_mask) {
case 1:
layout->front_ribs = 0x0;
break;
case 2:
layout->front_ribs = 0x1;
break;
case 3:
layout->front_ribs = 0x4;
break;
case 4:
layout->front_ribs = mini ? 0x2 : 0x3;
break;
case 5:
layout->front_ribs = mini ? 0x2 : 0x6;
break;
case 6:
layout->front_ribs = 0x5;
break;
default:
dev_err(&hd->dev,
"%s: Invalid endo front mask 0x%02x, id 0x%04x\n",
__func__, front_mask, endo_id);
return false;
}
return true;
}
/*
* The rear of an endo has a single vertical "spine", and the modules placed on
* the left and right of that spine are separated by ribs. Only one "cross"
* (i.e. rib that spans the entire width) is allowed of the back of the endo;
* all other ribs reach from the spine to the left or right edge.
*
* The width of the module positions on the left and right of the spine are
* determined by the width of the endo (either 1 or 2 "units"). The height of
* the modules is determined by the placement of the ribs (a module can be
* either 1 or 2 units high).
*
* The lower 13 bits of the 16-bit endo id are used to encode back ribs
* information. The large form factor endo uses all of these bits; the medium
* and mini form factors leave some bits unused (such bits shall be ignored, and
* are 0 for the purposes of this endo id definition).
*
* Each defined bit represents a rib position on one or the other side
* of the spine on the back of an endo. If that bit is set (1), it
* means a rib is present in the corresponding location; otherwise
* there is no rib there.
*
* Rotating an endo 180 degrees does not produce a new rib configuration. A
* single endo id represents a specific configuration of ribs without regard to
* its rotational orientation. We define one canonical id to represent a
* particular endo configuration.
*/
static bool validate_back_ribs(struct gb_host_device *hd,
struct endo_layout *layout, u16 endo_id)
{
u8 max_ribs = layout->max_ribs;
u8 left_ribs;
u8 right_ribs;
/* Extract the left and right rib masks */
left_ribs = endo_back_left_ribs(endo_id, max_ribs);
right_ribs = endo_back_right_ribs(endo_id, max_ribs);
if (!single_cross_rib(left_ribs, right_ribs)) {
dev_err(&hd->dev,
"%s: More than one spanning rib (left 0x%02x right 0x%02x), id 0x%04x\n",
__func__, left_ribs, right_ribs, endo_id);
return false;
}
if (modules_oversized(max_ribs, left_ribs)) {
dev_err(&hd->dev,
"%s: Oversized module (left) 0x%02x, id 0x%04x\n",
__func__, left_ribs, endo_id);
return false;
}
if (modules_oversized(max_ribs, right_ribs)) {
dev_err(&hd->dev,
"%s: Oversized module (Right) 0x%02x, id 0x%04x\n",
__func__, right_ribs, endo_id);
return false;
}
/*
* The Endo numbering scheme represents the left and right rib
* configuration in a way that's convenient for looking for multiple
* spanning ribs. But it doesn't match the normal Endo interface
* numbering scheme (increasing counter-clockwise around the back).
* Reverse the right bit positions so they do match.
*/
right_ribs = reverse_bits(right_ribs, max_ribs);
/*
* A mini or large Endo rotated 180 degrees is still the same Endo. In
* most cases that allows two distinct values to represent the same
* Endo; we choose one of them to be the canonical one (and the other is
* invalid). The canonical one is identified by higher value of left
* ribs mask.
*
* This doesn't apply to medium Endos, because the left and right sides
* are of different widths.
*/
if (max_ribs != ENDO_BACK_RIBS_MEDIUM && left_ribs < right_ribs) {
dev_err(&hd->dev, "%s: Non-canonical endo id 0x%04x\n", __func__,
endo_id);
return false;
}
layout->left_ribs = left_ribs;
layout->right_ribs = right_ribs;
return true;
}
/*
* Validate the endo-id passed from SVC. Error out if its not a valid Endo,
* else return structure representing ribs positions on front and back of Endo.
*/
static int gb_endo_validate_id(struct gb_host_device *hd,
struct endo_layout *layout, u16 endo_id)
{
/* Validate Endo Size */
if (endo_is_large(endo_id)) {
/* Large Endo type */
layout->max_ribs = ENDO_BACK_RIBS_LARGE;
} else if (endo_is_medium(endo_id)) {
/* Medium Endo type */
layout->max_ribs = ENDO_BACK_RIBS_MEDIUM;
} else if (endo_is_mini(endo_id)) {
/* Mini Endo type */
layout->max_ribs = ENDO_BACK_RIBS_MINI;
} else {
dev_err(&hd->dev, "%s: Invalid endo type, id 0x%04x\n",
__func__, endo_id);
return -EINVAL;
}
if (!validate_back_ribs(hd, layout, endo_id))
return -EINVAL;
if (!validate_front_ribs(hd, layout,
layout->max_ribs == ENDO_BACK_RIBS_MINI,
endo_id))
return -EINVAL;
return 0;
}
/*
* Look up which module contains the given interface.
*
* A module's ID is the same as its lowest-numbered interface ID. So the module
* ID for a 1x1 module is always the same as its interface ID.
*
* For Endo Back:
* The module ID for an interface on a 1x2 or 2x2 module (which use two
* interface blocks) can be either the interface ID, or one less than the
* interface ID if there is no rib "above" the interface.
*
* For Endo Front:
* There are three rib locations in front and all of them might be unused, i.e.
* a single module is used for all 4 interfaces. We need to check all ribs in
* that case to find module ID.
*/
u8 endo_get_module_id(struct gb_endo *endo, u8 interface_id)
{
struct endo_layout *layout = &endo->layout;
unsigned int height = layout->max_ribs + 1;
unsigned int iid = interface_id - 1;
unsigned int mask, rib_mask;
if (!interface_id)
return 0;
if (iid < height) { /* back left */
mask = layout->left_ribs;
} else if (iid < 2 * height) { /* back right */
mask = layout->right_ribs;
iid -= height;
} else { /* front */
mask = layout->front_ribs;
iid -= 2 * height;
}
/*
* Find the next rib *above* this interface to determine the lowest
* interface ID in the module.
*/
rib_mask = 1 << iid;
while ((rib_mask >>= 1) != 0 && !(mask & rib_mask))
--interface_id;
return interface_id;
}
/*
* Creates all possible modules for the Endo.
*
* We try to create modules for all possible interface IDs. If a module is
* already created, we skip creating it again with the help of prev_module_id.
*/
static int create_modules(struct gb_endo *endo)
{
struct gb_module *module;
int prev_module_id = 0;
int interface_id;
int module_id;
int max_id;
max_id = max_endo_interface_id(&endo->layout);
/* Find module corresponding to each interface */
for (interface_id = 1; interface_id <= max_id; interface_id++) {
module_id = endo_get_module_id(endo, interface_id);
if (WARN_ON(!module_id))
continue;
/* Skip already created modules */
if (module_id == prev_module_id)
continue;
prev_module_id = module_id;
/* New module, create it */
module = gb_module_create(&endo->dev, module_id);
if (!module)
return -EINVAL;
}
return 0;
}
static int gb_endo_register(struct gb_host_device *hd,
struct gb_endo *endo)
{
int dev_id;
int retval;
dev_id = ida_simple_get(&greybus_endo_id_map, 0, 0, GFP_KERNEL);
if (dev_id < 0)
return dev_id;
endo->dev_id = dev_id;
endo->dev.parent = &hd->dev;
endo->dev.bus = &greybus_bus_type;
endo->dev.type = &greybus_endo_type;
endo->dev.groups = endo_groups;
endo->dev.dma_mask = hd->dev.dma_mask;
device_initialize(&endo->dev);
dev_set_name(&endo->dev, "endo%hu", endo->dev_id);
// FIXME
// Get the version and serial number from the SVC, right now we are
// using "fake" numbers.
strcpy(&endo->svc_info.serial_number[0], "042");
strcpy(&endo->svc_info.version[0], "0.0");
retval = device_add(&endo->dev);
if (retval) {
dev_err(&hd->dev, "failed to add endo device of id 0x%04x\n",
endo->id);
put_device(&endo->dev);
}
return retval;
}
struct gb_endo *gb_endo_create(struct gb_host_device *hd, u16 endo_id,
u8 ap_intf_id)
{
struct gb_endo *endo;
int retval;
endo = kzalloc(sizeof(*endo), GFP_KERNEL);
if (!endo)
return ERR_PTR(-ENOMEM);
/* First check if the value supplied is a valid endo id */
if (gb_endo_validate_id(hd, &endo->layout, endo_id)) {
retval = -EINVAL;
goto free_endo;
}
if (ap_intf_id > max_endo_interface_id(&endo->layout)) {
retval = -EINVAL;
goto free_endo;
}
/* Register Endo device */
retval = gb_endo_register(hd, endo);
if (retval)
goto free_endo;
/* Create modules/interfaces */
retval = create_modules(endo);
if (retval) {
gb_endo_remove(endo);
return NULL;
}
return endo;
free_endo:
kfree(endo);
return ERR_PTR(retval);
}
void gb_endo_remove(struct gb_endo *endo)
{
if (!endo)
return;
/* remove all modules for this endo */
gb_module_remove_all(endo);
device_unregister(&endo->dev);
}
int greybus_endo_setup(struct gb_host_device *hd, u16 endo_id,
u8 ap_intf_id)
{
struct gb_endo *endo;
endo = gb_endo_create(hd, endo_id, ap_intf_id);
if (IS_ERR(endo))
return PTR_ERR(endo);
hd->endo = endo;
return 0;
}
EXPORT_SYMBOL_GPL(greybus_endo_setup);
int __init gb_endo_init(void)
{
ida_init(&greybus_endo_id_map);
return 0;
}
void gb_endo_exit(void)
{
ida_destroy(&greybus_endo_id_map);
}

63
drivers/staging/greybus/endo.h
View file

@ -1,63 +0,0 @@
/*
* Greybus endo code
*
* Copyright 2015 Google Inc.
* Copyright 2015 Linaro Ltd.
*
* Released under the GPLv2 only.
*/
#ifndef __ENDO_H
#define __ENDO_H
/* Greybus "public" definitions" */
struct gb_svc_info {
u8 serial_number[10];
u8 version[10];
};
/* Max ribs per Endo size */
#define ENDO_BACK_RIBS_MINI 0x4
#define ENDO_BACK_RIBS_MEDIUM 0x5
#define ENDO_BACK_RIBS_LARGE 0x6
/**
* struct endo_layout - represents front/back ribs of the endo.
*
* @front_ribs: Mask of present ribs in front.
* @left_ribs: Mask of present ribs in back (left).
* @right_ribs: Mask of present ribs in back (right).
* @max_ribs: Max ribs on endo back, possible values defined above.
*/
struct endo_layout {
u8 front_ribs;
u8 left_ribs;
u8 right_ribs;
u8 max_ribs;
};
struct gb_endo {
struct device dev;
struct endo_layout layout;
struct gb_svc_info svc_info;
u16 dev_id;
u16 id;
u8 ap_intf_id;
};
#define to_gb_endo(d) container_of(d, struct gb_endo, dev)
/* Greybus "private" definitions */
struct gb_host_device;
int gb_endo_init(void);
void gb_endo_exit(void);
struct gb_endo *gb_endo_create(struct gb_host_device *hd,
u16 endo_id, u8 ap_intf_id);
void gb_endo_remove(struct gb_endo *endo);
int greybus_endo_setup(struct gb_host_device *hd, u16 endo_id,
u8 ap_intf_id);
u8 endo_get_module_id(struct gb_endo *endo, u8 interface_id);
#endif /* __ENDO_H */

14
drivers/staging/greybus/greybus.h
View file

@ -26,10 +26,8 @@
#include "greybus_protocols.h"
#include "manifest.h"
#include "hd.h"
#include "endo.h"
#include "svc.h"
#include "firmware.h"
#include "module.h"
#include "control.h"
#include "interface.h"
#include "bundle.h"
@ -105,8 +103,6 @@ struct dentry *gb_debugfs_get(void);
extern struct bus_type greybus_bus_type;
extern struct device_type greybus_hd_type;
extern struct device_type greybus_endo_type;
extern struct device_type greybus_module_type;
extern struct device_type greybus_interface_type;
extern struct device_type greybus_bundle_type;
extern struct device_type greybus_svc_type;
@ -116,16 +112,6 @@ static inline int is_gb_host_device(const struct device *dev)
return dev->type == &greybus_hd_type;
}
static inline int is_gb_endo(const struct device *dev)
{
return dev->type == &greybus_endo_type;
}
static inline int is_gb_module(const struct device *dev)
{
return dev->type == &greybus_module_type;
}
static inline int is_gb_interface(const struct device *dev)
{
return dev->type == &greybus_interface_type;

6
drivers/staging/greybus/hd.c
View file

@ -130,13 +130,7 @@ EXPORT_SYMBOL_GPL(gb_hd_add);
void gb_hd_del(struct gb_host_device *hd)
{
/*
* Tear down all interfaces, modules, and the endo that is associated
* with this host controller before freeing the memory associated with
* the host controller.
*/
gb_interfaces_remove(hd);
gb_endo_remove(hd->endo);
gb_connection_destroy(hd->svc_connection);

1
drivers/staging/greybus/hd.h
View file

@ -40,7 +40,6 @@ struct gb_host_device {
/* Host device buffer constraints */
size_t buffer_size_max;
struct gb_endo *endo;
struct gb_svc *svc;
struct gb_connection *svc_connection;

178
drivers/staging/greybus/module.c
View file

@ -1,178 +0,0 @@
/*
* Greybus module code
*
* Copyright 2014 Google Inc.
* Copyright 2014 Linaro Ltd.
*
* Released under the GPLv2 only.
*/
#include "greybus.h"
/* module sysfs attributes */
static ssize_t epm_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
// FIXME
// Implement something here when we have a working control protocol
return sprintf(buf, "1\n");
}
static ssize_t epm_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t size)
{
// FIXME
// Implement something here when we have a working control protocol
return 0;
}
static DEVICE_ATTR_RW(epm);
static ssize_t power_control_show(struct device *dev,
struct device_attribute *addr, char *buf)
{
// FIXME
// Implement something here when we have a working control protocol
return sprintf(buf, "1\n");
}
static ssize_t power_control_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
// FIXME
// Implement something here when we have a working control protocol
return 0;
}
static DEVICE_ATTR_RW(power_control);
static ssize_t present_show(struct device *dev,
struct device_attribute *addr, char *buf)
{
// FIXME
// Implement something here when we have a working control protocol
return sprintf(buf, "1\n");
}
static ssize_t present_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t size)
{
// FIXME
// Implement something here when we have a working control protocol
return 0;
}
static DEVICE_ATTR_RW(present);
static struct attribute *module_attrs[] = {
&dev_attr_epm.attr,
&dev_attr_power_control.attr,
&dev_attr_present.attr,
NULL,
};
ATTRIBUTE_GROUPS(module);
static void gb_module_release(struct device *dev)
{
struct gb_module *module = to_gb_module(dev);
kfree(module);
}
struct device_type greybus_module_type = {
.name = "greybus_module",
.release = gb_module_release,
};
struct module_find {
struct gb_endo *endo;
u8 module_id;
};
static int module_find(struct device *dev, void *data)
{
struct gb_module *module;
struct module_find *find = data;
if (!is_gb_module(dev))
return 0;
module = to_gb_module(dev);
if ((module->module_id == find->module_id) &&
(module->dev.parent == &find->endo->dev))
return 1;
return 0;
}
/*
* Search the list of modules in the system. If one is found, return it, with
* the reference count incremented.
*/
struct gb_module *gb_module_find(struct gb_host_device *hd, u8 module_id)
{
struct device *dev;
struct gb_module *module = NULL;
struct module_find find;
if (!module_id)
return NULL;
find.module_id = module_id;
find.endo = hd->endo;
dev = bus_find_device(&greybus_bus_type, NULL,
&find, module_find);
if (dev)
module = to_gb_module(dev);
return module;
}
struct gb_module *gb_module_create(struct device *parent, u8 module_id)
{
struct gb_module *module;
int retval;
module = kzalloc(sizeof(*module), GFP_KERNEL);
if (!module)
return NULL;
module->module_id = module_id;
module->dev.parent = parent;
module->dev.bus = &greybus_bus_type;
module->dev.type = &greybus_module_type;
module->dev.groups = module_groups;
module->dev.dma_mask = parent->dma_mask;
device_initialize(&module->dev);
dev_set_name(&module->dev, "%s:%hhu", dev_name(parent), module_id);
retval = device_add(&module->dev);
if (retval) {
pr_err("failed to add module device for id 0x%02hhx\n",
module_id);
put_device(&module->dev);
return NULL;
}
return module;
}
static int module_remove(struct device *dev, void *data)
{
struct gb_module *module;
struct gb_endo *endo = data;
if (!is_gb_module(dev))
return 0;
module = to_gb_module(dev);
if (module->dev.parent == &endo->dev)
device_unregister(&module->dev);
return 0;
}
void gb_module_remove_all(struct gb_endo *endo)
{
bus_for_each_dev(&greybus_bus_type, NULL, endo, module_remove);
}

26
drivers/staging/greybus/module.h
View file

@ -1,26 +0,0 @@
/*
* Greybus module code
*
* Copyright 2014 Google Inc.
*
* Released under the GPLv2 only.
*/
#ifndef __MODULE_H
#define __MODULE_H
/* Greybus "public" definitions" */
struct gb_module {
struct device dev;
u8 module_id; /* Physical location within the Endo */
};
#define to_gb_module(d) container_of(d, struct gb_module, dev)
struct gb_host_device;
/* Greybus "private" definitions */
struct gb_module *gb_module_find(struct gb_host_device *hd, u8 module_id);
struct gb_module *gb_module_create(struct device *parent, u8 module_id);
void gb_module_remove_all(struct gb_endo *endo);
#endif /* __MODULE_H */

10
drivers/staging/greybus/svc.c
View file

@ -310,14 +310,9 @@ static int gb_svc_hello(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_svc *svc = connection->private;
struct gb_host_device *hd = connection->hd;
struct gb_svc_hello_request *hello_request;
int ret;
/*
* SVC sends information about the endo and interface-id on the hello
* request, use that to create an endo.
*/
if (op->request->payload_size < sizeof(*hello_request)) {
dev_warn(&svc->dev, "short hello request (%zu < %zu)\n",
op->request->payload_size,
@ -335,11 +330,6 @@ static int gb_svc_hello(struct gb_operation *op)
return ret;
}
/* Setup Endo */
ret = greybus_endo_setup(hd, svc->endo_id, svc->ap_intf_id);
if (ret)
return ret;
return 0;
}