// 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");