Implementation of USB Download function supporting THOR protocol.
Signed-off-by: Lukasz Majewski <l.majew...@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.p...@samsung.com>
Cc: Marek Vasut <ma...@denx.de>
---
drivers/usb/gadget/Makefile | 1 +
drivers/usb/gadget/f_usbd_thor.c | 808 ++++++++++++++++++++++++++++++++++++++
include/linux/usb/f_usbd_thor.h | 62 +++
3 files changed, 871 insertions(+), 0 deletions(-)
create mode 100644 drivers/usb/gadget/f_usbd_thor.c
create mode 100644 include/linux/usb/f_usbd_thor.h
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 2c067c8..0c48368 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -29,6 +29,7 @@ LIB := $(obj)libusb_gadget.o
ifdef CONFIG_USB_GADGET
COBJS-y += epautoconf.o config.o usbstring.o
COBJS-$(CONFIG_USB_GADGET_S3C_UDC_OTG) += s3c_udc_otg.o
+COBJS-$(CONFIG_USBDOWNLOAD_FUNCTION) += f_usbd_thor.o prot_thor.o
COBJS-$(CONFIG_USBDOWNLOAD_GADGET) += g_dnl.o
endif
ifdef CONFIG_USB_ETHER
diff --git a/drivers/usb/gadget/f_usbd_thor.c b/drivers/usb/gadget/f_usbd_thor.c
new file mode 100644
index 0000000..e2394e3
--- /dev/null
+++ b/drivers/usb/gadget/f_usbd_thor.c
@@ -0,0 +1,808 @@
+/*
+ * f_usbd_thor.c -- USB THOR Downloader gadget function
+ *
+ * Copyright (C) 2011-2012 Samsung Electronics
+ * Lukasz Majewski <l.majew...@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#undef DEBUG
+#include <errno.h>
+#include <common.h>
+#include <malloc.h>
+#include <linux/usb/ch9.h>
+#include <usbdescriptors.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/composite.h>
+#include <linux/usb/f_usbd_thor.h>
+#include <linux/usb/cdc.h>
+
+#include <g_dnl.h>
+#include <mmc.h>
+#include <part.h>
+
+#include "usbd_thor.h"
+#include "prot_thor.h"
+#include "gadget_chips.h"
+
+#define DMA_BUFFER_SIZE (4096*4)
+
+static struct f_usbd *usbd_func;
+static const unsigned buflen = 512; /* Standard request buffer length */
+
+struct usbd_dev {
+ struct usb_gadget *gadget;
+ struct usb_request *req; /* for control responses */
+
+ /* IN/OUT EP's and correspoinding requests */
+ struct usb_ep *in_ep, *out_ep, *int_ep;
+ struct usb_request *in_req, *out_req;
+
+ /* Control flow variables*/
+ int configuration_done;
+ int stop_done;
+ int rxdata;
+ int txdata;
+};
+
+struct f_usbd {
+ struct usb_function usb_function;
+ struct usbd_dev *dev;
+};
+
+static inline struct f_usbd *func_to_usbd(struct usb_function *f)
+{
+ return container_of(f, struct f_usbd, usb_function);
+}
+
+/* maxpacket and other transfer characteristics vary by speed. */
+static inline struct usb_endpoint_descriptor *
+ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
+ struct usb_endpoint_descriptor *fs)
+{
+ if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+ return hs;
+ return fs;
+}
+
+/* one interface in each configuration */
+static struct usb_interface_descriptor usb_downloader_intf_data = {
+ .bLength = sizeof usb_downloader_intf_data,
+ .bDescriptorType = USB_DT_INTERFACE,
+
+ .bNumEndpoints = 2,
+ .bInterfaceClass = USB_CLASS_CDC_DATA,
+};
+
+
+/* two full speed bulk endpoints; their use is config-dependent */
+static struct usb_endpoint_descriptor fs_in_desc = {
+ .bLength = USB_DT_ENDPOINT_SIZE,
+ .bDescriptorType = USB_DT_ENDPOINT,
+
+ .bEndpointAddress = USB_DIR_IN,
+ .bmAttributes = USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_endpoint_descriptor fs_out_desc = {
+ .bLength = USB_DT_ENDPOINT_SIZE,
+ .bDescriptorType = USB_DT_ENDPOINT,
+
+ .bEndpointAddress = USB_DIR_OUT,
+ .bmAttributes = USB_ENDPOINT_XFER_BULK,
+};
+
+/* CDC configuration */
+
+static struct usb_interface_descriptor usb_downloader_intf_int = {
+ .bLength = sizeof usb_downloader_intf_int,
+ .bDescriptorType = USB_DT_INTERFACE,
+
+ .bNumEndpoints = 1,
+ .bInterfaceClass = USB_CLASS_COMM,
+ /* 0x02 Abstract Line Control Model */
+ .bInterfaceSubClass = COMMUNICATIONS_INTERFACE_CLASS_CONTROL,
+ /* 0x01 Common AT commands */
+ .bInterfaceProtocol = COMMUNICATIONS_V25TER_PROTOCOL,
+};
+
+static struct usb_class_header_function_descriptor usb_downloader_cdc_header =
{
+ .bFunctionLength = sizeof usb_downloader_cdc_header,
+ .bDescriptorType = CS_INTERFACE, /* 0x24 */
+ .bDescriptorSubtype = 0x00, /* 0x00 */
+ .bcdCDC = 0x0110,
+};
+
+
+static struct usb_class_call_management_descriptor usb_downloader_cdc_call = {
+ .bFunctionLength = sizeof usb_downloader_cdc_call,
+ .bDescriptorType = CS_INTERFACE, /* 0x24 */
+ .bDescriptorSubtype = 0x01, /* 0x01 */
+ .bmCapabilities = 0x00,
+ .bDataInterface = 0x01,
+};
+
+struct usb_class_abstract_control_descriptor usb_downloader_cdc_abstract = {
+ .bFunctionLength = sizeof usb_downloader_cdc_abstract,
+ .bDescriptorType = CS_INTERFACE,
+ .bDescriptorSubtype = 0x02, /* 0x02 */
+ .bmCapabilities = 0x00,
+};
+
+struct usb_class_union_function_descriptor usb_downloader_cdc_union = {
+ .bFunctionLength = sizeof usb_downloader_cdc_union,
+ .bDescriptorType = CS_INTERFACE,
+ .bDescriptorSubtype = 0x06, /* 0x06 */
+};
+
+
+static struct usb_endpoint_descriptor fs_int_desc = {
+ .bLength = USB_DT_ENDPOINT_SIZE,
+ .bDescriptorType = USB_DT_ENDPOINT,
+
+ .bEndpointAddress = 3 | USB_DIR_IN,
+ .bmAttributes = USB_ENDPOINT_XFER_INT,
+ .wMaxPacketSize = __constant_cpu_to_le16(16),
+
+ .bInterval = 0x9,
+};
+
+static struct usb_interface_assoc_descriptor
+usbd_iad_descriptor = {
+ .bLength = sizeof usbd_iad_descriptor,
+ .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
+
+ .bFirstInterface = 0,
+ .bInterfaceCount = 2, /* control + data */
+ .bFunctionClass = USB_CLASS_COMM,
+ .bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
+ .bFunctionProtocol = USB_CDC_PROTO_NONE,
+ /* .iFunction = DYNAMIC */
+};
+
+
+/*
+ * usb 2.0 devices need to expose both high speed and full speed
+ * descriptors, unless they only run at full speed.
+ *
+ */
+
+static struct usb_endpoint_descriptor hs_in_desc = {
+ .bLength = USB_DT_ENDPOINT_SIZE,
+ .bDescriptorType = USB_DT_ENDPOINT,
+
+ .bmAttributes = USB_ENDPOINT_XFER_BULK,
+ .wMaxPacketSize = __constant_cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor hs_out_desc = {
+ .bLength = USB_DT_ENDPOINT_SIZE,
+ .bDescriptorType = USB_DT_ENDPOINT,
+
+ .bmAttributes = USB_ENDPOINT_XFER_BULK,
+ .wMaxPacketSize = __constant_cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor hs_int_desc = {
+ .bLength = USB_DT_ENDPOINT_SIZE,
+ .bDescriptorType = USB_DT_ENDPOINT,
+
+ .bmAttributes = USB_ENDPOINT_XFER_INT,
+ .wMaxPacketSize = __constant_cpu_to_le16(16),
+
+ .bInterval = 0x9,
+};
+
+static struct usb_qualifier_descriptor dev_qualifier = {
+ .bLength = sizeof dev_qualifier,
+ .bDescriptorType = USB_DT_DEVICE_QUALIFIER,
+
+ .bcdUSB = __constant_cpu_to_le16(0x0200),
+ .bDeviceClass = USB_CLASS_VENDOR_SPEC,
+
+ .bNumConfigurations = 2,
+};
+
+static const struct usb_descriptor_header *hs_usb_downloader_function[] = {
+ /* (struct usb_descriptor_header *) &otg_descriptor, */
+ (struct usb_descriptor_header *) &usbd_iad_descriptor,
+
+ (struct usb_descriptor_header *) &usb_downloader_intf_int,
+ (struct usb_descriptor_header *) &usb_downloader_cdc_header,
+ (struct usb_descriptor_header *) &usb_downloader_cdc_call,
+ (struct usb_descriptor_header *) &usb_downloader_cdc_abstract,
+ (struct usb_descriptor_header *) &usb_downloader_cdc_union,
+ (struct usb_descriptor_header *) &hs_int_desc,
+
+ (struct usb_descriptor_header *) &usb_downloader_intf_data,
+ (struct usb_descriptor_header *) &hs_in_desc,
+ (struct usb_descriptor_header *) &hs_out_desc,
+ NULL,
+};
+
+/*-------------------------------------------------------------------------*/
+
+
+static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)
+{
+ struct usb_request *req;
+
+ req = usb_ep_alloc_request(ep, GFP_ATOMIC);
+ if (req) {
+ req->length = length;
+ req->buf = malloc(length);
+ if (!req->buf) {
+ usb_ep_free_request(ep, req);
+ req = NULL;
+ }
+ }
+ return req;
+}
+
+unsigned int usbd_rx_data(void)
+{
+ int status;
+ struct usbd_dev *dev = usbd_func->dev;
+
+ static int data_to_rx = 0, tmp;
+
+ data_to_rx = dev->out_req->length;
+ tmp = data_to_rx;
+
+ do {
+
+ if (data_to_rx > DMA_BUFFER_SIZE)
+ dev->out_req->length = DMA_BUFFER_SIZE;
+ else
+ dev->out_req->length = data_to_rx;
+
+ debug("dev->out_req->length:%d dev->rxdata:%d\n",
+ dev->out_req->length, dev->rxdata);
+
+ status = usb_ep_queue(dev->out_ep, dev->out_req, GFP_ATOMIC);
+ if (status) {
+ printf("kill %s: resubmit %d bytes --> %d\n",
+ dev->out_ep->name, dev->out_req->length, status);
+ usb_ep_set_halt(dev->out_ep);
+ /* FIXME recover later ... somehow */
+ return -1;
+ }
+
+ while (!dev->rxdata)
+ usb_gadget_handle_interrupts();
+
+ dev->rxdata = 0;
+
+ if (data_to_rx > DMA_BUFFER_SIZE)
+ dev->out_req->buf += DMA_BUFFER_SIZE;
+
+ data_to_rx -= dev->out_req->actual;
+
+ } while (data_to_rx);
+
+ return tmp;
+}
+
+void usbd_tx_data(char *data, int len)
+{
+ int status;
+ struct usbd_dev *dev = usbd_func->dev;
+
+ unsigned char *ptr = dev->in_req->buf;
+
+ memset(ptr, '\0', len);
+ memcpy(ptr, data, len);
+
+ dev->in_req->length = len;
+
+ debug("%s: dev->in_req->length:%d to_cpy:%d\n", __func__,
+ dev->in_req->length, sizeof(data));
+
+ status = usb_ep_queue(dev->in_ep, dev->in_req, GFP_ATOMIC);
+ if (status) {
+ printf("kill %s: resubmit %d bytes --> %d\n",
+ dev->in_ep->name, dev->in_req->length, status);
+ usb_ep_set_halt(dev->in_ep);
+ /* FIXME recover later ... somehow */
+ }
+
+ /* Wait until tx interrupt received */
+ while (!dev->txdata)
+ usb_gadget_handle_interrupts();
+
+ dev->txdata = 0;
+}
+
+static void usbd_rx_tx_complete(struct usb_ep *ep, struct usb_request *req)
+{
+ int status = req->status;
+ struct usbd_dev *dev = usbd_func->dev;
+
+ debug("%s: ep_ptr:%p, req_ptr:%p\n", __func__, ep, req);
+ switch (status) {
+
+ case 0: /* normal completion? */
+ if (ep == dev->out_ep)
+ dev->rxdata = 1;
+ else
+ dev->txdata = 1;
+
+ break;
+
+ /* this endpoint is normally active while we're configured */
+ case -ECONNABORTED: /* hardware forced ep reset */
+ case -ECONNRESET: /* request dequeued */
+ case -ESHUTDOWN: /* disconnect from host */
+ /* Exeptional situation - print error message */
+
+ case -EOVERFLOW:
+ printf("%s: ERROR:%d\n", __func__, status);
+ default:
+ debug("%s complete --> %d, %d/%d\n", ep->name,
+ status, req->actual, req->length);
+ case -EREMOTEIO: /* short read */
+ break;
+ }
+}
+
+static struct usb_request *usbd_start_ep(struct usb_ep *ep)
+{
+ struct usb_request *req;
+
+ req = alloc_ep_req(ep, buflen);
+ debug("%s: ep:%p req:%p\n", __func__, ep, req);
+
+ if (!req)
+ return NULL;
+
+ memset(req->buf, 0, req->length);
+ req->complete = usbd_rx_tx_complete;
+
+ memset(req->buf, 0x55, req->length);
+
+ return req;
+}
+
+static void usbd_setup_complete(struct usb_ep *ep, struct usb_request *req)
+{
+ if (req->status || req->actual != req->length)
+ debug("setup complete --> %d, %d/%d\n",
+ req->status, req->actual, req->length);
+}
+
+static int
+usbd_func_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+{
+ int value = 0;
+ struct usbd_dev *dev = usbd_func->dev;
+ struct usb_request *req = dev->req;
+ struct usb_gadget *gadget = dev->gadget;
+
+ u16 len = le16_to_cpu(ctrl->wLength);
+ u16 wValue = le16_to_cpu(ctrl->wValue);
+
+ debug("Req_Type: 0x%x Req: 0x%x wValue: 0x%x wIndex: 0x%x wLen: 0x%x\n",
+ ctrl->bRequestType, ctrl->bRequest, ctrl->wValue, ctrl->wIndex,
+ ctrl->wLength);
+
+ switch (ctrl->bRequest) {
+ case SET_CONTROL_LINE_STATE:
+ value = 0;
+
+ switch (wValue) {
+ case DEACTIVATE_CARRIER:
+ /* Before reset wait for all ACM requests to be done */
+ dev->stop_done = 1;
+ break;
+ case ACTIVATE_CARRIER:
+ break;
+ default:
+ printf("usbd_setup:SetControlLine-unknown wValue: %d\n",
+ wValue);
+ }
+ break;
+ case SET_LINE_CODING:
+ value = len;
+
+ /* Line Coding set done = configuration done */
+ usbd_func->dev->configuration_done = 1;
+ break;
+
+ default:
+ printf("usbd_setup: unknown request: %d\n", ctrl->bRequest);
+ }
+
+ if (value >= 0) {
+ req->length = value;
+ req->zero = value < len;
+ value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
+ if (value < 0) {
+ debug("ep_queue --> %d\n", value);
+ req->status = 0;
+ }
+ }
+
+ return value;
+}
+
+/* Specific to the USBD_THOR protocol */
+void usbd_set_dma(char *addr, int len)
+{
+ struct usbd_dev *dev = usbd_func->dev;
+
+ debug("in_req:%p, out_req:%p\n", dev->in_req, dev->out_req);
+ debug("addr:%p, len:%d\n", addr, len);
+
+ dev->out_req->buf = addr;
+ dev->out_req->length = len;
+
+}
+
+static void usbd_cancel(int mode)
+{
+
+ switch (mode) {
+ case END_BOOT:
+ run_command("run bootcmd", 0);
+ break;
+ default:
+ break;
+ }
+}
+
+__attribute__ ((__aligned__ (__alignof__ (long long))))
+static char usbd_tx_buf[TX_DATA_LEN];
+__attribute__ ((__aligned__ (__alignof__ (long long))))
+static char usbd_rx_buf[RX_DATA_LEN];
+
+char *usbd_tx_data_buf = usbd_tx_buf;
+char *usbd_rx_data_buf = usbd_rx_buf;
+
+static const char *recv_key = "THOR";
+static const char *tx_key = "ROHT";
+
+static int usbd_init(struct g_dnl *dnl)
+{
+ int ret;
+ struct usbd_dev *dev = usbd_func->dev;
+
+ /* Wait for a device enumeration and configuration settings */
+ debug("USBD enumeration/configuration setting....\n");
+ while (!dev->configuration_done)
+ usb_gadget_handle_interrupts();
+
+ usbd_set_dma(usbd_rx_data_buf, strlen(recv_key));
+ /* detect the download request from Host PC */
+ ret = usbd_rx_data();
+
+ if (strncmp(usbd_rx_data_buf, recv_key, strlen(recv_key)) == 0) {
+ printf("Download request from the Host PC\n");
+ msleep(30);
+
+ strncpy(usbd_tx_data_buf, tx_key, strlen(tx_key));
+ usbd_tx_data(usbd_tx_data_buf, strlen(tx_key));
+ } else {
+ puts("Wrong reply information\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+static int usbd_handle(struct g_dnl *dnl)
+{
+ int ret;
+
+ debug("USBD Handle start....\n");
+
+ /* receive the data from Host PC */
+ while (1) {
+ usbd_set_dma(usbd_rx_data_buf, sizeof(rqt_box));
+ ret = usbd_rx_data();
+
+ if (ret > 0) {
+ ret = process_data(dnl);
+
+ if (ret < 0)
+ return -1;
+ else if (ret == 0)
+ return 0;
+ } else {
+ puts("No data received!\n");
+ usbd_cancel(END_BOOT);
+ }
+ }
+
+ return 0;
+}
+
+
+/* USB Downloader's specific definitions - required for this framework */
+
+void usbd_fill_dnl(struct g_dnl *dnl)
+{
+ dnl->prot = THOR;
+ dnl->init = &usbd_init;
+ dnl->dl = &usbd_handle;
+ dnl->cmd = &usbd_handle;
+
+ /* If the following pointers are set to NULL -> error */
+ dnl->rx_buf = (unsigned int *) CONFIG_SYS_DOWN_ADDR;
+ dnl->tx_buf = NULL;
+}
+
+static int usbd_func_bind(struct usb_configuration *c, struct usb_function *f)
+{
+ int status;
+ struct usb_ep *ep;
+ struct usbd_dev *dev;
+ struct f_usbd *f_usbd = func_to_usbd(f);
+ struct usb_gadget *gadget = c->cdev->gadget;
+ struct g_dnl *dnl = get_udc_gadget_private_data(gadget);
+
+ usbd_func = f_usbd;
+ dev = calloc(sizeof(*dev), 1);
+ if (!dev)
+ return -ENOMEM;
+
+ dev->gadget = gadget;
+
+ f_usbd->dev = dev;
+ f_usbd->dev->configuration_done = 0;
+ f_usbd->dev->rxdata = 0;
+ f_usbd->dev->txdata = 0;
+
+ debug("%s: usb_configuration: 0x%p usb_function: 0x%p\n",
+ __func__, c, f);
+ debug("f_usbd: 0x%p usbd: 0x%p\n", f_usbd, dev);
+
+ /* EP0 */
+ /* preallocate control response and buffer */
+ dev->req = usb_ep_alloc_request(gadget->ep0, 0);
+ if (!dev->req) {
+ status = -ENOMEM;
+ goto fail;
+ }
+ dev->req->buf = malloc(buflen);
+ if (!dev->req->buf) {
+ status = -ENOMEM;
+ goto fail;
+ }
+
+ dev->req->complete = usbd_setup_complete;
+
+ /* DYNAMIC interface numbers assignments */
+ status = usb_interface_id(c, f);
+
+ if (status < 0)
+ goto fail;
+
+ usb_downloader_intf_int.bInterfaceNumber = status;
+ usb_downloader_cdc_union.bMasterInterface = status;
+
+ status = usb_interface_id(c, f);
+
+ if (status < 0)
+ goto fail;
+
+ usb_downloader_intf_data.bInterfaceNumber = status;
+ usb_downloader_cdc_union.bSlaveInterface0 = status;
+
+
+ /* allocate instance-specific endpoints */
+ ep = usb_ep_autoconfig(gadget, &fs_in_desc);
+ if (!ep) {
+ status = -ENODEV;
+ goto fail;
+ }
+
+ if (gadget_is_dualspeed(gadget)) {
+ hs_in_desc.bEndpointAddress =
+ fs_in_desc.bEndpointAddress;
+ }
+
+ dev->in_ep = ep; /* Store IN EP for enabling @ setup */
+
+
+
+ ep = usb_ep_autoconfig(gadget, &fs_out_desc);
+ if (!ep) {
+ status = -ENODEV;
+ goto fail;
+ }
+
+ if (gadget_is_dualspeed(gadget)) {
+ hs_out_desc.bEndpointAddress =
+ fs_out_desc.bEndpointAddress;
+ }
+
+ dev->out_ep = ep; /* Store OUT EP for enabling @ setup */
+
+ /* note: a status/notification endpoint is, strictly speaking,
+ * optional. We don't treat it that way though! It's simpler,
+ * and some newer profiles don't treat it as optional.
+ */
+ ep = usb_ep_autoconfig(gadget, &fs_int_desc);
+ if (!ep) {
+ status = -ENODEV;
+ goto fail;
+ }
+
+ dev->int_ep = ep;
+
+ if (gadget_is_dualspeed(gadget)) {
+ hs_int_desc.bEndpointAddress =
+ fs_int_desc.bEndpointAddress;
+
+ /* copy descriptors, and track endpoint copies */
+ f->hs_descriptors = (struct usb_descriptor_header **)
+ &hs_usb_downloader_function;
+
+ if (!f->hs_descriptors)
+ goto fail;
+ }
+
+ debug("%s: out_ep:%p out_req:%p\n",
+ __func__, dev->out_ep, dev->out_req);
+ printf("%s: dnl: 0x%p\n", __func__, dnl);
+ usbd_fill_dnl(dnl);
+
+ return 0;
+
+ fail:
+ free(dev);
+ return status;
+}
+
+static void free_ep_req(struct usb_ep *ep, struct usb_request *req)
+{
+ free(req->buf);
+ usb_ep_free_request(ep, req);
+}
+
+static void usbd_func_disable(struct usb_function *f)
+{
+ struct f_usbd *f_usbd = func_to_usbd(f);
+ struct usbd_dev *dev = f_usbd->dev;
+
+ debug("%s:\n", __func__);
+
+ /* Avoid freeing memory when ep is still claimed */
+ if (dev->in_ep->driver_data) {
+ free_ep_req(dev->in_ep, dev->in_req);
+ usb_ep_disable(dev->in_ep);
+ dev->in_ep->driver_data = NULL;
+ }
+
+ if (dev->out_ep->driver_data) {
+ free_ep_req(dev->out_ep, dev->out_req);
+ usb_ep_disable(dev->out_ep);
+ dev->out_ep->driver_data = NULL;
+ }
+
+ if (dev->int_ep->driver_data) {
+ usb_ep_disable(dev->int_ep);
+ dev->int_ep->driver_data = NULL;
+ }
+}
+
+static int usbd_eps_setup(struct usb_function *f)
+{
+ int result;
+ struct usb_composite_dev *cdev = f->config->cdev;
+ struct usb_ep *ep;
+ struct usb_request *req;
+ struct usb_gadget *gadget = cdev->gadget;
+ struct usbd_dev *dev = usbd_func->dev;
+
+ struct usb_endpoint_descriptor *d;
+
+ ep = dev->in_ep;
+ d = ep_desc(gadget, &hs_in_desc, &fs_in_desc);
+ debug("(d)bEndpointAddress: 0x%x\n", d->bEndpointAddress);
+
+ result = usb_ep_enable(ep, d);
+
+ if (result == 0) {
+ ep->driver_data = cdev; /* claim */
+ req = usbd_start_ep(ep);
+ if (req != NULL) {
+ dev->in_req = req;
+ } else {
+ usb_ep_disable(ep);
+ result = -EIO;
+ }
+ } else
+ goto exit;
+
+ ep = dev->out_ep;
+ d = ep_desc(gadget, &hs_out_desc, &fs_out_desc);
+ debug("(d)bEndpointAddress: 0x%x\n", d->bEndpointAddress);
+
+ result = usb_ep_enable(ep, d);
+
+ if (result == 0) {
+ ep->driver_data = cdev; /* claim */
+ req = usbd_start_ep(ep);
+ if (req != NULL) {
+ dev->out_req = req;
+ } else {
+ usb_ep_disable(ep);
+ result = -EIO;
+ }
+ } else
+ goto exit;
+
+ /* ACM control EP */
+ ep = dev->int_ep;
+ ep->driver_data = cdev; /* claim */
+
+ exit:
+ return result;
+}
+
+static int usbd_func_set_alt(struct usb_function *f,
+ unsigned intf, unsigned alt)
+{
+ int result;
+ debug("%s: func: %s intf: %d alt: %d\n",
+ __func__, f->name, intf, alt);
+
+ switch (intf) {
+ case 0:
+ debug("ACM INTR interface\n");
+ break;
+ case 1:
+ debug("Communication Data interface\n");
+
+ result = usbd_eps_setup(f);
+ if (result)
+ printf("%s: EPs setup failed!\n", __func__);
+ break;
+ }
+
+ return 0;
+}
+
+static int usbd_func_init(struct usb_configuration *c)
+{
+ int status;
+ struct f_usbd *f_usbd;
+
+ debug("%s: cdev: 0x%p\n", __func__, c->cdev);
+
+ f_usbd = calloc(sizeof(*f_usbd), 1);
+ if (!f_usbd)
+ return -ENOMEM;
+
+ f_usbd->usb_function.name = "f_usbd";
+ f_usbd->usb_function.bind = usbd_func_bind;
+ f_usbd->usb_function.setup = usbd_func_setup;
+ f_usbd->usb_function.set_alt = usbd_func_set_alt;
+ f_usbd->usb_function.disable = usbd_func_disable;
+
+ status = usb_add_function(c, &f_usbd->usb_function);
+ if (status)
+ free(f_usbd);
+
+ return status;
+}
+
+int f_usbd_add(struct usb_configuration *c)
+{
+ debug("%s:\n", __func__);
+
+ return usbd_func_init(c);
+}
diff --git a/include/linux/usb/f_usbd_thor.h b/include/linux/usb/f_usbd_thor.h
new file mode 100644
index 0000000..8002791
--- /dev/null
+++ b/include/linux/usb/f_usbd_thor.h
@@ -0,0 +1,62 @@
+/*
+ * USB THOR Downloader
+ *
+ * Copyright (C) 2012 Samsung Electronics
+ * Lukasz Majewski <l.majew...@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef _USB_THOR_H_
+#define _USB_THOR_H_
+
+#include <linux/usb/composite.h>
+
+/* ACM -> THOR GADGET download */
+#define DEACTIVATE_CARRIER 0x0000
+#define ACTIVATE_CARRIER 0x0003
+
+#define SET_LINE_CODING 0x0020
+#define SET_CONTROL_LINE_STATE 0x0022
+
+/* THOR Composite Gadget */
+
+#define STRING_MANUFACTURER_IDX 0
+#define STRING_PRODUCT_IDX 1
+#define STRING_SERIAL_IDX 2
+
+/* Samsung's IDs */
+#define DRIVER_VENDOR_NUM 0x04E8
+#define DRIVER_PRODUCT_NUM 0x6601
+
+#define STRING_MANUFACTURER 25
+#define STRING_PRODUCT 2
+#define STRING_USBDOWN 2
+#define CONFIG_USBDOWNLOADER 2
+
+int f_usbd_add(struct usb_configuration *c);
+
+/* Interface to THOR protocol */
+#define TX_DATA_LEN 64
+#define RX_DATA_LEN 1024
+
+extern char *usbd_tx_data_buf;
+extern char *usbd_rx_data_buf;
+
+extern void usbd_set_dma(char *addr, int len);
+extern unsigned int usbd_rx_data(void);
+extern void usbd_tx_data(char *data, int len);
+
+#endif /* _USB_THOR_H_ */
--
1.7.2.3
_______________________________________________
U-Boot mailing list
U-Boot@lists.denx.de
http://lists.denx.de/mailman/listinfo/u-boot
