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