1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2003-2008 Takahiro Hirofuchi
4 * Copyright (C) 2015-2016 Samsung Electronics
5 * Krzysztof Opasiak <k.opasiak@samsung.com>
8 #include <asm/byteorder.h>
9 #include <linux/file.h>
11 #include <linux/kernel.h>
12 #include <linux/slab.h>
13 #include <linux/stat.h>
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
18 #include "usbip_common.h"
20 #define DRIVER_AUTHOR "Takahiro Hirofuchi <hirofuchi@users.sourceforge.net>"
21 #define DRIVER_DESC "USB/IP Core"
23 #ifdef CONFIG_USBIP_DEBUG
24 unsigned long usbip_debug_flag
= 0xffffffff;
26 unsigned long usbip_debug_flag
;
28 EXPORT_SYMBOL_GPL(usbip_debug_flag
);
29 module_param(usbip_debug_flag
, ulong
, S_IRUGO
|S_IWUSR
);
30 MODULE_PARM_DESC(usbip_debug_flag
, "debug flags (defined in usbip_common.h)");
33 struct device_attribute dev_attr_usbip_debug
;
34 EXPORT_SYMBOL_GPL(dev_attr_usbip_debug
);
36 static ssize_t
usbip_debug_show(struct device
*dev
,
37 struct device_attribute
*attr
, char *buf
)
39 return sprintf(buf
, "%lx\n", usbip_debug_flag
);
42 static ssize_t
usbip_debug_store(struct device
*dev
,
43 struct device_attribute
*attr
, const char *buf
,
46 if (sscanf(buf
, "%lx", &usbip_debug_flag
) != 1)
50 DEVICE_ATTR_RW(usbip_debug
);
52 static void usbip_dump_buffer(char *buff
, int bufflen
)
54 print_hex_dump(KERN_DEBUG
, "usbip-core", DUMP_PREFIX_OFFSET
, 16, 4,
55 buff
, bufflen
, false);
58 static void usbip_dump_pipe(unsigned int p
)
60 unsigned char type
= usb_pipetype(p
);
61 unsigned char ep
= usb_pipeendpoint(p
);
62 unsigned char dev
= usb_pipedevice(p
);
63 unsigned char dir
= usb_pipein(p
);
65 pr_debug("dev(%d) ep(%d) [%s] ", dev
, ep
, dir
? "IN" : "OUT");
68 case PIPE_ISOCHRONOUS
:
86 static void usbip_dump_usb_device(struct usb_device
*udev
)
88 struct device
*dev
= &udev
->dev
;
91 dev_dbg(dev
, " devnum(%d) devpath(%s) usb speed(%s)",
92 udev
->devnum
, udev
->devpath
, usb_speed_string(udev
->speed
));
94 pr_debug("tt hub ttport %d\n", udev
->ttport
);
97 for (i
= 0; i
< 16; i
++)
101 dev_dbg(dev
, " toggle0(IN) :");
102 for (i
= 0; i
< 16; i
++)
103 pr_debug(" %2u", (udev
->toggle
[0] & (1 << i
)) ? 1 : 0);
106 dev_dbg(dev
, " toggle1(OUT):");
107 for (i
= 0; i
< 16; i
++)
108 pr_debug(" %2u", (udev
->toggle
[1] & (1 << i
)) ? 1 : 0);
111 dev_dbg(dev
, " epmaxp_in :");
112 for (i
= 0; i
< 16; i
++) {
115 le16_to_cpu(udev
->ep_in
[i
]->desc
.wMaxPacketSize
));
119 dev_dbg(dev
, " epmaxp_out :");
120 for (i
= 0; i
< 16; i
++) {
123 le16_to_cpu(udev
->ep_out
[i
]->desc
.wMaxPacketSize
));
127 dev_dbg(dev
, "parent %s, bus %s\n", dev_name(&udev
->parent
->dev
),
128 udev
->bus
->bus_name
);
130 dev_dbg(dev
, "have_langid %d, string_langid %d\n",
131 udev
->have_langid
, udev
->string_langid
);
133 dev_dbg(dev
, "maxchild %d\n", udev
->maxchild
);
136 static void usbip_dump_request_type(__u8 rt
)
138 switch (rt
& USB_RECIP_MASK
) {
139 case USB_RECIP_DEVICE
:
142 case USB_RECIP_INTERFACE
:
145 case USB_RECIP_ENDPOINT
:
148 case USB_RECIP_OTHER
:
157 static void usbip_dump_usb_ctrlrequest(struct usb_ctrlrequest
*cmd
)
160 pr_debug(" : null pointer\n");
165 pr_debug("bRequestType(%02X) bRequest(%02X) wValue(%04X) wIndex(%04X) wLength(%04X) ",
166 cmd
->bRequestType
, cmd
->bRequest
,
167 cmd
->wValue
, cmd
->wIndex
, cmd
->wLength
);
170 if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_STANDARD
) {
171 pr_debug("STANDARD ");
172 switch (cmd
->bRequest
) {
173 case USB_REQ_GET_STATUS
:
174 pr_debug("GET_STATUS\n");
176 case USB_REQ_CLEAR_FEATURE
:
177 pr_debug("CLEAR_FEAT\n");
179 case USB_REQ_SET_FEATURE
:
180 pr_debug("SET_FEAT\n");
182 case USB_REQ_SET_ADDRESS
:
183 pr_debug("SET_ADDRRS\n");
185 case USB_REQ_GET_DESCRIPTOR
:
186 pr_debug("GET_DESCRI\n");
188 case USB_REQ_SET_DESCRIPTOR
:
189 pr_debug("SET_DESCRI\n");
191 case USB_REQ_GET_CONFIGURATION
:
192 pr_debug("GET_CONFIG\n");
194 case USB_REQ_SET_CONFIGURATION
:
195 pr_debug("SET_CONFIG\n");
197 case USB_REQ_GET_INTERFACE
:
198 pr_debug("GET_INTERF\n");
200 case USB_REQ_SET_INTERFACE
:
201 pr_debug("SET_INTERF\n");
203 case USB_REQ_SYNCH_FRAME
:
204 pr_debug("SYNC_FRAME\n");
207 pr_debug("REQ(%02X)\n", cmd
->bRequest
);
210 usbip_dump_request_type(cmd
->bRequestType
);
211 } else if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_CLASS
) {
213 } else if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_VENDOR
) {
214 pr_debug("VENDOR\n");
215 } else if ((cmd
->bRequestType
& USB_TYPE_MASK
) == USB_TYPE_RESERVED
) {
216 pr_debug("RESERVED\n");
220 void usbip_dump_urb(struct urb
*urb
)
225 pr_debug("urb: null pointer!!\n");
230 pr_debug("urb->dev: null pointer!!\n");
234 dev
= &urb
->dev
->dev
;
236 usbip_dump_usb_device(urb
->dev
);
238 dev_dbg(dev
, " pipe :%08x ", urb
->pipe
);
240 usbip_dump_pipe(urb
->pipe
);
242 dev_dbg(dev
, " status :%d\n", urb
->status
);
243 dev_dbg(dev
, " transfer_flags :%08X\n", urb
->transfer_flags
);
244 dev_dbg(dev
, " transfer_buffer_length:%d\n",
245 urb
->transfer_buffer_length
);
246 dev_dbg(dev
, " actual_length :%d\n", urb
->actual_length
);
248 if (urb
->setup_packet
&& usb_pipetype(urb
->pipe
) == PIPE_CONTROL
)
249 usbip_dump_usb_ctrlrequest(
250 (struct usb_ctrlrequest
*)urb
->setup_packet
);
252 dev_dbg(dev
, " start_frame :%d\n", urb
->start_frame
);
253 dev_dbg(dev
, " number_of_packets :%d\n", urb
->number_of_packets
);
254 dev_dbg(dev
, " interval :%d\n", urb
->interval
);
255 dev_dbg(dev
, " error_count :%d\n", urb
->error_count
);
257 EXPORT_SYMBOL_GPL(usbip_dump_urb
);
259 void usbip_dump_header(struct usbip_header
*pdu
)
261 pr_debug("BASE: cmd %u seq %u devid %u dir %u ep %u\n",
268 switch (pdu
->base
.command
) {
269 case USBIP_CMD_SUBMIT
:
270 pr_debug("USBIP_CMD_SUBMIT: x_flags %u x_len %u sf %u #p %d iv %d\n",
271 pdu
->u
.cmd_submit
.transfer_flags
,
272 pdu
->u
.cmd_submit
.transfer_buffer_length
,
273 pdu
->u
.cmd_submit
.start_frame
,
274 pdu
->u
.cmd_submit
.number_of_packets
,
275 pdu
->u
.cmd_submit
.interval
);
277 case USBIP_CMD_UNLINK
:
278 pr_debug("USBIP_CMD_UNLINK: seq %u\n",
279 pdu
->u
.cmd_unlink
.seqnum
);
281 case USBIP_RET_SUBMIT
:
282 pr_debug("USBIP_RET_SUBMIT: st %d al %u sf %d #p %d ec %d\n",
283 pdu
->u
.ret_submit
.status
,
284 pdu
->u
.ret_submit
.actual_length
,
285 pdu
->u
.ret_submit
.start_frame
,
286 pdu
->u
.ret_submit
.number_of_packets
,
287 pdu
->u
.ret_submit
.error_count
);
289 case USBIP_RET_UNLINK
:
290 pr_debug("USBIP_RET_UNLINK: status %d\n",
291 pdu
->u
.ret_unlink
.status
);
295 pr_err("unknown command\n");
299 EXPORT_SYMBOL_GPL(usbip_dump_header
);
301 /* Receive data over TCP/IP. */
302 int usbip_recv(struct socket
*sock
, void *buf
, int size
)
305 struct kvec iov
= {.iov_base
= buf
, .iov_len
= size
};
306 struct msghdr msg
= {.msg_flags
= MSG_NOSIGNAL
};
309 if (!sock
|| !buf
|| !size
)
312 iov_iter_kvec(&msg
.msg_iter
, READ
, &iov
, 1, size
);
314 usbip_dbg_xmit("enter\n");
317 sock
->sk
->sk_allocation
= GFP_NOIO
;
319 result
= sock_recvmsg(sock
, &msg
, MSG_WAITALL
);
324 } while (msg_data_left(&msg
));
326 if (usbip_dbg_flag_xmit
) {
327 pr_debug("receiving....\n");
328 usbip_dump_buffer(buf
, size
);
329 pr_debug("received, osize %d ret %d size %zd total %d\n",
330 size
, result
, msg_data_left(&msg
), total
);
338 EXPORT_SYMBOL_GPL(usbip_recv
);
340 /* there may be more cases to tweak the flags. */
341 static unsigned int tweak_transfer_flags(unsigned int flags
)
343 flags
&= ~URB_NO_TRANSFER_DMA_MAP
;
347 static void usbip_pack_cmd_submit(struct usbip_header
*pdu
, struct urb
*urb
,
350 struct usbip_header_cmd_submit
*spdu
= &pdu
->u
.cmd_submit
;
353 * Some members are not still implemented in usbip. I hope this issue
354 * will be discussed when usbip is ported to other operating systems.
357 spdu
->transfer_flags
=
358 tweak_transfer_flags(urb
->transfer_flags
);
359 spdu
->transfer_buffer_length
= urb
->transfer_buffer_length
;
360 spdu
->start_frame
= urb
->start_frame
;
361 spdu
->number_of_packets
= urb
->number_of_packets
;
362 spdu
->interval
= urb
->interval
;
364 urb
->transfer_flags
= spdu
->transfer_flags
;
365 urb
->transfer_buffer_length
= spdu
->transfer_buffer_length
;
366 urb
->start_frame
= spdu
->start_frame
;
367 urb
->number_of_packets
= spdu
->number_of_packets
;
368 urb
->interval
= spdu
->interval
;
372 static void usbip_pack_ret_submit(struct usbip_header
*pdu
, struct urb
*urb
,
375 struct usbip_header_ret_submit
*rpdu
= &pdu
->u
.ret_submit
;
378 rpdu
->status
= urb
->status
;
379 rpdu
->actual_length
= urb
->actual_length
;
380 rpdu
->start_frame
= urb
->start_frame
;
381 rpdu
->number_of_packets
= urb
->number_of_packets
;
382 rpdu
->error_count
= urb
->error_count
;
384 urb
->status
= rpdu
->status
;
385 urb
->actual_length
= rpdu
->actual_length
;
386 urb
->start_frame
= rpdu
->start_frame
;
387 urb
->number_of_packets
= rpdu
->number_of_packets
;
388 urb
->error_count
= rpdu
->error_count
;
392 void usbip_pack_pdu(struct usbip_header
*pdu
, struct urb
*urb
, int cmd
,
396 case USBIP_CMD_SUBMIT
:
397 usbip_pack_cmd_submit(pdu
, urb
, pack
);
399 case USBIP_RET_SUBMIT
:
400 usbip_pack_ret_submit(pdu
, urb
, pack
);
404 pr_err("unknown command\n");
408 EXPORT_SYMBOL_GPL(usbip_pack_pdu
);
410 static void correct_endian_basic(struct usbip_header_basic
*base
, int send
)
413 base
->command
= cpu_to_be32(base
->command
);
414 base
->seqnum
= cpu_to_be32(base
->seqnum
);
415 base
->devid
= cpu_to_be32(base
->devid
);
416 base
->direction
= cpu_to_be32(base
->direction
);
417 base
->ep
= cpu_to_be32(base
->ep
);
419 base
->command
= be32_to_cpu(base
->command
);
420 base
->seqnum
= be32_to_cpu(base
->seqnum
);
421 base
->devid
= be32_to_cpu(base
->devid
);
422 base
->direction
= be32_to_cpu(base
->direction
);
423 base
->ep
= be32_to_cpu(base
->ep
);
427 static void correct_endian_cmd_submit(struct usbip_header_cmd_submit
*pdu
,
431 pdu
->transfer_flags
= cpu_to_be32(pdu
->transfer_flags
);
433 cpu_to_be32s(&pdu
->transfer_buffer_length
);
434 cpu_to_be32s(&pdu
->start_frame
);
435 cpu_to_be32s(&pdu
->number_of_packets
);
436 cpu_to_be32s(&pdu
->interval
);
438 pdu
->transfer_flags
= be32_to_cpu(pdu
->transfer_flags
);
440 be32_to_cpus(&pdu
->transfer_buffer_length
);
441 be32_to_cpus(&pdu
->start_frame
);
442 be32_to_cpus(&pdu
->number_of_packets
);
443 be32_to_cpus(&pdu
->interval
);
447 static void correct_endian_ret_submit(struct usbip_header_ret_submit
*pdu
,
451 cpu_to_be32s(&pdu
->status
);
452 cpu_to_be32s(&pdu
->actual_length
);
453 cpu_to_be32s(&pdu
->start_frame
);
454 cpu_to_be32s(&pdu
->number_of_packets
);
455 cpu_to_be32s(&pdu
->error_count
);
457 be32_to_cpus(&pdu
->status
);
458 be32_to_cpus(&pdu
->actual_length
);
459 be32_to_cpus(&pdu
->start_frame
);
460 be32_to_cpus(&pdu
->number_of_packets
);
461 be32_to_cpus(&pdu
->error_count
);
465 static void correct_endian_cmd_unlink(struct usbip_header_cmd_unlink
*pdu
,
469 pdu
->seqnum
= cpu_to_be32(pdu
->seqnum
);
471 pdu
->seqnum
= be32_to_cpu(pdu
->seqnum
);
474 static void correct_endian_ret_unlink(struct usbip_header_ret_unlink
*pdu
,
478 cpu_to_be32s(&pdu
->status
);
480 be32_to_cpus(&pdu
->status
);
483 void usbip_header_correct_endian(struct usbip_header
*pdu
, int send
)
488 cmd
= pdu
->base
.command
;
490 correct_endian_basic(&pdu
->base
, send
);
493 cmd
= pdu
->base
.command
;
496 case USBIP_CMD_SUBMIT
:
497 correct_endian_cmd_submit(&pdu
->u
.cmd_submit
, send
);
499 case USBIP_RET_SUBMIT
:
500 correct_endian_ret_submit(&pdu
->u
.ret_submit
, send
);
502 case USBIP_CMD_UNLINK
:
503 correct_endian_cmd_unlink(&pdu
->u
.cmd_unlink
, send
);
505 case USBIP_RET_UNLINK
:
506 correct_endian_ret_unlink(&pdu
->u
.ret_unlink
, send
);
510 pr_err("unknown command\n");
514 EXPORT_SYMBOL_GPL(usbip_header_correct_endian
);
516 static void usbip_iso_packet_correct_endian(
517 struct usbip_iso_packet_descriptor
*iso
, int send
)
519 /* does not need all members. but copy all simply. */
521 iso
->offset
= cpu_to_be32(iso
->offset
);
522 iso
->length
= cpu_to_be32(iso
->length
);
523 iso
->status
= cpu_to_be32(iso
->status
);
524 iso
->actual_length
= cpu_to_be32(iso
->actual_length
);
526 iso
->offset
= be32_to_cpu(iso
->offset
);
527 iso
->length
= be32_to_cpu(iso
->length
);
528 iso
->status
= be32_to_cpu(iso
->status
);
529 iso
->actual_length
= be32_to_cpu(iso
->actual_length
);
533 static void usbip_pack_iso(struct usbip_iso_packet_descriptor
*iso
,
534 struct usb_iso_packet_descriptor
*uiso
, int pack
)
537 iso
->offset
= uiso
->offset
;
538 iso
->length
= uiso
->length
;
539 iso
->status
= uiso
->status
;
540 iso
->actual_length
= uiso
->actual_length
;
542 uiso
->offset
= iso
->offset
;
543 uiso
->length
= iso
->length
;
544 uiso
->status
= iso
->status
;
545 uiso
->actual_length
= iso
->actual_length
;
549 /* must free buffer */
550 struct usbip_iso_packet_descriptor
*
551 usbip_alloc_iso_desc_pdu(struct urb
*urb
, ssize_t
*bufflen
)
553 struct usbip_iso_packet_descriptor
*iso
;
554 int np
= urb
->number_of_packets
;
555 ssize_t size
= np
* sizeof(*iso
);
558 iso
= kzalloc(size
, GFP_KERNEL
);
562 for (i
= 0; i
< np
; i
++) {
563 usbip_pack_iso(&iso
[i
], &urb
->iso_frame_desc
[i
], 1);
564 usbip_iso_packet_correct_endian(&iso
[i
], 1);
571 EXPORT_SYMBOL_GPL(usbip_alloc_iso_desc_pdu
);
573 /* some members of urb must be substituted before. */
574 int usbip_recv_iso(struct usbip_device
*ud
, struct urb
*urb
)
577 struct usbip_iso_packet_descriptor
*iso
;
578 int np
= urb
->number_of_packets
;
579 int size
= np
* sizeof(*iso
);
582 int total_length
= 0;
584 if (!usb_pipeisoc(urb
->pipe
))
587 /* my Bluetooth dongle gets ISO URBs which are np = 0 */
591 buff
= kzalloc(size
, GFP_KERNEL
);
595 ret
= usbip_recv(ud
->tcp_socket
, buff
, size
);
597 dev_err(&urb
->dev
->dev
, "recv iso_frame_descriptor, %d\n",
601 if (ud
->side
== USBIP_STUB
|| ud
->side
== USBIP_VUDC
)
602 usbip_event_add(ud
, SDEV_EVENT_ERROR_TCP
);
604 usbip_event_add(ud
, VDEV_EVENT_ERROR_TCP
);
609 iso
= (struct usbip_iso_packet_descriptor
*) buff
;
610 for (i
= 0; i
< np
; i
++) {
611 usbip_iso_packet_correct_endian(&iso
[i
], 0);
612 usbip_pack_iso(&iso
[i
], &urb
->iso_frame_desc
[i
], 0);
613 total_length
+= urb
->iso_frame_desc
[i
].actual_length
;
618 if (total_length
!= urb
->actual_length
) {
619 dev_err(&urb
->dev
->dev
,
620 "total length of iso packets %d not equal to actual length of buffer %d\n",
621 total_length
, urb
->actual_length
);
623 if (ud
->side
== USBIP_STUB
|| ud
->side
== USBIP_VUDC
)
624 usbip_event_add(ud
, SDEV_EVENT_ERROR_TCP
);
626 usbip_event_add(ud
, VDEV_EVENT_ERROR_TCP
);
633 EXPORT_SYMBOL_GPL(usbip_recv_iso
);
636 * This functions restores the padding which was removed for optimizing
637 * the bandwidth during transfer over tcp/ip
639 * buffer and iso packets need to be stored and be in propeper endian in urb
640 * before calling this function
642 void usbip_pad_iso(struct usbip_device
*ud
, struct urb
*urb
)
644 int np
= urb
->number_of_packets
;
646 int actualoffset
= urb
->actual_length
;
648 if (!usb_pipeisoc(urb
->pipe
))
651 /* if no packets or length of data is 0, then nothing to unpack */
652 if (np
== 0 || urb
->actual_length
== 0)
656 * if actual_length is transfer_buffer_length then no padding is
659 if (urb
->actual_length
== urb
->transfer_buffer_length
)
663 * loop over all packets from last to first (to prevent overwriting
664 * memory when padding) and move them into the proper place
666 for (i
= np
-1; i
> 0; i
--) {
667 actualoffset
-= urb
->iso_frame_desc
[i
].actual_length
;
668 memmove(urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
,
669 urb
->transfer_buffer
+ actualoffset
,
670 urb
->iso_frame_desc
[i
].actual_length
);
673 EXPORT_SYMBOL_GPL(usbip_pad_iso
);
675 /* some members of urb must be substituted before. */
676 int usbip_recv_xbuff(struct usbip_device
*ud
, struct urb
*urb
)
678 struct scatterlist
*sg
;
685 if (ud
->side
== USBIP_STUB
|| ud
->side
== USBIP_VUDC
) {
686 /* the direction of urb must be OUT. */
687 if (usb_pipein(urb
->pipe
))
690 size
= urb
->transfer_buffer_length
;
692 /* the direction of urb must be IN. */
693 if (usb_pipeout(urb
->pipe
))
696 size
= urb
->actual_length
;
699 /* no need to recv xbuff */
703 if (size
> urb
->transfer_buffer_length
)
704 /* should not happen, probably malicious packet */
709 for_each_sg(urb
->sg
, sg
, urb
->num_sgs
, i
) {
712 if (copy
< sg
->length
)
715 recv_size
= sg
->length
;
717 recv
= usbip_recv(ud
->tcp_socket
, sg_virt(sg
),
720 if (recv
!= recv_size
)
733 ret
= usbip_recv(ud
->tcp_socket
, urb
->transfer_buffer
, size
);
741 dev_err(&urb
->dev
->dev
, "recv xbuf, %d\n", ret
);
742 if (ud
->side
== USBIP_STUB
|| ud
->side
== USBIP_VUDC
)
743 usbip_event_add(ud
, SDEV_EVENT_ERROR_TCP
);
745 usbip_event_add(ud
, VDEV_EVENT_ERROR_TCP
);
749 EXPORT_SYMBOL_GPL(usbip_recv_xbuff
);
751 static int __init
usbip_core_init(void)
753 return usbip_init_eh();
756 static void __exit
usbip_core_exit(void)
762 module_init(usbip_core_init
);
763 module_exit(usbip_core_exit
);
765 MODULE_AUTHOR(DRIVER_AUTHOR
);
766 MODULE_DESCRIPTION(DRIVER_DESC
);
767 MODULE_LICENSE("GPL");