[deliverable/linux.git] / drivers / usb / usbip / vudc_dev.c

/*
 * Copyright (C) 2015 Karol Kosik <karo9@interia.eu>
 * Copyright (C) 2015-2016 Samsung Electronics
 *               Igor Kotrasinski <i.kotrasinsk@samsung.com>
 *               Krzysztof Opasiak <k.opasiak@samsung.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/platform_device.h>
#include <linux/usb.h>
#include <linux/usb/gadget.h>
#include <linux/usb/hcd.h>
#include <linux/kthread.h>
#include <linux/file.h>
#include <linux/byteorder/generic.h>

#include "usbip_common.h"
#include "vudc.h"

#define VIRTUAL_ENDPOINTS (1 /* ep0 */ + 15 /* in eps */ + 15 /* out eps */)

/* urb-related structures alloc / free */


static void free_urb(struct urb *urb)
{
	if (!urb)
		return;

	kfree(urb->setup_packet);
	urb->setup_packet = NULL;

	kfree(urb->transfer_buffer);
	urb->transfer_buffer = NULL;

	usb_free_urb(urb);
}

struct urbp *alloc_urbp(void)
{
	struct urbp *urb_p;

	urb_p = kzalloc(sizeof(*urb_p), GFP_KERNEL);
	if (!urb_p)
		return urb_p;

	urb_p->urb = NULL;
	urb_p->ep = NULL;
	INIT_LIST_HEAD(&urb_p->urb_entry);
	return urb_p;
}

static void free_urbp(struct urbp *urb_p)
{
	kfree(urb_p);
}

void free_urbp_and_urb(struct urbp *urb_p)
{
	if (!urb_p)
		return;
	free_urb(urb_p->urb);
	free_urbp(urb_p);
}


/* utilities ; almost verbatim from dummy_hcd.c */

/* called with spinlock held */
static void nuke(struct vudc *udc, struct vep *ep)
{
	struct vrequest	*req;

	while (!list_empty(&ep->req_queue)) {
		req = list_first_entry(&ep->req_queue, struct vrequest,
				       req_entry);
		list_del_init(&req->req_entry);
		req->req.status = -ESHUTDOWN;

		spin_unlock(&udc->lock);
		usb_gadget_giveback_request(&ep->ep, &req->req);
		spin_lock(&udc->lock);
	}
}

/* caller must hold lock */
static void stop_activity(struct vudc *udc)
{
	int i;
	struct urbp *urb_p, *tmp;

	udc->address = 0;

	for (i = 0; i < VIRTUAL_ENDPOINTS; i++)
		nuke(udc, &udc->ep[i]);

	list_for_each_entry_safe(urb_p, tmp, &udc->urb_queue, urb_entry) {
		list_del(&urb_p->urb_entry);
		free_urbp_and_urb(urb_p);
	}
}

struct vep *vudc_find_endpoint(struct vudc *udc, u8 address)
{
	int i;

	if ((address & ~USB_DIR_IN) == 0)
		return &udc->ep[0];

	for (i = 1; i < VIRTUAL_ENDPOINTS; i++) {
		struct vep *ep = &udc->ep[i];

		if (!ep->desc)
			continue;
		if (ep->desc->bEndpointAddress == address)
			return ep;
	}
	return NULL;
}

/* gadget ops */

/* FIXME - this will probably misbehave when suspend/resume is added */
static int vgadget_get_frame(struct usb_gadget *_gadget)
{
	struct timeval now;
	struct vudc *udc = usb_gadget_to_vudc(_gadget);

	do_gettimeofday(&now);
	return ((now.tv_sec - udc->start_time.tv_sec) * 1000 +
			(now.tv_usec - udc->start_time.tv_usec) / 1000)
			% 0x7FF;
}

static int vgadget_set_selfpowered(struct usb_gadget *_gadget, int value)
{
	struct vudc *udc = usb_gadget_to_vudc(_gadget);

	if (value)
		udc->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
	else
		udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
	return 0;
}

static int vgadget_pullup(struct usb_gadget *_gadget, int value)
{
	struct vudc *udc = usb_gadget_to_vudc(_gadget);
	unsigned long flags;
	int ret;


	spin_lock_irqsave(&udc->lock, flags);
	value = !!value;
	if (value == udc->pullup)
		goto unlock;

	udc->pullup = value;
	if (value) {
		udc->gadget.speed = min_t(u8, USB_SPEED_HIGH,
					   udc->driver->max_speed);
		udc->ep[0].ep.maxpacket = 64;
		/*
		 * This is the first place where we can ask our
		 * gadget driver for descriptors.
		 */
		ret = get_gadget_descs(udc);
		if (ret) {
			dev_err(&udc->gadget.dev, "Unable go get desc: %d", ret);
			goto unlock;
		}

		spin_unlock_irqrestore(&udc->lock, flags);
		usbip_start_eh(&udc->ud);
	} else {
		/* Invalidate descriptors */
		udc->desc_cached = 0;

		spin_unlock_irqrestore(&udc->lock, flags);
		usbip_event_add(&udc->ud, VUDC_EVENT_REMOVED);
		usbip_stop_eh(&udc->ud); /* Wait for eh completion */
	}

	return 0;

unlock:
	spin_unlock_irqrestore(&udc->lock, flags);
	return 0;
}

static int vgadget_udc_start(struct usb_gadget *g,
		struct usb_gadget_driver *driver)
{
	struct vudc *udc = usb_gadget_to_vudc(g);
	unsigned long flags;

	spin_lock_irqsave(&udc->lock, flags);
	udc->driver = driver;
	udc->pullup = udc->connected = udc->desc_cached = 0;
	spin_unlock_irqrestore(&udc->lock, flags);

	return 0;
}

static int vgadget_udc_stop(struct usb_gadget *g)
{
	struct vudc *udc = usb_gadget_to_vudc(g);
	unsigned long flags;

	spin_lock_irqsave(&udc->lock, flags);
	udc->driver = NULL;
	spin_unlock_irqrestore(&udc->lock, flags);
	return 0;
}

static const struct usb_gadget_ops vgadget_ops = {
	.get_frame	= vgadget_get_frame,
	.set_selfpowered = vgadget_set_selfpowered,
	.pullup		= vgadget_pullup,
	.udc_start	= vgadget_udc_start,
	.udc_stop	= vgadget_udc_stop,
};


/* endpoint ops */

static int vep_enable(struct usb_ep *_ep,
		const struct usb_endpoint_descriptor *desc)
{
	struct vep *ep;
	struct vudc *udc;
	unsigned maxp;
	unsigned long flags;

	ep = to_vep(_ep);
	udc = ep_to_vudc(ep);

	if (!_ep || !desc || ep->desc || _ep->caps.type_control
			|| desc->bDescriptorType != USB_DT_ENDPOINT)
		return -EINVAL;

	if (!udc->driver)
		return -ESHUTDOWN;

	spin_lock_irqsave(&udc->lock, flags);

	maxp = usb_endpoint_maxp(desc) & 0x7ff;
	_ep->maxpacket = maxp;
	ep->desc = desc;
	ep->type = usb_endpoint_type(desc);
	ep->halted = ep->wedged = 0;

	spin_unlock_irqrestore(&udc->lock, flags);

	return 0;
}

static int vep_disable(struct usb_ep *_ep)
{
	struct vep *ep;
	struct vudc *udc;
	unsigned long flags;

	ep = to_vep(_ep);
	udc = ep_to_vudc(ep);
	if (!_ep || !ep->desc || _ep->caps.type_control)
		return -EINVAL;

	spin_lock_irqsave(&udc->lock, flags);
	ep->desc = NULL;
	nuke(udc, ep);
	spin_unlock_irqrestore(&udc->lock, flags);

	return 0;
}

static struct usb_request *vep_alloc_request(struct usb_ep *_ep,
		gfp_t mem_flags)
{
	struct vep *ep;
	struct vrequest *req;

	if (!_ep)
		return NULL;
	ep = to_vep(_ep);

	req = kzalloc(sizeof(*req), mem_flags);
	if (!req)
		return NULL;

	INIT_LIST_HEAD(&req->req_entry);

	return &req->req;
}

static void vep_free_request(struct usb_ep *_ep, struct usb_request *_req)
{
	struct vrequest *req;

	if (WARN_ON(!_ep || !_req))
		return;

	req = to_vrequest(_req);
	kfree(req);
}

static int vep_queue(struct usb_ep *_ep, struct usb_request *_req,
		gfp_t mem_flags)
{
	struct vep *ep;
	struct vrequest *req;
	struct vudc *udc;
	unsigned long flags;

	if (!_ep || !_req)
		return -EINVAL;

	ep = to_vep(_ep);
	req = to_vrequest(_req);
	udc = ep_to_vudc(ep);

	spin_lock_irqsave(&udc->lock, flags);
	_req->actual = 0;
	_req->status = -EINPROGRESS;

	list_add_tail(&req->req_entry, &ep->req_queue);
	spin_unlock_irqrestore(&udc->lock, flags);

	return 0;
}

static int vep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
{
	struct vep *ep;
	struct vrequest *req;
	struct vudc *udc;
	struct vrequest *lst;
	unsigned long flags;
	int ret = -EINVAL;

	if (!_ep || !_req)
		return ret;

	ep = to_vep(_ep);
	req = to_vrequest(_req);
	udc = req->udc;

	if (!udc->driver)
		return -ESHUTDOWN;

	spin_lock_irqsave(&udc->lock, flags);
	list_for_each_entry(lst, &ep->req_queue, req_entry) {
		if (&lst->req == _req) {
			list_del_init(&lst->req_entry);
			_req->status = -ECONNRESET;
			ret = 0;
			break;
		}
	}
	spin_unlock_irqrestore(&udc->lock, flags);

	if (ret == 0)
		usb_gadget_giveback_request(_ep, _req);

	return ret;
}

static int
vep_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
{
	struct vep *ep;
	struct vudc *udc;
	unsigned long flags;
	int ret = 0;

	ep = to_vep(_ep);
	if (!_ep)
		return -EINVAL;

	udc = ep_to_vudc(ep);
	if (!udc->driver)
		return -ESHUTDOWN;

	spin_lock_irqsave(&udc->lock, flags);
	if (!value)
		ep->halted = ep->wedged = 0;
	else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
			!list_empty(&ep->req_queue))
		ret = -EAGAIN;
	else {
		ep->halted = 1;
		if (wedged)
			ep->wedged = 1;
	}

	spin_unlock_irqrestore(&udc->lock, flags);
	return ret;
}

static int
vep_set_halt(struct usb_ep *_ep, int value)
{
	return vep_set_halt_and_wedge(_ep, value, 0);
}

static int vep_set_wedge(struct usb_ep *_ep)
{
	return vep_set_halt_and_wedge(_ep, 1, 1);
}

static const struct usb_ep_ops vep_ops = {
	.enable		= vep_enable,
	.disable	= vep_disable,

	.alloc_request	= vep_alloc_request,
	.free_request	= vep_free_request,

	.queue		= vep_queue,
	.dequeue	= vep_dequeue,

	.set_halt	= vep_set_halt,
	.set_wedge	= vep_set_wedge,
};


/* shutdown / reset / error handlers */

static void vudc_shutdown(struct usbip_device *ud)
{
	struct vudc *udc = container_of(ud, struct vudc, ud);
	int call_disconnect = 0;
	unsigned long flags;

	dev_dbg(&udc->pdev->dev, "device shutdown");
	if (ud->tcp_socket)
		kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR);

	if (ud->tcp_rx) {
		kthread_stop_put(ud->tcp_rx);
		ud->tcp_rx = NULL;
	}
	if (ud->tcp_tx) {
		kthread_stop_put(ud->tcp_tx);
		ud->tcp_tx = NULL;
	}

	if (ud->tcp_socket) {
		sockfd_put(ud->tcp_socket);
		ud->tcp_socket = NULL;
	}

	spin_lock_irqsave(&udc->lock, flags);
	stop_activity(udc);
	if (udc->connected && udc->driver->disconnect)
		call_disconnect = 1;
	udc->connected = 0;
	spin_unlock_irqrestore(&udc->lock, flags);
	if (call_disconnect)
		udc->driver->disconnect(&udc->gadget);
}

static void vudc_device_reset(struct usbip_device *ud)
{
	struct vudc *udc = container_of(ud, struct vudc, ud);
	unsigned long flags;

	dev_dbg(&udc->pdev->dev, "device reset");
	spin_lock_irqsave(&udc->lock, flags);
	stop_activity(udc);
	spin_unlock_irqrestore(&udc->lock, flags);
	if (udc->driver)
		usb_gadget_udc_reset(&udc->gadget, udc->driver);
	spin_lock_irqsave(&ud->lock, flags);
	ud->status = SDEV_ST_AVAILABLE;
	spin_unlock_irqrestore(&ud->lock, flags);
}

static void vudc_device_unusable(struct usbip_device *ud)
{
	unsigned long flags;

	spin_lock_irqsave(&ud->lock, flags);
	ud->status = SDEV_ST_ERROR;
	spin_unlock_irqrestore(&ud->lock, flags);
}

/* device setup / cleanup */

struct vudc_device *alloc_vudc_device(int devid)
{
	struct vudc_device *udc_dev = NULL;

	udc_dev = kzalloc(sizeof(*udc_dev), GFP_KERNEL);
	if (!udc_dev)
		goto out;

	INIT_LIST_HEAD(&udc_dev->dev_entry);

	udc_dev->pdev = platform_device_alloc(GADGET_NAME, devid);
	if (!udc_dev->pdev) {
		kfree(udc_dev);
		udc_dev = NULL;
	}

out:
	return udc_dev;
}

void put_vudc_device(struct vudc_device *udc_dev)
{
	platform_device_put(udc_dev->pdev);
	kfree(udc_dev);
}

static int init_vudc_hw(struct vudc *udc)
{
	int i;
	struct usbip_device *ud = &udc->ud;
	struct vep *ep;

	udc->ep = kcalloc(VIRTUAL_ENDPOINTS, sizeof(*udc->ep), GFP_KERNEL);
	if (!udc->ep)
		goto nomem_ep;

	INIT_LIST_HEAD(&udc->gadget.ep_list);

	/* create ep0 and 15 in, 15 out general purpose eps */
	for (i = 0; i < VIRTUAL_ENDPOINTS; ++i) {
		int is_out = i % 2;
		int num = (i + 1) / 2;

		ep = &udc->ep[i];

		sprintf(ep->name, "ep%d%s", num,
			i ? (is_out ? "out" : "in") : "");
		ep->ep.name = ep->name;
		if (i == 0) {
			ep->ep.caps.type_control = true;
			ep->ep.caps.dir_out = true;
			ep->ep.caps.dir_in = true;
		} else {
			ep->ep.caps.type_iso = true;
			ep->ep.caps.type_int = true;
			ep->ep.caps.type_bulk = true;
		}

		if (is_out)
			ep->ep.caps.dir_out = true;
		else
			ep->ep.caps.dir_in = true;

		ep->ep.ops = &vep_ops;
		list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
		ep->halted = ep->wedged = ep->already_seen =
			ep->setup_stage = 0;
		usb_ep_set_maxpacket_limit(&ep->ep, ~0);
		ep->ep.max_streams = 16;
		ep->gadget = &udc->gadget;
		ep->desc = NULL;
		INIT_LIST_HEAD(&ep->req_queue);
	}

	spin_lock_init(&udc->lock);
	spin_lock_init(&udc->lock_tx);
	INIT_LIST_HEAD(&udc->urb_queue);
	INIT_LIST_HEAD(&udc->tx_queue);
	init_waitqueue_head(&udc->tx_waitq);

	spin_lock_init(&ud->lock);
	ud->status = SDEV_ST_AVAILABLE;
	ud->side = USBIP_VUDC;

	ud->eh_ops.shutdown = vudc_shutdown;
	ud->eh_ops.reset    = vudc_device_reset;
	ud->eh_ops.unusable = vudc_device_unusable;

	udc->gadget.ep0 = &udc->ep[0].ep;
	list_del_init(&udc->ep[0].ep.ep_list);

	v_init_timer(udc);
	return 0;

nomem_ep:
		return -ENOMEM;
}

static void cleanup_vudc_hw(struct vudc *udc)
{
	kfree(udc->ep);
}

/* platform driver ops */

int vudc_probe(struct platform_device *pdev)
{
	struct vudc *udc;
	int ret = -ENOMEM;

	udc = kzalloc(sizeof(*udc), GFP_KERNEL);
	if (!udc)
		goto out;

	udc->gadget.name = GADGET_NAME;
	udc->gadget.ops = &vgadget_ops;
	udc->gadget.max_speed = USB_SPEED_HIGH;
	udc->gadget.dev.parent = &pdev->dev;
	udc->pdev = pdev;

	ret = init_vudc_hw(udc);
	if (ret)
		goto err_init_vudc_hw;

	ret = usb_add_gadget_udc(&pdev->dev, &udc->gadget);
	if (ret < 0)
		goto err_add_udc;

	ret = sysfs_create_group(&pdev->dev.kobj, &vudc_attr_group);
	if (ret) {
		dev_err(&udc->pdev->dev, "create sysfs files\n");
		goto err_sysfs;
	}

	platform_set_drvdata(pdev, udc);

	return ret;

err_sysfs:
	usb_del_gadget_udc(&udc->gadget);
err_add_udc:
	cleanup_vudc_hw(udc);
err_init_vudc_hw:
	kfree(udc);
out:
	return ret;
}

int vudc_remove(struct platform_device *pdev)
{
	struct vudc *udc = platform_get_drvdata(pdev);

	sysfs_remove_group(&pdev->dev.kobj, &vudc_attr_group);
	usb_del_gadget_udc(&udc->gadget);
	cleanup_vudc_hw(udc);
	kfree(udc);
	return 0;
}
Commit	Line	Data
b6a0ca11 IK	1	/*
	2	* Copyright (C) 2015 Karol Kosik <karo9@interia.eu>
	3	* Copyright (C) 2015-2016 Samsung Electronics
	4	* Igor Kotrasinski <i.kotrasinsk@samsung.com>
	5	* Krzysztof Opasiak <k.opasiak@samsung.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	19	*/
	20
	21	#include <linux/device.h>
	22	#include <linux/kernel.h>
	23	#include <linux/list.h>
	24	#include <linux/platform_device.h>
	25	#include <linux/usb.h>
	26	#include <linux/usb/gadget.h>
	27	#include <linux/usb/hcd.h>
	28	#include <linux/kthread.h>
	29	#include <linux/file.h>
	30	#include <linux/byteorder/generic.h>
	31
	32	#include "usbip_common.h"
	33	#include "vudc.h"
	34
	35	#define VIRTUAL_ENDPOINTS (1 /* ep0 / + 15 / in eps / + 15 / out eps */)
	36
	37	/* urb-related structures alloc / free */
	38
	39
	40	static void free_urb(struct urb *urb)
	41	{
	42	if (!urb)
	43	return;
	44
	45	kfree(urb->setup_packet);
	46	urb->setup_packet = NULL;
	47
	48	kfree(urb->transfer_buffer);
	49	urb->transfer_buffer = NULL;
	50
	51	usb_free_urb(urb);
	52	}
	53
	54	struct urbp *alloc_urbp(void)
	55	{
	56	struct urbp *urb_p;
	57
	58	urb_p = kzalloc(sizeof(*urb_p), GFP_KERNEL);
	59	if (!urb_p)
	60	return urb_p;
	61
	62	urb_p->urb = NULL;
	63	urb_p->ep = NULL;
	64	INIT_LIST_HEAD(&urb_p->urb_entry);
65	return urb_p;
66	}
67
68	static void free_urbp(struct urbp *urb_p)
69	{
70	kfree(urb_p);
71	}
72
73	void free_urbp_and_urb(struct urbp *urb_p)
74	{
75	if (!urb_p)
76	return;
77	free_urb(urb_p->urb);
78	free_urbp(urb_p);
79	}
80
81
82	/* utilities ; almost verbatim from dummy_hcd.c */
83
84	/* called with spinlock held */
85	static void nuke(struct vudc udc, struct vep ep)
86	{
87	struct vrequest *req;
88
89	while (!list_empty(&ep->req_queue)) {
90	req = list_first_entry(&ep->req_queue, struct vrequest,
91	req_entry);
92	list_del_init(&req->req_entry);
93	req->req.status = -ESHUTDOWN;
94
95	spin_unlock(&udc->lock);
96	usb_gadget_giveback_request(&ep->ep, &req->req);
97	spin_lock(&udc->lock);
98	}
99	}
100
101	/* caller must hold lock */
102	static void stop_activity(struct vudc *udc)
103	{
104	int i;
105	struct urbp urb_p, tmp;
106
107	udc->address = 0;
108
109	for (i = 0; i < VIRTUAL_ENDPOINTS; i++)
110	nuke(udc, &udc->ep[i]);
111
112	list_for_each_entry_safe(urb_p, tmp, &udc->urb_queue, urb_entry) {
113	list_del(&urb_p->urb_entry);
114	free_urbp_and_urb(urb_p);
115	}
116	}
117
0255cf9e	118	struct vep vudc_find_endpoint(struct vudc udc, u8 address)
b6a0ca11 IK	119	{
	120	int i;
	121
	122	if ((address & ~USB_DIR_IN) == 0)
	123	return &udc->ep[0];
	124
	125	for (i = 1; i < VIRTUAL_ENDPOINTS; i++) {
	126	struct vep *ep = &udc->ep[i];
	127
	128	if (!ep->desc)
	129	continue;
	130	if (ep->desc->bEndpointAddress == address)
	131	return ep;
	132	}
	133	return NULL;
	134	}
	135
	136	/* gadget ops */
	137
	138	/* FIXME - this will probably misbehave when suspend/resume is added */
	139	static int vgadget_get_frame(struct usb_gadget *_gadget)
	140	{
	141	struct timeval now;
	142	struct vudc *udc = usb_gadget_to_vudc(_gadget);
	143
	144	do_gettimeofday(&now);
	145	return ((now.tv_sec - udc->start_time.tv_sec) * 1000 +
	146	(now.tv_usec - udc->start_time.tv_usec) / 1000)
	147	% 0x7FF;
	148	}
	149
	150	static int vgadget_set_selfpowered(struct usb_gadget *_gadget, int value)
	151	{
	152	struct vudc *udc = usb_gadget_to_vudc(_gadget);
	153
	154	if (value)
	155	udc->devstatus \|= (1 << USB_DEVICE_SELF_POWERED);
	156	else
	157	udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
	158	return 0;
	159	}
	160
	161	static int vgadget_pullup(struct usb_gadget *_gadget, int value)
	162	{
	163	struct vudc *udc = usb_gadget_to_vudc(_gadget);
	164	unsigned long flags;
	165	int ret;
	166
	167
	168	spin_lock_irqsave(&udc->lock, flags);
	169	value = !!value;
	170	if (value == udc->pullup)
	171	goto unlock;
	172
	173	udc->pullup = value;
	174	if (value) {
	175	udc->gadget.speed = min_t(u8, USB_SPEED_HIGH,
	176	udc->driver->max_speed);
	177	udc->ep[0].ep.maxpacket = 64;
	178	/*
	179	* This is the first place where we can ask our
	180	* gadget driver for descriptors.
	181	*/
	182	ret = get_gadget_descs(udc);
183	if (ret) {
184	dev_err(&udc->gadget.dev, "Unable go get desc: %d", ret);
185	goto unlock;
186	}
187
188	spin_unlock_irqrestore(&udc->lock, flags);
189	usbip_start_eh(&udc->ud);
190	} else {
191	/* Invalidate descriptors */
192	udc->desc_cached = 0;
193
194	spin_unlock_irqrestore(&udc->lock, flags);
195	usbip_event_add(&udc->ud, VUDC_EVENT_REMOVED);
196	usbip_stop_eh(&udc->ud); /* Wait for eh completion */
197	}
198
199	return 0;
200
201	unlock:
202	spin_unlock_irqrestore(&udc->lock, flags);
203	return 0;
204	}
205
206	static int vgadget_udc_start(struct usb_gadget *g,
207	struct usb_gadget_driver *driver)
208	{
209	struct vudc *udc = usb_gadget_to_vudc(g);
210	unsigned long flags;
211
212	spin_lock_irqsave(&udc->lock, flags);
213	udc->driver = driver;
214	udc->pullup = udc->connected = udc->desc_cached = 0;
215	spin_unlock_irqrestore(&udc->lock, flags);
216
217	return 0;
218	}
219
220	static int vgadget_udc_stop(struct usb_gadget *g)
221	{
222	struct vudc *udc = usb_gadget_to_vudc(g);
223	unsigned long flags;
224
225	spin_lock_irqsave(&udc->lock, flags);
226	udc->driver = NULL;
227	spin_unlock_irqrestore(&udc->lock, flags);
228	return 0;
229	}
230
231	static const struct usb_gadget_ops vgadget_ops = {
232	.get_frame = vgadget_get_frame,
233	.set_selfpowered = vgadget_set_selfpowered,
234	.pullup = vgadget_pullup,
235	.udc_start = vgadget_udc_start,
236	.udc_stop = vgadget_udc_stop,
237	};
238
239
240	/* endpoint ops */
241
242	static int vep_enable(struct usb_ep *_ep,
243	const struct usb_endpoint_descriptor *desc)
244	{
245	struct vep *ep;
246	struct vudc *udc;
247	unsigned maxp;
248	unsigned long flags;
249
250	ep = to_vep(_ep);
251	udc = ep_to_vudc(ep);
252
253	if (!_ep \|\| !desc \|\| ep->desc \|\| _ep->caps.type_control
254	\|\| desc->bDescriptorType != USB_DT_ENDPOINT)
255	return -EINVAL;
256
257	if (!udc->driver)
258	return -ESHUTDOWN;
259
260	spin_lock_irqsave(&udc->lock, flags);
261
262	maxp = usb_endpoint_maxp(desc) & 0x7ff;
263	_ep->maxpacket = maxp;
264	ep->desc = desc;
265	ep->type = usb_endpoint_type(desc);
266	ep->halted = ep->wedged = 0;
267
268	spin_unlock_irqrestore(&udc->lock, flags);
269
270	return 0;
271	}
272
273	static int vep_disable(struct usb_ep *_ep)
274	{
275	struct vep *ep;
276	struct vudc *udc;
277	unsigned long flags;
278
279	ep = to_vep(_ep);
280	udc = ep_to_vudc(ep);
281	if (!_ep \|\| !ep->desc \|\| _ep->caps.type_control)
282	return -EINVAL;
283
284	spin_lock_irqsave(&udc->lock, flags);
285	ep->desc = NULL;
286	nuke(udc, ep);
287	spin_unlock_irqrestore(&udc->lock, flags);
288
289	return 0;
290	}
291
292	static struct usb_request vep_alloc_request(struct usb_ep _ep,
293	gfp_t mem_flags)
294	{
295	struct vep *ep;
296	struct vrequest *req;
297
298	if (!_ep)
299	return NULL;
300	ep = to_vep(_ep);
301
302	req = kzalloc(sizeof(*req), mem_flags);
303	if (!req)
304	return NULL;
305
306	INIT_LIST_HEAD(&req->req_entry);
307
308	return &req->req;
309	}
310
311	static void vep_free_request(struct usb_ep _ep, struct usb_request _req)
312	{
313	struct vrequest *req;
314
2bdf6ea5	315	if (WARN_ON(!_ep \|\| !_req))
b6a0ca11	316	return;
2bdf6ea5	317
b6a0ca11 IK	318	req = to_vrequest(_req);
	319	kfree(req);
	320	}
	321
	322	static int vep_queue(struct usb_ep _ep, struct usb_request _req,
	323	gfp_t mem_flags)
	324	{
	325	struct vep *ep;
	326	struct vrequest *req;
	327	struct vudc *udc;
	328	unsigned long flags;
	329
	330	if (!_ep \|\| !_req)
	331	return -EINVAL;
	332
	333	ep = to_vep(_ep);
	334	req = to_vrequest(_req);
	335	udc = ep_to_vudc(ep);
	336
	337	spin_lock_irqsave(&udc->lock, flags);
	338	_req->actual = 0;
	339	_req->status = -EINPROGRESS;
	340
	341	list_add_tail(&req->req_entry, &ep->req_queue);
	342	spin_unlock_irqrestore(&udc->lock, flags);
	343
	344	return 0;
	345	}
	346
	347	static int vep_dequeue(struct usb_ep _ep, struct usb_request _req)
	348	{
	349	struct vep *ep;
	350	struct vrequest *req;
	351	struct vudc *udc;
	352	struct vrequest *lst;
	353	unsigned long flags;
	354	int ret = -EINVAL;
	355
	356	if (!_ep \|\| !_req)
	357	return ret;
	358
	359	ep = to_vep(_ep);
	360	req = to_vrequest(_req);
	361	udc = req->udc;
	362
	363	if (!udc->driver)
	364	return -ESHUTDOWN;
	365
	366	spin_lock_irqsave(&udc->lock, flags);
	367	list_for_each_entry(lst, &ep->req_queue, req_entry) {
	368	if (&lst->req == _req) {
	369	list_del_init(&lst->req_entry);
	370	_req->status = -ECONNRESET;
	371	ret = 0;
	372	break;
	373	}
	374	}
	375	spin_unlock_irqrestore(&udc->lock, flags);
	376
	377	if (ret == 0)
	378	usb_gadget_giveback_request(_ep, _req);
	379
	380	return ret;
	381	}
382
383	static int
384	vep_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
385	{
386	struct vep *ep;
387	struct vudc *udc;
388	unsigned long flags;
389	int ret = 0;
390
391	ep = to_vep(_ep);
392	if (!_ep)
393	return -EINVAL;
394
395	udc = ep_to_vudc(ep);
396	if (!udc->driver)
397	return -ESHUTDOWN;
398
399	spin_lock_irqsave(&udc->lock, flags);
400	if (!value)
401	ep->halted = ep->wedged = 0;
402	else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
403	!list_empty(&ep->req_queue))
404	ret = -EAGAIN;
405	else {
406	ep->halted = 1;
407	if (wedged)
408	ep->wedged = 1;
409	}
410
411	spin_unlock_irqrestore(&udc->lock, flags);
412	return ret;
413	}
414
415	static int
416	vep_set_halt(struct usb_ep *_ep, int value)
417	{
418	return vep_set_halt_and_wedge(_ep, value, 0);
419	}
420
421	static int vep_set_wedge(struct usb_ep *_ep)
422	{
423	return vep_set_halt_and_wedge(_ep, 1, 1);
424	}
425
426	static const struct usb_ep_ops vep_ops = {
427	.enable = vep_enable,
428	.disable = vep_disable,
429
430	.alloc_request = vep_alloc_request,
431	.free_request = vep_free_request,
432
433	.queue = vep_queue,
434	.dequeue = vep_dequeue,
435
436	.set_halt = vep_set_halt,
437	.set_wedge = vep_set_wedge,
438	};
439
440
441	/* shutdown / reset / error handlers */
442
443	static void vudc_shutdown(struct usbip_device *ud)
444	{
445	struct vudc *udc = container_of(ud, struct vudc, ud);
446	int call_disconnect = 0;
447	unsigned long flags;
448
449	dev_dbg(&udc->pdev->dev, "device shutdown");
450	if (ud->tcp_socket)
451	kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR);
452
1328f7b9	453	if (ud->tcp_rx) {
b6a0ca11 IK	454	kthread_stop_put(ud->tcp_rx);
	455	ud->tcp_rx = NULL;
	456	}
	457	if (ud->tcp_tx) {
	458	kthread_stop_put(ud->tcp_tx);
	459	ud->tcp_tx = NULL;
	460	}
	461
	462	if (ud->tcp_socket) {
	463	sockfd_put(ud->tcp_socket);
	464	ud->tcp_socket = NULL;
	465	}
	466
	467	spin_lock_irqsave(&udc->lock, flags);
	468	stop_activity(udc);
	469	if (udc->connected && udc->driver->disconnect)
	470	call_disconnect = 1;
	471	udc->connected = 0;
	472	spin_unlock_irqrestore(&udc->lock, flags);
	473	if (call_disconnect)
	474	udc->driver->disconnect(&udc->gadget);
	475	}
	476
	477	static void vudc_device_reset(struct usbip_device *ud)
	478	{
	479	struct vudc *udc = container_of(ud, struct vudc, ud);
	480	unsigned long flags;
	481
	482	dev_dbg(&udc->pdev->dev, "device reset");
	483	spin_lock_irqsave(&udc->lock, flags);
	484	stop_activity(udc);
	485	spin_unlock_irqrestore(&udc->lock, flags);
	486	if (udc->driver)
	487	usb_gadget_udc_reset(&udc->gadget, udc->driver);
	488	spin_lock_irqsave(&ud->lock, flags);
	489	ud->status = SDEV_ST_AVAILABLE;
	490	spin_unlock_irqrestore(&ud->lock, flags);
	491	}
	492
	493	static void vudc_device_unusable(struct usbip_device *ud)
	494	{
	495	unsigned long flags;
	496
	497	spin_lock_irqsave(&ud->lock, flags);
	498	ud->status = SDEV_ST_ERROR;
	499	spin_unlock_irqrestore(&ud->lock, flags);
	500	}
	501
	502	/* device setup / cleanup */
	503
	504	struct vudc_device *alloc_vudc_device(int devid)
	505	{
	506	struct vudc_device *udc_dev = NULL;
	507
	508	udc_dev = kzalloc(sizeof(*udc_dev), GFP_KERNEL);
	509	if (!udc_dev)
	510	goto out;
	511
	512	INIT_LIST_HEAD(&udc_dev->dev_entry);
	513
	514	udc_dev->pdev = platform_device_alloc(GADGET_NAME, devid);
	515	if (!udc_dev->pdev) {
	516	kfree(udc_dev);
	517	udc_dev = NULL;
518	}
519
520	out:
521	return udc_dev;
522	}
523
524	void put_vudc_device(struct vudc_device *udc_dev)
525	{
526	platform_device_put(udc_dev->pdev);
527	kfree(udc_dev);
528	}
529
530	static int init_vudc_hw(struct vudc *udc)
531	{
532	int i;
533	struct usbip_device *ud = &udc->ud;
534	struct vep *ep;
535
536	udc->ep = kcalloc(VIRTUAL_ENDPOINTS, sizeof(*udc->ep), GFP_KERNEL);
537	if (!udc->ep)
538	goto nomem_ep;
539
540	INIT_LIST_HEAD(&udc->gadget.ep_list);
541
542	/* create ep0 and 15 in, 15 out general purpose eps */
543	for (i = 0; i < VIRTUAL_ENDPOINTS; ++i) {
544	int is_out = i % 2;
545	int num = (i + 1) / 2;
546
547	ep = &udc->ep[i];
548
549	sprintf(ep->name, "ep%d%s", num,
550	i ? (is_out ? "out" : "in") : "");
551	ep->ep.name = ep->name;
552	if (i == 0) {
553	ep->ep.caps.type_control = true;
554	ep->ep.caps.dir_out = true;
555	ep->ep.caps.dir_in = true;
556	} else {
557	ep->ep.caps.type_iso = true;
558	ep->ep.caps.type_int = true;
559	ep->ep.caps.type_bulk = true;
560	}
561
562	if (is_out)
563	ep->ep.caps.dir_out = true;
564	else
565	ep->ep.caps.dir_in = true;
566
567	ep->ep.ops = &vep_ops;
568	list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
569	ep->halted = ep->wedged = ep->already_seen =
570	ep->setup_stage = 0;
571	usb_ep_set_maxpacket_limit(&ep->ep, ~0);
572	ep->ep.max_streams = 16;
573	ep->gadget = &udc->gadget;
574	ep->desc = NULL;
575	INIT_LIST_HEAD(&ep->req_queue);
576	}
577
578	spin_lock_init(&udc->lock);
579	spin_lock_init(&udc->lock_tx);
580	INIT_LIST_HEAD(&udc->urb_queue);
581	INIT_LIST_HEAD(&udc->tx_queue);
582	init_waitqueue_head(&udc->tx_waitq);
583
584	spin_lock_init(&ud->lock);
585	ud->status = SDEV_ST_AVAILABLE;
586	ud->side = USBIP_VUDC;
587
588	ud->eh_ops.shutdown = vudc_shutdown;
589	ud->eh_ops.reset = vudc_device_reset;
590	ud->eh_ops.unusable = vudc_device_unusable;
591
592	udc->gadget.ep0 = &udc->ep[0].ep;
593	list_del_init(&udc->ep[0].ep.ep_list);
594
595	v_init_timer(udc);
596	return 0;
597
598	nomem_ep:
599	return -ENOMEM;
600	}
601
602	static void cleanup_vudc_hw(struct vudc *udc)
603	{
604	kfree(udc->ep);
605	}
606
607	/* platform driver ops */
608
609	int vudc_probe(struct platform_device *pdev)
610	{
611	struct vudc *udc;
612	int ret = -ENOMEM;
613
614	udc = kzalloc(sizeof(*udc), GFP_KERNEL);
615	if (!udc)
616	goto out;
617
618	udc->gadget.name = GADGET_NAME;
619	udc->gadget.ops = &vgadget_ops;
620	udc->gadget.max_speed = USB_SPEED_HIGH;
621	udc->gadget.dev.parent = &pdev->dev;
622	udc->pdev = pdev;
623
624	ret = init_vudc_hw(udc);
625	if (ret)
626	goto err_init_vudc_hw;
627
628	ret = usb_add_gadget_udc(&pdev->dev, &udc->gadget);
629	if (ret < 0)
630	goto err_add_udc;
631
632	ret = sysfs_create_group(&pdev->dev.kobj, &vudc_attr_group);
633	if (ret) {
634	dev_err(&udc->pdev->dev, "create sysfs files\n");
635	goto err_sysfs;
636	}
637
638	platform_set_drvdata(pdev, udc);
639
640	return ret;
641
642	err_sysfs:
643	usb_del_gadget_udc(&udc->gadget);
644	err_add_udc:
645	cleanup_vudc_hw(udc);
646	err_init_vudc_hw:
647	kfree(udc);
648	out:
649	return ret;
650	}
651
652	int vudc_remove(struct platform_device *pdev)
653	{
654	struct vudc *udc = platform_get_drvdata(pdev);
655
656	sysfs_remove_group(&pdev->dev.kobj, &vudc_attr_group);
657	usb_del_gadget_udc(&udc->gadget);
658	cleanup_vudc_hw(udc);
659	kfree(udc);
660	return 0;
661	}