2 * Copyright (C) 2003-2008 Takahiro Hirofuchi
3 * Copyright (C) 2015-2016 Samsung Electronics
4 * Krzysztof Opasiak <k.opasiak@samsung.com>
6 * This is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
22 #include <asm/byteorder.h>
23 #include <linux/file.h>
25 #include <linux/kernel.h>
26 #include <linux/slab.h>
27 #include <linux/stat.h>
28 #include <linux/module.h>
29 #include <linux/moduleparam.h>
32 #include "usbip_common.h"
34 #define DRIVER_AUTHOR "Takahiro Hirofuchi <hirofuchi@users.sourceforge.net>"
35 #define DRIVER_DESC "USB/IP Core"
37 #ifdef CONFIG_USBIP_DEBUG
38 unsigned long usbip_debug_flag
= 0xffffffff;
40 unsigned long usbip_debug_flag
;
42 EXPORT_SYMBOL_GPL(usbip_debug_flag
);
43 module_param(usbip_debug_flag
, ulong
, S_IRUGO
|S_IWUSR
);
44 MODULE_PARM_DESC(usbip_debug_flag
, "debug flags (defined in usbip_common.h)");
47 struct device_attribute dev_attr_usbip_debug
;
48 EXPORT_SYMBOL_GPL(dev_attr_usbip_debug
);
50 static ssize_t
usbip_debug_show(struct device
*dev
,
51 struct device_attribute
*attr
, char *buf
)
53 return sprintf(buf
, "%lx\n", usbip_debug_flag
);
56 static ssize_t
usbip_debug_store(struct device
*dev
,
57 struct device_attribute
*attr
, const char *buf
,
60 if (sscanf(buf
, "%lx", &usbip_debug_flag
) != 1)
64 DEVICE_ATTR_RW(usbip_debug
);
66 static void usbip_dump_buffer(char *buff
, int bufflen
)
68 print_hex_dump(KERN_DEBUG
, "usbip-core", DUMP_PREFIX_OFFSET
, 16, 4,
69 buff
, bufflen
, false);
72 static void usbip_dump_pipe(unsigned int p
)
74 unsigned char type
= usb_pipetype(p
);
75 unsigned char ep
= usb_pipeendpoint(p
);
76 unsigned char dev
= usb_pipedevice(p
);
77 unsigned char dir
= usb_pipein(p
);
79 pr_debug("dev(%d) ep(%d) [%s] ", dev
, ep
, dir
? "IN" : "OUT");
82 case PIPE_ISOCHRONOUS
:
100 static void usbip_dump_usb_device(struct usb_device
*udev
)
102 struct device
*dev
= &udev
->dev
;
105 dev_dbg(dev
, " devnum(%d) devpath(%s) usb speed(%s)",
106 udev
->devnum
, udev
->devpath
, usb_speed_string(udev
->speed
));
108 pr_debug("tt %p, ttport %d\n", udev
->tt
, udev
->ttport
);
111 for (i
= 0; i
< 16; i
++)
115 dev_dbg(dev
, " toggle0(IN) :");
116 for (i
= 0; i
< 16; i
++)
117 pr_debug(" %2u", (udev
->toggle
[0] & (1 << i
)) ? 1 : 0);
120 dev_dbg(dev
, " toggle1(OUT):");
121 for (i
= 0; i
< 16; i
++)
122 pr_debug(" %2u", (udev
->toggle
[1] & (1 << i
)) ? 1 : 0);
125 dev_dbg(dev
, " epmaxp_in :");
126 for (i
= 0; i
< 16; i
++) {
129 le16_to_cpu(udev
->ep_in
[i
]->desc
.wMaxPacketSize
));
133 dev_dbg(dev
, " epmaxp_out :");
134 for (i
= 0; i
< 16; i
++) {
137 le16_to_cpu(udev
->ep_out
[i
]->desc
.wMaxPacketSize
));
141 dev_dbg(dev
, "parent %p, bus %p\n", udev
->parent
, udev
->bus
);
144 "descriptor %p, config %p, actconfig %p, rawdescriptors %p\n",
145 &udev
->descriptor
, udev
->config
,
146 udev
->actconfig
, udev
->rawdescriptors
);
148 dev_dbg(dev
, "have_langid %d, string_langid %d\n",
149 udev
->have_langid
, udev
->string_langid
);
151 dev_dbg(dev
, "maxchild %d\n", udev
->maxchild
);
154 static void usbip_dump_request_type(__u8 rt
)
156 switch (rt
& USB_RECIP_MASK
) {
157 case USB_RECIP_DEVICE
:
160 case USB_RECIP_INTERFACE
:
163 case USB_RECIP_ENDPOINT
:
166 case USB_RECIP_OTHER
:
175 static void usbip_dump_usb_ctrlrequest(struct usb_ctrlrequest
*cmd
)
178 pr_debug(" : null pointer\n");
183 pr_debug("bRequestType(%02X) bRequest(%02X) wValue(%04X) wIndex(%04X) wLength(%04X) ",
184 cmd
->bRequestType
, cmd
->bRequest
,
185 cmd
->wValue
, cmd
->wIndex
, cmd
->wLength
);
188 if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_STANDARD
) {
189 pr_debug("STANDARD ");
190 switch (cmd
->bRequest
) {
191 case USB_REQ_GET_STATUS
:
192 pr_debug("GET_STATUS\n");
194 case USB_REQ_CLEAR_FEATURE
:
195 pr_debug("CLEAR_FEAT\n");
197 case USB_REQ_SET_FEATURE
:
198 pr_debug("SET_FEAT\n");
200 case USB_REQ_SET_ADDRESS
:
201 pr_debug("SET_ADDRRS\n");
203 case USB_REQ_GET_DESCRIPTOR
:
204 pr_debug("GET_DESCRI\n");
206 case USB_REQ_SET_DESCRIPTOR
:
207 pr_debug("SET_DESCRI\n");
209 case USB_REQ_GET_CONFIGURATION
:
210 pr_debug("GET_CONFIG\n");
212 case USB_REQ_SET_CONFIGURATION
:
213 pr_debug("SET_CONFIG\n");
215 case USB_REQ_GET_INTERFACE
:
216 pr_debug("GET_INTERF\n");
218 case USB_REQ_SET_INTERFACE
:
219 pr_debug("SET_INTERF\n");
221 case USB_REQ_SYNCH_FRAME
:
222 pr_debug("SYNC_FRAME\n");
225 pr_debug("REQ(%02X)\n", cmd
->bRequest
);
228 usbip_dump_request_type(cmd
->bRequestType
);
229 } else if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_CLASS
) {
231 } else if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_VENDOR
) {
232 pr_debug("VENDOR\n");
233 } else if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_RESERVED
) {
234 pr_debug("RESERVED\n");
238 void usbip_dump_urb(struct urb
*urb
)
243 pr_debug("urb: null pointer!!\n");
248 pr_debug("urb->dev: null pointer!!\n");
252 dev
= &urb
->dev
->dev
;
254 dev_dbg(dev
, " urb :%p\n", urb
);
255 dev_dbg(dev
, " dev :%p\n", urb
->dev
);
257 usbip_dump_usb_device(urb
->dev
);
259 dev_dbg(dev
, " pipe :%08x ", urb
->pipe
);
261 usbip_dump_pipe(urb
->pipe
);
263 dev_dbg(dev
, " status :%d\n", urb
->status
);
264 dev_dbg(dev
, " transfer_flags :%08X\n", urb
->transfer_flags
);
265 dev_dbg(dev
, " transfer_buffer :%p\n", urb
->transfer_buffer
);
266 dev_dbg(dev
, " transfer_buffer_length:%d\n",
267 urb
->transfer_buffer_length
);
268 dev_dbg(dev
, " actual_length :%d\n", urb
->actual_length
);
269 dev_dbg(dev
, " setup_packet :%p\n", urb
->setup_packet
);
271 if (urb
->setup_packet
&& usb_pipetype(urb
->pipe
) == PIPE_CONTROL
)
272 usbip_dump_usb_ctrlrequest(
273 (struct usb_ctrlrequest
*)urb
->setup_packet
);
275 dev_dbg(dev
, " start_frame :%d\n", urb
->start_frame
);
276 dev_dbg(dev
, " number_of_packets :%d\n", urb
->number_of_packets
);
277 dev_dbg(dev
, " interval :%d\n", urb
->interval
);
278 dev_dbg(dev
, " error_count :%d\n", urb
->error_count
);
279 dev_dbg(dev
, " context :%p\n", urb
->context
);
280 dev_dbg(dev
, " complete :%p\n", urb
->complete
);
282 EXPORT_SYMBOL_GPL(usbip_dump_urb
);
284 void usbip_dump_header(struct usbip_header
*pdu
)
286 pr_debug("BASE: cmd %u seq %u devid %u dir %u ep %u\n",
293 switch (pdu
->base
.command
) {
294 case USBIP_CMD_SUBMIT
:
295 pr_debug("USBIP_CMD_SUBMIT: x_flags %u x_len %u sf %u #p %d iv %d\n",
296 pdu
->u
.cmd_submit
.transfer_flags
,
297 pdu
->u
.cmd_submit
.transfer_buffer_length
,
298 pdu
->u
.cmd_submit
.start_frame
,
299 pdu
->u
.cmd_submit
.number_of_packets
,
300 pdu
->u
.cmd_submit
.interval
);
302 case USBIP_CMD_UNLINK
:
303 pr_debug("USBIP_CMD_UNLINK: seq %u\n",
304 pdu
->u
.cmd_unlink
.seqnum
);
306 case USBIP_RET_SUBMIT
:
307 pr_debug("USBIP_RET_SUBMIT: st %d al %u sf %d #p %d ec %d\n",
308 pdu
->u
.ret_submit
.status
,
309 pdu
->u
.ret_submit
.actual_length
,
310 pdu
->u
.ret_submit
.start_frame
,
311 pdu
->u
.ret_submit
.number_of_packets
,
312 pdu
->u
.ret_submit
.error_count
);
314 case USBIP_RET_UNLINK
:
315 pr_debug("USBIP_RET_UNLINK: status %d\n",
316 pdu
->u
.ret_unlink
.status
);
320 pr_err("unknown command\n");
324 EXPORT_SYMBOL_GPL(usbip_dump_header
);
326 /* Receive data over TCP/IP. */
327 int usbip_recv(struct socket
*sock
, void *buf
, int size
)
330 struct kvec iov
= {.iov_base
= buf
, .iov_len
= size
};
331 struct msghdr msg
= {.msg_flags
= MSG_NOSIGNAL
};
334 iov_iter_kvec(&msg
.msg_iter
, READ
|ITER_KVEC
, &iov
, 1, size
);
336 usbip_dbg_xmit("enter\n");
338 if (!sock
|| !buf
|| !size
) {
339 pr_err("invalid arg, sock %p buff %p size %d\n", sock
, buf
,
345 int sz
= msg_data_left(&msg
);
346 sock
->sk
->sk_allocation
= GFP_NOIO
;
348 result
= sock_recvmsg(sock
, &msg
, MSG_WAITALL
);
350 pr_debug("receive sock %p buf %p size %u ret %d total %d\n",
351 sock
, buf
+ total
, sz
, result
, total
);
356 } while (msg_data_left(&msg
));
358 if (usbip_dbg_flag_xmit
) {
360 pr_debug("%-10s:", current
->comm
);
362 pr_debug("interrupt :");
364 pr_debug("receiving....\n");
365 usbip_dump_buffer(buf
, size
);
366 pr_debug("received, osize %d ret %d size %zd total %d\n",
367 size
, result
, msg_data_left(&msg
), total
);
375 EXPORT_SYMBOL_GPL(usbip_recv
);
377 /* there may be more cases to tweak the flags. */
378 static unsigned int tweak_transfer_flags(unsigned int flags
)
380 flags
&= ~URB_NO_TRANSFER_DMA_MAP
;
384 static void usbip_pack_cmd_submit(struct usbip_header
*pdu
, struct urb
*urb
,
387 struct usbip_header_cmd_submit
*spdu
= &pdu
->u
.cmd_submit
;
390 * Some members are not still implemented in usbip. I hope this issue
391 * will be discussed when usbip is ported to other operating systems.
394 spdu
->transfer_flags
=
395 tweak_transfer_flags(urb
->transfer_flags
);
396 spdu
->transfer_buffer_length
= urb
->transfer_buffer_length
;
397 spdu
->start_frame
= urb
->start_frame
;
398 spdu
->number_of_packets
= urb
->number_of_packets
;
399 spdu
->interval
= urb
->interval
;
401 urb
->transfer_flags
= spdu
->transfer_flags
;
402 urb
->transfer_buffer_length
= spdu
->transfer_buffer_length
;
403 urb
->start_frame
= spdu
->start_frame
;
404 urb
->number_of_packets
= spdu
->number_of_packets
;
405 urb
->interval
= spdu
->interval
;
409 static void usbip_pack_ret_submit(struct usbip_header
*pdu
, struct urb
*urb
,
412 struct usbip_header_ret_submit
*rpdu
= &pdu
->u
.ret_submit
;
415 rpdu
->status
= urb
->status
;
416 rpdu
->actual_length
= urb
->actual_length
;
417 rpdu
->start_frame
= urb
->start_frame
;
418 rpdu
->number_of_packets
= urb
->number_of_packets
;
419 rpdu
->error_count
= urb
->error_count
;
421 urb
->status
= rpdu
->status
;
422 urb
->actual_length
= rpdu
->actual_length
;
423 urb
->start_frame
= rpdu
->start_frame
;
424 urb
->number_of_packets
= rpdu
->number_of_packets
;
425 urb
->error_count
= rpdu
->error_count
;
429 void usbip_pack_pdu(struct usbip_header
*pdu
, struct urb
*urb
, int cmd
,
433 case USBIP_CMD_SUBMIT
:
434 usbip_pack_cmd_submit(pdu
, urb
, pack
);
436 case USBIP_RET_SUBMIT
:
437 usbip_pack_ret_submit(pdu
, urb
, pack
);
441 pr_err("unknown command\n");
445 EXPORT_SYMBOL_GPL(usbip_pack_pdu
);
447 static void correct_endian_basic(struct usbip_header_basic
*base
, int send
)
450 base
->command
= cpu_to_be32(base
->command
);
451 base
->seqnum
= cpu_to_be32(base
->seqnum
);
452 base
->devid
= cpu_to_be32(base
->devid
);
453 base
->direction
= cpu_to_be32(base
->direction
);
454 base
->ep
= cpu_to_be32(base
->ep
);
456 base
->command
= be32_to_cpu(base
->command
);
457 base
->seqnum
= be32_to_cpu(base
->seqnum
);
458 base
->devid
= be32_to_cpu(base
->devid
);
459 base
->direction
= be32_to_cpu(base
->direction
);
460 base
->ep
= be32_to_cpu(base
->ep
);
464 static void correct_endian_cmd_submit(struct usbip_header_cmd_submit
*pdu
,
468 pdu
->transfer_flags
= cpu_to_be32(pdu
->transfer_flags
);
470 cpu_to_be32s(&pdu
->transfer_buffer_length
);
471 cpu_to_be32s(&pdu
->start_frame
);
472 cpu_to_be32s(&pdu
->number_of_packets
);
473 cpu_to_be32s(&pdu
->interval
);
475 pdu
->transfer_flags
= be32_to_cpu(pdu
->transfer_flags
);
477 be32_to_cpus(&pdu
->transfer_buffer_length
);
478 be32_to_cpus(&pdu
->start_frame
);
479 be32_to_cpus(&pdu
->number_of_packets
);
480 be32_to_cpus(&pdu
->interval
);
484 static void correct_endian_ret_submit(struct usbip_header_ret_submit
*pdu
,
488 cpu_to_be32s(&pdu
->status
);
489 cpu_to_be32s(&pdu
->actual_length
);
490 cpu_to_be32s(&pdu
->start_frame
);
491 cpu_to_be32s(&pdu
->number_of_packets
);
492 cpu_to_be32s(&pdu
->error_count
);
494 be32_to_cpus(&pdu
->status
);
495 be32_to_cpus(&pdu
->actual_length
);
496 be32_to_cpus(&pdu
->start_frame
);
497 be32_to_cpus(&pdu
->number_of_packets
);
498 be32_to_cpus(&pdu
->error_count
);
502 static void correct_endian_cmd_unlink(struct usbip_header_cmd_unlink
*pdu
,
506 pdu
->seqnum
= cpu_to_be32(pdu
->seqnum
);
508 pdu
->seqnum
= be32_to_cpu(pdu
->seqnum
);
511 static void correct_endian_ret_unlink(struct usbip_header_ret_unlink
*pdu
,
515 cpu_to_be32s(&pdu
->status
);
517 be32_to_cpus(&pdu
->status
);
520 void usbip_header_correct_endian(struct usbip_header
*pdu
, int send
)
525 cmd
= pdu
->base
.command
;
527 correct_endian_basic(&pdu
->base
, send
);
530 cmd
= pdu
->base
.command
;
533 case USBIP_CMD_SUBMIT
:
534 correct_endian_cmd_submit(&pdu
->u
.cmd_submit
, send
);
536 case USBIP_RET_SUBMIT
:
537 correct_endian_ret_submit(&pdu
->u
.ret_submit
, send
);
539 case USBIP_CMD_UNLINK
:
540 correct_endian_cmd_unlink(&pdu
->u
.cmd_unlink
, send
);
542 case USBIP_RET_UNLINK
:
543 correct_endian_ret_unlink(&pdu
->u
.ret_unlink
, send
);
547 pr_err("unknown command\n");
551 EXPORT_SYMBOL_GPL(usbip_header_correct_endian
);
553 static void usbip_iso_packet_correct_endian(
554 struct usbip_iso_packet_descriptor
*iso
, int send
)
556 /* does not need all members. but copy all simply. */
558 iso
->offset
= cpu_to_be32(iso
->offset
);
559 iso
->length
= cpu_to_be32(iso
->length
);
560 iso
->status
= cpu_to_be32(iso
->status
);
561 iso
->actual_length
= cpu_to_be32(iso
->actual_length
);
563 iso
->offset
= be32_to_cpu(iso
->offset
);
564 iso
->length
= be32_to_cpu(iso
->length
);
565 iso
->status
= be32_to_cpu(iso
->status
);
566 iso
->actual_length
= be32_to_cpu(iso
->actual_length
);
570 static void usbip_pack_iso(struct usbip_iso_packet_descriptor
*iso
,
571 struct usb_iso_packet_descriptor
*uiso
, int pack
)
574 iso
->offset
= uiso
->offset
;
575 iso
->length
= uiso
->length
;
576 iso
->status
= uiso
->status
;
577 iso
->actual_length
= uiso
->actual_length
;
579 uiso
->offset
= iso
->offset
;
580 uiso
->length
= iso
->length
;
581 uiso
->status
= iso
->status
;
582 uiso
->actual_length
= iso
->actual_length
;
586 /* must free buffer */
587 struct usbip_iso_packet_descriptor
*
588 usbip_alloc_iso_desc_pdu(struct urb
*urb
, ssize_t
*bufflen
)
590 struct usbip_iso_packet_descriptor
*iso
;
591 int np
= urb
->number_of_packets
;
592 ssize_t size
= np
* sizeof(*iso
);
595 iso
= kzalloc(size
, GFP_KERNEL
);
599 for (i
= 0; i
< np
; i
++) {
600 usbip_pack_iso(&iso
[i
], &urb
->iso_frame_desc
[i
], 1);
601 usbip_iso_packet_correct_endian(&iso
[i
], 1);
608 EXPORT_SYMBOL_GPL(usbip_alloc_iso_desc_pdu
);
610 /* some members of urb must be substituted before. */
611 int usbip_recv_iso(struct usbip_device
*ud
, struct urb
*urb
)
614 struct usbip_iso_packet_descriptor
*iso
;
615 int np
= urb
->number_of_packets
;
616 int size
= np
* sizeof(*iso
);
619 int total_length
= 0;
621 if (!usb_pipeisoc(urb
->pipe
))
624 /* my Bluetooth dongle gets ISO URBs which are np = 0 */
628 buff
= kzalloc(size
, GFP_KERNEL
);
632 ret
= usbip_recv(ud
->tcp_socket
, buff
, size
);
634 dev_err(&urb
->dev
->dev
, "recv iso_frame_descriptor, %d\n",
638 if (ud
->side
== USBIP_STUB
|| ud
->side
== USBIP_VUDC
)
639 usbip_event_add(ud
, SDEV_EVENT_ERROR_TCP
);
641 usbip_event_add(ud
, VDEV_EVENT_ERROR_TCP
);
646 iso
= (struct usbip_iso_packet_descriptor
*) buff
;
647 for (i
= 0; i
< np
; i
++) {
648 usbip_iso_packet_correct_endian(&iso
[i
], 0);
649 usbip_pack_iso(&iso
[i
], &urb
->iso_frame_desc
[i
], 0);
650 total_length
+= urb
->iso_frame_desc
[i
].actual_length
;
655 if (total_length
!= urb
->actual_length
) {
656 dev_err(&urb
->dev
->dev
,
657 "total length of iso packets %d not equal to actual length of buffer %d\n",
658 total_length
, urb
->actual_length
);
660 if (ud
->side
== USBIP_STUB
|| ud
->side
== USBIP_VUDC
)
661 usbip_event_add(ud
, SDEV_EVENT_ERROR_TCP
);
663 usbip_event_add(ud
, VDEV_EVENT_ERROR_TCP
);
670 EXPORT_SYMBOL_GPL(usbip_recv_iso
);
673 * This functions restores the padding which was removed for optimizing
674 * the bandwidth during transfer over tcp/ip
676 * buffer and iso packets need to be stored and be in propeper endian in urb
677 * before calling this function
679 void usbip_pad_iso(struct usbip_device
*ud
, struct urb
*urb
)
681 int np
= urb
->number_of_packets
;
683 int actualoffset
= urb
->actual_length
;
685 if (!usb_pipeisoc(urb
->pipe
))
688 /* if no packets or length of data is 0, then nothing to unpack */
689 if (np
== 0 || urb
->actual_length
== 0)
693 * if actual_length is transfer_buffer_length then no padding is
696 if (urb
->actual_length
== urb
->transfer_buffer_length
)
700 * loop over all packets from last to first (to prevent overwriting
701 * memory when padding) and move them into the proper place
703 for (i
= np
-1; i
> 0; i
--) {
704 actualoffset
-= urb
->iso_frame_desc
[i
].actual_length
;
705 memmove(urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
,
706 urb
->transfer_buffer
+ actualoffset
,
707 urb
->iso_frame_desc
[i
].actual_length
);
710 EXPORT_SYMBOL_GPL(usbip_pad_iso
);
712 /* some members of urb must be substituted before. */
713 int usbip_recv_xbuff(struct usbip_device
*ud
, struct urb
*urb
)
718 if (ud
->side
== USBIP_STUB
|| ud
->side
== USBIP_VUDC
) {
719 /* the direction of urb must be OUT. */
720 if (usb_pipein(urb
->pipe
))
723 size
= urb
->transfer_buffer_length
;
725 /* the direction of urb must be IN. */
726 if (usb_pipeout(urb
->pipe
))
729 size
= urb
->actual_length
;
732 /* no need to recv xbuff */
736 if (size
> urb
->transfer_buffer_length
) {
737 /* should not happen, probably malicious packet */
738 if (ud
->side
== USBIP_STUB
) {
739 usbip_event_add(ud
, SDEV_EVENT_ERROR_TCP
);
742 usbip_event_add(ud
, VDEV_EVENT_ERROR_TCP
);
747 ret
= usbip_recv(ud
->tcp_socket
, urb
->transfer_buffer
, size
);
749 dev_err(&urb
->dev
->dev
, "recv xbuf, %d\n", ret
);
750 if (ud
->side
== USBIP_STUB
|| ud
->side
== USBIP_VUDC
) {
751 usbip_event_add(ud
, SDEV_EVENT_ERROR_TCP
);
753 usbip_event_add(ud
, VDEV_EVENT_ERROR_TCP
);
760 EXPORT_SYMBOL_GPL(usbip_recv_xbuff
);
762 static int __init
usbip_core_init(void)
766 pr_info(DRIVER_DESC
" v" USBIP_VERSION
"\n");
767 ret
= usbip_init_eh();
774 static void __exit
usbip_core_exit(void)
780 module_init(usbip_core_init
);
781 module_exit(usbip_core_exit
);
783 MODULE_AUTHOR(DRIVER_AUTHOR
);
784 MODULE_DESCRIPTION(DRIVER_DESC
);
785 MODULE_LICENSE("GPL");
786 MODULE_VERSION(USBIP_VERSION
);