1 /* $FreeBSD$ */ 2 /*- 3 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/stdint.h> 28 #include <sys/queue.h> 29 #include <sys/types.h> 30 #include <sys/systm.h> 31 #include <sys/kernel.h> 32 #include <sys/bus.h> 33 #include <sys/module.h> 34 #include <sys/lock.h> 35 #include <sys/mutex.h> 36 #include <sys/condvar.h> 37 #include <sys/sysctl.h> 38 #include <sys/unistd.h> 39 #include <sys/callout.h> 40 #include <sys/malloc.h> 41 #include <sys/priv.h> 42 43 #include <bus/u4b/usb.h> 44 #include <bus/u4b/usbdi.h> 45 46 #include <bus/u4b/usb_core.h> 47 #include <bus/u4b/usb_debug.h> 48 #include <bus/u4b/usb_process.h> 49 #include <bus/u4b/usb_device.h> 50 #include <bus/u4b/usb_busdma.h> 51 #include <bus/u4b/usb_transfer.h> 52 53 #include <ddb/ddb.h> 54 #include <ddb/db_sym.h> 55 56 /* 57 * Define this unconditionally in case a kernel module is loaded that 58 * has been compiled with debugging options. 59 */ 60 int usb_debug = 0; 61 62 SYSCTL_NODE(_hw, OID_AUTO, usb, CTLFLAG_RW, 0, "USB debugging"); 63 SYSCTL_INT(_hw_usb, OID_AUTO, debug, CTLFLAG_RW, 64 &usb_debug, 0, "Debug level"); 65 66 TUNABLE_INT("hw.usb.debug", &usb_debug); 67 68 #ifdef USB_DEBUG 69 /* 70 * Sysctls to modify timings/delays 71 */ 72 static SYSCTL_NODE(_hw_usb, OID_AUTO, timings, CTLFLAG_RW, 0, "Timings"); 73 static int usb_timings_sysctl_handler(SYSCTL_HANDLER_ARGS); 74 75 TUNABLE_INT("hw.usb.timings.port_reset_delay", (int *)&usb_port_reset_delay); 76 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_reset_delay, CTLTYPE_UINT | CTLFLAG_RW, 77 &usb_port_reset_delay, sizeof(usb_port_reset_delay), 78 usb_timings_sysctl_handler, "IU", "Port Reset Delay"); 79 TUNABLE_INT("hw.usb.timings.port_root_reset_delay", (int *)&usb_port_root_reset_delay); 80 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_root_reset_delay, CTLTYPE_UINT | CTLFLAG_RW, 81 &usb_port_root_reset_delay, sizeof(usb_port_root_reset_delay), 82 usb_timings_sysctl_handler, "IU", "Root Port Reset Delay"); 83 TUNABLE_INT("hw.usb.timings.port_reset_recovery", (int *)&usb_port_reset_recovery); 84 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_reset_recovery, CTLTYPE_UINT | CTLFLAG_RW, 85 &usb_port_reset_recovery, sizeof(usb_port_reset_recovery), 86 usb_timings_sysctl_handler, "IU", "Port Reset Recovery"); 87 TUNABLE_INT("hw.usb.timings.port_powerup_delay", (int *)&usb_port_powerup_delay); 88 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_powerup_delay, CTLTYPE_UINT | CTLFLAG_RW, 89 &usb_port_powerup_delay, sizeof(usb_port_powerup_delay), 90 usb_timings_sysctl_handler, "IU", "Port PowerUp Delay"); 91 TUNABLE_INT("hw.usb.timings.port_resume_delay", (int *)&usb_port_resume_delay); 92 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, port_resume_delay, CTLTYPE_UINT | CTLFLAG_RW, 93 &usb_port_resume_delay, sizeof(usb_port_resume_delay), 94 usb_timings_sysctl_handler, "IU", "Port Resume Delay"); 95 TUNABLE_INT("hw.usb.timings.set_address_settle", (int *)&usb_set_address_settle); 96 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, set_address_settle, CTLTYPE_UINT | CTLFLAG_RW, 97 &usb_set_address_settle, sizeof(usb_set_address_settle), 98 usb_timings_sysctl_handler, "IU", "Set Address Settle"); 99 TUNABLE_INT("hw.usb.timings.resume_delay", (int *)&usb_resume_delay); 100 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_delay, CTLTYPE_UINT | CTLFLAG_RW, 101 &usb_resume_delay, sizeof(usb_resume_delay), 102 usb_timings_sysctl_handler, "IU", "Resume Delay"); 103 TUNABLE_INT("hw.usb.timings.resume_wait", (int *)&usb_resume_wait); 104 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_wait, CTLTYPE_UINT | CTLFLAG_RW, 105 &usb_resume_wait, sizeof(usb_resume_wait), 106 usb_timings_sysctl_handler, "IU", "Resume Wait"); 107 TUNABLE_INT("hw.usb.timings.resume_recovery", (int *)&usb_resume_recovery); 108 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, resume_recovery, CTLTYPE_UINT | CTLFLAG_RW, 109 &usb_resume_recovery, sizeof(usb_resume_recovery), 110 usb_timings_sysctl_handler, "IU", "Resume Recovery"); 111 TUNABLE_INT("hw.usb.timings.extra_power_up_time", (int *)&usb_extra_power_up_time); 112 SYSCTL_PROC(_hw_usb_timings, OID_AUTO, extra_power_up_time, CTLTYPE_UINT | CTLFLAG_RW, 113 &usb_extra_power_up_time, sizeof(usb_extra_power_up_time), 114 usb_timings_sysctl_handler, "IU", "Extra PowerUp Time"); 115 #endif 116 117 /*------------------------------------------------------------------------* 118 * usb_dump_iface 119 * 120 * This function dumps information about an USB interface. 121 *------------------------------------------------------------------------*/ 122 void 123 usb_dump_iface(struct usb_interface *iface) 124 { 125 kprintf("usb_dump_iface: iface=%p\n", iface); 126 if (iface == NULL) { 127 return; 128 } 129 kprintf(" iface=%p idesc=%p altindex=%d\n", 130 iface, iface->idesc, iface->alt_index); 131 } 132 133 /*------------------------------------------------------------------------* 134 * usb_dump_device 135 * 136 * This function dumps information about an USB device. 137 *------------------------------------------------------------------------*/ 138 void 139 usb_dump_device(struct usb_device *udev) 140 { 141 kprintf("usb_dump_device: dev=%p\n", udev); 142 if (udev == NULL) { 143 return; 144 } 145 kprintf(" bus=%p \n" 146 " address=%d config=%d depth=%d speed=%d self_powered=%d\n" 147 " power=%d langid=%d\n", 148 udev->bus, 149 udev->address, udev->curr_config_no, udev->depth, udev->speed, 150 udev->flags.self_powered, udev->power, udev->langid); 151 } 152 153 /*------------------------------------------------------------------------* 154 * usb_dump_queue 155 * 156 * This function dumps the USB transfer that are queued up on an USB endpoint. 157 *------------------------------------------------------------------------*/ 158 void 159 usb_dump_queue(struct usb_endpoint *ep) 160 { 161 struct usb_xfer *xfer; 162 usb_stream_t x; 163 164 kprintf("usb_dump_queue: endpoint=%p xfer: ", ep); 165 for (x=0; x != USB_MAX_EP_STREAMS; x++) { 166 TAILQ_FOREACH(xfer, &ep->endpoint_q[x].head, wait_entry) { 167 kprintf(" %p", xfer); 168 } 169 } 170 kprintf("\n"); 171 } 172 173 /*------------------------------------------------------------------------* 174 * usb_dump_endpoint 175 * 176 * This function dumps information about an USB endpoint. 177 *------------------------------------------------------------------------*/ 178 void 179 usb_dump_endpoint(struct usb_endpoint *ep) 180 { 181 if (ep) { 182 kprintf("usb_dump_endpoint: endpoint=%p", ep); 183 184 kprintf(" edesc=%p isoc_next=%d toggle_next=%d", 185 ep->edesc, ep->isoc_next, ep->toggle_next); 186 187 if (ep->edesc) { 188 kprintf(" bEndpointAddress=0x%02x", 189 ep->edesc->bEndpointAddress); 190 } 191 kprintf("\n"); 192 usb_dump_queue(ep); 193 } else { 194 kprintf("usb_dump_endpoint: endpoint=NULL\n"); 195 } 196 } 197 198 /*------------------------------------------------------------------------* 199 * usb_dump_xfer 200 * 201 * This function dumps information about an USB transfer. 202 *------------------------------------------------------------------------*/ 203 void 204 usb_dump_xfer(struct usb_xfer *xfer) 205 { 206 struct usb_device *udev; 207 kprintf("usb_dump_xfer: xfer=%p\n", xfer); 208 if (xfer == NULL) { 209 return; 210 } 211 if (xfer->endpoint == NULL) { 212 kprintf("xfer %p: endpoint=NULL\n", 213 xfer); 214 return; 215 } 216 udev = xfer->xroot->udev; 217 kprintf("xfer %p: udev=%p vid=0x%04x pid=0x%04x addr=%d " 218 "endpoint=%p ep=0x%02x attr=0x%02x\n", 219 xfer, udev, 220 UGETW(udev->ddesc.idVendor), 221 UGETW(udev->ddesc.idProduct), 222 udev->address, xfer->endpoint, 223 xfer->endpoint->edesc->bEndpointAddress, 224 xfer->endpoint->edesc->bmAttributes); 225 } 226 227 #ifdef USB_DEBUG 228 unsigned int usb_port_reset_delay = USB_PORT_RESET_DELAY; 229 unsigned int usb_port_root_reset_delay = USB_PORT_ROOT_RESET_DELAY; 230 unsigned int usb_port_reset_recovery = USB_PORT_RESET_RECOVERY; 231 unsigned int usb_port_powerup_delay = USB_PORT_POWERUP_DELAY; 232 unsigned int usb_port_resume_delay = USB_PORT_RESUME_DELAY; 233 unsigned int usb_set_address_settle = USB_SET_ADDRESS_SETTLE; 234 unsigned int usb_resume_delay = USB_RESUME_DELAY; 235 unsigned int usb_resume_wait = USB_RESUME_WAIT; 236 unsigned int usb_resume_recovery = USB_RESUME_RECOVERY; 237 unsigned int usb_extra_power_up_time = USB_EXTRA_POWER_UP_TIME; 238 239 /*------------------------------------------------------------------------* 240 * usb_timings_sysctl_handler 241 * 242 * This function updates timings variables, adjusting them where necessary. 243 *------------------------------------------------------------------------*/ 244 static int usb_timings_sysctl_handler(SYSCTL_HANDLER_ARGS) 245 { 246 int error = 0; 247 unsigned int val; 248 249 /* 250 * Attempt to get a coherent snapshot by making a copy of the data. 251 */ 252 if (arg1) 253 val = *(unsigned int *)arg1; 254 else 255 val = arg2; 256 error = SYSCTL_OUT(req, &val, sizeof(int)); 257 if (error || !req->newptr) 258 return (error); 259 260 if (!arg1) 261 return EPERM; 262 263 error = SYSCTL_IN(req, &val, sizeof(unsigned int)); 264 if (error) 265 return (error); 266 267 /* 268 * Now make sure the values are decent, and certainly no lower than 269 * what the USB spec prescribes. 270 */ 271 unsigned int *p = (unsigned int *)arg1; 272 if (p == &usb_port_reset_delay) { 273 if (val < USB_PORT_RESET_DELAY_SPEC) 274 return (EINVAL); 275 } else if (p == &usb_port_root_reset_delay) { 276 if (val < USB_PORT_ROOT_RESET_DELAY_SPEC) 277 return (EINVAL); 278 } else if (p == &usb_port_reset_recovery) { 279 if (val < USB_PORT_RESET_RECOVERY_SPEC) 280 return (EINVAL); 281 } else if (p == &usb_port_powerup_delay) { 282 if (val < USB_PORT_POWERUP_DELAY_SPEC) 283 return (EINVAL); 284 } else if (p == &usb_port_resume_delay) { 285 if (val < USB_PORT_RESUME_DELAY_SPEC) 286 return (EINVAL); 287 } else if (p == &usb_set_address_settle) { 288 if (val < USB_SET_ADDRESS_SETTLE_SPEC) 289 return (EINVAL); 290 } else if (p == &usb_resume_delay) { 291 if (val < USB_RESUME_DELAY_SPEC) 292 return (EINVAL); 293 } else if (p == &usb_resume_wait) { 294 if (val < USB_RESUME_WAIT_SPEC) 295 return (EINVAL); 296 } else if (p == &usb_resume_recovery) { 297 if (val < USB_RESUME_RECOVERY_SPEC) 298 return (EINVAL); 299 } else if (p == &usb_extra_power_up_time) { 300 if (val < USB_EXTRA_POWER_UP_TIME_SPEC) 301 return (EINVAL); 302 } else { 303 /* noop */ 304 } 305 306 *p = val; 307 return 0; 308 } 309 #endif 310