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 <asm/byteorder.h>
21 #include <linux/file.h>
23 #include <linux/kernel.h>
24 #include <linux/slab.h>
25 #include <linux/stat.h>
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
30 #include "usbip_common.h"
32 #define DRIVER_AUTHOR "Takahiro Hirofuchi <hirofuchi@users.sourceforge.net>"
33 #define DRIVER_DESC "USB/IP Core"
35 #ifdef CONFIG_USBIP_DEBUG
36 unsigned long usbip_debug_flag
= 0xffffffff;
38 unsigned long usbip_debug_flag
;
40 EXPORT_SYMBOL_GPL(usbip_debug_flag
);
41 module_param(usbip_debug_flag
, ulong
, S_IRUGO
|S_IWUSR
);
42 MODULE_PARM_DESC(usbip_debug_flag
, "debug flags (defined in usbip_common.h)");
45 struct device_attribute dev_attr_usbip_debug
;
46 EXPORT_SYMBOL_GPL(dev_attr_usbip_debug
);
48 static ssize_t
usbip_debug_show(struct device
*dev
,
49 struct device_attribute
*attr
, char *buf
)
51 return sprintf(buf
, "%lx\n", usbip_debug_flag
);
54 static ssize_t
usbip_debug_store(struct device
*dev
,
55 struct device_attribute
*attr
, const char *buf
,
58 sscanf(buf
, "%lx", &usbip_debug_flag
);
61 DEVICE_ATTR_RW(usbip_debug
);
63 static void usbip_dump_buffer(char *buff
, int bufflen
)
65 print_hex_dump(KERN_DEBUG
, "usbip-core", DUMP_PREFIX_OFFSET
, 16, 4,
66 buff
, bufflen
, false);
69 static void usbip_dump_pipe(unsigned int p
)
71 unsigned char type
= usb_pipetype(p
);
72 unsigned char ep
= usb_pipeendpoint(p
);
73 unsigned char dev
= usb_pipedevice(p
);
74 unsigned char dir
= usb_pipein(p
);
76 pr_debug("dev(%d) ep(%d) [%s] ", dev
, ep
, dir
? "IN" : "OUT");
79 case PIPE_ISOCHRONOUS
:
97 static void usbip_dump_usb_device(struct usb_device
*udev
)
99 struct device
*dev
= &udev
->dev
;
102 dev_dbg(dev
, " devnum(%d) devpath(%s) ",
103 udev
->devnum
, udev
->devpath
);
105 switch (udev
->speed
) {
107 pr_debug("SPD_HIGH ");
110 pr_debug("SPD_FULL ");
113 pr_debug("SPD_LOW ");
115 case USB_SPEED_UNKNOWN
:
116 pr_debug("SPD_UNKNOWN ");
119 pr_debug("SPD_ERROR ");
123 pr_debug("tt %p, ttport %d\n", udev
->tt
, udev
->ttport
);
126 for (i
= 0; i
< 16; i
++)
130 dev_dbg(dev
, " toggle0(IN) :");
131 for (i
= 0; i
< 16; i
++)
132 pr_debug(" %2u", (udev
->toggle
[0] & (1 << i
)) ? 1 : 0);
135 dev_dbg(dev
, " toggle1(OUT):");
136 for (i
= 0; i
< 16; i
++)
137 pr_debug(" %2u", (udev
->toggle
[1] & (1 << i
)) ? 1 : 0);
140 dev_dbg(dev
, " epmaxp_in :");
141 for (i
= 0; i
< 16; i
++) {
144 le16_to_cpu(udev
->ep_in
[i
]->desc
.wMaxPacketSize
));
148 dev_dbg(dev
, " epmaxp_out :");
149 for (i
= 0; i
< 16; i
++) {
152 le16_to_cpu(udev
->ep_out
[i
]->desc
.wMaxPacketSize
));
156 dev_dbg(dev
, "parent %p, bus %p\n", udev
->parent
, udev
->bus
);
159 "descriptor %p, config %p, actconfig %p, rawdescriptors %p\n",
160 &udev
->descriptor
, udev
->config
,
161 udev
->actconfig
, udev
->rawdescriptors
);
163 dev_dbg(dev
, "have_langid %d, string_langid %d\n",
164 udev
->have_langid
, udev
->string_langid
);
166 dev_dbg(dev
, "maxchild %d\n", udev
->maxchild
);
169 static void usbip_dump_request_type(__u8 rt
)
171 switch (rt
& USB_RECIP_MASK
) {
172 case USB_RECIP_DEVICE
:
175 case USB_RECIP_INTERFACE
:
178 case USB_RECIP_ENDPOINT
:
181 case USB_RECIP_OTHER
:
190 static void usbip_dump_usb_ctrlrequest(struct usb_ctrlrequest
*cmd
)
193 pr_debug(" : null pointer\n");
198 pr_debug("bRequestType(%02X) bRequest(%02X) wValue(%04X) wIndex(%04X) "
199 "wLength(%04X) ", cmd
->bRequestType
, cmd
->bRequest
,
200 cmd
->wValue
, cmd
->wIndex
, cmd
->wLength
);
203 if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_STANDARD
) {
204 pr_debug("STANDARD ");
205 switch (cmd
->bRequest
) {
206 case USB_REQ_GET_STATUS
:
207 pr_debug("GET_STATUS\n");
209 case USB_REQ_CLEAR_FEATURE
:
210 pr_debug("CLEAR_FEAT\n");
212 case USB_REQ_SET_FEATURE
:
213 pr_debug("SET_FEAT\n");
215 case USB_REQ_SET_ADDRESS
:
216 pr_debug("SET_ADDRRS\n");
218 case USB_REQ_GET_DESCRIPTOR
:
219 pr_debug("GET_DESCRI\n");
221 case USB_REQ_SET_DESCRIPTOR
:
222 pr_debug("SET_DESCRI\n");
224 case USB_REQ_GET_CONFIGURATION
:
225 pr_debug("GET_CONFIG\n");
227 case USB_REQ_SET_CONFIGURATION
:
228 pr_debug("SET_CONFIG\n");
230 case USB_REQ_GET_INTERFACE
:
231 pr_debug("GET_INTERF\n");
233 case USB_REQ_SET_INTERFACE
:
234 pr_debug("SET_INTERF\n");
236 case USB_REQ_SYNCH_FRAME
:
237 pr_debug("SYNC_FRAME\n");
240 pr_debug("REQ(%02X)\n", cmd
->bRequest
);
243 usbip_dump_request_type(cmd
->bRequestType
);
244 } else if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_CLASS
) {
246 } else if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_VENDOR
) {
247 pr_debug("VENDOR\n");
248 } else if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_RESERVED
) {
249 pr_debug("RESERVED\n");
253 void usbip_dump_urb(struct urb
*urb
)
258 pr_debug("urb: null pointer!!\n");
263 pr_debug("urb->dev: null pointer!!\n");
267 dev
= &urb
->dev
->dev
;
269 dev_dbg(dev
, " urb :%p\n", urb
);
270 dev_dbg(dev
, " dev :%p\n", urb
->dev
);
272 usbip_dump_usb_device(urb
->dev
);
274 dev_dbg(dev
, " pipe :%08x ", urb
->pipe
);
276 usbip_dump_pipe(urb
->pipe
);
278 dev_dbg(dev
, " status :%d\n", urb
->status
);
279 dev_dbg(dev
, " transfer_flags :%08X\n", urb
->transfer_flags
);
280 dev_dbg(dev
, " transfer_buffer :%p\n", urb
->transfer_buffer
);
281 dev_dbg(dev
, " transfer_buffer_length:%d\n",
282 urb
->transfer_buffer_length
);
283 dev_dbg(dev
, " actual_length :%d\n", urb
->actual_length
);
284 dev_dbg(dev
, " setup_packet :%p\n", urb
->setup_packet
);
286 if (urb
->setup_packet
&& usb_pipetype(urb
->pipe
) == PIPE_CONTROL
)
287 usbip_dump_usb_ctrlrequest(
288 (struct usb_ctrlrequest
*)urb
->setup_packet
);
290 dev_dbg(dev
, " start_frame :%d\n", urb
->start_frame
);
291 dev_dbg(dev
, " number_of_packets :%d\n", urb
->number_of_packets
);
292 dev_dbg(dev
, " interval :%d\n", urb
->interval
);
293 dev_dbg(dev
, " error_count :%d\n", urb
->error_count
);
294 dev_dbg(dev
, " context :%p\n", urb
->context
);
295 dev_dbg(dev
, " complete :%p\n", urb
->complete
);
297 EXPORT_SYMBOL_GPL(usbip_dump_urb
);
299 void usbip_dump_header(struct usbip_header
*pdu
)
301 pr_debug("BASE: cmd %u seq %u devid %u dir %u ep %u\n",
308 switch (pdu
->base
.command
) {
309 case USBIP_CMD_SUBMIT
:
310 pr_debug("USBIP_CMD_SUBMIT: "
311 "x_flags %u x_len %u sf %u #p %d iv %d\n",
312 pdu
->u
.cmd_submit
.transfer_flags
,
313 pdu
->u
.cmd_submit
.transfer_buffer_length
,
314 pdu
->u
.cmd_submit
.start_frame
,
315 pdu
->u
.cmd_submit
.number_of_packets
,
316 pdu
->u
.cmd_submit
.interval
);
318 case USBIP_CMD_UNLINK
:
319 pr_debug("USBIP_CMD_UNLINK: seq %u\n",
320 pdu
->u
.cmd_unlink
.seqnum
);
322 case USBIP_RET_SUBMIT
:
323 pr_debug("USBIP_RET_SUBMIT: st %d al %u sf %d #p %d ec %d\n",
324 pdu
->u
.ret_submit
.status
,
325 pdu
->u
.ret_submit
.actual_length
,
326 pdu
->u
.ret_submit
.start_frame
,
327 pdu
->u
.ret_submit
.number_of_packets
,
328 pdu
->u
.ret_submit
.error_count
);
330 case USBIP_RET_UNLINK
:
331 pr_debug("USBIP_RET_UNLINK: status %d\n",
332 pdu
->u
.ret_unlink
.status
);
336 pr_err("unknown command\n");
340 EXPORT_SYMBOL_GPL(usbip_dump_header
);
342 /* Receive data over TCP/IP. */
343 int usbip_recv(struct socket
*sock
, void *buf
, int size
)
350 /* for blocks of if (usbip_dbg_flag_xmit) */
354 usbip_dbg_xmit("enter\n");
356 if (!sock
|| !buf
|| !size
) {
357 pr_err("invalid arg, sock %p buff %p size %d\n", sock
, buf
,
363 sock
->sk
->sk_allocation
= GFP_NOIO
;
368 msg
.msg_control
= NULL
;
369 msg
.msg_controllen
= 0;
371 msg
.msg_flags
= MSG_NOSIGNAL
;
373 result
= kernel_recvmsg(sock
, &msg
, &iov
, 1, size
, MSG_WAITALL
);
375 pr_debug("receive sock %p buf %p size %u ret %d total %d\n",
376 sock
, buf
, size
, result
, total
);
385 if (usbip_dbg_flag_xmit
) {
387 pr_debug("%-10s:", current
->comm
);
389 pr_debug("interrupt :");
391 pr_debug("receiving....\n");
392 usbip_dump_buffer(bp
, osize
);
393 pr_debug("received, osize %d ret %d size %d total %d\n",
394 osize
, result
, size
, total
);
402 EXPORT_SYMBOL_GPL(usbip_recv
);
404 struct socket
*sockfd_to_socket(unsigned int sockfd
)
406 struct socket
*socket
;
412 pr_err("invalid sockfd\n");
416 inode
= file_inode(file
);
418 if (!inode
|| !S_ISSOCK(inode
->i_mode
)) {
423 socket
= SOCKET_I(inode
);
427 EXPORT_SYMBOL_GPL(sockfd_to_socket
);
429 /* there may be more cases to tweak the flags. */
430 static unsigned int tweak_transfer_flags(unsigned int flags
)
432 flags
&= ~URB_NO_TRANSFER_DMA_MAP
;
436 static void usbip_pack_cmd_submit(struct usbip_header
*pdu
, struct urb
*urb
,
439 struct usbip_header_cmd_submit
*spdu
= &pdu
->u
.cmd_submit
;
442 * Some members are not still implemented in usbip. I hope this issue
443 * will be discussed when usbip is ported to other operating systems.
446 spdu
->transfer_flags
=
447 tweak_transfer_flags(urb
->transfer_flags
);
448 spdu
->transfer_buffer_length
= urb
->transfer_buffer_length
;
449 spdu
->start_frame
= urb
->start_frame
;
450 spdu
->number_of_packets
= urb
->number_of_packets
;
451 spdu
->interval
= urb
->interval
;
453 urb
->transfer_flags
= spdu
->transfer_flags
;
454 urb
->transfer_buffer_length
= spdu
->transfer_buffer_length
;
455 urb
->start_frame
= spdu
->start_frame
;
456 urb
->number_of_packets
= spdu
->number_of_packets
;
457 urb
->interval
= spdu
->interval
;
461 static void usbip_pack_ret_submit(struct usbip_header
*pdu
, struct urb
*urb
,
464 struct usbip_header_ret_submit
*rpdu
= &pdu
->u
.ret_submit
;
467 rpdu
->status
= urb
->status
;
468 rpdu
->actual_length
= urb
->actual_length
;
469 rpdu
->start_frame
= urb
->start_frame
;
470 rpdu
->number_of_packets
= urb
->number_of_packets
;
471 rpdu
->error_count
= urb
->error_count
;
473 urb
->status
= rpdu
->status
;
474 urb
->actual_length
= rpdu
->actual_length
;
475 urb
->start_frame
= rpdu
->start_frame
;
476 urb
->number_of_packets
= rpdu
->number_of_packets
;
477 urb
->error_count
= rpdu
->error_count
;
481 void usbip_pack_pdu(struct usbip_header
*pdu
, struct urb
*urb
, int cmd
,
485 case USBIP_CMD_SUBMIT
:
486 usbip_pack_cmd_submit(pdu
, urb
, pack
);
488 case USBIP_RET_SUBMIT
:
489 usbip_pack_ret_submit(pdu
, urb
, pack
);
493 pr_err("unknown command\n");
497 EXPORT_SYMBOL_GPL(usbip_pack_pdu
);
499 static void correct_endian_basic(struct usbip_header_basic
*base
, int send
)
502 base
->command
= cpu_to_be32(base
->command
);
503 base
->seqnum
= cpu_to_be32(base
->seqnum
);
504 base
->devid
= cpu_to_be32(base
->devid
);
505 base
->direction
= cpu_to_be32(base
->direction
);
506 base
->ep
= cpu_to_be32(base
->ep
);
508 base
->command
= be32_to_cpu(base
->command
);
509 base
->seqnum
= be32_to_cpu(base
->seqnum
);
510 base
->devid
= be32_to_cpu(base
->devid
);
511 base
->direction
= be32_to_cpu(base
->direction
);
512 base
->ep
= be32_to_cpu(base
->ep
);
516 static void correct_endian_cmd_submit(struct usbip_header_cmd_submit
*pdu
,
520 pdu
->transfer_flags
= cpu_to_be32(pdu
->transfer_flags
);
522 cpu_to_be32s(&pdu
->transfer_buffer_length
);
523 cpu_to_be32s(&pdu
->start_frame
);
524 cpu_to_be32s(&pdu
->number_of_packets
);
525 cpu_to_be32s(&pdu
->interval
);
527 pdu
->transfer_flags
= be32_to_cpu(pdu
->transfer_flags
);
529 be32_to_cpus(&pdu
->transfer_buffer_length
);
530 be32_to_cpus(&pdu
->start_frame
);
531 be32_to_cpus(&pdu
->number_of_packets
);
532 be32_to_cpus(&pdu
->interval
);
536 static void correct_endian_ret_submit(struct usbip_header_ret_submit
*pdu
,
540 cpu_to_be32s(&pdu
->status
);
541 cpu_to_be32s(&pdu
->actual_length
);
542 cpu_to_be32s(&pdu
->start_frame
);
543 cpu_to_be32s(&pdu
->number_of_packets
);
544 cpu_to_be32s(&pdu
->error_count
);
546 be32_to_cpus(&pdu
->status
);
547 be32_to_cpus(&pdu
->actual_length
);
548 be32_to_cpus(&pdu
->start_frame
);
549 be32_to_cpus(&pdu
->number_of_packets
);
550 be32_to_cpus(&pdu
->error_count
);
554 static void correct_endian_cmd_unlink(struct usbip_header_cmd_unlink
*pdu
,
558 pdu
->seqnum
= cpu_to_be32(pdu
->seqnum
);
560 pdu
->seqnum
= be32_to_cpu(pdu
->seqnum
);
563 static void correct_endian_ret_unlink(struct usbip_header_ret_unlink
*pdu
,
567 cpu_to_be32s(&pdu
->status
);
569 be32_to_cpus(&pdu
->status
);
572 void usbip_header_correct_endian(struct usbip_header
*pdu
, int send
)
577 cmd
= pdu
->base
.command
;
579 correct_endian_basic(&pdu
->base
, send
);
582 cmd
= pdu
->base
.command
;
585 case USBIP_CMD_SUBMIT
:
586 correct_endian_cmd_submit(&pdu
->u
.cmd_submit
, send
);
588 case USBIP_RET_SUBMIT
:
589 correct_endian_ret_submit(&pdu
->u
.ret_submit
, send
);
591 case USBIP_CMD_UNLINK
:
592 correct_endian_cmd_unlink(&pdu
->u
.cmd_unlink
, send
);
594 case USBIP_RET_UNLINK
:
595 correct_endian_ret_unlink(&pdu
->u
.ret_unlink
, send
);
599 pr_err("unknown command\n");
603 EXPORT_SYMBOL_GPL(usbip_header_correct_endian
);
605 static void usbip_iso_packet_correct_endian(
606 struct usbip_iso_packet_descriptor
*iso
, int send
)
608 /* does not need all members. but copy all simply. */
610 iso
->offset
= cpu_to_be32(iso
->offset
);
611 iso
->length
= cpu_to_be32(iso
->length
);
612 iso
->status
= cpu_to_be32(iso
->status
);
613 iso
->actual_length
= cpu_to_be32(iso
->actual_length
);
615 iso
->offset
= be32_to_cpu(iso
->offset
);
616 iso
->length
= be32_to_cpu(iso
->length
);
617 iso
->status
= be32_to_cpu(iso
->status
);
618 iso
->actual_length
= be32_to_cpu(iso
->actual_length
);
622 static void usbip_pack_iso(struct usbip_iso_packet_descriptor
*iso
,
623 struct usb_iso_packet_descriptor
*uiso
, int pack
)
626 iso
->offset
= uiso
->offset
;
627 iso
->length
= uiso
->length
;
628 iso
->status
= uiso
->status
;
629 iso
->actual_length
= uiso
->actual_length
;
631 uiso
->offset
= iso
->offset
;
632 uiso
->length
= iso
->length
;
633 uiso
->status
= iso
->status
;
634 uiso
->actual_length
= iso
->actual_length
;
638 /* must free buffer */
639 struct usbip_iso_packet_descriptor
*
640 usbip_alloc_iso_desc_pdu(struct urb
*urb
, ssize_t
*bufflen
)
642 struct usbip_iso_packet_descriptor
*iso
;
643 int np
= urb
->number_of_packets
;
644 ssize_t size
= np
* sizeof(*iso
);
647 iso
= kzalloc(size
, GFP_KERNEL
);
651 for (i
= 0; i
< np
; i
++) {
652 usbip_pack_iso(&iso
[i
], &urb
->iso_frame_desc
[i
], 1);
653 usbip_iso_packet_correct_endian(&iso
[i
], 1);
660 EXPORT_SYMBOL_GPL(usbip_alloc_iso_desc_pdu
);
662 /* some members of urb must be substituted before. */
663 int usbip_recv_iso(struct usbip_device
*ud
, struct urb
*urb
)
666 struct usbip_iso_packet_descriptor
*iso
;
667 int np
= urb
->number_of_packets
;
668 int size
= np
* sizeof(*iso
);
671 int total_length
= 0;
673 if (!usb_pipeisoc(urb
->pipe
))
676 /* my Bluetooth dongle gets ISO URBs which are np = 0 */
680 buff
= kzalloc(size
, GFP_KERNEL
);
684 ret
= usbip_recv(ud
->tcp_socket
, buff
, size
);
686 dev_err(&urb
->dev
->dev
, "recv iso_frame_descriptor, %d\n",
690 if (ud
->side
== USBIP_STUB
)
691 usbip_event_add(ud
, SDEV_EVENT_ERROR_TCP
);
693 usbip_event_add(ud
, VDEV_EVENT_ERROR_TCP
);
698 iso
= (struct usbip_iso_packet_descriptor
*) buff
;
699 for (i
= 0; i
< np
; i
++) {
700 usbip_iso_packet_correct_endian(&iso
[i
], 0);
701 usbip_pack_iso(&iso
[i
], &urb
->iso_frame_desc
[i
], 0);
702 total_length
+= urb
->iso_frame_desc
[i
].actual_length
;
707 if (total_length
!= urb
->actual_length
) {
708 dev_err(&urb
->dev
->dev
,
709 "total length of iso packets %d not equal to actual "
710 "length of buffer %d\n",
711 total_length
, urb
->actual_length
);
713 if (ud
->side
== USBIP_STUB
)
714 usbip_event_add(ud
, SDEV_EVENT_ERROR_TCP
);
716 usbip_event_add(ud
, VDEV_EVENT_ERROR_TCP
);
723 EXPORT_SYMBOL_GPL(usbip_recv_iso
);
726 * This functions restores the padding which was removed for optimizing
727 * the bandwidth during transfer over tcp/ip
729 * buffer and iso packets need to be stored and be in propeper endian in urb
730 * before calling this function
732 void usbip_pad_iso(struct usbip_device
*ud
, struct urb
*urb
)
734 int np
= urb
->number_of_packets
;
736 int actualoffset
= urb
->actual_length
;
738 if (!usb_pipeisoc(urb
->pipe
))
741 /* if no packets or length of data is 0, then nothing to unpack */
742 if (np
== 0 || urb
->actual_length
== 0)
746 * if actual_length is transfer_buffer_length then no padding is
749 if (urb
->actual_length
== urb
->transfer_buffer_length
)
753 * loop over all packets from last to first (to prevent overwritting
754 * memory when padding) and move them into the proper place
756 for (i
= np
-1; i
> 0; i
--) {
757 actualoffset
-= urb
->iso_frame_desc
[i
].actual_length
;
758 memmove(urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
,
759 urb
->transfer_buffer
+ actualoffset
,
760 urb
->iso_frame_desc
[i
].actual_length
);
763 EXPORT_SYMBOL_GPL(usbip_pad_iso
);
765 /* some members of urb must be substituted before. */
766 int usbip_recv_xbuff(struct usbip_device
*ud
, struct urb
*urb
)
771 if (ud
->side
== USBIP_STUB
) {
772 /* the direction of urb must be OUT. */
773 if (usb_pipein(urb
->pipe
))
776 size
= urb
->transfer_buffer_length
;
778 /* the direction of urb must be IN. */
779 if (usb_pipeout(urb
->pipe
))
782 size
= urb
->actual_length
;
785 /* no need to recv xbuff */
789 ret
= usbip_recv(ud
->tcp_socket
, urb
->transfer_buffer
, size
);
791 dev_err(&urb
->dev
->dev
, "recv xbuf, %d\n", ret
);
792 if (ud
->side
== USBIP_STUB
) {
793 usbip_event_add(ud
, SDEV_EVENT_ERROR_TCP
);
795 usbip_event_add(ud
, VDEV_EVENT_ERROR_TCP
);
802 EXPORT_SYMBOL_GPL(usbip_recv_xbuff
);
804 static int __init
usbip_core_init(void)
806 pr_info(DRIVER_DESC
" v" USBIP_VERSION
"\n");
810 static void __exit
usbip_core_exit(void)
815 module_init(usbip_core_init
);
816 module_exit(usbip_core_exit
);
818 MODULE_AUTHOR(DRIVER_AUTHOR
);
819 MODULE_DESCRIPTION(DRIVER_DESC
);
820 MODULE_LICENSE("GPL");
821 MODULE_VERSION(USBIP_VERSION
);