| // 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 <linux/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 { | |
| DECLARE_FLEX_ARRAY(u8, buf); | |
| }; | |
| 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_DESCRIPTION("USB host driver for the Greybus 'generic' USB module"); | |
| MODULE_LICENSE("GPL v2"); |