2014-11-25 17:59:21 -07:00
|
|
|
/*
|
|
|
|
* USB host driver for the Greybus "generic" USB module.
|
|
|
|
*
|
|
|
|
* Copyright 2014 Google Inc.
|
2014-12-12 11:08:42 -07:00
|
|
|
* Copyright 2014 Linaro Ltd.
|
2014-11-25 17:59:21 -07:00
|
|
|
*
|
|
|
|
* Released under the GPLv2 only.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/usb.h>
|
|
|
|
#include <linux/usb/hcd.h>
|
|
|
|
|
|
|
|
#include "greybus.h"
|
|
|
|
|
|
|
|
/* Version of the Greybus USB protocol we support */
|
|
|
|
#define GB_USB_VERSION_MAJOR 0x00
|
|
|
|
#define GB_USB_VERSION_MINOR 0x01
|
|
|
|
|
|
|
|
/* Greybus USB request types */
|
|
|
|
#define GB_USB_TYPE_INVALID 0x00
|
|
|
|
#define GB_USB_TYPE_PROTOCOL_VERSION 0x01
|
|
|
|
#define GB_USB_TYPE_HCD_STOP 0x02
|
|
|
|
#define GB_USB_TYPE_HCD_START 0x03
|
|
|
|
#define GB_USB_TYPE_URB_ENQUEUE 0x04
|
|
|
|
#define GB_USB_TYPE_URB_DEQUEUE 0x05
|
|
|
|
#define GB_USB_TYPE_ENDPOINT_DISABLE 0x06
|
|
|
|
#define GB_USB_TYPE_HUB_CONTROL 0x07
|
|
|
|
#define GB_USB_TYPE_GET_FRAME_NUMBER 0x08
|
|
|
|
#define GB_USB_TYPE_HUB_STATUS_DATA 0x09
|
|
|
|
|
|
|
|
struct gb_usb_urb_enqueue_request {
|
|
|
|
__le32 pipe;
|
|
|
|
__le32 transfer_flags;
|
|
|
|
__le32 transfer_buffer_length;
|
|
|
|
__le32 maxpacket;
|
|
|
|
__le32 interval;
|
|
|
|
__le64 hcpriv_ep;
|
|
|
|
__le32 number_of_packets;
|
|
|
|
u8 setup_packet[8];
|
|
|
|
u8 payload[0];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gb_usb_urb_dequeue_request {
|
|
|
|
__le64 hcpriv_ep;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gb_usb_endpoint_disable_request {
|
|
|
|
__le64 hcpriv;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gb_usb_hub_control_request {
|
|
|
|
__le16 typeReq;
|
|
|
|
__le16 wValue;
|
|
|
|
__le16 wIndex;
|
|
|
|
__le16 wLength;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gb_usb_hub_control_response {
|
|
|
|
u8 buf[0];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gb_usb_header {
|
|
|
|
__le16 size;
|
|
|
|
__le16 id;
|
|
|
|
__u8 type;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct gb_usb_hub_status {
|
|
|
|
__le32 status;
|
|
|
|
__le16 buf_size;
|
|
|
|
u8 buf[0];
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct gb_usb_hub_status *hub_status; // FIXME!!!
|
|
|
|
static DEFINE_SPINLOCK(hub_status_lock);
|
|
|
|
static atomic_t frame_number; // FIXME!!!
|
|
|
|
|
|
|
|
struct gb_usb_device {
|
|
|
|
struct gb_connection *connection;
|
|
|
|
|
|
|
|
struct usb_hcd *hcd;
|
|
|
|
u8 version_major;
|
|
|
|
u8 version_minor;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define to_gb_usb_device(d) ((struct gb_usb_device*) d->hcd_priv)
|
|
|
|
|
2015-01-21 05:42:36 -07:00
|
|
|
/* Define get_version() routine */
|
|
|
|
define_get_version(gb_usb_device, USB);
|
2014-11-25 17:59:21 -07:00
|
|
|
|
|
|
|
static void hcd_stop(struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
struct gb_usb_device *dev = to_gb_usb_device(hcd);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = gb_operation_sync(dev->connection, GB_USB_TYPE_HCD_STOP,
|
|
|
|
NULL, 0, NULL, 0);
|
|
|
|
if (ret)
|
|
|
|
dev_err(&dev->connection->dev, "HCD stop failed '%d'\n", ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hcd_start(struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
struct usb_bus *bus = hcd_to_bus(hcd);
|
|
|
|
struct gb_usb_device *dev = to_gb_usb_device(hcd);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = gb_operation_sync(dev->connection, GB_USB_TYPE_HCD_START,
|
|
|
|
NULL, 0, NULL, 0);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&dev->connection->dev, "HCD start failed '%d'\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
hcd->state = HC_STATE_RUNNING;
|
|
|
|
if (bus->root_hub)
|
|
|
|
usb_hcd_resume_root_hub(hcd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
|
|
|
|
{
|
|
|
|
struct gb_usb_device *dev = to_gb_usb_device(hcd);
|
|
|
|
struct gb_usb_urb_enqueue_request *request;
|
|
|
|
struct gb_operation *operation;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
operation = gb_operation_create(dev->connection,
|
|
|
|
GB_USB_TYPE_URB_ENQUEUE,
|
|
|
|
sizeof(*request) +
|
2015-07-01 04:37:22 -06:00
|
|
|
urb->transfer_buffer_length, 0,
|
|
|
|
GFP_KERNEL);
|
2014-11-25 17:59:21 -07:00
|
|
|
if (!operation)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
request = operation->request->payload;
|
|
|
|
request->pipe = cpu_to_le32(urb->pipe);
|
|
|
|
request->transfer_flags = cpu_to_le32(urb->transfer_flags);
|
|
|
|
request->transfer_buffer_length = cpu_to_le32(urb->transfer_buffer_length);
|
|
|
|
request->interval = cpu_to_le32(urb->interval);
|
2015-03-19 09:46:13 -06:00
|
|
|
request->hcpriv_ep = cpu_to_le64((unsigned long)urb->ep->hcpriv);
|
2014-11-25 17:59:21 -07:00
|
|
|
request->number_of_packets = cpu_to_le32(urb->number_of_packets);
|
|
|
|
|
|
|
|
memcpy(request->setup_packet, urb->setup_packet, 8);
|
|
|
|
memcpy(&request->payload, urb->transfer_buffer,
|
|
|
|
urb->transfer_buffer_length);
|
|
|
|
|
2014-12-03 07:35:09 -07:00
|
|
|
ret = gb_operation_request_send_sync(operation);
|
2014-11-25 17:59:21 -07:00
|
|
|
gb_operation_destroy(operation);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
|
|
|
{
|
|
|
|
struct gb_usb_device *dev = to_gb_usb_device(hcd);
|
|
|
|
struct gb_usb_urb_dequeue_request request;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
urb->ep->hcpriv = NULL;
|
2015-03-19 09:46:13 -06:00
|
|
|
request.hcpriv_ep = cpu_to_le64((unsigned long)urb->hcpriv);
|
2014-11-25 17:59:21 -07:00
|
|
|
ret = gb_operation_sync(dev->connection, GB_USB_TYPE_URB_DEQUEUE,
|
|
|
|
&request, sizeof(request), NULL, 0);
|
|
|
|
urb->hcpriv = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
|
|
|
|
{
|
|
|
|
struct gb_usb_device *dev = to_gb_usb_device(hcd);
|
|
|
|
struct gb_usb_endpoint_disable_request request;
|
|
|
|
int ret;
|
|
|
|
|
2015-03-19 09:46:13 -06:00
|
|
|
request.hcpriv = cpu_to_le64((unsigned long)ep->hcpriv);
|
2014-11-25 17:59:21 -07:00
|
|
|
ret = gb_operation_sync(dev->connection, GB_USB_TYPE_ENDPOINT_DISABLE,
|
|
|
|
&request, sizeof(request), NULL, 0);
|
|
|
|
ep->hcpriv = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static int get_frame_number(struct usb_hcd *hcd)
|
|
|
|
{
|
|
|
|
return atomic_read(&frame_number);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hub_status_data(struct usb_hcd *hcd, char *buf)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&hub_status_lock, flags);
|
|
|
|
memcpy(buf, hub_status->buf, le16_to_cpu(hub_status->buf_size));
|
|
|
|
retval = le32_to_cpu(hub_status->status);
|
|
|
|
spin_unlock_irqrestore(&hub_status_lock, flags);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, u16 wIndex,
|
|
|
|
char *buf, u16 wLength)
|
|
|
|
{
|
|
|
|
struct gb_usb_hub_control_request request;
|
|
|
|
struct gb_usb_device *dev = to_gb_usb_device(hcd);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
request.typeReq = cpu_to_le16(typeReq);
|
|
|
|
request.wValue = cpu_to_le16(wValue);
|
|
|
|
request.wIndex = cpu_to_le16(wIndex);
|
|
|
|
request.wLength = cpu_to_le16(wLength);
|
|
|
|
|
|
|
|
// FIXME - buf needs to come back in struct gb_usb_hub_control_response
|
|
|
|
// for some types of requests, depending on typeReq. Do we do this in a
|
|
|
|
// "generic" way, or only ask for a response for the ones we "know" need
|
|
|
|
// a response (a small subset of all valid typeReq, thankfully.)
|
|
|
|
ret = gb_operation_sync(dev->connection, GB_USB_TYPE_HUB_CONTROL,
|
|
|
|
&request, sizeof(request), NULL, 0);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct hc_driver usb_gb_hc_driver = {
|
|
|
|
.description = "greybus_usb",
|
|
|
|
.product_desc = "GB-Bridge USB Controller", /* TODO: Get this from GPB ?*/
|
|
|
|
.flags = HCD_MEMORY | HCD_USB2, /* FIXME: Get this from GPB */
|
|
|
|
.hcd_priv_size = sizeof(struct gb_usb_device),
|
|
|
|
|
|
|
|
.start = hcd_start,
|
|
|
|
.stop = hcd_stop,
|
|
|
|
.urb_enqueue = urb_enqueue,
|
|
|
|
.urb_dequeue = urb_dequeue,
|
|
|
|
.endpoint_disable = endpoint_disable,
|
|
|
|
.endpoint_reset = endpoint_reset,
|
|
|
|
.get_frame_number = get_frame_number,
|
|
|
|
.hub_status_data = hub_status_data,
|
|
|
|
.hub_control = hub_control,
|
|
|
|
};
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
static inline void gb_usb_handle_get_frame_number(struct gbuf *gbuf)
|
|
|
|
{
|
|
|
|
__le32 frame_num;
|
|
|
|
const size_t packet_size = sizeof(struct gb_usb_header) +
|
|
|
|
sizeof(frame_num);
|
|
|
|
struct gb_usb_header* hdr = gbuf->transfer_buffer;
|
|
|
|
|
|
|
|
if (le16_to_cpu(hdr->size) != packet_size) {
|
|
|
|
pr_err("%s(): dropping packet too small\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
frame_num = (__le32) ((char*) gbuf->transfer_buffer +
|
|
|
|
sizeof(struct gb_usb_header));
|
|
|
|
atomic_set(&frame_number, le32_to_cpu(frame_num));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void gb_usb_handle_hubs_status_data(struct gbuf *gbuf)
|
|
|
|
{
|
|
|
|
struct gb_usb_hub_status *new_hubstatus, *hubstatus;
|
|
|
|
struct gb_usb_header* hdr = gbuf->transfer_buffer;
|
|
|
|
const size_t min_packet_size = sizeof(struct gb_usb_header) +
|
|
|
|
sizeof(struct gb_usb_hub_status);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (le16_to_cpu(hdr->size) < min_packet_size) {
|
|
|
|
pr_err("%s(): dropping packet too small\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
hubstatus = (struct gb_usb_hub_status*) ((char*) gbuf->transfer_buffer
|
|
|
|
+ sizeof(struct gb_usb_header));
|
|
|
|
|
|
|
|
if (le16_to_cpu(hdr->size) != min_packet_size + hubstatus->buf_size) {
|
|
|
|
pr_err("%s(): invalid packet size, dropping packet\n",
|
|
|
|
__func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
new_hubstatus = kmalloc(hubstatus->buf_size, GFP_KERNEL);
|
|
|
|
memcpy(&new_hubstatus, hubstatus, hubstatus->buf_size);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&hub_status_lock, flags);
|
|
|
|
hubstatus = hub_status;
|
|
|
|
hub_status = new_hubstatus;
|
|
|
|
spin_unlock_irqrestore(&hub_status_lock, flags);
|
|
|
|
|
|
|
|
kfree(hubstatus);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gb_usb_in_handler(struct gbuf *gbuf)
|
|
|
|
{
|
|
|
|
struct gb_usb_header* hdr = gbuf->transfer_buffer;
|
|
|
|
|
|
|
|
switch (hdr->type) {
|
|
|
|
case GB_USB_TYPE_GET_FRAME_NUMBER:
|
|
|
|
gb_usb_handle_get_frame_number(gbuf);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GB_USB_TYPE_HUB_STATUS_DATA:
|
|
|
|
gb_usb_handle_hubs_status_data(gbuf);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int gb_usb_connection_init(struct gb_connection *connection)
|
|
|
|
{
|
|
|
|
struct device *dev = &connection->dev;
|
|
|
|
struct gb_usb_device *gb_usb_dev;
|
|
|
|
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
gb_usb_dev = kzalloc(sizeof(*gb_usb_dev), GFP_KERNEL);
|
|
|
|
if (!gb_usb_dev)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
gb_usb_dev->connection = connection;
|
2014-12-03 11:27:42 -07:00
|
|
|
connection->private = gb_usb_dev;
|
2014-11-25 17:59:21 -07:00
|
|
|
|
|
|
|
/* Check for compatible protocol version */
|
|
|
|
retval = get_version(gb_usb_dev);
|
|
|
|
if (retval)
|
|
|
|
goto error_create_hcd;
|
|
|
|
|
|
|
|
gb_usb_dev->hcd = usb_create_hcd(&usb_gb_hc_driver, dev, dev_name(dev));
|
|
|
|
if (!gb_usb_dev->hcd) {
|
|
|
|
retval = -ENODEV;
|
|
|
|
goto error_create_hcd;
|
|
|
|
}
|
|
|
|
|
|
|
|
gb_usb_dev->hcd->has_tt = 1;
|
|
|
|
gb_usb_dev->hcd->hcd_priv[0] = (unsigned long) gb_usb_dev;
|
|
|
|
|
|
|
|
retval = usb_add_hcd(gb_usb_dev->hcd, 0, 0);
|
|
|
|
if (retval)
|
|
|
|
goto error_add_hcd;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
error_add_hcd:
|
|
|
|
usb_put_hcd(gb_usb_dev->hcd);
|
|
|
|
error_create_hcd:
|
|
|
|
kfree(gb_usb_dev);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gb_usb_connection_exit(struct gb_connection *connection)
|
|
|
|
{
|
|
|
|
// FIXME - tear everything down!
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct gb_protocol usb_protocol = {
|
2014-12-24 14:01:45 -07:00
|
|
|
.name = "usb",
|
2014-11-25 17:59:21 -07:00
|
|
|
.id = GREYBUS_PROTOCOL_USB,
|
|
|
|
.major = 0,
|
|
|
|
.minor = 1,
|
|
|
|
.connection_init = gb_usb_connection_init,
|
|
|
|
.connection_exit = gb_usb_connection_exit,
|
|
|
|
.request_recv = NULL, /* FIXME we have requests!!! */
|
|
|
|
};
|
|
|
|
|
2015-07-01 00:43:52 -06:00
|
|
|
gb_builtin_protocol_driver(usb_protocol);
|