2 * Copyright (C) 2003-2008 Takahiro Hirofuchi
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.
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.
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,
20 #include <linux/kernel.h>
21 #include <linux/smp_lock.h>
22 #include <linux/file.h>
23 #include <linux/tcp.h>
25 #include <linux/kthread.h>
26 #include <linux/slab.h>
27 #include "usbip_common.h"
29 /* version information */
30 #define DRIVER_VERSION "1.0"
31 #define DRIVER_AUTHOR "Takahiro Hirofuchi <hirofuchi _at_ users.sourceforge.net>"
32 #define DRIVER_DESC "usbip common driver"
34 /*-------------------------------------------------------------------------*/
37 #ifdef CONFIG_USB_IP_DEBUG_ENABLE
38 unsigned long usbip_debug_flag
= 0xffffffff;
40 unsigned long usbip_debug_flag
;
42 EXPORT_SYMBOL_GPL(usbip_debug_flag
);
46 struct device_attribute dev_attr_usbip_debug
;
47 EXPORT_SYMBOL_GPL(dev_attr_usbip_debug
);
50 static ssize_t
show_flag(struct device
*dev
, struct device_attribute
*attr
,
53 return sprintf(buf
, "%lx\n", usbip_debug_flag
);
56 static ssize_t
store_flag(struct device
*dev
, struct device_attribute
*attr
,
57 const char *buf
, size_t count
)
59 sscanf(buf
, "%lx", &usbip_debug_flag
);
63 DEVICE_ATTR(usbip_debug
, (S_IRUGO
| S_IWUSR
), show_flag
, store_flag
);
65 static void usbip_dump_buffer(char *buff
, int bufflen
)
67 print_hex_dump(KERN_DEBUG
, "usb-ip", DUMP_PREFIX_OFFSET
, 16, 4,
68 buff
, bufflen
, false);
71 static void usbip_dump_pipe(unsigned int p
)
73 unsigned char type
= usb_pipetype(p
);
74 unsigned char ep
= usb_pipeendpoint(p
);
75 unsigned char dev
= usb_pipedevice(p
);
76 unsigned char dir
= usb_pipein(p
);
78 printk(KERN_DEBUG
"dev(%d) ", dev
);
79 printk(KERN_DEBUG
"ep(%d) ", ep
);
80 printk(KERN_DEBUG
"%s ", dir
? "IN" : "OUT");
83 case PIPE_ISOCHRONOUS
:
84 printk(KERN_DEBUG
"%s ", "ISO");
87 printk(KERN_DEBUG
"%s ", "INT");
90 printk(KERN_DEBUG
"%s ", "CTL");
93 printk(KERN_DEBUG
"%s ", "BLK");
96 printk(KERN_DEBUG
"ERR");
99 printk(KERN_DEBUG
"\n");
103 static void usbip_dump_usb_device(struct usb_device
*udev
)
105 struct device
*dev
= &udev
->dev
;
108 dev_dbg(dev
, " devnum(%d) devpath(%s)",
109 udev
->devnum
, udev
->devpath
);
111 switch (udev
->speed
) {
113 printk(KERN_DEBUG
" SPD_HIGH");
116 printk(KERN_DEBUG
" SPD_FULL");
119 printk(KERN_DEBUG
" SPD_LOW");
121 case USB_SPEED_UNKNOWN
:
122 printk(KERN_DEBUG
" SPD_UNKNOWN");
125 printk(KERN_DEBUG
" SPD_ERROR");
128 printk(KERN_DEBUG
" tt %p, ttport %d", udev
->tt
, udev
->ttport
);
129 printk(KERN_DEBUG
"\n");
132 for (i
= 0; i
< 16; i
++)
133 printk(KERN_DEBUG
" %2u", i
);
134 printk(KERN_DEBUG
"\n");
136 dev_dbg(dev
, " toggle0(IN) :");
137 for (i
= 0; i
< 16; i
++)
138 printk(KERN_DEBUG
" %2u", (udev
->toggle
[0] & (1 << i
)) ? 1 : 0);
139 printk(KERN_DEBUG
"\n");
141 dev_dbg(dev
, " toggle1(OUT):");
142 for (i
= 0; i
< 16; i
++)
143 printk(KERN_DEBUG
" %2u", (udev
->toggle
[1] & (1 << i
)) ? 1 : 0);
144 printk(KERN_DEBUG
"\n");
147 dev_dbg(dev
, " epmaxp_in :");
148 for (i
= 0; i
< 16; i
++) {
150 printk(KERN_DEBUG
" %2u",
151 le16_to_cpu(udev
->ep_in
[i
]->desc
.wMaxPacketSize
));
153 printk(KERN_DEBUG
"\n");
155 dev_dbg(dev
, " epmaxp_out :");
156 for (i
= 0; i
< 16; i
++) {
158 printk(KERN_DEBUG
" %2u",
159 le16_to_cpu(udev
->ep_out
[i
]->desc
.wMaxPacketSize
));
161 printk(KERN_DEBUG
"\n");
163 dev_dbg(dev
, "parent %p, bus %p\n", udev
->parent
, udev
->bus
);
165 dev_dbg(dev
, "descriptor %p, config %p, actconfig %p, "
166 "rawdescriptors %p\n", &udev
->descriptor
, udev
->config
,
167 udev
->actconfig
, udev
->rawdescriptors
);
169 dev_dbg(dev
, "have_langid %d, string_langid %d\n",
170 udev
->have_langid
, udev
->string_langid
);
172 dev_dbg(dev
, "maxchild %d, children %p\n",
173 udev
->maxchild
, udev
->children
);
176 static void usbip_dump_request_type(__u8 rt
)
178 switch (rt
& USB_RECIP_MASK
) {
179 case USB_RECIP_DEVICE
:
180 printk(KERN_DEBUG
"DEVICE");
182 case USB_RECIP_INTERFACE
:
183 printk(KERN_DEBUG
"INTERF");
185 case USB_RECIP_ENDPOINT
:
186 printk(KERN_DEBUG
"ENDPOI");
188 case USB_RECIP_OTHER
:
189 printk(KERN_DEBUG
"OTHER ");
192 printk(KERN_DEBUG
"------");
196 static void usbip_dump_usb_ctrlrequest(struct usb_ctrlrequest
*cmd
)
199 printk(KERN_DEBUG
" %s : null pointer\n", __func__
);
203 printk(KERN_DEBUG
" ");
204 printk(KERN_DEBUG
"bRequestType(%02X) ", cmd
->bRequestType
);
205 printk(KERN_DEBUG
"bRequest(%02X) " , cmd
->bRequest
);
206 printk(KERN_DEBUG
"wValue(%04X) ", cmd
->wValue
);
207 printk(KERN_DEBUG
"wIndex(%04X) ", cmd
->wIndex
);
208 printk(KERN_DEBUG
"wLength(%04X) ", cmd
->wLength
);
210 printk(KERN_DEBUG
"\n ");
212 if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_STANDARD
) {
213 printk(KERN_DEBUG
"STANDARD ");
214 switch (cmd
->bRequest
) {
215 case USB_REQ_GET_STATUS
:
216 printk(KERN_DEBUG
"GET_STATUS");
218 case USB_REQ_CLEAR_FEATURE
:
219 printk(KERN_DEBUG
"CLEAR_FEAT");
221 case USB_REQ_SET_FEATURE
:
222 printk(KERN_DEBUG
"SET_FEAT ");
224 case USB_REQ_SET_ADDRESS
:
225 printk(KERN_DEBUG
"SET_ADDRRS");
227 case USB_REQ_GET_DESCRIPTOR
:
228 printk(KERN_DEBUG
"GET_DESCRI");
230 case USB_REQ_SET_DESCRIPTOR
:
231 printk(KERN_DEBUG
"SET_DESCRI");
233 case USB_REQ_GET_CONFIGURATION
:
234 printk(KERN_DEBUG
"GET_CONFIG");
236 case USB_REQ_SET_CONFIGURATION
:
237 printk(KERN_DEBUG
"SET_CONFIG");
239 case USB_REQ_GET_INTERFACE
:
240 printk(KERN_DEBUG
"GET_INTERF");
242 case USB_REQ_SET_INTERFACE
:
243 printk(KERN_DEBUG
"SET_INTERF");
245 case USB_REQ_SYNCH_FRAME
:
246 printk(KERN_DEBUG
"SYNC_FRAME");
249 printk(KERN_DEBUG
"REQ(%02X) ", cmd
->bRequest
);
252 printk(KERN_DEBUG
" ");
253 usbip_dump_request_type(cmd
->bRequestType
);
255 } else if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_CLASS
)
256 printk(KERN_DEBUG
"CLASS ");
258 else if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_VENDOR
)
259 printk(KERN_DEBUG
"VENDOR ");
261 else if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_RESERVED
)
262 printk(KERN_DEBUG
"RESERVED");
264 printk(KERN_DEBUG
"\n");
267 void usbip_dump_urb(struct urb
*urb
)
272 printk(KERN_DEBUG KBUILD_MODNAME
273 ":%s: urb: null pointer!!\n", __func__
);
278 printk(KERN_DEBUG KBUILD_MODNAME
279 ":%s: urb->dev: null pointer!!\n", __func__
);
282 dev
= &urb
->dev
->dev
;
284 dev_dbg(dev
, " urb :%p\n", urb
);
285 dev_dbg(dev
, " dev :%p\n", urb
->dev
);
287 usbip_dump_usb_device(urb
->dev
);
289 dev_dbg(dev
, " pipe :%08x ", urb
->pipe
);
291 usbip_dump_pipe(urb
->pipe
);
293 dev_dbg(dev
, " status :%d\n", urb
->status
);
294 dev_dbg(dev
, " transfer_flags :%08X\n", urb
->transfer_flags
);
295 dev_dbg(dev
, " transfer_buffer :%p\n", urb
->transfer_buffer
);
296 dev_dbg(dev
, " transfer_buffer_length:%d\n",
297 urb
->transfer_buffer_length
);
298 dev_dbg(dev
, " actual_length :%d\n", urb
->actual_length
);
299 dev_dbg(dev
, " setup_packet :%p\n", urb
->setup_packet
);
301 if (urb
->setup_packet
&& usb_pipetype(urb
->pipe
) == PIPE_CONTROL
)
302 usbip_dump_usb_ctrlrequest(
303 (struct usb_ctrlrequest
*)urb
->setup_packet
);
305 dev_dbg(dev
, " start_frame :%d\n", urb
->start_frame
);
306 dev_dbg(dev
, " number_of_packets :%d\n", urb
->number_of_packets
);
307 dev_dbg(dev
, " interval :%d\n", urb
->interval
);
308 dev_dbg(dev
, " error_count :%d\n", urb
->error_count
);
309 dev_dbg(dev
, " context :%p\n", urb
->context
);
310 dev_dbg(dev
, " complete :%p\n", urb
->complete
);
312 EXPORT_SYMBOL_GPL(usbip_dump_urb
);
314 void usbip_dump_header(struct usbip_header
*pdu
)
316 usbip_udbg("BASE: cmd %u seq %u devid %u dir %u ep %u\n",
323 switch (pdu
->base
.command
) {
324 case USBIP_CMD_SUBMIT
:
325 usbip_udbg("CMD_SUBMIT: "
326 "x_flags %u x_len %u sf %u #p %u iv %u\n",
327 pdu
->u
.cmd_submit
.transfer_flags
,
328 pdu
->u
.cmd_submit
.transfer_buffer_length
,
329 pdu
->u
.cmd_submit
.start_frame
,
330 pdu
->u
.cmd_submit
.number_of_packets
,
331 pdu
->u
.cmd_submit
.interval
);
333 case USBIP_CMD_UNLINK
:
334 usbip_udbg("CMD_UNLINK: seq %u\n", pdu
->u
.cmd_unlink
.seqnum
);
336 case USBIP_RET_SUBMIT
:
337 usbip_udbg("RET_SUBMIT: st %d al %u sf %d ec %d\n",
338 pdu
->u
.ret_submit
.status
,
339 pdu
->u
.ret_submit
.actual_length
,
340 pdu
->u
.ret_submit
.start_frame
,
341 pdu
->u
.ret_submit
.error_count
);
342 case USBIP_RET_UNLINK
:
343 usbip_udbg("RET_UNLINK: status %d\n", pdu
->u
.ret_unlink
.status
);
347 usbip_udbg("UNKNOWN\n");
350 EXPORT_SYMBOL_GPL(usbip_dump_header
);
353 /*-------------------------------------------------------------------------*/
354 /* thread routines */
356 int usbip_thread(void *param
)
358 struct usbip_task
*ut
= param
;
365 allow_signal(SIGKILL
);
366 ut
->thread
= current
;
369 /* srv.rb must wait for rx_thread starting */
370 complete(&ut
->thread_done
);
372 /* start of while loop */
378 complete_and_exit(&ut
->thread_done
, 0);
381 static void stop_rx_thread(struct usbip_device
*ud
)
383 if (ud
->tcp_rx
.thread
!= NULL
) {
384 send_sig(SIGKILL
, ud
->tcp_rx
.thread
, 1);
385 wait_for_completion(&ud
->tcp_rx
.thread_done
);
386 usbip_udbg("rx_thread for ud %p has finished\n", ud
);
390 static void stop_tx_thread(struct usbip_device
*ud
)
392 if (ud
->tcp_tx
.thread
!= NULL
) {
393 send_sig(SIGKILL
, ud
->tcp_tx
.thread
, 1);
394 wait_for_completion(&ud
->tcp_tx
.thread_done
);
395 usbip_udbg("tx_thread for ud %p has finished\n", ud
);
399 int usbip_start_threads(struct usbip_device
*ud
)
402 * threads are invoked per one device (per one connection).
404 struct task_struct
*th
;
407 th
= kthread_run(usbip_thread
, (void *)&ud
->tcp_rx
, "usbip");
410 "Unable to start control thread\n");
415 th
= kthread_run(usbip_thread
, (void *)&ud
->tcp_tx
, "usbip");
418 "Unable to start control thread\n");
423 /* confirm threads are starting */
424 wait_for_completion(&ud
->tcp_rx
.thread_done
);
425 wait_for_completion(&ud
->tcp_tx
.thread_done
);
435 EXPORT_SYMBOL_GPL(usbip_start_threads
);
437 void usbip_stop_threads(struct usbip_device
*ud
)
439 /* kill threads related to this sdev, if v.c. exists */
443 EXPORT_SYMBOL_GPL(usbip_stop_threads
);
445 void usbip_task_init(struct usbip_task
*ut
, char *name
,
446 void (*loop_ops
)(struct usbip_task
*))
449 init_completion(&ut
->thread_done
);
451 ut
->loop_ops
= loop_ops
;
453 EXPORT_SYMBOL_GPL(usbip_task_init
);
456 /*-------------------------------------------------------------------------*/
457 /* socket routines */
459 /* Send/receive messages over TCP/IP. I refer drivers/block/nbd.c */
460 int usbip_xmit(int send
, struct socket
*sock
, char *buf
,
461 int size
, int msg_flags
)
468 /* for blocks of if (usbip_dbg_flag_xmit) */
472 usbip_dbg_xmit("enter\n");
474 if (!sock
|| !buf
|| !size
) {
475 printk(KERN_ERR
"%s: invalid arg, sock %p buff %p size %d\n",
476 __func__
, sock
, buf
, size
);
481 if (usbip_dbg_flag_xmit
) {
484 printk(KERN_DEBUG
"%-10s:", current
->comm
);
486 printk(KERN_DEBUG
"interrupt :");
488 printk(KERN_DEBUG
"%s: sending... , sock %p, buf %p, "
489 "size %d, msg_flags %d\n", __func__
,
490 sock
, buf
, size
, msg_flags
);
491 usbip_dump_buffer(buf
, size
);
497 sock
->sk
->sk_allocation
= GFP_NOIO
;
502 msg
.msg_control
= NULL
;
503 msg
.msg_controllen
= 0;
505 msg
.msg_flags
= msg_flags
| MSG_NOSIGNAL
;
508 result
= kernel_sendmsg(sock
, &msg
, &iov
, 1, size
);
510 result
= kernel_recvmsg(sock
, &msg
, &iov
, 1, size
,
514 usbip_udbg("usbip_xmit: %s sock %p buf %p size %u ret "
516 send
? "send" : "receive", sock
, buf
,
517 size
, result
, total
);
528 if (usbip_dbg_flag_xmit
) {
531 printk(KERN_DEBUG
"%-10s:", current
->comm
);
533 printk(KERN_DEBUG
"interrupt :");
535 printk(KERN_DEBUG
"usbip_xmit: receiving....\n");
536 usbip_dump_buffer(bp
, osize
);
537 printk(KERN_DEBUG
"usbip_xmit: received, osize %d ret "
538 "%d size %d total %d\n", osize
, result
,
543 printk(KERN_DEBUG
"usbip_xmit: send, total %d\n",
552 EXPORT_SYMBOL_GPL(usbip_xmit
);
554 struct socket
*sockfd_to_socket(unsigned int sockfd
)
556 struct socket
*socket
;
562 printk(KERN_ERR
"%s: invalid sockfd\n", __func__
);
566 inode
= file
->f_dentry
->d_inode
;
568 if (!inode
|| !S_ISSOCK(inode
->i_mode
))
571 socket
= SOCKET_I(inode
);
575 EXPORT_SYMBOL_GPL(sockfd_to_socket
);
579 /*-------------------------------------------------------------------------*/
582 /* there may be more cases to tweak the flags. */
583 static unsigned int tweak_transfer_flags(unsigned int flags
)
585 flags
&= ~URB_NO_TRANSFER_DMA_MAP
;
589 static void usbip_pack_cmd_submit(struct usbip_header
*pdu
, struct urb
*urb
,
592 struct usbip_header_cmd_submit
*spdu
= &pdu
->u
.cmd_submit
;
595 * Some members are not still implemented in usbip. I hope this issue
596 * will be discussed when usbip is ported to other operating systems.
600 spdu
->transfer_flags
=
601 tweak_transfer_flags(urb
->transfer_flags
);
602 spdu
->transfer_buffer_length
= urb
->transfer_buffer_length
;
603 spdu
->start_frame
= urb
->start_frame
;
604 spdu
->number_of_packets
= urb
->number_of_packets
;
605 spdu
->interval
= urb
->interval
;
608 urb
->transfer_flags
= spdu
->transfer_flags
;
610 urb
->transfer_buffer_length
= spdu
->transfer_buffer_length
;
611 urb
->start_frame
= spdu
->start_frame
;
612 urb
->number_of_packets
= spdu
->number_of_packets
;
613 urb
->interval
= spdu
->interval
;
617 static void usbip_pack_ret_submit(struct usbip_header
*pdu
, struct urb
*urb
,
620 struct usbip_header_ret_submit
*rpdu
= &pdu
->u
.ret_submit
;
625 rpdu
->status
= urb
->status
;
626 rpdu
->actual_length
= urb
->actual_length
;
627 rpdu
->start_frame
= urb
->start_frame
;
628 rpdu
->error_count
= urb
->error_count
;
632 urb
->status
= rpdu
->status
;
633 urb
->actual_length
= rpdu
->actual_length
;
634 urb
->start_frame
= rpdu
->start_frame
;
635 urb
->error_count
= rpdu
->error_count
;
640 void usbip_pack_pdu(struct usbip_header
*pdu
, struct urb
*urb
, int cmd
,
644 case USBIP_CMD_SUBMIT
:
645 usbip_pack_cmd_submit(pdu
, urb
, pack
);
647 case USBIP_RET_SUBMIT
:
648 usbip_pack_ret_submit(pdu
, urb
, pack
);
651 err("unknown command");
656 EXPORT_SYMBOL_GPL(usbip_pack_pdu
);
659 static void correct_endian_basic(struct usbip_header_basic
*base
, int send
)
662 base
->command
= cpu_to_be32(base
->command
);
663 base
->seqnum
= cpu_to_be32(base
->seqnum
);
664 base
->devid
= cpu_to_be32(base
->devid
);
665 base
->direction
= cpu_to_be32(base
->direction
);
666 base
->ep
= cpu_to_be32(base
->ep
);
668 base
->command
= be32_to_cpu(base
->command
);
669 base
->seqnum
= be32_to_cpu(base
->seqnum
);
670 base
->devid
= be32_to_cpu(base
->devid
);
671 base
->direction
= be32_to_cpu(base
->direction
);
672 base
->ep
= be32_to_cpu(base
->ep
);
676 static void correct_endian_cmd_submit(struct usbip_header_cmd_submit
*pdu
,
680 pdu
->transfer_flags
= cpu_to_be32(pdu
->transfer_flags
);
682 cpu_to_be32s(&pdu
->transfer_buffer_length
);
683 cpu_to_be32s(&pdu
->start_frame
);
684 cpu_to_be32s(&pdu
->number_of_packets
);
685 cpu_to_be32s(&pdu
->interval
);
687 pdu
->transfer_flags
= be32_to_cpu(pdu
->transfer_flags
);
689 be32_to_cpus(&pdu
->transfer_buffer_length
);
690 be32_to_cpus(&pdu
->start_frame
);
691 be32_to_cpus(&pdu
->number_of_packets
);
692 be32_to_cpus(&pdu
->interval
);
696 static void correct_endian_ret_submit(struct usbip_header_ret_submit
*pdu
,
700 cpu_to_be32s(&pdu
->status
);
701 cpu_to_be32s(&pdu
->actual_length
);
702 cpu_to_be32s(&pdu
->start_frame
);
703 cpu_to_be32s(&pdu
->error_count
);
705 be32_to_cpus(&pdu
->status
);
706 be32_to_cpus(&pdu
->actual_length
);
707 be32_to_cpus(&pdu
->start_frame
);
708 be32_to_cpus(&pdu
->error_count
);
712 static void correct_endian_cmd_unlink(struct usbip_header_cmd_unlink
*pdu
,
716 pdu
->seqnum
= cpu_to_be32(pdu
->seqnum
);
718 pdu
->seqnum
= be32_to_cpu(pdu
->seqnum
);
721 static void correct_endian_ret_unlink(struct usbip_header_ret_unlink
*pdu
,
725 cpu_to_be32s(&pdu
->status
);
727 be32_to_cpus(&pdu
->status
);
730 void usbip_header_correct_endian(struct usbip_header
*pdu
, int send
)
735 cmd
= pdu
->base
.command
;
737 correct_endian_basic(&pdu
->base
, send
);
740 cmd
= pdu
->base
.command
;
743 case USBIP_CMD_SUBMIT
:
744 correct_endian_cmd_submit(&pdu
->u
.cmd_submit
, send
);
746 case USBIP_RET_SUBMIT
:
747 correct_endian_ret_submit(&pdu
->u
.ret_submit
, send
);
749 case USBIP_CMD_UNLINK
:
750 correct_endian_cmd_unlink(&pdu
->u
.cmd_unlink
, send
);
752 case USBIP_RET_UNLINK
:
753 correct_endian_ret_unlink(&pdu
->u
.ret_unlink
, send
);
757 err("unknown command in pdu header: %d", cmd
);
761 EXPORT_SYMBOL_GPL(usbip_header_correct_endian
);
763 static void usbip_iso_pakcet_correct_endian(
764 struct usbip_iso_packet_descriptor
*iso
,
767 /* does not need all members. but copy all simply. */
769 iso
->offset
= cpu_to_be32(iso
->offset
);
770 iso
->length
= cpu_to_be32(iso
->length
);
771 iso
->status
= cpu_to_be32(iso
->status
);
772 iso
->actual_length
= cpu_to_be32(iso
->actual_length
);
774 iso
->offset
= be32_to_cpu(iso
->offset
);
775 iso
->length
= be32_to_cpu(iso
->length
);
776 iso
->status
= be32_to_cpu(iso
->status
);
777 iso
->actual_length
= be32_to_cpu(iso
->actual_length
);
781 static void usbip_pack_iso(struct usbip_iso_packet_descriptor
*iso
,
782 struct usb_iso_packet_descriptor
*uiso
, int pack
)
785 iso
->offset
= uiso
->offset
;
786 iso
->length
= uiso
->length
;
787 iso
->status
= uiso
->status
;
788 iso
->actual_length
= uiso
->actual_length
;
790 uiso
->offset
= iso
->offset
;
791 uiso
->length
= iso
->length
;
792 uiso
->status
= iso
->status
;
793 uiso
->actual_length
= iso
->actual_length
;
798 /* must free buffer */
799 void *usbip_alloc_iso_desc_pdu(struct urb
*urb
, ssize_t
*bufflen
)
802 struct usbip_iso_packet_descriptor
*iso
;
803 int np
= urb
->number_of_packets
;
804 ssize_t size
= np
* sizeof(*iso
);
807 buff
= kzalloc(size
, GFP_KERNEL
);
811 for (i
= 0; i
< np
; i
++) {
812 iso
= buff
+ (i
* sizeof(*iso
));
814 usbip_pack_iso(iso
, &urb
->iso_frame_desc
[i
], 1);
815 usbip_iso_pakcet_correct_endian(iso
, 1);
822 EXPORT_SYMBOL_GPL(usbip_alloc_iso_desc_pdu
);
824 /* some members of urb must be substituted before. */
825 int usbip_recv_iso(struct usbip_device
*ud
, struct urb
*urb
)
828 struct usbip_iso_packet_descriptor
*iso
;
829 int np
= urb
->number_of_packets
;
830 int size
= np
* sizeof(*iso
);
834 if (!usb_pipeisoc(urb
->pipe
))
837 /* my Bluetooth dongle gets ISO URBs which are np = 0 */
839 /* usbip_uinfo("iso np == 0\n"); */
840 /* usbip_dump_urb(urb); */
844 buff
= kzalloc(size
, GFP_KERNEL
);
848 ret
= usbip_xmit(0, ud
->tcp_socket
, buff
, size
, 0);
850 dev_err(&urb
->dev
->dev
, "recv iso_frame_descriptor, %d\n",
854 if (ud
->side
== USBIP_STUB
)
855 usbip_event_add(ud
, SDEV_EVENT_ERROR_TCP
);
857 usbip_event_add(ud
, VDEV_EVENT_ERROR_TCP
);
862 for (i
= 0; i
< np
; i
++) {
863 iso
= buff
+ (i
* sizeof(*iso
));
865 usbip_iso_pakcet_correct_endian(iso
, 0);
866 usbip_pack_iso(iso
, &urb
->iso_frame_desc
[i
], 0);
873 EXPORT_SYMBOL_GPL(usbip_recv_iso
);
876 /* some members of urb must be substituted before. */
877 int usbip_recv_xbuff(struct usbip_device
*ud
, struct urb
*urb
)
882 if (ud
->side
== USBIP_STUB
) {
884 /* the direction of urb must be OUT. */
885 if (usb_pipein(urb
->pipe
))
888 size
= urb
->transfer_buffer_length
;
891 /* the direction of urb must be IN. */
892 if (usb_pipeout(urb
->pipe
))
895 size
= urb
->actual_length
;
898 /* no need to recv xbuff */
902 ret
= usbip_xmit(0, ud
->tcp_socket
, (char *)urb
->transfer_buffer
,
905 dev_err(&urb
->dev
->dev
, "recv xbuf, %d\n", ret
);
906 if (ud
->side
== USBIP_STUB
) {
907 usbip_event_add(ud
, SDEV_EVENT_ERROR_TCP
);
909 usbip_event_add(ud
, VDEV_EVENT_ERROR_TCP
);
916 EXPORT_SYMBOL_GPL(usbip_recv_xbuff
);
919 /*-------------------------------------------------------------------------*/
921 static int __init
usbip_common_init(void)
923 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_DESC
"" DRIVER_VERSION
);
928 static void __exit
usbip_common_exit(void)
936 module_init(usbip_common_init
);
937 module_exit(usbip_common_exit
);
939 MODULE_AUTHOR(DRIVER_AUTHOR
);
940 MODULE_DESCRIPTION(DRIVER_DESC
);
941 MODULE_LICENSE("GPL");