1 /*- 2 * Copyright (c) 2010 Hans Petter Selasky. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 */ 25 26 /* 27 * Comm Class spec: http://www.usb.org/developers/devclass_docs/usbccs10.pdf 28 * http://www.usb.org/developers/devclass_docs/usbcdc11.pdf 29 * http://www.usb.org/developers/devclass_docs/cdc_wmc10.zip 30 */ 31 32 #include <sys/param.h> 33 __FBSDID("$FreeBSD$"); 34 35 #include <sys/stdint.h> 36 #include <sys/stddef.h> 37 #include <sys/queue.h> 38 #include <sys/systm.h> 39 #include <sys/kernel.h> 40 #include <sys/bus.h> 41 #include <sys/linker_set.h> 42 #include <sys/module.h> 43 #include <sys/lock.h> 44 #include <sys/mutex.h> 45 #include <sys/condvar.h> 46 #include <sys/sysctl.h> 47 #include <sys/sx.h> 48 #include <sys/unistd.h> 49 #include <sys/callout.h> 50 #include <sys/malloc.h> 51 #include <sys/priv.h> 52 53 #include <dev/usb/usb.h> 54 #include <dev/usb/usb_cdc.h> 55 #include <dev/usb/usbdi.h> 56 #include <dev/usb/usbdi_util.h> 57 #include <dev/usb/usbhid.h> 58 #include "usb_if.h" 59 60 #define USB_DEBUG_VAR g_modem_debug 61 #include <dev/usb/usb_debug.h> 62 63 #include <dev/usb/gadget/g_modem.h> 64 65 enum { 66 G_MODEM_INTR_DT, 67 G_MODEM_BULK_RD, 68 G_MODEM_BULK_WR, 69 G_MODEM_N_TRANSFER, 70 }; 71 72 struct g_modem_softc { 73 struct mtx sc_mtx; 74 struct usb_callout sc_callout; 75 struct usb_callout sc_watchdog; 76 struct usb_xfer *sc_xfer[G_MODEM_N_TRANSFER]; 77 78 int sc_mode; 79 int sc_tx_busy; 80 int sc_pattern_len; 81 int sc_throughput; 82 int sc_tx_interval; 83 84 char sc_pattern[G_MODEM_MAX_STRLEN]; 85 86 uint16_t sc_data_len; 87 88 uint8_t sc_data_buf[G_MODEM_BUFSIZE]; 89 uint8_t sc_line_coding[32]; 90 uint8_t sc_abstract_state[32]; 91 }; 92 93 static SYSCTL_NODE(_hw_usb, OID_AUTO, g_modem, CTLFLAG_RW, 0, "USB modem gadget"); 94 95 #ifdef USB_DEBUG 96 static int g_modem_debug = 0; 97 98 SYSCTL_INT(_hw_usb_g_modem, OID_AUTO, debug, CTLFLAG_RW, 99 &g_modem_debug, 0, "Debug level"); 100 #endif 101 102 static int g_modem_mode = 0; 103 104 SYSCTL_INT(_hw_usb_g_modem, OID_AUTO, mode, CTLFLAG_RW, 105 &g_modem_mode, 0, "Mode selection"); 106 107 static int g_modem_pattern_interval = 1000; 108 109 SYSCTL_INT(_hw_usb_g_modem, OID_AUTO, pattern_interval, CTLFLAG_RW, 110 &g_modem_pattern_interval, 0, "Pattern interval in milliseconds"); 111 112 static char g_modem_pattern_data[G_MODEM_MAX_STRLEN]; 113 114 SYSCTL_STRING(_hw_usb_g_modem, OID_AUTO, pattern, CTLFLAG_RW, 115 &g_modem_pattern_data, sizeof(g_modem_pattern_data), "Data pattern"); 116 117 static int g_modem_throughput; 118 119 SYSCTL_INT(_hw_usb_g_modem, OID_AUTO, throughput, CTLFLAG_RD, 120 &g_modem_throughput, sizeof(g_modem_throughput), "Throughput in bytes per second"); 121 122 static device_probe_t g_modem_probe; 123 static device_attach_t g_modem_attach; 124 static device_detach_t g_modem_detach; 125 static usb_handle_request_t g_modem_handle_request; 126 static usb_callback_t g_modem_intr_callback; 127 static usb_callback_t g_modem_bulk_read_callback; 128 static usb_callback_t g_modem_bulk_write_callback; 129 130 static void g_modem_timeout(void *arg); 131 132 static devclass_t g_modem_devclass; 133 134 static device_method_t g_modem_methods[] = { 135 /* USB interface */ 136 DEVMETHOD(usb_handle_request, g_modem_handle_request), 137 138 /* Device interface */ 139 DEVMETHOD(device_probe, g_modem_probe), 140 DEVMETHOD(device_attach, g_modem_attach), 141 DEVMETHOD(device_detach, g_modem_detach), 142 143 DEVMETHOD_END 144 }; 145 146 static driver_t g_modem_driver = { 147 .name = "g_modem", 148 .methods = g_modem_methods, 149 .size = sizeof(struct g_modem_softc), 150 }; 151 152 DRIVER_MODULE(g_modem, uhub, g_modem_driver, g_modem_devclass, 0, 0); 153 MODULE_DEPEND(g_modem, usb, 1, 1, 1); 154 155 static const struct usb_config g_modem_config[G_MODEM_N_TRANSFER] = { 156 157 [G_MODEM_INTR_DT] = { 158 .type = UE_INTERRUPT, 159 .endpoint = UE_ADDR_ANY, 160 .direction = UE_DIR_TX, 161 .flags = {.ext_buffer = 1,.pipe_bof = 1,}, 162 .bufsize = 0, /* use wMaxPacketSize */ 163 .callback = &g_modem_intr_callback, 164 .frames = 1, 165 .usb_mode = USB_MODE_DEVICE, 166 .if_index = 0, 167 }, 168 169 [G_MODEM_BULK_RD] = { 170 .type = UE_BULK, 171 .endpoint = UE_ADDR_ANY, 172 .direction = UE_DIR_RX, 173 .flags = {.ext_buffer = 1,.pipe_bof = 1,.short_xfer_ok = 1,}, 174 .bufsize = G_MODEM_BUFSIZE, 175 .callback = &g_modem_bulk_read_callback, 176 .frames = 1, 177 .usb_mode = USB_MODE_DEVICE, 178 .if_index = 1, 179 }, 180 181 [G_MODEM_BULK_WR] = { 182 .type = UE_BULK, 183 .endpoint = UE_ADDR_ANY, 184 .direction = UE_DIR_TX, 185 .flags = {.ext_buffer = 1,.pipe_bof = 1,}, 186 .bufsize = G_MODEM_BUFSIZE, 187 .callback = &g_modem_bulk_write_callback, 188 .frames = 1, 189 .usb_mode = USB_MODE_DEVICE, 190 .if_index = 1, 191 }, 192 }; 193 194 static void 195 g_modem_timeout_reset(struct g_modem_softc *sc) 196 { 197 int i = g_modem_pattern_interval; 198 199 sc->sc_tx_interval = i; 200 201 if (i <= 0) 202 i = 1; 203 else if (i > 1023) 204 i = 1023; 205 206 i = USB_MS_TO_TICKS(i); 207 208 usb_callout_reset(&sc->sc_callout, i, &g_modem_timeout, sc); 209 } 210 211 static void 212 g_modem_timeout(void *arg) 213 { 214 struct g_modem_softc *sc = arg; 215 216 sc->sc_mode = g_modem_mode; 217 218 memcpy(sc->sc_pattern, g_modem_pattern_data, sizeof(sc->sc_pattern)); 219 220 sc->sc_pattern[G_MODEM_MAX_STRLEN - 1] = 0; 221 222 sc->sc_pattern_len = strlen(sc->sc_pattern); 223 224 DPRINTFN(11, "Timeout %p\n", sc->sc_xfer[G_MODEM_INTR_DT]); 225 226 usbd_transfer_start(sc->sc_xfer[G_MODEM_BULK_WR]); 227 usbd_transfer_start(sc->sc_xfer[G_MODEM_BULK_RD]); 228 229 g_modem_timeout_reset(sc); 230 } 231 232 static void g_modem_watchdog(void *arg); 233 234 static void 235 g_modem_watchdog_reset(struct g_modem_softc *sc) 236 { 237 usb_callout_reset(&sc->sc_watchdog, hz, &g_modem_watchdog, sc); 238 } 239 240 static void 241 g_modem_watchdog(void *arg) 242 { 243 struct g_modem_softc *sc = arg; 244 int i; 245 246 i = sc->sc_throughput; 247 248 sc->sc_throughput = 0; 249 250 g_modem_throughput = i; 251 252 g_modem_watchdog_reset(sc); 253 } 254 255 static int 256 g_modem_probe(device_t dev) 257 { 258 struct usb_attach_arg *uaa = device_get_ivars(dev); 259 260 DPRINTFN(11, "\n"); 261 262 if (uaa->usb_mode != USB_MODE_DEVICE) 263 return (ENXIO); 264 265 if ((uaa->info.bInterfaceClass == UICLASS_CDC) && 266 (uaa->info.bInterfaceSubClass == UISUBCLASS_ABSTRACT_CONTROL_MODEL) && 267 (uaa->info.bInterfaceProtocol == UIPROTO_CDC_AT)) 268 return (0); 269 270 return (ENXIO); 271 } 272 273 static int 274 g_modem_attach(device_t dev) 275 { 276 struct g_modem_softc *sc = device_get_softc(dev); 277 struct usb_attach_arg *uaa = device_get_ivars(dev); 278 int error; 279 uint8_t iface_index[2]; 280 281 DPRINTFN(11, "\n"); 282 283 device_set_usb_desc(dev); 284 285 mtx_init(&sc->sc_mtx, "g_modem", NULL, MTX_DEF); 286 287 usb_callout_init_mtx(&sc->sc_callout, &sc->sc_mtx, 0); 288 usb_callout_init_mtx(&sc->sc_watchdog, &sc->sc_mtx, 0); 289 290 sc->sc_mode = G_MODEM_MODE_SILENT; 291 292 iface_index[0] = uaa->info.bIfaceIndex; 293 iface_index[1] = uaa->info.bIfaceIndex + 1; 294 295 error = usbd_transfer_setup(uaa->device, 296 iface_index, sc->sc_xfer, g_modem_config, 297 G_MODEM_N_TRANSFER, sc, &sc->sc_mtx); 298 299 if (error) { 300 DPRINTF("error=%s\n", usbd_errstr(error)); 301 goto detach; 302 } 303 usbd_set_parent_iface(uaa->device, iface_index[1], iface_index[0]); 304 305 mtx_lock(&sc->sc_mtx); 306 g_modem_timeout_reset(sc); 307 g_modem_watchdog_reset(sc); 308 mtx_unlock(&sc->sc_mtx); 309 310 return (0); /* success */ 311 312 detach: 313 g_modem_detach(dev); 314 315 return (ENXIO); /* error */ 316 } 317 318 static int 319 g_modem_detach(device_t dev) 320 { 321 struct g_modem_softc *sc = device_get_softc(dev); 322 323 DPRINTF("\n"); 324 325 mtx_lock(&sc->sc_mtx); 326 usb_callout_stop(&sc->sc_callout); 327 usb_callout_stop(&sc->sc_watchdog); 328 mtx_unlock(&sc->sc_mtx); 329 330 usbd_transfer_unsetup(sc->sc_xfer, G_MODEM_N_TRANSFER); 331 332 usb_callout_drain(&sc->sc_callout); 333 usb_callout_drain(&sc->sc_watchdog); 334 335 mtx_destroy(&sc->sc_mtx); 336 337 return (0); 338 } 339 340 static void 341 g_modem_intr_callback(struct usb_xfer *xfer, usb_error_t error) 342 { 343 int actlen; 344 int aframes; 345 346 usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL); 347 348 DPRINTF("st=%d aframes=%d actlen=%d bytes\n", 349 USB_GET_STATE(xfer), aframes, actlen); 350 351 switch (USB_GET_STATE(xfer)) { 352 case USB_ST_TRANSFERRED: 353 break; 354 355 case USB_ST_SETUP: 356 tr_setup: 357 break; 358 359 default: /* Error */ 360 DPRINTF("error=%s\n", usbd_errstr(error)); 361 362 if (error != USB_ERR_CANCELLED) { 363 /* try to clear stall first */ 364 usbd_xfer_set_stall(xfer); 365 goto tr_setup; 366 } 367 break; 368 } 369 } 370 371 static void 372 g_modem_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error) 373 { 374 struct g_modem_softc *sc = usbd_xfer_softc(xfer); 375 int actlen; 376 int aframes; 377 int mod; 378 int x; 379 int max; 380 381 usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL); 382 383 DPRINTF("st=%d aframes=%d actlen=%d bytes\n", 384 USB_GET_STATE(xfer), aframes, actlen); 385 386 switch (USB_GET_STATE(xfer)) { 387 case USB_ST_TRANSFERRED: 388 389 sc->sc_tx_busy = 0; 390 sc->sc_throughput += actlen; 391 392 if (sc->sc_mode == G_MODEM_MODE_LOOP) { 393 /* start loop */ 394 usbd_transfer_start(sc->sc_xfer[G_MODEM_BULK_RD]); 395 break; 396 } else if ((sc->sc_mode == G_MODEM_MODE_PATTERN) && (sc->sc_tx_interval != 0)) { 397 /* wait for next timeout */ 398 break; 399 } 400 case USB_ST_SETUP: 401 tr_setup: 402 if (sc->sc_mode == G_MODEM_MODE_PATTERN) { 403 404 mod = sc->sc_pattern_len; 405 max = sc->sc_tx_interval ? mod : G_MODEM_BUFSIZE; 406 407 if (mod == 0) { 408 for (x = 0; x != max; x++) 409 sc->sc_data_buf[x] = x % 255; 410 } else { 411 for (x = 0; x != max; x++) 412 sc->sc_data_buf[x] = sc->sc_pattern[x % mod]; 413 } 414 415 usbd_xfer_set_frame_data(xfer, 0, sc->sc_data_buf, max); 416 usbd_xfer_set_interval(xfer, 0); 417 usbd_xfer_set_frames(xfer, 1); 418 usbd_transfer_submit(xfer); 419 420 } else if (sc->sc_mode == G_MODEM_MODE_LOOP) { 421 422 if (sc->sc_tx_busy == 0) 423 break; 424 425 x = sc->sc_tx_interval; 426 427 if (x < 0) 428 x = 0; 429 else if (x > 256) 430 x = 256; 431 432 usbd_xfer_set_frame_data(xfer, 0, sc->sc_data_buf, sc->sc_data_len); 433 usbd_xfer_set_interval(xfer, x); 434 usbd_xfer_set_frames(xfer, 1); 435 usbd_transfer_submit(xfer); 436 } else { 437 sc->sc_tx_busy = 0; 438 } 439 break; 440 441 default: /* Error */ 442 DPRINTF("error=%s\n", usbd_errstr(error)); 443 444 if (error != USB_ERR_CANCELLED) { 445 /* try to clear stall first */ 446 usbd_xfer_set_stall(xfer); 447 goto tr_setup; 448 } 449 break; 450 } 451 } 452 453 static void 454 g_modem_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error) 455 { 456 struct g_modem_softc *sc = usbd_xfer_softc(xfer); 457 int actlen; 458 int aframes; 459 460 usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL); 461 462 DPRINTF("st=%d aframes=%d actlen=%d bytes\n", 463 USB_GET_STATE(xfer), aframes, actlen); 464 465 switch (USB_GET_STATE(xfer)) { 466 case USB_ST_TRANSFERRED: 467 468 sc->sc_throughput += actlen; 469 470 if (sc->sc_mode == G_MODEM_MODE_LOOP) { 471 sc->sc_tx_busy = 1; 472 sc->sc_data_len = actlen; 473 usbd_transfer_start(sc->sc_xfer[G_MODEM_BULK_WR]); 474 break; 475 } 476 477 case USB_ST_SETUP: 478 tr_setup: 479 if ((sc->sc_mode == G_MODEM_MODE_SILENT) || 480 (sc->sc_tx_busy != 0)) 481 break; 482 483 usbd_xfer_set_frame_data(xfer, 0, sc->sc_data_buf, G_MODEM_BUFSIZE); 484 usbd_xfer_set_frames(xfer, 1); 485 usbd_transfer_submit(xfer); 486 break; 487 488 default: /* Error */ 489 DPRINTF("error=%s\n", usbd_errstr(error)); 490 491 if (error != USB_ERR_CANCELLED) { 492 /* try to clear stall first */ 493 usbd_xfer_set_stall(xfer); 494 goto tr_setup; 495 } 496 break; 497 } 498 } 499 500 501 static int 502 g_modem_handle_request(device_t dev, 503 const void *preq, void **pptr, uint16_t *plen, 504 uint16_t offset, uint8_t *pstate) 505 { 506 struct g_modem_softc *sc = device_get_softc(dev); 507 const struct usb_device_request *req = preq; 508 uint8_t is_complete = *pstate; 509 510 if (!is_complete) { 511 if ((req->bmRequestType == UT_WRITE_CLASS_INTERFACE) && 512 (req->bRequest == UCDC_SET_LINE_CODING) && 513 (req->wValue[0] == 0x00) && 514 (req->wValue[1] == 0x00)) { 515 516 if (offset == 0) { 517 *plen = sizeof(sc->sc_line_coding); 518 *pptr = &sc->sc_line_coding; 519 } else { 520 *plen = 0; 521 } 522 return (0); 523 } else if ((req->bmRequestType == UT_WRITE_CLASS_INTERFACE) && 524 (req->bRequest == UCDC_SET_COMM_FEATURE)) { 525 526 if (offset == 0) { 527 *plen = sizeof(sc->sc_abstract_state); 528 *pptr = &sc->sc_abstract_state; 529 } else { 530 *plen = 0; 531 } 532 return (0); 533 } else if ((req->bmRequestType == UT_WRITE_CLASS_INTERFACE) && 534 (req->bRequest == UCDC_SET_CONTROL_LINE_STATE)) { 535 *plen = 0; 536 return (0); 537 } else if ((req->bmRequestType == UT_WRITE_CLASS_INTERFACE) && 538 (req->bRequest == UCDC_SEND_BREAK)) { 539 *plen = 0; 540 return (0); 541 } 542 } 543 return (ENXIO); /* use builtin handler */ 544 } 545