[mirror_ubuntu-bionic-kernel.git] / drivers / usb / usbip / vhci_tx.c

/*
 * Copyright (C) 2003-2008 Takahiro Hirofuchi
 *
 * This 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 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 * USA.
 */

#include <linux/kthread.h>
#include <linux/slab.h>

#include "usbip_common.h"
#include "vhci.h"

static void setup_cmd_submit_pdu(struct usbip_header *pdup,  struct urb *urb)
{
	struct vhci_priv *priv = ((struct vhci_priv *)urb->hcpriv);
	struct vhci_device *vdev = priv->vdev;

	usbip_dbg_vhci_tx("URB, local devnum %u, remote devid %u\n",
			  usb_pipedevice(urb->pipe), vdev->devid);

	pdup->base.command   = USBIP_CMD_SUBMIT;
	pdup->base.seqnum    = priv->seqnum;
	pdup->base.devid     = vdev->devid;
	pdup->base.direction = usb_pipein(urb->pipe) ?
		USBIP_DIR_IN : USBIP_DIR_OUT;
	pdup->base.ep	     = usb_pipeendpoint(urb->pipe);

	usbip_pack_pdu(pdup, urb, USBIP_CMD_SUBMIT, 1);

	if (urb->setup_packet)
		memcpy(pdup->u.cmd_submit.setup, urb->setup_packet, 8);
}

static struct vhci_priv *dequeue_from_priv_tx(struct vhci_device *vdev)
{
	struct vhci_priv *priv, *tmp;

	spin_lock(&vdev->priv_lock);

	list_for_each_entry_safe(priv, tmp, &vdev->priv_tx, list) {
		list_move_tail(&priv->list, &vdev->priv_rx);
		spin_unlock(&vdev->priv_lock);
		return priv;
	}

	spin_unlock(&vdev->priv_lock);

	return NULL;
}

static int vhci_send_cmd_submit(struct vhci_device *vdev)
{
	struct vhci_priv *priv = NULL;

	struct msghdr msg;
	struct kvec iov[3];
	size_t txsize;

	size_t total_size = 0;

	while ((priv = dequeue_from_priv_tx(vdev)) != NULL) {
		int ret;
		struct urb *urb = priv->urb;
		struct usbip_header pdu_header;
		struct usbip_iso_packet_descriptor *iso_buffer = NULL;

		txsize = 0;
		memset(&pdu_header, 0, sizeof(pdu_header));
		memset(&msg, 0, sizeof(msg));
		memset(&iov, 0, sizeof(iov));

		usbip_dbg_vhci_tx("setup txdata urb %p\n", urb);

		/* 1. setup usbip_header */
		setup_cmd_submit_pdu(&pdu_header, urb);
		usbip_header_correct_endian(&pdu_header, 1);

		iov[0].iov_base = &pdu_header;
		iov[0].iov_len  = sizeof(pdu_header);
		txsize += sizeof(pdu_header);

		/* 2. setup transfer buffer */
		if (!usb_pipein(urb->pipe) && urb->transfer_buffer_length > 0) {
			iov[1].iov_base = urb->transfer_buffer;
			iov[1].iov_len  = urb->transfer_buffer_length;
			txsize += urb->transfer_buffer_length;
		}

		/* 3. setup iso_packet_descriptor */
		if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
			ssize_t len = 0;

			iso_buffer = usbip_alloc_iso_desc_pdu(urb, &len);
			if (!iso_buffer) {
				usbip_event_add(&vdev->ud,
						SDEV_EVENT_ERROR_MALLOC);
				return -1;
			}

			iov[2].iov_base = iso_buffer;
			iov[2].iov_len  = len;
			txsize += len;
		}

		ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 3, txsize);
		if (ret != txsize) {
			pr_err("sendmsg failed!, ret=%d for %zd\n", ret,
			       txsize);
			kfree(iso_buffer);
			usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP);
			return -1;
		}

		kfree(iso_buffer);
		usbip_dbg_vhci_tx("send txdata\n");

		total_size += txsize;
	}

	return total_size;
}

static struct vhci_unlink *dequeue_from_unlink_tx(struct vhci_device *vdev)
{
	struct vhci_unlink *unlink, *tmp;

	spin_lock(&vdev->priv_lock);

	list_for_each_entry_safe(unlink, tmp, &vdev->unlink_tx, list) {
		list_move_tail(&unlink->list, &vdev->unlink_rx);
		spin_unlock(&vdev->priv_lock);
		return unlink;
	}

	spin_unlock(&vdev->priv_lock);

	return NULL;
}

static int vhci_send_cmd_unlink(struct vhci_device *vdev)
{
	struct vhci_unlink *unlink = NULL;

	struct msghdr msg;
	struct kvec iov[3];
	size_t txsize;

	size_t total_size = 0;

	while ((unlink = dequeue_from_unlink_tx(vdev)) != NULL) {
		int ret;
		struct usbip_header pdu_header;

		txsize = 0;
		memset(&pdu_header, 0, sizeof(pdu_header));
		memset(&msg, 0, sizeof(msg));
		memset(&iov, 0, sizeof(iov));

		usbip_dbg_vhci_tx("setup cmd unlink, %lu\n", unlink->seqnum);

		/* 1. setup usbip_header */
		pdu_header.base.command = USBIP_CMD_UNLINK;
		pdu_header.base.seqnum  = unlink->seqnum;
		pdu_header.base.devid	= vdev->devid;
		pdu_header.base.ep	= 0;
		pdu_header.u.cmd_unlink.seqnum = unlink->unlink_seqnum;

		usbip_header_correct_endian(&pdu_header, 1);

		iov[0].iov_base = &pdu_header;
		iov[0].iov_len  = sizeof(pdu_header);
		txsize += sizeof(pdu_header);

		ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 1, txsize);
		if (ret != txsize) {
			pr_err("sendmsg failed!, ret=%d for %zd\n", ret,
			       txsize);
			usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP);
			return -1;
		}

		usbip_dbg_vhci_tx("send txdata\n");

		total_size += txsize;
	}

	return total_size;
}

int vhci_tx_loop(void *data)
{
	struct usbip_device *ud = data;
	struct vhci_device *vdev = container_of(ud, struct vhci_device, ud);

	while (!kthread_should_stop()) {
		if (vhci_send_cmd_submit(vdev) < 0)
			break;

		if (vhci_send_cmd_unlink(vdev) < 0)
			break;

		wait_event_interruptible(vdev->waitq_tx,
					 (!list_empty(&vdev->priv_tx) ||
					  !list_empty(&vdev->unlink_tx) ||
					  kthread_should_stop()));

		usbip_dbg_vhci_tx("pending urbs ?, now wake up\n");
	}

	return 0;
}
Commit	Line	Data
04679b34 TH	1	/*
	2	* Copyright (C) 2003-2008 Takahiro Hirofuchi
	3	*
	4	* This is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*
	9	* This is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
	17	* USA.
	18	*/
	19
9720b4bc	20	#include <linux/kthread.h>
7aaacb43	21	#include <linux/slab.h>
5a0e3ad6	22
04679b34 TH	23	#include "usbip_common.h"
	24	#include "vhci.h"
	25
04679b34 TH	26	static void setup_cmd_submit_pdu(struct usbip_header pdup, struct urb urb)
	27	{
	28	struct vhci_priv priv = ((struct vhci_priv )urb->hcpriv);
	29	struct vhci_device *vdev = priv->vdev;
	30
b8868e45	31	usbip_dbg_vhci_tx("URB, local devnum %u, remote devid %u\n",
5c6499d8	32	usb_pipedevice(urb->pipe), vdev->devid);
04679b34	33
5c6499d8	34	pdup->base.command = USBIP_CMD_SUBMIT;
	35	pdup->base.seqnum = priv->seqnum;
	36	pdup->base.devid = vdev->devid;
	37	pdup->base.direction = usb_pipein(urb->pipe) ?
	38	USBIP_DIR_IN : USBIP_DIR_OUT;
	39	pdup->base.ep = usb_pipeendpoint(urb->pipe);
04679b34 TH	40
	41	usbip_pack_pdu(pdup, urb, USBIP_CMD_SUBMIT, 1);
	42
	43	if (urb->setup_packet)
	44	memcpy(pdup->u.cmd_submit.setup, urb->setup_packet, 8);
	45	}
	46
	47	static struct vhci_priv dequeue_from_priv_tx(struct vhci_device vdev)
	48	{
04679b34 TH	49	struct vhci_priv priv, tmp;
04679b34 TH	50
50b66b5c	51	spin_lock(&vdev->priv_lock);
04679b34 TH	52
	53	list_for_each_entry_safe(priv, tmp, &vdev->priv_tx, list) {
	54	list_move_tail(&priv->list, &vdev->priv_rx);
50b66b5c	55	spin_unlock(&vdev->priv_lock);
04679b34 TH	56	return priv;
	57	}
	58
50b66b5c	59	spin_unlock(&vdev->priv_lock);
04679b34 TH	60
	61	return NULL;
	62	}
	63
04679b34 TH	64	static int vhci_send_cmd_submit(struct vhci_device *vdev)
	65	{
	66	struct vhci_priv *priv = NULL;
	67
	68	struct msghdr msg;
	69	struct kvec iov[3];
	70	size_t txsize;
	71
	72	size_t total_size = 0;
	73
	74	while ((priv = dequeue_from_priv_tx(vdev)) != NULL) {
	75	int ret;
	76	struct urb *urb = priv->urb;
	77	struct usbip_header pdu_header;
36ac9b05	78	struct usbip_iso_packet_descriptor *iso_buffer = NULL;
04679b34 TH	79
	80	txsize = 0;
	81	memset(&pdu_header, 0, sizeof(pdu_header));
	82	memset(&msg, 0, sizeof(msg));
	83	memset(&iov, 0, sizeof(iov));
	84
b8868e45	85	usbip_dbg_vhci_tx("setup txdata urb %p\n", urb);
04679b34	86
04679b34 TH	87	/* 1. setup usbip_header */
	88	setup_cmd_submit_pdu(&pdu_header, urb);
	89	usbip_header_correct_endian(&pdu_header, 1);
	90
	91	iov[0].iov_base = &pdu_header;
	92	iov[0].iov_len = sizeof(pdu_header);
	93	txsize += sizeof(pdu_header);
	94
	95	/* 2. setup transfer buffer */
	96	if (!usb_pipein(urb->pipe) && urb->transfer_buffer_length > 0) {
	97	iov[1].iov_base = urb->transfer_buffer;
	98	iov[1].iov_len = urb->transfer_buffer_length;
	99	txsize += urb->transfer_buffer_length;
	100	}
	101
	102	/* 3. setup iso_packet_descriptor */
	103	if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
	104	ssize_t len = 0;
	105
	106	iso_buffer = usbip_alloc_iso_desc_pdu(urb, &len);
	107	if (!iso_buffer) {
	108	usbip_event_add(&vdev->ud,
	109	SDEV_EVENT_ERROR_MALLOC);
	110	return -1;
	111	}
	112
	113	iov[2].iov_base = iso_buffer;
	114	iov[2].iov_len = len;
	115	txsize += len;
	116	}
	117
	118	ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 3, txsize);
	119	if (ret != txsize) {
1a4b6f66	120	pr_err("sendmsg failed!, ret=%d for %zd\n", ret,
1a4b6f66	121	txsize);
04679b34 TH	122	kfree(iso_buffer);
	123	usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP);
	124	return -1;
	125	}
	126
	127	kfree(iso_buffer);
b8868e45	128	usbip_dbg_vhci_tx("send txdata\n");
04679b34 TH	129
	130	total_size += txsize;
	131	}
	132
	133	return total_size;
	134	}
	135
04679b34 TH	136	static struct vhci_unlink dequeue_from_unlink_tx(struct vhci_device vdev)
04679b34 TH	137	{
04679b34 TH	138	struct vhci_unlink unlink, tmp;
04679b34 TH	139
50b66b5c	140	spin_lock(&vdev->priv_lock);
04679b34 TH	141
	142	list_for_each_entry_safe(unlink, tmp, &vdev->unlink_tx, list) {
	143	list_move_tail(&unlink->list, &vdev->unlink_rx);
50b66b5c	144	spin_unlock(&vdev->priv_lock);
04679b34 TH	145	return unlink;
	146	}
	147
50b66b5c	148	spin_unlock(&vdev->priv_lock);
04679b34 TH	149
	150	return NULL;
	151	}
	152
	153	static int vhci_send_cmd_unlink(struct vhci_device *vdev)
	154	{
	155	struct vhci_unlink *unlink = NULL;
	156
	157	struct msghdr msg;
	158	struct kvec iov[3];
	159	size_t txsize;
	160
	161	size_t total_size = 0;
	162
	163	while ((unlink = dequeue_from_unlink_tx(vdev)) != NULL) {
	164	int ret;
	165	struct usbip_header pdu_header;
	166
	167	txsize = 0;
	168	memset(&pdu_header, 0, sizeof(pdu_header));
	169	memset(&msg, 0, sizeof(msg));
	170	memset(&iov, 0, sizeof(iov));
	171
acc4e416	172	usbip_dbg_vhci_tx("setup cmd unlink, %lu\n", unlink->seqnum);
04679b34	173
04679b34 TH	174	/* 1. setup usbip_header */
	175	pdu_header.base.command = USBIP_CMD_UNLINK;
	176	pdu_header.base.seqnum = unlink->seqnum;
	177	pdu_header.base.devid = vdev->devid;
	178	pdu_header.base.ep = 0;
	179	pdu_header.u.cmd_unlink.seqnum = unlink->unlink_seqnum;
	180
	181	usbip_header_correct_endian(&pdu_header, 1);
	182
	183	iov[0].iov_base = &pdu_header;
	184	iov[0].iov_len = sizeof(pdu_header);
	185	txsize += sizeof(pdu_header);
	186
	187	ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 1, txsize);
	188	if (ret != txsize) {
1a4b6f66	189	pr_err("sendmsg failed!, ret=%d for %zd\n", ret,
1a4b6f66	190	txsize);
04679b34 TH	191	usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP);
	192	return -1;
	193	}
	194
b8868e45	195	usbip_dbg_vhci_tx("send txdata\n");
04679b34 TH	196
	197	total_size += txsize;
	198	}
	199
	200	return total_size;
	201	}
	202
9720b4bc	203	int vhci_tx_loop(void *data)
04679b34	204	{
9720b4bc	205	struct usbip_device *ud = data;
04679b34 TH	206	struct vhci_device *vdev = container_of(ud, struct vhci_device, ud);
04679b34 TH	207
9720b4bc	208	while (!kthread_should_stop()) {
04679b34 TH	209	if (vhci_send_cmd_submit(vdev) < 0)
	210	break;
	211
	212	if (vhci_send_cmd_unlink(vdev) < 0)
	213	break;
	214
	215	wait_event_interruptible(vdev->waitq_tx,
5c6499d8	216	(!list_empty(&vdev->priv_tx) \|\|
	217	!list_empty(&vdev->unlink_tx) \|\|
	218	kthread_should_stop()));
04679b34	219
b8868e45	220	usbip_dbg_vhci_tx("pending urbs ?, now wake up\n");
04679b34	221	}
9720b4bc AB	222
9720b4bc AB	223	return 0;
04679b34	224	}