]>
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 | ||
5a0e3ad6 TH |
20 | #include <linux/slab.h> |
21 | ||
04679b34 TH |
22 | #include "usbip_common.h" |
23 | #include "vhci.h" | |
24 | ||
25 | ||
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", |
04679b34 TH |
32 | usb_pipedevice(urb->pipe), vdev->devid); |
33 | ||
34 | pdup->base.command = USBIP_CMD_SUBMIT; | |
35 | pdup->base.seqnum = priv->seqnum; | |
36 | pdup->base.devid = vdev->devid; | |
37 | if (usb_pipein(urb->pipe)) | |
38 | pdup->base.direction = USBIP_DIR_IN; | |
39 | else | |
40 | pdup->base.direction = USBIP_DIR_OUT; | |
41 | pdup->base.ep = usb_pipeendpoint(urb->pipe); | |
42 | ||
43 | usbip_pack_pdu(pdup, urb, USBIP_CMD_SUBMIT, 1); | |
44 | ||
45 | if (urb->setup_packet) | |
46 | memcpy(pdup->u.cmd_submit.setup, urb->setup_packet, 8); | |
47 | } | |
48 | ||
49 | static struct vhci_priv *dequeue_from_priv_tx(struct vhci_device *vdev) | |
50 | { | |
51 | unsigned long flags; | |
52 | struct vhci_priv *priv, *tmp; | |
53 | ||
54 | spin_lock_irqsave(&vdev->priv_lock, flags); | |
55 | ||
56 | list_for_each_entry_safe(priv, tmp, &vdev->priv_tx, list) { | |
57 | list_move_tail(&priv->list, &vdev->priv_rx); | |
58 | spin_unlock_irqrestore(&vdev->priv_lock, flags); | |
59 | return priv; | |
60 | } | |
61 | ||
62 | spin_unlock_irqrestore(&vdev->priv_lock, flags); | |
63 | ||
64 | return NULL; | |
65 | } | |
66 | ||
67 | ||
68 | ||
69 | static int vhci_send_cmd_submit(struct vhci_device *vdev) | |
70 | { | |
71 | struct vhci_priv *priv = NULL; | |
72 | ||
73 | struct msghdr msg; | |
74 | struct kvec iov[3]; | |
75 | size_t txsize; | |
76 | ||
77 | size_t total_size = 0; | |
78 | ||
79 | while ((priv = dequeue_from_priv_tx(vdev)) != NULL) { | |
80 | int ret; | |
81 | struct urb *urb = priv->urb; | |
82 | struct usbip_header pdu_header; | |
83 | void *iso_buffer = NULL; | |
84 | ||
85 | txsize = 0; | |
86 | memset(&pdu_header, 0, sizeof(pdu_header)); | |
87 | memset(&msg, 0, sizeof(msg)); | |
88 | memset(&iov, 0, sizeof(iov)); | |
89 | ||
b8868e45 | 90 | usbip_dbg_vhci_tx("setup txdata urb %p\n", urb); |
04679b34 TH |
91 | |
92 | ||
93 | /* 1. setup usbip_header */ | |
94 | setup_cmd_submit_pdu(&pdu_header, urb); | |
95 | usbip_header_correct_endian(&pdu_header, 1); | |
96 | ||
97 | iov[0].iov_base = &pdu_header; | |
98 | iov[0].iov_len = sizeof(pdu_header); | |
99 | txsize += sizeof(pdu_header); | |
100 | ||
101 | /* 2. setup transfer buffer */ | |
102 | if (!usb_pipein(urb->pipe) && urb->transfer_buffer_length > 0) { | |
103 | iov[1].iov_base = urb->transfer_buffer; | |
104 | iov[1].iov_len = urb->transfer_buffer_length; | |
105 | txsize += urb->transfer_buffer_length; | |
106 | } | |
107 | ||
108 | /* 3. setup iso_packet_descriptor */ | |
109 | if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) { | |
110 | ssize_t len = 0; | |
111 | ||
112 | iso_buffer = usbip_alloc_iso_desc_pdu(urb, &len); | |
113 | if (!iso_buffer) { | |
114 | usbip_event_add(&vdev->ud, | |
115 | SDEV_EVENT_ERROR_MALLOC); | |
116 | return -1; | |
117 | } | |
118 | ||
119 | iov[2].iov_base = iso_buffer; | |
120 | iov[2].iov_len = len; | |
121 | txsize += len; | |
122 | } | |
123 | ||
124 | ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 3, txsize); | |
125 | if (ret != txsize) { | |
b8868e45 BM |
126 | usbip_uerr("sendmsg failed!, retval %d for %zd\n", ret, |
127 | txsize); | |
04679b34 TH |
128 | kfree(iso_buffer); |
129 | usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP); | |
130 | return -1; | |
131 | } | |
132 | ||
133 | kfree(iso_buffer); | |
b8868e45 | 134 | usbip_dbg_vhci_tx("send txdata\n"); |
04679b34 TH |
135 | |
136 | total_size += txsize; | |
137 | } | |
138 | ||
139 | return total_size; | |
140 | } | |
141 | ||
142 | ||
143 | /*-------------------------------------------------------------------------*/ | |
144 | ||
145 | static struct vhci_unlink *dequeue_from_unlink_tx(struct vhci_device *vdev) | |
146 | { | |
147 | unsigned long flags; | |
148 | struct vhci_unlink *unlink, *tmp; | |
149 | ||
150 | spin_lock_irqsave(&vdev->priv_lock, flags); | |
151 | ||
152 | list_for_each_entry_safe(unlink, tmp, &vdev->unlink_tx, list) { | |
153 | list_move_tail(&unlink->list, &vdev->unlink_rx); | |
154 | spin_unlock_irqrestore(&vdev->priv_lock, flags); | |
155 | return unlink; | |
156 | } | |
157 | ||
158 | spin_unlock_irqrestore(&vdev->priv_lock, flags); | |
159 | ||
160 | return NULL; | |
161 | } | |
162 | ||
163 | static int vhci_send_cmd_unlink(struct vhci_device *vdev) | |
164 | { | |
165 | struct vhci_unlink *unlink = NULL; | |
166 | ||
167 | struct msghdr msg; | |
168 | struct kvec iov[3]; | |
169 | size_t txsize; | |
170 | ||
171 | size_t total_size = 0; | |
172 | ||
173 | while ((unlink = dequeue_from_unlink_tx(vdev)) != NULL) { | |
174 | int ret; | |
175 | struct usbip_header pdu_header; | |
176 | ||
177 | txsize = 0; | |
178 | memset(&pdu_header, 0, sizeof(pdu_header)); | |
179 | memset(&msg, 0, sizeof(msg)); | |
180 | memset(&iov, 0, sizeof(iov)); | |
181 | ||
b8868e45 | 182 | usbip_dbg_vhci_tx("setup cmd unlink, %lu \n", unlink->seqnum); |
04679b34 TH |
183 | |
184 | ||
185 | /* 1. setup usbip_header */ | |
186 | pdu_header.base.command = USBIP_CMD_UNLINK; | |
187 | pdu_header.base.seqnum = unlink->seqnum; | |
188 | pdu_header.base.devid = vdev->devid; | |
189 | pdu_header.base.ep = 0; | |
190 | pdu_header.u.cmd_unlink.seqnum = unlink->unlink_seqnum; | |
191 | ||
192 | usbip_header_correct_endian(&pdu_header, 1); | |
193 | ||
194 | iov[0].iov_base = &pdu_header; | |
195 | iov[0].iov_len = sizeof(pdu_header); | |
196 | txsize += sizeof(pdu_header); | |
197 | ||
198 | ret = kernel_sendmsg(vdev->ud.tcp_socket, &msg, iov, 1, txsize); | |
199 | if (ret != txsize) { | |
b8868e45 BM |
200 | usbip_uerr("sendmsg failed!, retval %d for %zd\n", ret, |
201 | txsize); | |
04679b34 TH |
202 | usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_TCP); |
203 | return -1; | |
204 | } | |
205 | ||
206 | ||
b8868e45 | 207 | usbip_dbg_vhci_tx("send txdata\n"); |
04679b34 TH |
208 | |
209 | total_size += txsize; | |
210 | } | |
211 | ||
212 | return total_size; | |
213 | } | |
214 | ||
215 | ||
216 | /*-------------------------------------------------------------------------*/ | |
217 | ||
218 | void vhci_tx_loop(struct usbip_task *ut) | |
219 | { | |
220 | struct usbip_device *ud = container_of(ut, struct usbip_device, tcp_tx); | |
221 | struct vhci_device *vdev = container_of(ud, struct vhci_device, ud); | |
222 | ||
223 | while (1) { | |
224 | if (signal_pending(current)) { | |
b8868e45 | 225 | usbip_uinfo("vhci_tx signal catched\n"); |
04679b34 TH |
226 | break; |
227 | } | |
228 | ||
229 | if (vhci_send_cmd_submit(vdev) < 0) | |
230 | break; | |
231 | ||
232 | if (vhci_send_cmd_unlink(vdev) < 0) | |
233 | break; | |
234 | ||
235 | wait_event_interruptible(vdev->waitq_tx, | |
236 | (!list_empty(&vdev->priv_tx) || | |
237 | !list_empty(&vdev->unlink_tx))); | |
238 | ||
b8868e45 | 239 | usbip_dbg_vhci_tx("pending urbs ?, now wake up\n"); |
04679b34 TH |
240 | } |
241 | } |