LXR linux/drivers/staging/usbip/usbip

   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
  20#ifndef __VHCI_COMMON_H
  21#define __VHCI_COMMON_H
  22
  23
  24#include <linux/version.h>
  25#include <linux/usb.h>
  26#include <asm/byteorder.h>
  27#include <net/sock.h>
  28
  29/*-------------------------------------------------------------------------*/
  30
  31/*
  32 * define macros to print messages
  33 */
  34
  35/**
  36 * usbip_udbg - print debug messages if CONFIG_USB_DEBUG is defined
  37 * @fmt:
  38 * @args:
  39 */
  40
  41#ifdef CONFIG_USB_DEBUG
  42
  43#define usbip_udbg(fmt, args...)                                        \
  44        do {                                                            \
  45                printk(KERN_DEBUG "%-10s:(%s,%d) %s: " fmt,             \
  46                        (in_interrupt() ? "interrupt" : (current)->comm),\
  47                        __FILE__, __LINE__, __func__, ##args);          \
  48        } while (0)
  49
  50#else  /* CONFIG_USB_DEBUG */
  51
  52#define usbip_udbg(fmt, args...)                do { } while (0)
  53
  54#endif /* CONFIG_USB_DEBUG */
  55
  56
  57enum {
  58        usbip_debug_xmit        = (1 << 0),
  59        usbip_debug_sysfs       = (1 << 1),
  60        usbip_debug_urb         = (1 << 2),
  61        usbip_debug_eh          = (1 << 3),
  62
  63        usbip_debug_stub_cmp    = (1 << 8),
  64        usbip_debug_stub_dev    = (1 << 9),
  65        usbip_debug_stub_rx     = (1 << 10),
  66        usbip_debug_stub_tx     = (1 << 11),
  67
  68        usbip_debug_vhci_rh     = (1 << 8),
  69        usbip_debug_vhci_hc     = (1 << 9),
  70        usbip_debug_vhci_rx     = (1 << 10),
  71        usbip_debug_vhci_tx     = (1 << 11),
  72        usbip_debug_vhci_sysfs  = (1 << 12)
  73};
  74
  75#define usbip_dbg_flag_xmit     (usbip_debug_flag & usbip_debug_xmit)
  76#define usbip_dbg_flag_vhci_rh  (usbip_debug_flag & usbip_debug_vhci_rh)
  77#define usbip_dbg_flag_vhci_hc  (usbip_debug_flag & usbip_debug_vhci_hc)
  78#define usbip_dbg_flag_vhci_rx  (usbip_debug_flag & usbip_debug_vhci_rx)
  79#define usbip_dbg_flag_vhci_tx  (usbip_debug_flag & usbip_debug_vhci_tx)
  80#define usbip_dbg_flag_stub_rx  (usbip_debug_flag & usbip_debug_stub_rx)
  81#define usbip_dbg_flag_stub_tx  (usbip_debug_flag & usbip_debug_stub_tx)
  82#define usbip_dbg_flag_vhci_sysfs   (usbip_debug_flag & usbip_debug_vhci_sysfs)
  83
  84extern unsigned long usbip_debug_flag;
  85extern struct device_attribute dev_attr_usbip_debug;
  86
  87#define usbip_dbg_with_flag(flag, fmt, args...)         \
  88        do {                                            \
  89                if (flag & usbip_debug_flag)            \
  90                        usbip_udbg(fmt , ##args);               \
  91        } while (0)
  92
  93#define usbip_dbg_sysfs(fmt, args...)           \
  94        usbip_dbg_with_flag(usbip_debug_sysfs, fmt , ##args)
  95#define usbip_dbg_xmit(fmt, args...)            \
  96        usbip_dbg_with_flag(usbip_debug_xmit, fmt , ##args)
  97#define usbip_dbg_urb(fmt, args...)             \
  98        usbip_dbg_with_flag(usbip_debug_urb, fmt , ##args)
  99#define usbip_dbg_eh(fmt, args...)              \
 100        usbip_dbg_with_flag(usbip_debug_eh, fmt , ##args)
 101
 102#define usbip_dbg_vhci_rh(fmt, args...) \
 103        usbip_dbg_with_flag(usbip_debug_vhci_rh, fmt , ##args)
 104#define usbip_dbg_vhci_hc(fmt, args...) \
 105        usbip_dbg_with_flag(usbip_debug_vhci_hc, fmt , ##args)
 106#define usbip_dbg_vhci_rx(fmt, args...) \
 107        usbip_dbg_with_flag(usbip_debug_vhci_rx, fmt , ##args)
 108#define usbip_dbg_vhci_tx(fmt, args...) \
 109        usbip_dbg_with_flag(usbip_debug_vhci_tx, fmt , ##args)
 110#define usbip_dbg_vhci_sysfs(fmt, args...)      \
 111        usbip_dbg_with_flag(usbip_debug_vhci_sysfs, fmt , ##args)
 112
 113#define usbip_dbg_stub_cmp(fmt, args...)        \
 114        usbip_dbg_with_flag(usbip_debug_stub_cmp, fmt , ##args)
 115#define usbip_dbg_stub_rx(fmt, args...) \
 116        usbip_dbg_with_flag(usbip_debug_stub_rx, fmt , ##args)
 117#define usbip_dbg_stub_tx(fmt, args...) \
 118        usbip_dbg_with_flag(usbip_debug_stub_tx, fmt , ##args)
 119
 120
 121/**
 122 * usbip_uerr - print error messages
 123 * @fmt:
 124 * @args:
 125 */
 126#define usbip_uerr(fmt, args...)                                        \
 127        do {                                                            \
 128                printk(KERN_ERR "%-10s: ***ERROR*** (%s,%d) %s: " fmt,  \
 129                        (in_interrupt() ? "interrupt" : (current)->comm),\
 130                        __FILE__, __LINE__, __func__, ##args);  \
 131        } while (0)
 132
 133/**
 134 * usbip_uinfo - print information messages
 135 * @fmt:
 136 * @args:
 137 */
 138#define usbip_uinfo(fmt, args...)                               \
 139        do {                                                    \
 140                printk(KERN_INFO "usbip: " fmt , ## args);      \
 141        } while (0)
 142
 143
 144/*-------------------------------------------------------------------------*/
 145
 146/*
 147 * USB/IP request headers.
 148 * Currently, we define 4 request types:
 149 *
 150 *  - CMD_SUBMIT transfers a USB request, corresponding to usb_submit_urb().
 151 *    (client to server)
 152 *  - RET_RETURN transfers the result of CMD_SUBMIT.
 153 *    (server to client)
 154 *  - CMD_UNLINK transfers an unlink request of a pending USB request.
 155 *    (client to server)
 156 *  - RET_UNLINK transfers the result of CMD_UNLINK.
 157 *    (server to client)
 158 *
 159 * Note: The below request formats are based on the USB subsystem of Linux. Its
 160 * details will be defined when other implementations come.
 161 *
 162 *
 163 */
 164
 165/*
 166 * A basic header followed by other additional headers.
 167 */
 168struct usbip_header_basic {
 169#define USBIP_CMD_SUBMIT        0x0001
 170#define USBIP_CMD_UNLINK        0x0002
 171#define USBIP_RET_SUBMIT        0x0003
 172#define USBIP_RET_UNLINK        0x0004
 173        __u32 command;
 174
 175         /* sequencial number which identifies requests.
 176          * incremented per connections */
 177        __u32 seqnum;
 178
 179        /* devid is used to specify a remote USB device uniquely instead
 180         * of busnum and devnum in Linux. In the case of Linux stub_driver,
 181         * this value is ((busnum << 16) | devnum) */
 182        __u32 devid;
 183
 184#define USBIP_DIR_OUT   0
 185#define USBIP_DIR_IN    1
 186        __u32 direction;
 187        __u32 ep;     /* endpoint number */
 188} __attribute__ ((packed));
 189
 190/*
 191 * An additional header for a CMD_SUBMIT packet.
 192 */
 193struct usbip_header_cmd_submit {
 194        /* these values are basically the same as in a URB. */
 195
 196        /* the same in a URB. */
 197        __u32 transfer_flags;
 198
 199        /* set the following data size (out),
 200         * or expected reading data size (in) */
 201        __s32 transfer_buffer_length;
 202
 203        /* it is difficult for usbip to sync frames (reserved only?) */
 204        __s32 start_frame;
 205
 206        /* the number of iso descriptors that follows this header */
 207        __s32 number_of_packets;
 208
 209        /* the maximum time within which this request works in a host
 210         * controller of a server side */
 211        __s32 interval;
 212
 213        /* set setup packet data for a CTRL request */
 214        unsigned char setup[8];
 215} __attribute__ ((packed));
 216
 217/*
 218 * An additional header for a RET_SUBMIT packet.
 219 */
 220struct usbip_header_ret_submit {
 221        __s32 status;
 222        __s32 actual_length; /* returned data length */
 223        __s32 start_frame; /* ISO and INT */
 224        __s32 number_of_packets;  /* ISO only */
 225        __s32 error_count; /* ISO only */
 226} __attribute__ ((packed));
 227
 228/*
 229 * An additional header for a CMD_UNLINK packet.
 230 */
 231struct usbip_header_cmd_unlink {
 232        __u32 seqnum; /* URB's seqnum which will be unlinked */
 233} __attribute__ ((packed));
 234
 235
 236/*
 237 * An additional header for a RET_UNLINK packet.
 238 */
 239struct usbip_header_ret_unlink {
 240        __s32 status;
 241} __attribute__ ((packed));
 242
 243
 244/* the same as usb_iso_packet_descriptor but packed for pdu */
 245struct usbip_iso_packet_descriptor {
 246        __u32 offset;
 247        __u32 length;            /* expected length */
 248        __u32 actual_length;
 249        __u32 status;
 250} __attribute__ ((packed));
 251
 252
 253/*
 254 * All usbip packets use a common header to keep code simple.
 255 */
 256struct usbip_header {
 257        struct usbip_header_basic base;
 258
 259        union {
 260                struct usbip_header_cmd_submit  cmd_submit;
 261                struct usbip_header_ret_submit  ret_submit;
 262                struct usbip_header_cmd_unlink  cmd_unlink;
 263                struct usbip_header_ret_unlink  ret_unlink;
 264        } u;
 265} __attribute__ ((packed));
 266
 267
 268
 269
 270/*-------------------------------------------------------------------------*/
 271
 272
 273int usbip_xmit(int, struct socket *, char *, int, int);
 274int usbip_sendmsg(struct socket *, struct msghdr *, int);
 275
 276
 277static inline int interface_to_busnum(struct usb_interface *interface)
 278{
 279        struct usb_device *udev = interface_to_usbdev(interface);
 280        return udev->bus->busnum;
 281}
 282
 283static inline int interface_to_devnum(struct usb_interface *interface)
 284{
 285        struct usb_device *udev = interface_to_usbdev(interface);
 286        return udev->devnum;
 287}
 288
 289static inline int interface_to_infnum(struct usb_interface *interface)
 290{
 291        return interface->cur_altsetting->desc.bInterfaceNumber;
 292}
 293
 294#if 0
 295int setnodelay(struct socket *);
 296int setquickack(struct socket *);
 297int setkeepalive(struct socket *socket);
 298void setreuse(struct socket *);
 299#endif
 300
 301struct socket *sockfd_to_socket(unsigned int);
 302int set_sockaddr(struct socket *socket, struct sockaddr_storage *ss);
 303
 304void usbip_dump_urb(struct urb *purb);
 305void usbip_dump_header(struct usbip_header *pdu);
 306
 307
 308struct usbip_device;
 309
 310struct usbip_task {
 311        struct task_struct *thread;
 312        struct completion thread_done;
 313        char *name;
 314        void (*loop_ops)(struct usbip_task *);
 315};
 316
 317enum usbip_side {
 318        USBIP_VHCI,
 319        USBIP_STUB,
 320};
 321
 322enum usbip_status {
 323        /* sdev is available. */
 324        SDEV_ST_AVAILABLE = 0x01,
 325        /* sdev is now used. */
 326        SDEV_ST_USED,
 327        /* sdev is unusable because of a fatal error. */
 328        SDEV_ST_ERROR,
 329
 330        /* vdev does not connect a remote device. */
 331        VDEV_ST_NULL,
 332        /* vdev is used, but the USB address is not assigned yet */
 333        VDEV_ST_NOTASSIGNED,
 334        VDEV_ST_USED,
 335        VDEV_ST_ERROR
 336};
 337
 338/* a common structure for stub_device and vhci_device */
 339struct usbip_device {
 340        enum usbip_side side;
 341
 342        enum usbip_status status;
 343
 344        /* lock for status */
 345        spinlock_t lock;
 346
 347        struct socket *tcp_socket;
 348
 349        struct usbip_task tcp_rx;
 350        struct usbip_task tcp_tx;
 351
 352        /* event handler */
 353#define USBIP_EH_SHUTDOWN       (1 << 0)
 354#define USBIP_EH_BYE            (1 << 1)
 355#define USBIP_EH_RESET          (1 << 2)
 356#define USBIP_EH_UNUSABLE       (1 << 3)
 357
 358#define SDEV_EVENT_REMOVED   (USBIP_EH_SHUTDOWN | USBIP_EH_RESET | USBIP_EH_BYE)
 359#define SDEV_EVENT_DOWN         (USBIP_EH_SHUTDOWN | USBIP_EH_RESET)
 360#define SDEV_EVENT_ERROR_TCP    (USBIP_EH_SHUTDOWN | USBIP_EH_RESET)
 361#define SDEV_EVENT_ERROR_SUBMIT (USBIP_EH_SHUTDOWN | USBIP_EH_RESET)
 362#define SDEV_EVENT_ERROR_MALLOC (USBIP_EH_SHUTDOWN | USBIP_EH_UNUSABLE)
 363
 364#define VDEV_EVENT_REMOVED      (USBIP_EH_SHUTDOWN | USBIP_EH_BYE)
 365#define VDEV_EVENT_DOWN         (USBIP_EH_SHUTDOWN | USBIP_EH_RESET)
 366#define VDEV_EVENT_ERROR_TCP    (USBIP_EH_SHUTDOWN | USBIP_EH_RESET)
 367#define VDEV_EVENT_ERROR_MALLOC (USBIP_EH_SHUTDOWN | USBIP_EH_UNUSABLE)
 368
 369        unsigned long event;
 370        struct usbip_task eh;
 371        wait_queue_head_t eh_waitq;
 372
 373        struct eh_ops {
 374                void (*shutdown)(struct usbip_device *);
 375                void (*reset)(struct usbip_device *);
 376                void (*unusable)(struct usbip_device *);
 377        } eh_ops;
 378};
 379
 380
 381void usbip_task_init(struct usbip_task *ut, char *,
 382                                void (*loop_ops)(struct usbip_task *));
 383
 384int usbip_start_threads(struct usbip_device *ud);
 385void usbip_stop_threads(struct usbip_device *ud);
 386int usbip_thread(void *param);
 387
 388void usbip_pack_pdu(struct usbip_header *pdu, struct urb *urb, int cmd,
 389                                                                int pack);
 390
 391void usbip_header_correct_endian(struct usbip_header *pdu, int send);
 392/* some members of urb must be substituted before. */
 393int usbip_recv_xbuff(struct usbip_device *ud, struct urb *urb);
 394/* some members of urb must be substituted before. */
 395int usbip_recv_iso(struct usbip_device *ud, struct urb *urb);
 396void *usbip_alloc_iso_desc_pdu(struct urb *urb, ssize_t *bufflen);
 397
 398
 399/* usbip_event.c */
 400int usbip_start_eh(struct usbip_device *ud);
 401void usbip_stop_eh(struct usbip_device *ud);
 402void usbip_event_add(struct usbip_device *ud, unsigned long event);
 403int usbip_event_happened(struct usbip_device *ud);
 404
 405
 406#endif
 407