Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/usb/misc/ehset.c

  1 /*
  2  * Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
  3  *
  4  * This program is free software; you can redistribute it and/or modify
  5  * it under the terms of the GNU General Public License version 2 and
  6  * only version 2 as published by the Free Software Foundation.
  7  *
  8  * This program is distributed in the hope that it will be useful,
  9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11  * GNU General Public License for more details.
 12  */
 13 
 14 #include <linux/kernel.h>
 15 #include <linux/errno.h>
 16 #include <linux/module.h>
 17 #include <linux/slab.h>
 18 #include <linux/usb.h>
 19 #include <linux/usb/ch11.h>
 20 
 21 #define TEST_SE0_NAK_PID                        0x0101
 22 #define TEST_J_PID                              0x0102
 23 #define TEST_K_PID                              0x0103
 24 #define TEST_PACKET_PID                         0x0104
 25 #define TEST_HS_HOST_PORT_SUSPEND_RESUME        0x0106
 26 #define TEST_SINGLE_STEP_GET_DEV_DESC           0x0107
 27 #define TEST_SINGLE_STEP_SET_FEATURE            0x0108
 28 
 29 static int ehset_probe(struct usb_interface *intf,
 30                        const struct usb_device_id *id)
 31 {
 32         int ret = -EINVAL;
 33         struct usb_device *dev = interface_to_usbdev(intf);
 34         struct usb_device *hub_udev = dev->parent;
 35         struct usb_device_descriptor *buf;
 36         u8 portnum = dev->portnum;
 37         u16 test_pid = le16_to_cpu(dev->descriptor.idProduct);
 38 
 39         switch (test_pid) {
 40         case TEST_SE0_NAK_PID:
 41                 ret = usb_control_msg(hub_udev, usb_sndctrlpipe(hub_udev, 0),
 42                                         USB_REQ_SET_FEATURE, USB_RT_PORT,
 43                                         USB_PORT_FEAT_TEST,
 44                                         (TEST_SE0_NAK << 8) | portnum,
 45                                         NULL, 0, 1000);
 46                 break;
 47         case TEST_J_PID:
 48                 ret = usb_control_msg(hub_udev, usb_sndctrlpipe(hub_udev, 0),
 49                                         USB_REQ_SET_FEATURE, USB_RT_PORT,
 50                                         USB_PORT_FEAT_TEST,
 51                                         (TEST_J << 8) | portnum,
 52                                         NULL, 0, 1000);
 53                 break;
 54         case TEST_K_PID:
 55                 ret = usb_control_msg(hub_udev, usb_sndctrlpipe(hub_udev, 0),
 56                                         USB_REQ_SET_FEATURE, USB_RT_PORT,
 57                                         USB_PORT_FEAT_TEST,
 58                                         (TEST_K << 8) | portnum,
 59                                         NULL, 0, 1000);
 60                 break;
 61         case TEST_PACKET_PID:
 62                 ret = usb_control_msg(hub_udev, usb_sndctrlpipe(hub_udev, 0),
 63                                         USB_REQ_SET_FEATURE, USB_RT_PORT,
 64                                         USB_PORT_FEAT_TEST,
 65                                         (TEST_PACKET << 8) | portnum,
 66                                         NULL, 0, 1000);
 67                 break;
 68         case TEST_HS_HOST_PORT_SUSPEND_RESUME:
 69                 /* Test: wait for 15secs -> suspend -> 15secs delay -> resume */
 70                 msleep(15 * 1000);
 71                 ret = usb_control_msg(hub_udev, usb_sndctrlpipe(hub_udev, 0),
 72                                         USB_REQ_SET_FEATURE, USB_RT_PORT,
 73                                         USB_PORT_FEAT_SUSPEND, portnum,
 74                                         NULL, 0, 1000);
 75                 if (ret < 0)
 76                         break;
 77 
 78                 msleep(15 * 1000);
 79                 ret = usb_control_msg(hub_udev, usb_sndctrlpipe(hub_udev, 0),
 80                                         USB_REQ_CLEAR_FEATURE, USB_RT_PORT,
 81                                         USB_PORT_FEAT_SUSPEND, portnum,
 82                                         NULL, 0, 1000);
 83                 break;
 84         case TEST_SINGLE_STEP_GET_DEV_DESC:
 85                 /* Test: wait for 15secs -> GetDescriptor request */
 86                 msleep(15 * 1000);
 87                 buf = kmalloc(USB_DT_DEVICE_SIZE, GFP_KERNEL);
 88                 if (!buf)
 89                         return -ENOMEM;
 90 
 91                 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 92                                         USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
 93                                         USB_DT_DEVICE << 8, 0,
 94                                         buf, USB_DT_DEVICE_SIZE,
 95                                         USB_CTRL_GET_TIMEOUT);
 96                 kfree(buf);
 97                 break;
 98         case TEST_SINGLE_STEP_SET_FEATURE:
 99                 /*
100                  * GetDescriptor SETUP request -> 15secs delay -> IN & STATUS
101                  *
102                  * Note, this test is only supported on root hubs since the
103                  * SetPortFeature handling can only be done inside the HCD's
104                  * hub_control callback function.
105                  */
106                 if (hub_udev != dev->bus->root_hub) {
107                         dev_err(&intf->dev, "SINGLE_STEP_SET_FEATURE test only supported on root hub\n");
108                         break;
109                 }
110 
111                 ret = usb_control_msg(hub_udev, usb_sndctrlpipe(hub_udev, 0),
112                                         USB_REQ_SET_FEATURE, USB_RT_PORT,
113                                         USB_PORT_FEAT_TEST,
114                                         (6 << 8) | portnum,
115                                         NULL, 0, 60 * 1000);
116 
117                 break;
118         default:
119                 dev_err(&intf->dev, "%s: unsupported PID: 0x%x\n",
120                         __func__, test_pid);
121         }
122 
123         return (ret < 0) ? ret : 0;
124 }
125 
126 static void ehset_disconnect(struct usb_interface *intf)
127 {
128 }
129 
130 static const struct usb_device_id ehset_id_table[] = {
131         { USB_DEVICE(0x1a0a, TEST_SE0_NAK_PID) },
132         { USB_DEVICE(0x1a0a, TEST_J_PID) },
133         { USB_DEVICE(0x1a0a, TEST_K_PID) },
134         { USB_DEVICE(0x1a0a, TEST_PACKET_PID) },
135         { USB_DEVICE(0x1a0a, TEST_HS_HOST_PORT_SUSPEND_RESUME) },
136         { USB_DEVICE(0x1a0a, TEST_SINGLE_STEP_GET_DEV_DESC) },
137         { USB_DEVICE(0x1a0a, TEST_SINGLE_STEP_SET_FEATURE) },
138         { }                     /* Terminating entry */
139 };
140 MODULE_DEVICE_TABLE(usb, ehset_id_table);
141 
142 static struct usb_driver ehset_driver = {
143         .name =         "usb_ehset_test",
144         .probe =        ehset_probe,
145         .disconnect =   ehset_disconnect,
146         .id_table =     ehset_id_table,
147 };
148 
149 module_usb_driver(ehset_driver);
150 
151 MODULE_DESCRIPTION("USB Driver for EHSET Test Fixture");
152 MODULE_LICENSE("GPL v2");
153 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us