1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2010-2013, The Linux Foundation. All rights reserved. 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/errno.h> 8 #include <linux/module.h> 9 #include <linux/slab.h> 10 #include <linux/usb.h> 11 #include <linux/usb/ch11.h> 12 13 #define TEST_SE0_NAK_PID 0x0101 14 #define TEST_J_PID 0x0102 15 #define TEST_K_PID 0x0103 16 #define TEST_PACKET_PID 0x0104 17 #define TEST_HS_HOST_PORT_SUSPEND_RESUME 0x0106 18 #define TEST_SINGLE_STEP_GET_DEV_DESC 0x0107 19 #define TEST_SINGLE_STEP_SET_FEATURE 0x0108 20 21 extern const struct usb_device_id *usb_device_match_id(struct usb_device *udev, 22 const struct usb_device_id *id); 23 24 /* 25 * A list of USB hubs which requires to disable the power 26 * to the port before starting the testing procedures. 27 */ 28 static const struct usb_device_id ehset_hub_list[] = { 29 { USB_DEVICE(0x0424, 0x4502) }, 30 { USB_DEVICE(0x0424, 0x4913) }, 31 { USB_DEVICE(0x0451, 0x8027) }, 32 { } 33 }; 34 ehset_prepare_port_for_testing(struct usb_device * hub_udev,u16 portnum)35 static int ehset_prepare_port_for_testing(struct usb_device *hub_udev, u16 portnum) 36 { 37 int ret = 0; 38 39 /* 40 * The USB2.0 spec chapter 11.24.2.13 says that the USB port which is 41 * going under test needs to be put in suspend before sending the 42 * test command. Most hubs don't enforce this precondition, but there 43 * are some hubs which needs to disable the power to the port before 44 * starting the test. 45 */ 46 if (usb_device_match_id(hub_udev, ehset_hub_list)) { 47 ret = usb_control_msg_send(hub_udev, 0, USB_REQ_CLEAR_FEATURE, 48 USB_RT_PORT, USB_PORT_FEAT_ENABLE, 49 portnum, NULL, 0, 1000, GFP_KERNEL); 50 /* 51 * Wait for the port to be disabled. It's an arbitrary value 52 * which worked every time. 53 */ 54 msleep(100); 55 } else { 56 /* 57 * For the hubs which are compliant with the spec, 58 * put the port in SUSPEND. 59 */ 60 ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE, 61 USB_RT_PORT, USB_PORT_FEAT_SUSPEND, 62 portnum, NULL, 0, 1000, GFP_KERNEL); 63 } 64 return ret; 65 } 66 ehset_probe(struct usb_interface * intf,const struct usb_device_id * id)67 static int ehset_probe(struct usb_interface *intf, 68 const struct usb_device_id *id) 69 { 70 int ret = -EINVAL; 71 struct usb_device *dev = interface_to_usbdev(intf); 72 struct usb_device *hub_udev = dev->parent; 73 struct usb_device_descriptor buf; 74 u8 portnum = dev->portnum; 75 u16 test_pid = le16_to_cpu(dev->descriptor.idProduct); 76 77 switch (test_pid) { 78 case TEST_SE0_NAK_PID: 79 ret = ehset_prepare_port_for_testing(hub_udev, portnum); 80 if (!ret) 81 break; 82 ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE, 83 USB_RT_PORT, USB_PORT_FEAT_TEST, 84 (USB_TEST_SE0_NAK << 8) | portnum, 85 NULL, 0, 1000, GFP_KERNEL); 86 break; 87 case TEST_J_PID: 88 ret = ehset_prepare_port_for_testing(hub_udev, portnum); 89 if (!ret) 90 break; 91 ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE, 92 USB_RT_PORT, USB_PORT_FEAT_TEST, 93 (USB_TEST_J << 8) | portnum, NULL, 0, 94 1000, GFP_KERNEL); 95 break; 96 case TEST_K_PID: 97 ret = ehset_prepare_port_for_testing(hub_udev, portnum); 98 if (!ret) 99 break; 100 ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE, 101 USB_RT_PORT, USB_PORT_FEAT_TEST, 102 (USB_TEST_K << 8) | portnum, NULL, 0, 103 1000, GFP_KERNEL); 104 break; 105 case TEST_PACKET_PID: 106 ret = ehset_prepare_port_for_testing(hub_udev, portnum); 107 if (!ret) 108 break; 109 ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE, 110 USB_RT_PORT, USB_PORT_FEAT_TEST, 111 (USB_TEST_PACKET << 8) | portnum, 112 NULL, 0, 1000, GFP_KERNEL); 113 break; 114 case TEST_HS_HOST_PORT_SUSPEND_RESUME: 115 /* Test: wait for 15secs -> suspend -> 15secs delay -> resume */ 116 msleep(15 * 1000); 117 ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE, 118 USB_RT_PORT, USB_PORT_FEAT_SUSPEND, 119 portnum, NULL, 0, 1000, GFP_KERNEL); 120 if (ret < 0) 121 break; 122 123 msleep(15 * 1000); 124 ret = usb_control_msg_send(hub_udev, 0, USB_REQ_CLEAR_FEATURE, 125 USB_RT_PORT, USB_PORT_FEAT_SUSPEND, 126 portnum, NULL, 0, 1000, GFP_KERNEL); 127 break; 128 case TEST_SINGLE_STEP_GET_DEV_DESC: 129 /* Test: wait for 15secs -> GetDescriptor request */ 130 msleep(15 * 1000); 131 132 ret = usb_control_msg_recv(dev, 0, USB_REQ_GET_DESCRIPTOR, 133 USB_DIR_IN, USB_DT_DEVICE << 8, 0, 134 &buf, USB_DT_DEVICE_SIZE, 135 USB_CTRL_GET_TIMEOUT, GFP_KERNEL); 136 break; 137 case TEST_SINGLE_STEP_SET_FEATURE: 138 /* 139 * GetDescriptor SETUP request -> 15secs delay -> IN & STATUS 140 * 141 * Note, this test is only supported on root hubs since the 142 * SetPortFeature handling can only be done inside the HCD's 143 * hub_control callback function. 144 */ 145 if (hub_udev != dev->bus->root_hub) { 146 dev_err(&intf->dev, "SINGLE_STEP_SET_FEATURE test only supported on root hub\n"); 147 break; 148 } 149 150 ret = usb_control_msg_send(hub_udev, 0, USB_REQ_SET_FEATURE, 151 USB_RT_PORT, USB_PORT_FEAT_TEST, 152 (6 << 8) | portnum, NULL, 0, 153 60 * 1000, GFP_KERNEL); 154 155 break; 156 default: 157 dev_err(&intf->dev, "%s: unsupported PID: 0x%x\n", 158 __func__, test_pid); 159 } 160 161 return ret; 162 } 163 ehset_disconnect(struct usb_interface * intf)164 static void ehset_disconnect(struct usb_interface *intf) 165 { 166 } 167 168 static const struct usb_device_id ehset_id_table[] = { 169 { USB_DEVICE(0x1a0a, TEST_SE0_NAK_PID) }, 170 { USB_DEVICE(0x1a0a, TEST_J_PID) }, 171 { USB_DEVICE(0x1a0a, TEST_K_PID) }, 172 { USB_DEVICE(0x1a0a, TEST_PACKET_PID) }, 173 { USB_DEVICE(0x1a0a, TEST_HS_HOST_PORT_SUSPEND_RESUME) }, 174 { USB_DEVICE(0x1a0a, TEST_SINGLE_STEP_GET_DEV_DESC) }, 175 { USB_DEVICE(0x1a0a, TEST_SINGLE_STEP_SET_FEATURE) }, 176 { } /* Terminating entry */ 177 }; 178 MODULE_DEVICE_TABLE(usb, ehset_id_table); 179 180 static struct usb_driver ehset_driver = { 181 .name = "usb_ehset_test", 182 .probe = ehset_probe, 183 .disconnect = ehset_disconnect, 184 .id_table = ehset_id_table, 185 }; 186 187 module_usb_driver(ehset_driver); 188 189 MODULE_DESCRIPTION("USB Driver for EHSET Test Fixture"); 190 MODULE_LICENSE("GPL v2"); 191