191 lines
5.6 KiB
C
191 lines
5.6 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/usb.h>
|
|
#include <linux/usb/ch11.h>
|
|
|
|
#define TEST_SE0_NAK_PID 0x0101
|
|
#define TEST_J_PID 0x0102
|
|
#define TEST_K_PID 0x0103
|
|
#define TEST_PACKET_PID 0x0104
|
|
#define TEST_HS_HOST_PORT_SUSPEND_RESUME 0x0106
|
|
#define TEST_SINGLE_STEP_GET_DEV_DESC 0x0107
|
|
#define TEST_SINGLE_STEP_SET_FEATURE 0x0108
|
|
|
|
extern const struct usb_device_id *usb_device_match_id(struct usb_device *udev,
|
|
const struct usb_device_id *id);
|
|
|
|
/*
|
|
* A list of USB hubs which requires to disable the power
|
|
* to the port before starting the testing procedures.
|
|
*/
|
|
static const struct usb_device_id ehset_hub_list[] = {
|
|
{ USB_DEVICE(0x0424, 0x4502) },
|
|
{ USB_DEVICE(0x0424, 0x4913) },
|
|
{ USB_DEVICE(0x0451, 0x8027) },
|
|
{ }
|
|
};
|
|
|
|
static int ehset_prepare_port_for_testing(struct usb_device *hub_udev, u16 portnum)
|
|
{
|
|
int ret = 0;
|
|
|
|
/*
|
|
* The USB2.0 spec chapter 11.24.2.13 says that the USB port which is
|
|
* going under test needs to be put in suspend before sending the
|
|
* test command. Most hubs don't enforce this precondition, but there
|
|
* are some hubs which needs to disable the power to the port before
|
|
* starting the test.
|
|
*/
|
|
if (usb_device_match_id(hub_udev, ehset_hub_list)) {
|
|
ret = usb_control_msg_send(hub_udev, 0, USB_REQ_CLEAR_FEATURE,
|
|
USB_RT_PORT, USB_PORT_FEAT_ENABLE,
|
|
portnum, NULL, 0, 1000, GFP_KERNEL);
|
|
/*
|
|
* Wait for the port to be disabled. It's an arbitrary value
|
|
* which worked every time.
|
|
*/
|
|
msleep(100);
|
|
} else {
|
|
/*
|
|
* For the hubs which are compliant with the spec,
|
|
* put the port in SUSPEND.
|
|
*/
|
|
ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE,
|
|
USB_RT_PORT, USB_PORT_FEAT_SUSPEND,
|
|
portnum, NULL, 0, 1000, GFP_KERNEL);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int ehset_probe(struct usb_interface *intf,
|
|
const struct usb_device_id *id)
|
|
{
|
|
int ret = -EINVAL;
|
|
struct usb_device *dev = interface_to_usbdev(intf);
|
|
struct usb_device *hub_udev = dev->parent;
|
|
struct usb_device_descriptor buf;
|
|
u8 portnum = dev->portnum;
|
|
u16 test_pid = le16_to_cpu(dev->descriptor.idProduct);
|
|
|
|
switch (test_pid) {
|
|
case TEST_SE0_NAK_PID:
|
|
ret = ehset_prepare_port_for_testing(hub_udev, portnum);
|
|
if (ret < 0)
|
|
break;
|
|
ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE,
|
|
USB_RT_PORT, USB_PORT_FEAT_TEST,
|
|
(USB_TEST_SE0_NAK << 8) | portnum,
|
|
NULL, 0, 1000, GFP_KERNEL);
|
|
break;
|
|
case TEST_J_PID:
|
|
ret = ehset_prepare_port_for_testing(hub_udev, portnum);
|
|
if (ret < 0)
|
|
break;
|
|
ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE,
|
|
USB_RT_PORT, USB_PORT_FEAT_TEST,
|
|
(USB_TEST_J << 8) | portnum, NULL, 0,
|
|
1000, GFP_KERNEL);
|
|
break;
|
|
case TEST_K_PID:
|
|
ret = ehset_prepare_port_for_testing(hub_udev, portnum);
|
|
if (ret < 0)
|
|
break;
|
|
ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE,
|
|
USB_RT_PORT, USB_PORT_FEAT_TEST,
|
|
(USB_TEST_K << 8) | portnum, NULL, 0,
|
|
1000, GFP_KERNEL);
|
|
break;
|
|
case TEST_PACKET_PID:
|
|
ret = ehset_prepare_port_for_testing(hub_udev, portnum);
|
|
if (ret < 0)
|
|
break;
|
|
ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE,
|
|
USB_RT_PORT, USB_PORT_FEAT_TEST,
|
|
(USB_TEST_PACKET << 8) | portnum,
|
|
NULL, 0, 1000, GFP_KERNEL);
|
|
break;
|
|
case TEST_HS_HOST_PORT_SUSPEND_RESUME:
|
|
/* Test: wait for 15secs -> suspend -> 15secs delay -> resume */
|
|
msleep(15 * 1000);
|
|
ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE,
|
|
USB_RT_PORT, USB_PORT_FEAT_SUSPEND,
|
|
portnum, NULL, 0, 1000, GFP_KERNEL);
|
|
if (ret < 0)
|
|
break;
|
|
|
|
msleep(15 * 1000);
|
|
ret = usb_control_msg_send(hub_udev, 0, USB_REQ_CLEAR_FEATURE,
|
|
USB_RT_PORT, USB_PORT_FEAT_SUSPEND,
|
|
portnum, NULL, 0, 1000, GFP_KERNEL);
|
|
break;
|
|
case TEST_SINGLE_STEP_GET_DEV_DESC:
|
|
/* Test: wait for 15secs -> GetDescriptor request */
|
|
msleep(15 * 1000);
|
|
|
|
ret = usb_control_msg_recv(dev, 0, USB_REQ_GET_DESCRIPTOR,
|
|
USB_DIR_IN, USB_DT_DEVICE << 8, 0,
|
|
&buf, USB_DT_DEVICE_SIZE,
|
|
USB_CTRL_GET_TIMEOUT, GFP_KERNEL);
|
|
break;
|
|
case TEST_SINGLE_STEP_SET_FEATURE:
|
|
/*
|
|
* GetDescriptor SETUP request -> 15secs delay -> IN & STATUS
|
|
*
|
|
* Note, this test is only supported on root hubs since the
|
|
* SetPortFeature handling can only be done inside the HCD's
|
|
* hub_control callback function.
|
|
*/
|
|
if (hub_udev != dev->bus->root_hub) {
|
|
dev_err(&intf->dev, "SINGLE_STEP_SET_FEATURE test only supported on root hub\n");
|
|
break;
|
|
}
|
|
|
|
ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE,
|
|
USB_RT_PORT, USB_PORT_FEAT_TEST,
|
|
(6 << 8) | portnum, NULL, 0,
|
|
60 * 1000, GFP_KERNEL);
|
|
|
|
break;
|
|
default:
|
|
dev_err(&intf->dev, "%s: unsupported PID: 0x%x\n",
|
|
__func__, test_pid);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void ehset_disconnect(struct usb_interface *intf)
|
|
{
|
|
}
|
|
|
|
static const struct usb_device_id ehset_id_table[] = {
|
|
{ USB_DEVICE(0x1a0a, TEST_SE0_NAK_PID) },
|
|
{ USB_DEVICE(0x1a0a, TEST_J_PID) },
|
|
{ USB_DEVICE(0x1a0a, TEST_K_PID) },
|
|
{ USB_DEVICE(0x1a0a, TEST_PACKET_PID) },
|
|
{ USB_DEVICE(0x1a0a, TEST_HS_HOST_PORT_SUSPEND_RESUME) },
|
|
{ USB_DEVICE(0x1a0a, TEST_SINGLE_STEP_GET_DEV_DESC) },
|
|
{ USB_DEVICE(0x1a0a, TEST_SINGLE_STEP_SET_FEATURE) },
|
|
{ } /* Terminating entry */
|
|
};
|
|
MODULE_DEVICE_TABLE(usb, ehset_id_table);
|
|
|
|
static struct usb_driver ehset_driver = {
|
|
.name = "usb_ehset_test",
|
|
.probe = ehset_probe,
|
|
.disconnect = ehset_disconnect,
|
|
.id_table = ehset_id_table,
|
|
};
|
|
|
|
module_usb_driver(ehset_driver);
|
|
|
|
MODULE_DESCRIPTION("USB Driver for EHSET Test Fixture");
|
|
MODULE_LICENSE("GPL v2");
|