![Greg Kroah-Hartman](/assets/img/avatar_default.png)
Now that the SPDX tag is in all greybus files, that identifies the license in a specific and legally-defined manner. So the extra GPL text wording can be removed as it is no longer needed at all. This is done on a quest to remove the 700+ different ways that files in the kernel describe the GPL license text. And there's unneeded stuff like the address (sometimes incorrect) for the FSF which is never needed. No copyright headers or other non-license-description text was removed. Cc: Vaibhav Hiremath <hvaibhav.linux@gmail.com> Reviewed-by: Alex Elder <elder@linaro.org> Acked-by: Vaibhav Agarwal <vaibhav.sr@gmail.com> Acked-by: David Lin <dtwlin@gmail.com> Acked-by: Johan Hovold <johan@kernel.org> Acked-by: Viresh Kumar <viresh.kumar@linaro.org> Acked-by: Mark Greer <mgreer@animalcreek.com> Acked-by: Rui Miguel Silva <rmfrfs@gmail.com> Acked-by: "Bryan O'Donoghue" <pure.logic@nexus-software.ie> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
246 lines
5.5 KiB
C
246 lines
5.5 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* USB host driver for the Greybus "generic" USB module.
|
|
*
|
|
* Copyright 2014 Google Inc.
|
|
* Copyright 2014 Linaro Ltd.
|
|
*/
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/usb.h>
|
|
#include <linux/usb/hcd.h>
|
|
|
|
#include "greybus.h"
|
|
#include "gbphy.h"
|
|
|
|
/* Greybus USB request types */
|
|
#define GB_USB_TYPE_HCD_START 0x02
|
|
#define GB_USB_TYPE_HCD_STOP 0x03
|
|
#define GB_USB_TYPE_HUB_CONTROL 0x04
|
|
|
|
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_device {
|
|
struct gb_connection *connection;
|
|
struct gbphy_device *gbphy_dev;
|
|
};
|
|
|
|
static inline struct gb_usb_device *to_gb_usb_device(struct usb_hcd *hcd)
|
|
{
|
|
return (struct gb_usb_device *)hcd->hcd_priv;
|
|
}
|
|
|
|
static inline struct usb_hcd *gb_usb_device_to_hcd(struct gb_usb_device *dev)
|
|
{
|
|
return container_of((void *)dev, struct usb_hcd, hcd_priv);
|
|
}
|
|
|
|
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->gbphy_dev->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->gbphy_dev->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)
|
|
{
|
|
return -ENXIO;
|
|
}
|
|
|
|
static int urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
|
{
|
|
return -ENXIO;
|
|
}
|
|
|
|
static int get_frame_number(struct usb_hcd *hcd)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int hub_status_data(struct usb_hcd *hcd, char *buf)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, u16 wIndex,
|
|
char *buf, u16 wLength)
|
|
{
|
|
struct gb_usb_device *dev = to_gb_usb_device(hcd);
|
|
struct gb_operation *operation;
|
|
struct gb_usb_hub_control_request *request;
|
|
struct gb_usb_hub_control_response *response;
|
|
size_t response_size;
|
|
int ret;
|
|
|
|
/* FIXME: handle unspecified lengths */
|
|
response_size = sizeof(*response) + wLength;
|
|
|
|
operation = gb_operation_create(dev->connection,
|
|
GB_USB_TYPE_HUB_CONTROL,
|
|
sizeof(*request),
|
|
response_size,
|
|
GFP_KERNEL);
|
|
if (!operation)
|
|
return -ENOMEM;
|
|
|
|
request = operation->request->payload;
|
|
request->typeReq = cpu_to_le16(typeReq);
|
|
request->wValue = cpu_to_le16(wValue);
|
|
request->wIndex = cpu_to_le16(wIndex);
|
|
request->wLength = cpu_to_le16(wLength);
|
|
|
|
ret = gb_operation_request_send_sync(operation);
|
|
if (ret)
|
|
goto out;
|
|
|
|
if (wLength) {
|
|
/* Greybus core has verified response size */
|
|
response = operation->response->payload;
|
|
memcpy(buf, response->buf, wLength);
|
|
}
|
|
out:
|
|
gb_operation_put(operation);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static const struct hc_driver usb_gb_hc_driver = {
|
|
.description = "greybus-hcd",
|
|
.product_desc = "Greybus USB Host Controller",
|
|
.hcd_priv_size = sizeof(struct gb_usb_device),
|
|
|
|
.flags = HCD_USB2,
|
|
|
|
.start = hcd_start,
|
|
.stop = hcd_stop,
|
|
|
|
.urb_enqueue = urb_enqueue,
|
|
.urb_dequeue = urb_dequeue,
|
|
|
|
.get_frame_number = get_frame_number,
|
|
.hub_status_data = hub_status_data,
|
|
.hub_control = hub_control,
|
|
};
|
|
|
|
static int gb_usb_probe(struct gbphy_device *gbphy_dev,
|
|
const struct gbphy_device_id *id)
|
|
{
|
|
struct gb_connection *connection;
|
|
struct device *dev = &gbphy_dev->dev;
|
|
struct gb_usb_device *gb_usb_dev;
|
|
struct usb_hcd *hcd;
|
|
int retval;
|
|
|
|
hcd = usb_create_hcd(&usb_gb_hc_driver, dev, dev_name(dev));
|
|
if (!hcd)
|
|
return -ENOMEM;
|
|
|
|
connection = gb_connection_create(gbphy_dev->bundle,
|
|
le16_to_cpu(gbphy_dev->cport_desc->id),
|
|
NULL);
|
|
if (IS_ERR(connection)) {
|
|
retval = PTR_ERR(connection);
|
|
goto exit_usb_put;
|
|
}
|
|
|
|
gb_usb_dev = to_gb_usb_device(hcd);
|
|
gb_usb_dev->connection = connection;
|
|
gb_connection_set_data(connection, gb_usb_dev);
|
|
gb_usb_dev->gbphy_dev = gbphy_dev;
|
|
gb_gbphy_set_data(gbphy_dev, gb_usb_dev);
|
|
|
|
hcd->has_tt = 1;
|
|
|
|
retval = gb_connection_enable(connection);
|
|
if (retval)
|
|
goto exit_connection_destroy;
|
|
|
|
/*
|
|
* FIXME: The USB bridged-PHY protocol driver depends on changes to
|
|
* USB core which are not yet upstream.
|
|
*
|
|
* Disable for now.
|
|
*/
|
|
if (1) {
|
|
dev_warn(dev, "USB protocol disabled\n");
|
|
retval = -EPROTONOSUPPORT;
|
|
goto exit_connection_disable;
|
|
}
|
|
|
|
retval = usb_add_hcd(hcd, 0, 0);
|
|
if (retval)
|
|
goto exit_connection_disable;
|
|
|
|
return 0;
|
|
|
|
exit_connection_disable:
|
|
gb_connection_disable(connection);
|
|
exit_connection_destroy:
|
|
gb_connection_destroy(connection);
|
|
exit_usb_put:
|
|
usb_put_hcd(hcd);
|
|
|
|
return retval;
|
|
}
|
|
|
|
static void gb_usb_remove(struct gbphy_device *gbphy_dev)
|
|
{
|
|
struct gb_usb_device *gb_usb_dev = gb_gbphy_get_data(gbphy_dev);
|
|
struct gb_connection *connection = gb_usb_dev->connection;
|
|
struct usb_hcd *hcd = gb_usb_device_to_hcd(gb_usb_dev);
|
|
|
|
usb_remove_hcd(hcd);
|
|
gb_connection_disable(connection);
|
|
gb_connection_destroy(connection);
|
|
usb_put_hcd(hcd);
|
|
}
|
|
|
|
static const struct gbphy_device_id gb_usb_id_table[] = {
|
|
{ GBPHY_PROTOCOL(GREYBUS_PROTOCOL_USB) },
|
|
{ },
|
|
};
|
|
MODULE_DEVICE_TABLE(gbphy, gb_usb_id_table);
|
|
|
|
static struct gbphy_driver usb_driver = {
|
|
.name = "usb",
|
|
.probe = gb_usb_probe,
|
|
.remove = gb_usb_remove,
|
|
.id_table = gb_usb_id_table,
|
|
};
|
|
|
|
module_gbphy_driver(usb_driver);
|
|
MODULE_LICENSE("GPL v2");
|