]>
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 | 49 | struct vhci_priv *priv, *tmp; |
21619792 | 50 | unsigned long flags; |
04679b34 | 51 | |
21619792 | 52 | spin_lock_irqsave(&vdev->priv_lock, flags); |
04679b34 TH |
53 | |
54 | list_for_each_entry_safe(priv, tmp, &vdev->priv_tx, list) { | |
55 | list_move_tail(&priv->list, &vdev->priv_rx); | |
21619792 | 56 | spin_unlock_irqrestore(&vdev->priv_lock, flags); |
04679b34 TH |
57 | return priv; |
58 | } | |
59 | ||
21619792 | 60 | spin_unlock_irqrestore(&vdev->priv_lock, flags); |
04679b34 TH |
61 | |
62 | return NULL; | |
63 | } | |
64 | ||
04679b34 TH |
65 | static int vhci_send_cmd_submit(struct vhci_device *vdev) |
66 | { | |
67 | struct vhci_priv *priv = NULL; | |
68 | ||
69 | struct msghdr msg; | |
70 | struct kvec iov[3]; | |
71 | size_t txsize; | |
72 | ||
73 | size_t total_size = 0; | |
74 | ||
75 | while ((priv = dequeue_from_priv_tx(vdev)) != NULL) { | |
76 | int ret; | |
77 | struct urb *urb = priv->urb; | |
78 | struct usbip_header pdu_header; | |
36ac9b05 | 79 | struct usbip_iso_packet_descriptor *iso_buffer = NULL; |
04679b34 TH |
80 | |
81 | txsize = 0; | |
82 | memset(&pdu_header, 0, sizeof(pdu_header)); | |
83 | memset(&msg, 0, sizeof(msg)); | |
84 | memset(&iov, 0, sizeof(iov)); | |
85 | ||
b8868e45 | 86 | usbip_dbg_vhci_tx("setup txdata urb %p\n", urb); |
04679b34 | 87 | |
04679b34 TH |
88 | /* 1. setup usbip_header */ |
89 | setup_cmd_submit_pdu(&pdu_header, urb); | |
90 | usbip_header_correct_endian(&pdu_header, 1); | |
91 | ||
92 | iov[0].iov_base = &pdu_header; | |
93 | iov[0].iov_len = sizeof(pdu_header); | |
94 | txsize += sizeof(pdu_header); | |
95 | ||
96 | /* 2. setup transfer buffer */ | |
97 | if (!usb_pipein(urb->pipe) && urb->transfer_buffer_length > 0) { | |
98 | iov[1].iov_base = urb->transfer_buffer; | |
99 | iov[1].iov_len = urb->transfer_buffer_length; | |
100 | txsize += urb->transfer_buffer_length; | |
101 | } | |
102 | ||
103 | /* 3. setup iso_packet_descriptor */ | |
104 | if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) { | |
105 | ssize_t len = 0; | |
106 | ||
107 | iso_buffer = usbip_alloc_iso_desc_pdu(urb, &len); | |
108 | if (!iso_buffer) { | |
109 | usbip_event_add(&vdev->ud, | |
110 | SDEV_EVENT_ERROR_MALLOC); | |
111 | return -1; | |
112 | } | |
113 | ||
114 | iov[2].iov_base = iso_buffer; | |
115 | iov[2].iov_len = len; | |
116 | txsize += len; | |
117 | } | |
118 | ||
119 | ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 3, txsize); | |
120 | if (ret != txsize) { | |
1a4b6f66 | 121 | pr_err("sendmsg failed!, ret=%d for %zd\n", ret, |
122 | txsize); | |
04679b34 TH |
123 | kfree(iso_buffer); |
124 | usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP); | |
125 | return -1; | |
126 | } | |
127 | ||
128 | kfree(iso_buffer); | |
b8868e45 | 129 | usbip_dbg_vhci_tx("send txdata\n"); |
04679b34 TH |
130 | |
131 | total_size += txsize; | |
132 | } | |
133 | ||
134 | return total_size; | |
135 | } | |
136 | ||
04679b34 TH |
137 | static struct vhci_unlink *dequeue_from_unlink_tx(struct vhci_device *vdev) |
138 | { | |
04679b34 | 139 | struct vhci_unlink *unlink, *tmp; |
21619792 | 140 | unsigned long flags; |
04679b34 | 141 | |
21619792 | 142 | spin_lock_irqsave(&vdev->priv_lock, flags); |
04679b34 TH |
143 | |
144 | list_for_each_entry_safe(unlink, tmp, &vdev->unlink_tx, list) { | |
145 | list_move_tail(&unlink->list, &vdev->unlink_rx); | |
21619792 | 146 | spin_unlock_irqrestore(&vdev->priv_lock, flags); |
04679b34 TH |
147 | return unlink; |
148 | } | |
149 | ||
21619792 | 150 | spin_unlock_irqrestore(&vdev->priv_lock, flags); |
04679b34 TH |
151 | |
152 | return NULL; | |
153 | } | |
154 | ||
155 | static int vhci_send_cmd_unlink(struct vhci_device *vdev) | |
156 | { | |
157 | struct vhci_unlink *unlink = NULL; | |
158 | ||
159 | struct msghdr msg; | |
160 | struct kvec iov[3]; | |
161 | size_t txsize; | |
162 | ||
163 | size_t total_size = 0; | |
164 | ||
165 | while ((unlink = dequeue_from_unlink_tx(vdev)) != NULL) { | |
166 | int ret; | |
167 | struct usbip_header pdu_header; | |
168 | ||
169 | txsize = 0; | |
170 | memset(&pdu_header, 0, sizeof(pdu_header)); | |
171 | memset(&msg, 0, sizeof(msg)); | |
172 | memset(&iov, 0, sizeof(iov)); | |
173 | ||
acc4e416 | 174 | usbip_dbg_vhci_tx("setup cmd unlink, %lu\n", unlink->seqnum); |
04679b34 | 175 | |
04679b34 TH |
176 | /* 1. setup usbip_header */ |
177 | pdu_header.base.command = USBIP_CMD_UNLINK; | |
178 | pdu_header.base.seqnum = unlink->seqnum; | |
179 | pdu_header.base.devid = vdev->devid; | |
180 | pdu_header.base.ep = 0; | |
181 | pdu_header.u.cmd_unlink.seqnum = unlink->unlink_seqnum; | |
182 | ||
183 | usbip_header_correct_endian(&pdu_header, 1); | |
184 | ||
185 | iov[0].iov_base = &pdu_header; | |
186 | iov[0].iov_len = sizeof(pdu_header); | |
187 | txsize += sizeof(pdu_header); | |
188 | ||
189 | ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 1, txsize); | |
190 | if (ret != txsize) { | |
1a4b6f66 | 191 | pr_err("sendmsg failed!, ret=%d for %zd\n", ret, |
192 | txsize); | |
04679b34 TH |
193 | usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP); |
194 | return -1; | |
195 | } | |
196 | ||
b8868e45 | 197 | usbip_dbg_vhci_tx("send txdata\n"); |
04679b34 TH |
198 | |
199 | total_size += txsize; | |
200 | } | |
201 | ||
202 | return total_size; | |
203 | } | |
204 | ||
9720b4bc | 205 | int vhci_tx_loop(void *data) |
04679b34 | 206 | { |
9720b4bc | 207 | struct usbip_device *ud = data; |
04679b34 TH |
208 | struct vhci_device *vdev = container_of(ud, struct vhci_device, ud); |
209 | ||
9720b4bc | 210 | while (!kthread_should_stop()) { |
04679b34 TH |
211 | if (vhci_send_cmd_submit(vdev) < 0) |
212 | break; | |
213 | ||
214 | if (vhci_send_cmd_unlink(vdev) < 0) | |
215 | break; | |
216 | ||
217 | wait_event_interruptible(vdev->waitq_tx, | |
5c6499d8 | 218 | (!list_empty(&vdev->priv_tx) || |
219 | !list_empty(&vdev->unlink_tx) || | |
220 | kthread_should_stop())); | |
04679b34 | 221 | |
b8868e45 | 222 | usbip_dbg_vhci_tx("pending urbs ?, now wake up\n"); |
04679b34 | 223 | } |
9720b4bc AB |
224 | |
225 | return 0; | |
04679b34 | 226 | } |