1 /* 2 * Copyright (C) 2003-2008 Takahiro Hirofuchi 3 * Copyright (C) 2015 Nobuo Iwata 4 * 5 * This is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 */ 11 12 #ifndef __USBIP_VHCI_H 13 #define __USBIP_VHCI_H 14 15 #include <linux/device.h> 16 #include <linux/list.h> 17 #include <linux/spinlock.h> 18 #include <linux/sysfs.h> 19 #include <linux/types.h> 20 #include <linux/usb.h> 21 #include <linux/usb/hcd.h> 22 #include <linux/wait.h> 23 24 struct vhci_device { 25 struct usb_device *udev; 26 27 /* 28 * devid specifies a remote usb device uniquely instead 29 * of combination of busnum and devnum. 30 */ 31 __u32 devid; 32 33 /* speed of a remote device */ 34 enum usb_device_speed speed; 35 36 /* vhci root-hub port to which this device is attached */ 37 __u32 rhport; 38 39 struct usbip_device ud; 40 41 /* lock for the below link lists */ 42 spinlock_t priv_lock; 43 44 /* vhci_priv is linked to one of them. */ 45 struct list_head priv_tx; 46 struct list_head priv_rx; 47 48 /* vhci_unlink is linked to one of them */ 49 struct list_head unlink_tx; 50 struct list_head unlink_rx; 51 52 /* vhci_tx thread sleeps for this queue */ 53 wait_queue_head_t waitq_tx; 54 }; 55 56 /* urb->hcpriv, use container_of() */ 57 struct vhci_priv { 58 unsigned long seqnum; 59 struct list_head list; 60 61 struct vhci_device *vdev; 62 struct urb *urb; 63 }; 64 65 struct vhci_unlink { 66 /* seqnum of this request */ 67 unsigned long seqnum; 68 69 struct list_head list; 70 71 /* seqnum of the unlink target */ 72 unsigned long unlink_seqnum; 73 }; 74 75 /* Number of supported ports. Value has an upperbound of USB_MAXCHILDREN */ 76 #ifdef CONFIG_USBIP_VHCI_HC_PORTS 77 #define VHCI_HC_PORTS CONFIG_USBIP_VHCI_HC_PORTS 78 #else 79 #define VHCI_HC_PORTS 8 80 #endif 81 82 #ifdef CONFIG_USBIP_VHCI_NR_HCS 83 #define VHCI_NR_HCS CONFIG_USBIP_VHCI_NR_HCS 84 #else 85 #define VHCI_NR_HCS 1 86 #endif 87 88 #define MAX_STATUS_NAME 16 89 90 /* for usb_bus.hcpriv */ 91 struct vhci_hcd { 92 spinlock_t lock; 93 94 u32 port_status[VHCI_HC_PORTS]; 95 96 unsigned resuming:1; 97 unsigned long re_timeout; 98 99 atomic_t seqnum; 100 101 /* 102 * NOTE: 103 * wIndex shows the port number and begins from 1. 104 * But, the index of this array begins from 0. 105 */ 106 struct vhci_device vdev[VHCI_HC_PORTS]; 107 }; 108 109 extern int vhci_num_controllers; 110 extern struct platform_device **vhci_pdevs; 111 extern struct attribute_group vhci_attr_group; 112 113 /* vhci_hcd.c */ 114 void rh_port_connect(struct vhci_device *vdev, enum usb_device_speed speed); 115 116 /* vhci_sysfs.c */ 117 int vhci_init_attr_group(void); 118 void vhci_finish_attr_group(void); 119 120 /* vhci_rx.c */ 121 struct urb *pickup_urb_and_free_priv(struct vhci_device *vdev, __u32 seqnum); 122 int vhci_rx_loop(void *data); 123 124 /* vhci_tx.c */ 125 int vhci_tx_loop(void *data); 126 127 static inline __u32 port_to_rhport(__u32 port) 128 { 129 return port % VHCI_HC_PORTS; 130 } 131 132 static inline int port_to_pdev_nr(__u32 port) 133 { 134 return port / VHCI_HC_PORTS; 135 } 136 137 static inline struct vhci_hcd *hcd_to_vhci(struct usb_hcd *hcd) 138 { 139 return (struct vhci_hcd *) (hcd->hcd_priv); 140 } 141 142 static inline struct device *hcd_dev(struct usb_hcd *hcd) 143 { 144 return (hcd)->self.controller; 145 } 146 147 static inline const char *hcd_name(struct usb_hcd *hcd) 148 { 149 return (hcd)->self.bus_name; 150 } 151 152 static inline struct usb_hcd *vhci_to_hcd(struct vhci_hcd *vhci) 153 { 154 return container_of((void *) vhci, struct usb_hcd, hcd_priv); 155 } 156 157 static inline struct vhci_hcd *vdev_to_vhci(struct vhci_device *vdev) 158 { 159 return container_of( 160 (void *)(vdev - vdev->rhport), struct vhci_hcd, vdev); 161 } 162 163 #endif /* __USBIP_VHCI_H */ 164