#include "greybus.h"
static const struct usb_device_id id_table[] = {
- { USB_DEVICE(0x0000, 0x0000) }, // FIXME
+ { USB_DEVICE(0xffff, 0x0001) }, // FIXME
{ },
};
MODULE_DEVICE_TABLE(usb, id_table);
struct es1_ap_dev {
struct usb_device *usb_dev;
struct usb_interface *usb_intf;
+ struct greybus_host_device *hd;
- __u8 ap_in_endpoint;
- __u8 ap_out_endpoint;
+ __u8 ap_comm_endpoint; /* endpoint to talk to the AP */
+ __u8 ap_in_endpoint; /* bulk in for CPort data */
+ __u8 ap_out_endpoint; /* bulk out for CPort data */
u8 *ap_buffer;
};
+static inline struct es1_ap_dev *hd_to_es1(struct greybus_host_device *hd)
+{
+ return (struct es1_ap_dev *)(hd->hd_priv);
+}
+
/*
- * Hack, we "know" we will only have one of these at any one time, so only
- * create one static structure pointer.
+ * Allocate the actual buffer for this gbuf and device and cport
+ *
+ * We are responsible for setting the following fields in a struct gbuf:
+ * void *hcpriv;
+ * void *transfer_buffer;
+ * u32 transfer_buffer_length;
*/
-static struct es1_ap_dev *es1_ap_dev;
+static int alloc_gbuf(struct gbuf *gbuf, unsigned int size, gfp_t gfp_mask)
+{
+ struct es1_ap_dev *es1 = hd_to_es1(gbuf->gdev->hd);
+ u8 *buffer;
+
+ /* For ES2 we need to figure out what cport is going to what endpoint,
+ * but for ES1, it's so dirt simple, we don't have a choice...
+ *
+ * Also, do a "slow" allocation now, if we need speed, use a cache
+ */
+ buffer = kmalloc(size + 1, gfp_mask);
+ if (!buffer)
+ return -ENOMEM;
+
+ /*
+ * we will encode the cport number in the first byte of the buffer, so
+ * set the second byte to be the "transfer buffer"
+ */
+ buffer[0] = gbuf->cport->number;
+ gbuf->transfer_buffer = &buffer[1];
+ gbuf->transfer_buffer_length = size;
+
+ gbuf->hdpriv = es1; /* really, we could do something else here... */
+
+ return 0;
+}
+
+/* Free the memory we allocated with a gbuf */
+static void free_gbuf(struct gbuf *gbuf)
+{
+ u8 *transfer_buffer;
+ u8 *buffer;
+
+ transfer_buffer = gbuf->transfer_buffer;
+ buffer = &transfer_buffer[-1]; /* yes, we mean -1 */
+ kfree(buffer);
+}
+
+
+static struct greybus_host_driver es1_driver = {
+ .hd_priv_size = sizeof(struct es1_ap_dev),
+ .alloc_gbuf = alloc_gbuf,
+ .free_gbuf = free_gbuf,
+};
+
void ap_in_callback(struct urb *urb)
{
static int ap_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
+ struct es1_ap_dev *es1;
+ struct greybus_host_device *hd;
+ struct usb_device *udev;
struct usb_host_interface *iface_desc;
struct usb_endpoint_descriptor *endpoint;
- size_t buffer_size;
int i;
- if (es1_ap_dev) {
- dev_err(&interface->dev, "Already have a es1_ap_dev???\n");
- return -ENODEV;
- }
- es1_ap_dev = kzalloc(sizeof(*es1_ap_dev), GFP_KERNEL);
- if (!es1_ap_dev)
+ udev = usb_get_dev(interface_to_usbdev(interface));
+
+ hd = greybus_create_hd(&es1_driver, &udev->dev);
+ if (!hd)
return -ENOMEM;
+ es1 = hd_to_es1(hd);
+ es1->hd = hd;
+
+ /* Control endpoint is the pipe to talk to this AP, so save it off */
+ endpoint = &udev->ep0.desc;
+ es1->ap_comm_endpoint = endpoint->bEndpointAddress;
+
// FIXME
// figure out endpoint for talking to the AP.
iface_desc = interface->cur_altsetting;
endpoint = &iface_desc->endpoint[i].desc;
if (usb_endpoint_is_bulk_in(endpoint)) {
- buffer_size = usb_endpoint_maxp(endpoint);
- // FIXME - Save buffer_size?
- es1_ap_dev->ap_in_endpoint = endpoint->bEndpointAddress;
+ es1->ap_in_endpoint = endpoint->bEndpointAddress;
}
if (usb_endpoint_is_bulk_out(endpoint)) {
- // FIXME - anything else about this we need?
- es1_ap_dev->ap_out_endpoint = endpoint->bEndpointAddress;
+ es1->ap_out_endpoint = endpoint->bEndpointAddress;
}
// FIXME - properly exit once found the AP endpoint
// FIXME - set up cport endpoints
// FIXME - allocate buffer
// FIXME = start up talking, then create the gb "devices" based on what the AP tells us.
- es1_ap_dev->usb_intf = interface;
- es1_ap_dev->usb_dev = usb_get_dev(interface_to_usbdev(interface));
- usb_set_intfdata(interface, es1_ap_dev);
+ es1->usb_intf = interface;
+ es1->usb_dev = udev;
+ usb_set_intfdata(interface, es1);
return 0;
}
static void ap_disconnect(struct usb_interface *interface)
{
- es1_ap_dev = usb_get_intfdata(interface);
+ struct es1_ap_dev *es1;
+
+ es1 = usb_get_intfdata(interface);
/* Tear down everything! */
- usb_put_dev(es1_ap_dev->usb_dev);
- kfree(es1_ap_dev->ap_buffer);
- kfree(es1_ap_dev);
- es1_ap_dev = NULL;
+ usb_put_dev(es1->usb_dev);
+ kfree(es1->ap_buffer);
+ // FIXME
+ //greybus_destroy_hd(es1->hd);
}
static struct usb_driver es1_ap_driver = {
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
+#include <linux/kref.h>
#include <linux/device.h>
+#include <linux/slab.h>
#include "greybus.h"
+/**
+ * greybus_alloc_gbuf - allocate a greybus buffer
+ *
+ * @gdev: greybus device that wants to allocate this
+ * @cport: cport to send the data to
+ * @complete: callback when the gbuf is finished with
+ * @size: size of the buffer
+ * @gfp_mask: allocation mask
+ * @context: context added to the gbuf by the driver
+ *
+ * TODO: someday it will be nice to handle DMA, but for now, due to the
+ * architecture we are stuck with, the greybus core has to allocate the buffer
+ * that the driver can then fill up with the data to be sent out. Curse
+ * hardware designers for this issue...
+ */
struct gbuf *greybus_alloc_gbuf(struct greybus_device *gdev,
struct gdev_cport *cport,
- gfp_t mem_flags)
+ gbuf_complete_t complete,
+ unsigned int size,
+ gfp_t gfp_mask,
+ void *context)
{
- return NULL;
+ struct gbuf *gbuf;
+ int retval;
+
+ /*
+ * change this to a slab allocation if it's too slow, but for now, let's
+ * be dumb and simple.
+ */
+ gbuf = kzalloc(sizeof(*gbuf), gfp_mask);
+ if (!gbuf)
+ return NULL;
+
+ kref_init(&gbuf->kref);
+ gbuf->gdev = gdev;
+ gbuf->cport = cport;
+ gbuf->complete = complete;
+ gbuf->context = context;
+
+ /* Host controller specific allocation for the actual buffer */
+ retval = gbuf->gdev->hd->driver->alloc_gbuf(gbuf, size, gfp_mask);
+ if (retval) {
+ kfree(gbuf);
+ return NULL;
+ }
+
+ return gbuf;
+}
+EXPORT_SYMBOL_GPL(greybus_alloc_gbuf);
+
+static DEFINE_MUTEX(gbuf_mutex);
+
+static void free_gbuf(struct kref *kref)
+{
+ struct gbuf *gbuf = container_of(kref, struct gbuf, kref);
+
+ /* let the host controller free what it wants to */
+ gbuf->gdev->hd->driver->free_gbuf(gbuf);
+
+ kfree(gbuf);
}
void greybus_free_gbuf(struct gbuf *gbuf)
{
+ /* drop the reference count and get out of here */
+ kref_put_mutex(&gbuf->kref, free_gbuf, &gbuf_mutex);
+
}
+EXPORT_SYMBOL_GPL(greybus_free_gbuf);
+
+struct gbuf *greybus_get_gbuf(struct gbuf *gbuf)
+{
+ mutex_lock(&gbuf_mutex);
+ kref_get(&gbuf->kref);
+ mutex_unlock(&gbuf_mutex);
+ return gbuf;
+}
+EXPORT_SYMBOL_GPL(greybus_get_gbuf);
+
+
int greybus_submit_gbuf(struct gbuf *gbuf, gfp_t mem_flags)
{
struct gbuf {
struct kref kref;
- void *hcpriv;
-
- struct list_head anchor_list;
- struct gbuf_anchor *anchor; // FIXME do we need?
+ void *hdpriv;
struct greybus_device *gdev;
struct gdev_cport *cport;
u32 transfer_buffer_length;
u32 actual_length;
+#if 0
struct scatterlist *sg; // FIXME do we need?
int num_sgs;
+#endif
void *context;
gbuf_complete_t complete;
struct gb_sdio_host;
struct gb_tty;
struct gb_usb_device;
+struct greybus_host_device;
+
+/* Greybus "Host driver" structure, needed by a host controller driver to be
+ * able to handle both SVC control as well as "real" greybus messages
+ */
+struct greybus_host_driver {
+ size_t hd_priv_size;
+
+ int (*start)(struct greybus_host_device *hd);
+ int (*alloc_gbuf)(struct gbuf *gbuf, unsigned int size, gfp_t gfp_mask);
+ void (*free_gbuf)(struct gbuf *gbuf);
+};
+
+struct greybus_host_device {
+ struct kref kref;
+ const struct greybus_host_driver *driver;
+ unsigned long hd_priv_size;
+
+ /* Private data for the host driver */
+ unsigned long hd_priv[0] __attribute__ ((aligned(sizeof(s64))));
+};
+
+struct greybus_host_device *greybus_create_hd(struct greybus_host_driver *host_driver,
+ struct device *parent);
+
/* Increase these values if needed */
#define MAX_CPORTS_PER_MODULE 10
struct gdev_cport *cport[MAX_CPORTS_PER_MODULE];
struct gdev_string *string[MAX_STRINGS_PER_MODULE];
+ struct greybus_host_device *hd;
+
struct gb_i2c_device *gb_i2c_dev;
struct gb_gpio_device *gb_gpio_dev;
struct gb_sdio_host *gb_sdio_host;
struct gbuf *greybus_alloc_gbuf(struct greybus_device *gdev,
struct gdev_cport *cport,
- gfp_t mem_flags);
+ 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
int greybus_submit_gbuf(struct gbuf *gbuf, gfp_t mem_flags);
int greybus_kill_gbuf(struct gbuf *gbuf);
projects / GitHub / LineageOS / android_kernel_motorola_exynos9610.git / commitdiff