[mirror_ubuntu-zesty-kernel.git] / drivers / usb / misc / lvstest.c

/*
 * drivers/usb/misc/lvstest.c
 *
 * Test pattern generation for Link Layer Validation System Tests
 *
 * Copyright (C) 2014 ST Microelectronics
 * Pratyush Anand <pratyush.anand@gmail.com>
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2. This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/usb.h>
#include <linux/usb/ch11.h>
#include <linux/usb/hcd.h>
#include <linux/usb/phy.h>

struct lvs_rh {
	/* root hub interface */
	struct usb_interface *intf;
	/* if lvs device connected */
	bool present;
	/* port no at which lvs device is present */
	int portnum;
	/* urb buffer */
	u8 buffer[8];
	/* class descriptor */
	struct usb_hub_descriptor descriptor;
	/* urb for polling interrupt pipe */
	struct urb *urb;
	/* LVH RH work */
	struct work_struct	rh_work;
	/* RH port status */
	struct usb_port_status port_status;
};

static struct usb_device *create_lvs_device(struct usb_interface *intf)
{
	struct usb_device *udev, *hdev;
	struct usb_hcd *hcd;
	struct lvs_rh *lvs = usb_get_intfdata(intf);

	if (!lvs->present) {
		dev_err(&intf->dev, "No LVS device is present\n");
		return NULL;
	}

	hdev = interface_to_usbdev(intf);
	hcd = bus_to_hcd(hdev->bus);

	udev = usb_alloc_dev(hdev, hdev->bus, lvs->portnum);
	if (!udev) {
		dev_err(&intf->dev, "Could not allocate lvs udev\n");
		return NULL;
	}
	udev->speed = USB_SPEED_SUPER;
	udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
	usb_set_device_state(udev, USB_STATE_DEFAULT);

	if (hcd->driver->enable_device) {
		if (hcd->driver->enable_device(hcd, udev) < 0) {
			dev_err(&intf->dev, "Failed to enable\n");
			usb_put_dev(udev);
			return NULL;
		}
	}

	return udev;
}

static void destroy_lvs_device(struct usb_device *udev)
{
	struct usb_device *hdev = udev->parent;
	struct usb_hcd *hcd = bus_to_hcd(hdev->bus);

	if (hcd->driver->free_dev)
		hcd->driver->free_dev(hcd, udev);

	usb_put_dev(udev);
}

static int lvs_rh_clear_port_feature(struct usb_device *hdev,
		int port1, int feature)
{
	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
		USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
		NULL, 0, 1000);
}

static int lvs_rh_set_port_feature(struct usb_device *hdev,
		int port1, int feature)
{
	return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
		USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
		NULL, 0, 1000);
}

static ssize_t u3_entry_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_device *hdev = interface_to_usbdev(intf);
	struct lvs_rh *lvs = usb_get_intfdata(intf);
	struct usb_device *udev;
	int ret;

	udev = create_lvs_device(intf);
	if (!udev) {
		dev_err(dev, "failed to create lvs device\n");
		return -ENOMEM;
	}

	ret = lvs_rh_set_port_feature(hdev, lvs->portnum,
			USB_PORT_FEAT_SUSPEND);
	if (ret < 0)
		dev_err(dev, "can't issue U3 entry %d\n", ret);

	destroy_lvs_device(udev);

	if (ret < 0)
		return ret;

	return count;
}
static DEVICE_ATTR_WO(u3_entry);

static ssize_t u3_exit_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_device *hdev = interface_to_usbdev(intf);
	struct lvs_rh *lvs = usb_get_intfdata(intf);
	struct usb_device *udev;
	int ret;

	udev = create_lvs_device(intf);
	if (!udev) {
		dev_err(dev, "failed to create lvs device\n");
		return -ENOMEM;
	}

	ret = lvs_rh_clear_port_feature(hdev, lvs->portnum,
			USB_PORT_FEAT_SUSPEND);
	if (ret < 0)
		dev_err(dev, "can't issue U3 exit %d\n", ret);

	destroy_lvs_device(udev);

	if (ret < 0)
		return ret;

	return count;
}
static DEVICE_ATTR_WO(u3_exit);

static ssize_t hot_reset_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_device *hdev = interface_to_usbdev(intf);
	struct lvs_rh *lvs = usb_get_intfdata(intf);
	int ret;

	ret = lvs_rh_set_port_feature(hdev, lvs->portnum,
			USB_PORT_FEAT_RESET);
	if (ret < 0) {
		dev_err(dev, "can't issue hot reset %d\n", ret);
		return ret;
	}

	return count;
}
static DEVICE_ATTR_WO(hot_reset);

static ssize_t u2_timeout_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_device *hdev = interface_to_usbdev(intf);
	struct lvs_rh *lvs = usb_get_intfdata(intf);
	unsigned long val;
	int ret;

	ret = kstrtoul(buf, 10, &val);
	if (ret < 0) {
		dev_err(dev, "couldn't parse string %d\n", ret);
		return ret;
	}

	if (val < 0 || val > 127)
		return -EINVAL;

	ret = lvs_rh_set_port_feature(hdev, lvs->portnum | (val << 8),
			USB_PORT_FEAT_U2_TIMEOUT);
	if (ret < 0) {
		dev_err(dev, "Error %d while setting U2 timeout %ld\n", ret, val);
		return ret;
	}

	return count;
}
static DEVICE_ATTR_WO(u2_timeout);

static ssize_t u1_timeout_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_device *hdev = interface_to_usbdev(intf);
	struct lvs_rh *lvs = usb_get_intfdata(intf);
	unsigned long val;
	int ret;

	ret = kstrtoul(buf, 10, &val);
	if (ret < 0) {
		dev_err(dev, "couldn't parse string %d\n", ret);
		return ret;
	}

	if (val < 0 || val > 127)
		return -EINVAL;

	ret = lvs_rh_set_port_feature(hdev, lvs->portnum | (val << 8),
			USB_PORT_FEAT_U1_TIMEOUT);
	if (ret < 0) {
		dev_err(dev, "Error %d while setting U1 timeout %ld\n", ret, val);
		return ret;
	}

	return count;
}
static DEVICE_ATTR_WO(u1_timeout);

static ssize_t get_dev_desc_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct usb_interface *intf = to_usb_interface(dev);
	struct usb_device *udev;
	struct usb_device_descriptor *descriptor;
	int ret;

	descriptor = kmalloc(sizeof(*descriptor), GFP_KERNEL);
	if (!descriptor)
		return -ENOMEM;

	udev = create_lvs_device(intf);
	if (!udev) {
		dev_err(dev, "failed to create lvs device\n");
		ret = -ENOMEM;
		goto free_desc;
	}

	ret = usb_control_msg(udev, (PIPE_CONTROL << 30) | USB_DIR_IN,
			USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, USB_DT_DEVICE << 8,
			0, descriptor, sizeof(*descriptor),
			USB_CTRL_GET_TIMEOUT);
	if (ret < 0)
		dev_err(dev, "can't read device descriptor %d\n", ret);

	destroy_lvs_device(udev);

free_desc:
	kfree(descriptor);

	if (ret < 0)
		return ret;

	return count;
}
static DEVICE_ATTR_WO(get_dev_desc);

static struct attribute *lvs_attributes[] = {
	&dev_attr_get_dev_desc.attr,
	&dev_attr_u1_timeout.attr,
	&dev_attr_u2_timeout.attr,
	&dev_attr_hot_reset.attr,
	&dev_attr_u3_entry.attr,
	&dev_attr_u3_exit.attr,
	NULL
};

static const struct attribute_group lvs_attr_group = {
	.attrs = lvs_attributes,
};

static void lvs_rh_work(struct work_struct *work)
{
	struct lvs_rh *lvs = container_of(work, struct lvs_rh, rh_work);
	struct usb_interface *intf = lvs->intf;
	struct usb_device *hdev = interface_to_usbdev(intf);
	struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
	struct usb_hub_descriptor *descriptor = &lvs->descriptor;
	struct usb_port_status *port_status = &lvs->port_status;
	int i, ret = 0;
	u16 portchange;

	/* Examine each root port */
	for (i = 1; i <= descriptor->bNbrPorts; i++) {
		ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
			USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, i,
			port_status, sizeof(*port_status), 1000);
		if (ret < 4)
			continue;

		portchange = le16_to_cpu(port_status->wPortChange);

		if (portchange & USB_PORT_STAT_C_LINK_STATE)
			lvs_rh_clear_port_feature(hdev, i,
					USB_PORT_FEAT_C_PORT_LINK_STATE);
		if (portchange & USB_PORT_STAT_C_ENABLE)
			lvs_rh_clear_port_feature(hdev, i,
					USB_PORT_FEAT_C_ENABLE);
		if (portchange & USB_PORT_STAT_C_RESET)
			lvs_rh_clear_port_feature(hdev, i,
					USB_PORT_FEAT_C_RESET);
		if (portchange & USB_PORT_STAT_C_BH_RESET)
			lvs_rh_clear_port_feature(hdev, i,
					USB_PORT_FEAT_C_BH_PORT_RESET);
		if (portchange & USB_PORT_STAT_C_CONNECTION) {
			lvs_rh_clear_port_feature(hdev, i,
					USB_PORT_FEAT_C_CONNECTION);

			if (le16_to_cpu(port_status->wPortStatus) &
					USB_PORT_STAT_CONNECTION) {
				lvs->present = true;
				lvs->portnum = i;
				if (hcd->usb_phy)
					usb_phy_notify_connect(hcd->usb_phy,
							USB_SPEED_SUPER);
			} else {
				lvs->present = false;
				if (hcd->usb_phy)
					usb_phy_notify_disconnect(hcd->usb_phy,
							USB_SPEED_SUPER);
			}
			break;
		}
	}

	ret = usb_submit_urb(lvs->urb, GFP_KERNEL);
	if (ret != 0 && ret != -ENODEV && ret != -EPERM)
		dev_err(&intf->dev, "urb resubmit error %d\n", ret);
}

static void lvs_rh_irq(struct urb *urb)
{
	struct lvs_rh *lvs = urb->context;

	schedule_work(&lvs->rh_work);
}

static int lvs_rh_probe(struct usb_interface *intf,
		const struct usb_device_id *id)
{
	struct usb_device *hdev;
	struct usb_host_interface *desc;
	struct usb_endpoint_descriptor *endpoint;
	struct lvs_rh *lvs;
	unsigned int pipe;
	int ret, maxp;

	hdev = interface_to_usbdev(intf);
	desc = intf->cur_altsetting;
	endpoint = &desc->endpoint[0].desc;

	/* valid only for SS root hub */
	if (hdev->descriptor.bDeviceProtocol != USB_HUB_PR_SS || hdev->parent) {
		dev_err(&intf->dev, "Bind LVS driver with SS root Hub only\n");
		return -EINVAL;
	}

	lvs = devm_kzalloc(&intf->dev, sizeof(*lvs), GFP_KERNEL);
	if (!lvs)
		return -ENOMEM;

	lvs->intf = intf;
	usb_set_intfdata(intf, lvs);

	/* how many number of ports this root hub has */
	ret = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
			USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
			USB_DT_SS_HUB << 8, 0, &lvs->descriptor,
			USB_DT_SS_HUB_SIZE, USB_CTRL_GET_TIMEOUT);
	if (ret < (USB_DT_HUB_NONVAR_SIZE + 2)) {
		dev_err(&hdev->dev, "wrong root hub descriptor read %d\n", ret);
		return ret;
	}

	/* submit urb to poll interrupt endpoint */
	lvs->urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!lvs->urb)
		return -ENOMEM;

	INIT_WORK(&lvs->rh_work, lvs_rh_work);

	ret = sysfs_create_group(&intf->dev.kobj, &lvs_attr_group);
	if (ret < 0) {
		dev_err(&intf->dev, "Failed to create sysfs node %d\n", ret);
		goto free_urb;
	}

	pipe = usb_rcvintpipe(hdev, endpoint->bEndpointAddress);
	maxp = usb_maxpacket(hdev, pipe, usb_pipeout(pipe));
	usb_fill_int_urb(lvs->urb, hdev, pipe, &lvs->buffer[0], maxp,
			lvs_rh_irq, lvs, endpoint->bInterval);

	ret = usb_submit_urb(lvs->urb, GFP_KERNEL);
	if (ret < 0) {
		dev_err(&intf->dev, "couldn't submit lvs urb %d\n", ret);
		goto sysfs_remove;
	}

	return ret;

sysfs_remove:
	sysfs_remove_group(&intf->dev.kobj, &lvs_attr_group);
free_urb:
	usb_free_urb(lvs->urb);
	return ret;
}

static void lvs_rh_disconnect(struct usb_interface *intf)
{
	struct lvs_rh *lvs = usb_get_intfdata(intf);

	sysfs_remove_group(&intf->dev.kobj, &lvs_attr_group);
	flush_work(&lvs->rh_work);
	usb_free_urb(lvs->urb);
}

static struct usb_driver lvs_driver = {
	.name =		"lvs",
	.probe =	lvs_rh_probe,
	.disconnect =	lvs_rh_disconnect,
};

module_usb_driver(lvs_driver);

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