greybus: descriptor type updates

Some more updates to the definition of a manifest descriptor.
    - We get rid of function descriptors.  The type of function is
      easily specified with the CPort it uses.
    - Add a new interface descriptor type.
    - Clean up the CPort descriptor structure, eliminating fields
      that serve no purpose and adding the function id field

The sysfs stuff will be updated a little later to add entries
for the Greybus interfaces associated with modules.

Rearrange the order of a few things in "greybus_manifest.h".

Signed-off-by: Alex Elder <elder@linaro.org>
Signed-off-by: Greg Kroah-Hartman <greg@kroah.com>

diff --git a/drivers/staging/greybus/core.c b/drivers/staging/greybus/core.c
index c065beb..e93ee40 100644 (file)
--- a/drivers/staging/greybus/core.c
+++ b/drivers/staging/greybus/core.c
@@ -232,19 +232,6 @@ static const struct greybus_module_id fake_gb_id = {
        GREYBUS_DEVICE(0x42, 0x42)
 };
 
-static int create_function(struct greybus_module *gmod,
-                          struct greybus_descriptor_function *function,
-                          size_t desc_size)
-{
-       if (desc_size != sizeof(*function)) {
-               dev_err(gmod->dev.parent, "invalid function header size %zu\n",
-                       desc_size);
-               return -EINVAL;
-       }
-       memcpy(&gmod->function, function, desc_size);
-       return 0;
-}
-
 static int create_module(struct greybus_module *gmod,
                            struct greybus_descriptor_module *module,
                            size_t desc_size)
@@ -385,9 +372,7 @@ void gb_add_module(struct greybus_host_device *hd, u8 module_id,
                data_size = (size_t)desc_size - sizeof(desc->header);
 
                switch (le16_to_cpu(desc->header.type)) {
-               case GREYBUS_TYPE_FUNCTION:
-                       retval = create_function(gmod, &desc->function,
-                                                data_size);
+               case GREYBUS_TYPE_DEVICE:
                        break;
 
                case GREYBUS_TYPE_MODULE:

diff --git a/drivers/staging/greybus/greybus.h b/drivers/staging/greybus/greybus.h
index 4ca11f2..c8bd8eb 100644 (file)
--- a/drivers/staging/greybus/greybus.h
+++ b/drivers/staging/greybus/greybus.h
@@ -192,7 +192,6 @@ void greybus_gbuf_finished(struct gbuf *gbuf);
 struct greybus_module {
        struct device dev;
        u16 module_number;
-       struct greybus_descriptor_function function;
        struct greybus_descriptor_module module;
        int num_cports;
        int num_strings;
@@ -210,12 +209,9 @@ struct greybus_module {
 };
 #define to_greybus_module(d) container_of(d, struct greybus_module, dev)
 
-struct gbuf *greybus_alloc_gbuf(struct greybus_module *gmod,
-                               u16 cport_id,
-                               gbuf_complete_t complete,
-                               unsigned int size,
-                               gfp_t gfp_mask,
-                               void *context);
+struct gbuf *greybus_alloc_gbuf(struct greybus_module *gmod, u16 cport_id,
+                               gbuf_complete_t complete, unsigned int size,
+                               gfp_t gfp_mask, void *context);
 void greybus_free_gbuf(struct gbuf *gbuf);
 struct gbuf *greybus_get_gbuf(struct gbuf *gbuf);
 #define greybus_put_gbuf       greybus_free_gbuf

diff --git a/drivers/staging/greybus/greybus_manifest.h b/drivers/staging/greybus/greybus_manifest.h
index 4d801d7..6118999 100644 (file)
--- a/drivers/staging/greybus/greybus_manifest.h
+++ b/drivers/staging/greybus/greybus_manifest.h
@@ -14,26 +14,15 @@
 
 #pragma pack(push, 1)
 
-struct greybus_manifest_header {
-       __le16  size;
-       __u8    version_major;
-       __u8    version_minor;
-};
-
 enum greybus_descriptor_type {
        GREYBUS_TYPE_INVALID            = 0x00,
        GREYBUS_TYPE_MODULE             = 0x01,
-       GREYBUS_TYPE_FUNCTION           = 0x02,
+       GREYBUS_TYPE_DEVICE             = 0x02,
        GREYBUS_TYPE_CLASS              = 0x03,
        GREYBUS_TYPE_STRING             = 0x04,
        GREYBUS_TYPE_CPORT              = 0x05,
 };
 
-struct greybus_descriptor_header {
-       __le16  size;
-       __u8    type;   /* enum greybus_descriptor_type */
-};
-
 enum greybus_function_type {
        GREYBUS_FUNCTION_CONTROL        = 0x00,
        GREYBUS_FUNCTION_USB            = 0x01,
@@ -51,11 +40,10 @@ enum greybus_function_type {
        GREYBUS_FUNCTION_VENDOR         = 0xff,
 };
 
-struct greybus_descriptor_function {
-       __le16  cport;
-       __u8    function_type;  /* enum greybus_function_type */
-};
-
+/*
+ * A module descriptor describes information about a module as a
+ * whole, *not* the functions within it.
+ */
 struct greybus_descriptor_module {
        __le16  vendor;
        __le16  product;
@@ -65,26 +53,61 @@ struct greybus_descriptor_module {
        __u8    product_stringid;
 };
 
+/*
+ * A UniPro device normally supports a range of 32 CPorts (0..31).
+ * It is possible to support more than this by having a UniPro
+ * switch treat one device as if it were more than one.  E.g.,
+ * allocate 3 device ids (rather than the normal--1) to physical
+ * device 5, and configure the switch to route all packets destined
+ * for "encoded" device ids 5, 6, and 7 to physical device 5.
+ * Device 5 uses the encoded device id in incoming UniPro packets to
+ * determine which bank of 32 CPorts should receive the UniPro
+ * segment.
+ *
+ * The "scale" field in this structure is used to define the number
+ * of encoded device ids should be allocated for this physical
+ * device.  Scale is normally 1, to represent 32 available CPorts.
+ * A scale value 2 represents up to 64 CPorts; scale value 3
+ * represents up to 96 CPorts, and so on.
+ */
+struct greybus_descriptor_interface {
+       __u8    id;     /* module-relative id (0..) */
+       __u8    scale;  /* indicates range of of CPorts supported */
+       /* UniPro gear, number of in/out lanes */
+};
+
+struct greybus_descriptor_cport {
+       __le16  id;
+       __u8    function_type;  /* enum greybus_function_type */
+};
+
 struct greybus_descriptor_string {
        __u8    length;
        __u8    id;
        __u8    string[0];
 };
 
-struct greybus_descriptor_cport {
-       __le16  id;
+struct greybus_descriptor_header {
+       __le16  size;
+       __u8    type;   /* enum greybus_descriptor_type */
 };
 
 struct greybus_descriptor {
        struct greybus_descriptor_header        header;
        union {
-               struct greybus_descriptor_function      function;
                struct greybus_descriptor_module        module;
                struct greybus_descriptor_string        string;
+               struct greybus_descriptor_interface     interface;
                struct greybus_descriptor_cport         cport;
        };
 };
 
+struct greybus_manifest_header {
+       __le16  size;
+       __u8    version_major;
+       __u8    version_minor;
+};
+
 struct greybus_manifest {
        struct greybus_manifest_header          header;
        struct greybus_descriptor               descriptors[0];

diff --git a/drivers/staging/greybus/sysfs.c b/drivers/staging/greybus/sysfs.c
index 1f17388..a2dce7a 100644 (file)
--- a/drivers/staging/greybus/sysfs.c
+++ b/drivers/staging/greybus/sysfs.c
@@ -20,44 +20,6 @@
 
 #include "kernel_ver.h"
 
-/* Function fields */
-#define greybus_function_attr(field)                                   \
-static ssize_t function_##field##_show(struct device *dev,             \
-                                      struct device_attribute *attr,   \
-                                      char *buf)                       \
-{                                                                      \
-       struct greybus_module *gmod = to_greybus_module(dev);           \
-       return sprintf(buf, "%d\n", gmod->function.field);              \
-}                                                                      \
-static DEVICE_ATTR_RO(function_##field)
-
-greybus_function_attr(cport);
-greybus_function_attr(function_type);
-
-static struct attribute *function_attrs[] = {
-       &dev_attr_function_cport.attr,
-       &dev_attr_function_function_type.attr,
-       NULL,
-};
-
-static umode_t function_attrs_are_visible(struct kobject *kobj,
-                                         struct attribute *a, int n)
-{
-       struct greybus_module *gmod = to_greybus_module(kobj_to_dev(kobj));
-
-       // FIXME - make this a dynamic structure to "know" if it really is here
-       // or not easier?
-       if (gmod->function.cport ||
-           gmod->function.function_type)
-               return a->mode;
-       return 0;
-}
-
-static struct attribute_group function_attr_grp = {
-       .attrs =        function_attrs,
-       .is_visible =   function_attrs_are_visible,
-};
-
 /* Module fields */
 #define greybus_module_attr(field)                                     \
 static ssize_t module_##field##_show(struct device *dev,               \
@@ -147,7 +109,6 @@ static struct attribute_group module_attr_grp = {
 
 
 const struct attribute_group *greybus_module_groups[] = {
-       &function_attr_grp,
        &module_attr_grp,
        NULL,
 };