source: src/linux/universal/linux-3.18/drivers/usb/misc/lvstest.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 6 weeks ago

update

File size: 11.5 KB
Line 
1/*
2 * drivers/usb/misc/lvstest.c
3 *
4 * Test pattern generation for Link Layer Validation System Tests
5 *
6 * Copyright (C) 2014 ST Microelectronics
7 * Pratyush Anand <pratyush.anand@st.com>
8 *
9 * This file is licensed under the terms of the GNU General Public
10 * License version 2. This program is licensed "as is" without any
11 * warranty of any kind, whether express or implied.
12 */
13
14#include <linux/init.h>
15#include <linux/kernel.h>
16#include <linux/module.h>
17#include <linux/platform_device.h>
18#include <linux/slab.h>
19#include <linux/usb.h>
20#include <linux/usb/ch11.h>
21#include <linux/usb/hcd.h>
22#include <linux/usb/phy.h>
23
24struct lvs_rh {
25        /* root hub interface */
26        struct usb_interface *intf;
27        /* if lvs device connected */
28        bool present;
29        /* port no at which lvs device is present */
30        int portnum;
31        /* urb buffer */
32        u8 buffer[8];
33        /* class descriptor */
34        struct usb_hub_descriptor descriptor;
35        /* urb for polling interrupt pipe */
36        struct urb *urb;
37        /* LVS RH work queue */
38        struct workqueue_struct *rh_queue;
39        /* LVH RH work */
40        struct work_struct      rh_work;
41        /* RH port status */
42        struct usb_port_status port_status;
43};
44
45static struct usb_device *create_lvs_device(struct usb_interface *intf)
46{
47        struct usb_device *udev, *hdev;
48        struct usb_hcd *hcd;
49        struct lvs_rh *lvs = usb_get_intfdata(intf);
50
51        if (!lvs->present) {
52                dev_err(&intf->dev, "No LVS device is present\n");
53                return NULL;
54        }
55
56        hdev = interface_to_usbdev(intf);
57        hcd = bus_to_hcd(hdev->bus);
58
59        udev = usb_alloc_dev(hdev, hdev->bus, lvs->portnum);
60        if (!udev) {
61                dev_err(&intf->dev, "Could not allocate lvs udev\n");
62                return NULL;
63        }
64        udev->speed = USB_SPEED_SUPER;
65        udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
66        usb_set_device_state(udev, USB_STATE_DEFAULT);
67
68        if (hcd->driver->enable_device) {
69                if (hcd->driver->enable_device(hcd, udev) < 0) {
70                        dev_err(&intf->dev, "Failed to enable\n");
71                        usb_put_dev(udev);
72                        return NULL;
73                }
74        }
75
76        return udev;
77}
78
79static void destroy_lvs_device(struct usb_device *udev)
80{
81        struct usb_device *hdev = udev->parent;
82        struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
83
84        if (hcd->driver->free_dev)
85                hcd->driver->free_dev(hcd, udev);
86
87        usb_put_dev(udev);
88}
89
90static int lvs_rh_clear_port_feature(struct usb_device *hdev,
91                int port1, int feature)
92{
93        return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
94                USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
95                NULL, 0, 1000);
96}
97
98static int lvs_rh_set_port_feature(struct usb_device *hdev,
99                int port1, int feature)
100{
101        return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
102                USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
103                NULL, 0, 1000);
104}
105
106static ssize_t u3_entry_store(struct device *dev,
107                struct device_attribute *attr, const char *buf, size_t count)
108{
109        struct usb_interface *intf = to_usb_interface(dev);
110        struct usb_device *hdev = interface_to_usbdev(intf);
111        struct lvs_rh *lvs = usb_get_intfdata(intf);
112        struct usb_device *udev;
113        int ret;
114
115        udev = create_lvs_device(intf);
116        if (!udev) {
117                dev_err(dev, "failed to create lvs device\n");
118                return -ENOMEM;
119        }
120
121        ret = lvs_rh_set_port_feature(hdev, lvs->portnum,
122                        USB_PORT_FEAT_SUSPEND);
123        if (ret < 0)
124                dev_err(dev, "can't issue U3 entry %d\n", ret);
125
126        destroy_lvs_device(udev);
127
128        if (ret < 0)
129                return ret;
130
131        return count;
132}
133static DEVICE_ATTR_WO(u3_entry);
134
135static ssize_t u3_exit_store(struct device *dev,
136                struct device_attribute *attr, const char *buf, size_t count)
137{
138        struct usb_interface *intf = to_usb_interface(dev);
139        struct usb_device *hdev = interface_to_usbdev(intf);
140        struct lvs_rh *lvs = usb_get_intfdata(intf);
141        struct usb_device *udev;
142        int ret;
143
144        udev = create_lvs_device(intf);
145        if (!udev) {
146                dev_err(dev, "failed to create lvs device\n");
147                return -ENOMEM;
148        }
149
150        ret = lvs_rh_clear_port_feature(hdev, lvs->portnum,
151                        USB_PORT_FEAT_SUSPEND);
152        if (ret < 0)
153                dev_err(dev, "can't issue U3 exit %d\n", ret);
154
155        destroy_lvs_device(udev);
156
157        if (ret < 0)
158                return ret;
159
160        return count;
161}
162static DEVICE_ATTR_WO(u3_exit);
163
164static ssize_t hot_reset_store(struct device *dev,
165                struct device_attribute *attr, const char *buf, size_t count)
166{
167        struct usb_interface *intf = to_usb_interface(dev);
168        struct usb_device *hdev = interface_to_usbdev(intf);
169        struct lvs_rh *lvs = usb_get_intfdata(intf);
170        int ret;
171
172        ret = lvs_rh_set_port_feature(hdev, lvs->portnum,
173                        USB_PORT_FEAT_RESET);
174        if (ret < 0) {
175                dev_err(dev, "can't issue hot reset %d\n", ret);
176                return ret;
177        }
178
179        return count;
180}
181static DEVICE_ATTR_WO(hot_reset);
182
183static ssize_t u2_timeout_store(struct device *dev,
184                struct device_attribute *attr, const char *buf, size_t count)
185{
186        struct usb_interface *intf = to_usb_interface(dev);
187        struct usb_device *hdev = interface_to_usbdev(intf);
188        struct lvs_rh *lvs = usb_get_intfdata(intf);
189        unsigned long val;
190        int ret;
191
192        ret = kstrtoul(buf, 10, &val);
193        if (ret < 0) {
194                dev_err(dev, "couldn't parse string %d\n", ret);
195                return ret;
196        }
197
198        if (val < 0 || val > 127)
199                return -EINVAL;
200
201        ret = lvs_rh_set_port_feature(hdev, lvs->portnum | (val << 8),
202                        USB_PORT_FEAT_U2_TIMEOUT);
203        if (ret < 0) {
204                dev_err(dev, "Error %d while setting U2 timeout %ld\n", ret, val);
205                return ret;
206        }
207
208        return count;
209}
210static DEVICE_ATTR_WO(u2_timeout);
211
212static ssize_t u1_timeout_store(struct device *dev,
213                struct device_attribute *attr, const char *buf, size_t count)
214{
215        struct usb_interface *intf = to_usb_interface(dev);
216        struct usb_device *hdev = interface_to_usbdev(intf);
217        struct lvs_rh *lvs = usb_get_intfdata(intf);
218        unsigned long val;
219        int ret;
220
221        ret = kstrtoul(buf, 10, &val);
222        if (ret < 0) {
223                dev_err(dev, "couldn't parse string %d\n", ret);
224                return ret;
225        }
226
227        if (val < 0 || val > 127)
228                return -EINVAL;
229
230        ret = lvs_rh_set_port_feature(hdev, lvs->portnum | (val << 8),
231                        USB_PORT_FEAT_U1_TIMEOUT);
232        if (ret < 0) {
233                dev_err(dev, "Error %d while setting U1 timeout %ld\n", ret, val);
234                return ret;
235        }
236
237        return count;
238}
239static DEVICE_ATTR_WO(u1_timeout);
240
241static ssize_t get_dev_desc_store(struct device *dev,
242                struct device_attribute *attr, const char *buf, size_t count)
243{
244        struct usb_interface *intf = to_usb_interface(dev);
245        struct usb_device *udev;
246        struct usb_device_descriptor *descriptor;
247        int ret;
248
249        descriptor = kmalloc(sizeof(*descriptor), GFP_KERNEL);
250        if (!descriptor) {
251                dev_err(dev, "failed to allocate descriptor memory\n");
252                return -ENOMEM;
253        }
254
255        udev = create_lvs_device(intf);
256        if (!udev) {
257                dev_err(dev, "failed to create lvs device\n");
258                ret = -ENOMEM;
259                goto free_desc;
260        }
261
262        ret = usb_control_msg(udev, (PIPE_CONTROL << 30) | USB_DIR_IN,
263                        USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, USB_DT_DEVICE << 8,
264                        0, descriptor, sizeof(*descriptor),
265                        USB_CTRL_GET_TIMEOUT);
266        if (ret < 0)
267                dev_err(dev, "can't read device descriptor %d\n", ret);
268
269        destroy_lvs_device(udev);
270
271free_desc:
272        kfree(descriptor);
273
274        if (ret < 0)
275                return ret;
276
277        return count;
278}
279static DEVICE_ATTR_WO(get_dev_desc);
280
281static struct attribute *lvs_attributes[] = {
282        &dev_attr_get_dev_desc.attr,
283        &dev_attr_u1_timeout.attr,
284        &dev_attr_u2_timeout.attr,
285        &dev_attr_hot_reset.attr,
286        &dev_attr_u3_entry.attr,
287        &dev_attr_u3_exit.attr,
288        NULL
289};
290
291static const struct attribute_group lvs_attr_group = {
292        .attrs = lvs_attributes,
293};
294
295static void lvs_rh_work(struct work_struct *work)
296{
297        struct lvs_rh *lvs = container_of(work, struct lvs_rh, rh_work);
298        struct usb_interface *intf = lvs->intf;
299        struct usb_device *hdev = interface_to_usbdev(intf);
300        struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
301        struct usb_hub_descriptor *descriptor = &lvs->descriptor;
302        struct usb_port_status *port_status = &lvs->port_status;
303        int i, ret = 0;
304        u16 portchange;
305
306        /* Examine each root port */
307        for (i = 1; i <= descriptor->bNbrPorts; i++) {
308                ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
309                        USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, i,
310                        port_status, sizeof(*port_status), 1000);
311                if (ret < 4)
312                        continue;
313
314                portchange = le16_to_cpu(port_status->wPortChange);
315
316                if (portchange & USB_PORT_STAT_C_LINK_STATE)
317                        lvs_rh_clear_port_feature(hdev, i,
318                                        USB_PORT_FEAT_C_PORT_LINK_STATE);
319                if (portchange & USB_PORT_STAT_C_ENABLE)
320                        lvs_rh_clear_port_feature(hdev, i,
321                                        USB_PORT_FEAT_C_ENABLE);
322                if (portchange & USB_PORT_STAT_C_RESET)
323                        lvs_rh_clear_port_feature(hdev, i,
324                                        USB_PORT_FEAT_C_RESET);
325                if (portchange & USB_PORT_STAT_C_BH_RESET)
326                        lvs_rh_clear_port_feature(hdev, i,
327                                        USB_PORT_FEAT_C_BH_PORT_RESET);
328                if (portchange & USB_PORT_STAT_C_CONNECTION) {
329                        lvs_rh_clear_port_feature(hdev, i,
330                                        USB_PORT_FEAT_C_CONNECTION);
331
332                        if (le16_to_cpu(port_status->wPortStatus) &
333                                        USB_PORT_STAT_CONNECTION) {
334                                lvs->present = true;
335                                lvs->portnum = i;
336                                if (hcd->usb_phy)
337                                        usb_phy_notify_connect(hcd->usb_phy,
338                                                        USB_SPEED_SUPER);
339                        } else {
340                                lvs->present = false;
341                                if (hcd->usb_phy)
342                                        usb_phy_notify_disconnect(hcd->usb_phy,
343                                                        USB_SPEED_SUPER);
344                        }
345                        break;
346                }
347        }
348
349        ret = usb_submit_urb(lvs->urb, GFP_KERNEL);
350        if (ret != 0 && ret != -ENODEV && ret != -EPERM)
351                dev_err(&intf->dev, "urb resubmit error %d\n", ret);
352}
353
354static void lvs_rh_irq(struct urb *urb)
355{
356        struct lvs_rh *lvs = urb->context;
357
358        queue_work(lvs->rh_queue, &lvs->rh_work);
359}
360
361static int lvs_rh_probe(struct usb_interface *intf,
362                const struct usb_device_id *id)
363{
364        struct usb_device *hdev;
365        struct usb_host_interface *desc;
366        struct usb_endpoint_descriptor *endpoint;
367        struct lvs_rh *lvs;
368        unsigned int pipe;
369        int ret, maxp;
370
371        hdev = interface_to_usbdev(intf);
372        desc = intf->cur_altsetting;
373
374        if (desc->desc.bNumEndpoints < 1)
375                return -ENODEV;
376
377        endpoint = &desc->endpoint[0].desc;
378
379        /* valid only for SS root hub */
380        if (hdev->descriptor.bDeviceProtocol != USB_HUB_PR_SS || hdev->parent) {
381                dev_err(&intf->dev, "Bind LVS driver with SS root Hub only\n");
382                return -EINVAL;
383        }
384
385        lvs = devm_kzalloc(&intf->dev, sizeof(*lvs), GFP_KERNEL);
386        if (!lvs)
387                return -ENOMEM;
388
389        lvs->intf = intf;
390        usb_set_intfdata(intf, lvs);
391
392        /* how many number of ports this root hub has */
393        ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
394                        USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
395                        USB_DT_SS_HUB << 8, 0, &lvs->descriptor,
396                        USB_DT_SS_HUB_SIZE, USB_CTRL_GET_TIMEOUT);
397        if (ret < (USB_DT_HUB_NONVAR_SIZE + 2)) {
398                dev_err(&hdev->dev, "wrong root hub descriptor read %d\n", ret);
399                return ret;
400        }
401
402        /* submit urb to poll interrupt endpoint */
403        lvs->urb = usb_alloc_urb(0, GFP_KERNEL);
404        if (!lvs->urb) {
405                dev_err(&intf->dev, "couldn't allocate lvs urb\n");
406                return -ENOMEM;
407        }
408
409        lvs->rh_queue = create_singlethread_workqueue("lvs_rh_queue");
410        if (!lvs->rh_queue) {
411                dev_err(&intf->dev, "couldn't create workqueue\n");
412                ret = -ENOMEM;
413                goto free_urb;
414        }
415
416        INIT_WORK(&lvs->rh_work, lvs_rh_work);
417
418        ret = sysfs_create_group(&intf->dev.kobj, &lvs_attr_group);
419        if (ret < 0) {
420                dev_err(&intf->dev, "Failed to create sysfs node %d\n", ret);
421                goto destroy_queue;
422        }
423
424        pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
425        maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
426        usb_fill_int_urb(lvs->urb, hdev, pipe, &lvs->buffer[0], maxp,
427                        lvs_rh_irq, lvs, endpoint->bInterval);
428
429        ret = usb_submit_urb(lvs->urb, GFP_KERNEL);
430        if (ret < 0) {
431                dev_err(&intf->dev, "couldn't submit lvs urb %d\n", ret);
432                goto sysfs_remove;
433        }
434
435        return ret;
436
437sysfs_remove:
438        sysfs_remove_group(&intf->dev.kobj, &lvs_attr_group);
439destroy_queue:
440        destroy_workqueue(lvs->rh_queue);
441free_urb:
442        usb_free_urb(lvs->urb);
443        return ret;
444}
445
446static void lvs_rh_disconnect(struct usb_interface *intf)
447{
448        struct lvs_rh *lvs = usb_get_intfdata(intf);
449
450        sysfs_remove_group(&intf->dev.kobj, &lvs_attr_group);
451        destroy_workqueue(lvs->rh_queue);
452        usb_free_urb(lvs->urb);
453}
454
455static struct usb_driver lvs_driver = {
456        .name =         "lvs",
457        .probe =        lvs_rh_probe,
458        .disconnect =   lvs_rh_disconnect,
459};
460
461module_usb_driver(lvs_driver);
462
463MODULE_DESCRIPTION("Link Layer Validation System Driver");
464MODULE_LICENSE("GPL");
Note: See TracBrowser for help on using the repository browser.