1 /* $OpenBSD: ucycom.c,v 1.42 2024/05/23 03:21:09 jsg Exp $ */ 2 /* $NetBSD: ucycom.c,v 1.3 2005/08/05 07:27:47 skrll Exp $ */ 3 4 /* 5 * Copyright (c) 2005 The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Nick Hudson 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 /* 33 * This code is based on the ucom driver. 34 */ 35 36 /* 37 * Device driver for Cypress CY7C637xx and CY7C640/1xx series USB to 38 * RS232 bridges. 39 */ 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/malloc.h> 44 #include <sys/device.h> 45 #include <sys/tty.h> 46 47 #include <dev/usb/usb.h> 48 #include <dev/usb/usbhid.h> 49 50 #include <dev/usb/usbdi.h> 51 #include <dev/usb/usbdevs.h> 52 #include <dev/usb/uhidev.h> 53 54 #include <dev/usb/ucomvar.h> 55 56 #ifdef UCYCOM_DEBUG 57 #define DPRINTF(x) if (ucycomdebug) printf x 58 #define DPRINTFN(n, x) if (ucycomdebug > (n)) printf x 59 int ucycomdebug = 200; 60 #else 61 #define DPRINTF(x) 62 #define DPRINTFN(n,x) 63 #endif 64 65 /* Configuration Byte */ 66 #define UCYCOM_RESET 0x80 67 #define UCYCOM_PARITY_TYPE_MASK 0x20 68 #define UCYCOM_PARITY_ODD 0x20 69 #define UCYCOM_PARITY_EVEN 0x00 70 #define UCYCOM_PARITY_MASK 0x10 71 #define UCYCOM_PARITY_ON 0x10 72 #define UCYCOM_PARITY_OFF 0x00 73 #define UCYCOM_STOP_MASK 0x08 74 #define UCYCOM_STOP_BITS_2 0x08 75 #define UCYCOM_STOP_BITS_1 0x00 76 #define UCYCOM_DATA_MASK 0x03 77 #define UCYCOM_DATA_BITS_8 0x03 78 #define UCYCOM_DATA_BITS_7 0x02 79 #define UCYCOM_DATA_BITS_6 0x01 80 #define UCYCOM_DATA_BITS_5 0x00 81 82 /* Modem (Input) status byte */ 83 #define UCYCOM_RI 0x80 84 #define UCYCOM_DCD 0x40 85 #define UCYCOM_DSR 0x20 86 #define UCYCOM_CTS 0x10 87 #define UCYCOM_ERROR 0x08 88 #define UCYCOM_LMASK 0x07 89 90 /* Modem (Output) control byte */ 91 #define UCYCOM_DTR 0x20 92 #define UCYCOM_RTS 0x10 93 #define UCYCOM_ORESET 0x08 94 95 struct ucycom_softc { 96 struct uhidev sc_hdev; 97 struct usbd_device *sc_udev; 98 99 /* uhidev parameters */ 100 size_t sc_flen; /* feature report length */ 101 size_t sc_ilen; /* input report length */ 102 size_t sc_olen; /* output report length */ 103 104 uint8_t *sc_obuf; 105 106 uint8_t *sc_ibuf; 107 uint32_t sc_icnt; 108 109 /* settings */ 110 uint32_t sc_baud; 111 uint8_t sc_cfg; /* Data format */ 112 uint8_t sc_mcr; /* Modem control */ 113 uint8_t sc_msr; /* Modem status */ 114 uint8_t sc_newmsr; /* from HID intr */ 115 int sc_swflags; 116 117 struct device *sc_subdev; 118 }; 119 120 /* Callback routines */ 121 void ucycom_set(void *, int, int, int); 122 int ucycom_param(void *, int, struct termios *); 123 void ucycom_get_status(void *, int, u_char *, u_char *); 124 int ucycom_open(void *, int); 125 void ucycom_close(void *, int); 126 void ucycom_write(void *, int, u_char *, u_char *, u_int32_t *); 127 void ucycom_read(void *, int, u_char **, u_int32_t *); 128 129 const struct ucom_methods ucycom_methods = { 130 NULL, /* ucycom_get_status, */ 131 ucycom_set, 132 ucycom_param, 133 NULL, 134 ucycom_open, 135 ucycom_close, 136 ucycom_read, 137 ucycom_write, 138 }; 139 140 void ucycom_intr(struct uhidev *, void *, u_int); 141 142 const struct usb_devno ucycom_devs[] = { 143 { USB_VENDOR_CYPRESS, USB_PRODUCT_CYPRESS_USBRS232 }, 144 { USB_VENDOR_DELORME, USB_PRODUCT_DELORME_EMUSB }, 145 { USB_VENDOR_DELORME, USB_PRODUCT_DELORME_EMLT20 }, 146 }; 147 148 int ucycom_match(struct device *, void *, void *); 149 void ucycom_attach(struct device *, struct device *, void *); 150 int ucycom_detach(struct device *, int); 151 152 struct cfdriver ucycom_cd = { 153 NULL, "ucycom", DV_DULL 154 }; 155 156 const struct cfattach ucycom_ca = { 157 sizeof(struct ucycom_softc), ucycom_match, ucycom_attach, ucycom_detach 158 }; 159 160 int 161 ucycom_match(struct device *parent, void *match, void *aux) 162 { 163 struct uhidev_attach_arg *uha = aux; 164 165 if (UHIDEV_CLAIM_MULTIPLE_REPORTID(uha)) 166 return (UMATCH_NONE); 167 168 return (usb_lookup(ucycom_devs, uha->uaa->vendor, uha->uaa->product) != NULL ? 169 UMATCH_VENDOR_PRODUCT : UMATCH_NONE); 170 } 171 172 void 173 ucycom_attach(struct device *parent, struct device *self, void *aux) 174 { 175 struct ucycom_softc *sc = (struct ucycom_softc *)self; 176 struct usb_attach_arg *uaa = aux; 177 struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)uaa; 178 struct usbd_device *dev = uha->parent->sc_udev; 179 struct ucom_attach_args uca; 180 int size, repid, err; 181 void *desc; 182 183 sc->sc_hdev.sc_intr = ucycom_intr; 184 sc->sc_hdev.sc_parent = uha->parent; 185 sc->sc_hdev.sc_report_id = uha->reportid; 186 187 uhidev_get_report_desc(uha->parent, &desc, &size); 188 repid = uha->reportid; 189 sc->sc_ilen = hid_report_size(desc, size, hid_input, repid); 190 sc->sc_olen = hid_report_size(desc, size, hid_output, repid); 191 sc->sc_flen = hid_report_size(desc, size, hid_feature, repid); 192 193 DPRINTF(("ucycom_open: olen %d ilen %d flen %d\n", sc->sc_ilen, 194 sc->sc_olen, sc->sc_flen)); 195 196 printf("\n"); 197 198 sc->sc_udev = dev; 199 200 err = uhidev_open(&sc->sc_hdev); 201 if (err) { 202 DPRINTF(("ucycom_open: uhidev_open %d\n", err)); 203 return; 204 } 205 206 DPRINTF(("ucycom attach: sc %p opipe %p ipipe %p report_id %d\n", 207 sc, sc->sc_hdev.sc_parent->sc_opipe, sc->sc_hdev.sc_parent->sc_ipipe, 208 uha->reportid)); 209 210 /* bulkin, bulkout set above */ 211 bzero(&uca, sizeof uca); 212 uca.bulkin = uca.bulkout = -1; 213 uca.ibufsize = sc->sc_ilen - 1; 214 uca.obufsize = sc->sc_olen - 1; 215 uca.ibufsizepad = 1; 216 uca.opkthdrlen = 0; 217 uca.uhidev = sc->sc_hdev.sc_parent; 218 uca.device = uaa->device; 219 uca.iface = uaa->iface; 220 uca.methods = &ucycom_methods; 221 uca.arg = sc; 222 uca.info = NULL; 223 224 sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch); 225 DPRINTF(("ucycom_attach: complete %p\n", sc->sc_subdev)); 226 } 227 228 void 229 ucycom_get_status(void *addr, int portno, u_char *lsr, u_char *msr) 230 { 231 struct ucycom_softc *sc = addr; 232 233 DPRINTF(("ucycom_get_status:\n")); 234 235 #if 0 236 if (lsr != NULL) 237 *lsr = sc->sc_lsr; 238 #endif 239 if (msr != NULL) 240 *msr = sc->sc_msr; 241 } 242 243 int 244 ucycom_open(void *addr, int portno) 245 { 246 struct ucycom_softc *sc = addr; 247 struct termios t; 248 int err; 249 250 DPRINTF(("ucycom_open: complete\n")); 251 252 if (usbd_is_dying(sc->sc_udev)) 253 return (EIO); 254 255 /* Allocate an output report buffer */ 256 sc->sc_obuf = malloc(sc->sc_olen, M_USBDEV, M_WAITOK | M_ZERO); 257 258 /* Allocate an input report buffer */ 259 sc->sc_ibuf = malloc(sc->sc_ilen, M_USBDEV, M_WAITOK); 260 261 DPRINTF(("ucycom_open: sc->sc_ibuf=%p sc->sc_obuf=%p \n", 262 sc->sc_ibuf, sc->sc_obuf)); 263 264 t.c_ospeed = 9600; 265 t.c_cflag = CSTOPB | CS8; 266 (void)ucycom_param(sc, portno, &t); 267 268 sc->sc_mcr = UCYCOM_DTR | UCYCOM_RTS; 269 sc->sc_obuf[0] = sc->sc_mcr; 270 err = uhidev_write(sc->sc_hdev.sc_parent, sc->sc_obuf, sc->sc_olen); 271 if (err) { 272 DPRINTF(("ucycom_open: set RTS err=%d\n", err)); 273 return (EIO); 274 } 275 276 return (0); 277 } 278 279 void 280 ucycom_close(void *addr, int portno) 281 { 282 struct ucycom_softc *sc = addr; 283 int s; 284 285 if (usbd_is_dying(sc->sc_udev)) 286 return; 287 288 s = splusb(); 289 if (sc->sc_obuf != NULL) { 290 free(sc->sc_obuf, M_USBDEV, sc->sc_olen); 291 sc->sc_obuf = NULL; 292 } 293 if (sc->sc_ibuf != NULL) { 294 free(sc->sc_ibuf, M_USBDEV, sc->sc_ilen); 295 sc->sc_ibuf = NULL; 296 } 297 splx(s); 298 } 299 300 void 301 ucycom_read(void *addr, int portno, u_char **ptr, u_int32_t *count) 302 { 303 struct ucycom_softc *sc = addr; 304 305 if (sc->sc_newmsr ^ sc->sc_msr) { 306 DPRINTF(("ucycom_read: msr %d new %d\n", 307 sc->sc_msr, sc->sc_newmsr)); 308 sc->sc_msr = sc->sc_newmsr; 309 ucom_status_change((struct ucom_softc *)sc->sc_subdev); 310 } 311 312 DPRINTF(("ucycom_read: buf %p chars %d\n", sc->sc_ibuf, sc->sc_icnt)); 313 *ptr = sc->sc_ibuf; 314 *count = sc->sc_icnt; 315 } 316 317 void 318 ucycom_write(void *addr, int portno, u_char *to, u_char *data, u_int32_t *cnt) 319 { 320 struct ucycom_softc *sc = addr; 321 u_int32_t len; 322 #ifdef UCYCOM_DEBUG 323 u_int32_t want = *cnt; 324 #endif 325 326 /* 327 * The 8 byte output report uses byte 0 for control and byte 328 * count. 329 * 330 * The 32 byte output report uses byte 0 for control. Byte 1 331 * is used for byte count. 332 */ 333 len = sc->sc_olen; 334 memset(to, 0, len); 335 switch (sc->sc_olen) { 336 case 8: 337 to[0] = *cnt | sc->sc_mcr; 338 memcpy(&to[1], data, *cnt); 339 DPRINTF(("ucycomstart(8): to[0] = %d | %d = %d\n", 340 *cnt, sc->sc_mcr, to[0])); 341 break; 342 343 case 32: 344 to[0] = sc->sc_mcr; 345 to[1] = *cnt; 346 memcpy(&to[2], data, *cnt); 347 DPRINTF(("ucycomstart(32): to[0] = %d\nto[1] = %d\n", 348 to[0], to[1])); 349 break; 350 } 351 352 #ifdef UCYCOM_DEBUG 353 if (ucycomdebug > 5) { 354 int i; 355 356 if (len != 0) { 357 DPRINTF(("ucycomstart: to[0..%d) =", len-1)); 358 for (i = 0; i < len; i++) 359 DPRINTF((" %02x", to[i])); 360 DPRINTF(("\n")); 361 } 362 } 363 #endif 364 *cnt = len; 365 366 DPRINTFN(4,("ucycomstart: req %d chars did %d chars\n", want, len)); 367 } 368 369 int 370 ucycom_param(void *addr, int portno, struct termios *t) 371 { 372 struct ucycom_softc *sc = addr; 373 uint8_t report[5]; 374 size_t rlen; 375 uint32_t baud = 0; 376 uint8_t cfg; 377 378 if (usbd_is_dying(sc->sc_udev)) 379 return (EIO); 380 381 switch (t->c_ospeed) { 382 case 600: 383 case 1200: 384 case 2400: 385 case 4800: 386 case 9600: 387 case 19200: 388 case 38400: 389 case 57600: 390 #if 0 391 /* 392 * Stock chips only support standard baud rates in the 600 - 57600 393 * range, but higher rates can be achieved using custom firmware. 394 */ 395 case 115200: 396 case 153600: 397 case 192000: 398 #endif 399 baud = t->c_ospeed; 400 break; 401 default: 402 return (EINVAL); 403 } 404 405 if (t->c_cflag & CIGNORE) { 406 cfg = sc->sc_cfg; 407 } else { 408 cfg = 0; 409 switch (t->c_cflag & CSIZE) { 410 case CS8: 411 cfg |= UCYCOM_DATA_BITS_8; 412 break; 413 case CS7: 414 cfg |= UCYCOM_DATA_BITS_7; 415 break; 416 case CS6: 417 cfg |= UCYCOM_DATA_BITS_6; 418 break; 419 case CS5: 420 cfg |= UCYCOM_DATA_BITS_5; 421 break; 422 default: 423 return (EINVAL); 424 } 425 cfg |= ISSET(t->c_cflag, CSTOPB) ? 426 UCYCOM_STOP_BITS_2 : UCYCOM_STOP_BITS_1; 427 cfg |= ISSET(t->c_cflag, PARENB) ? 428 UCYCOM_PARITY_ON : UCYCOM_PARITY_OFF; 429 cfg |= ISSET(t->c_cflag, PARODD) ? 430 UCYCOM_PARITY_ODD : UCYCOM_PARITY_EVEN; 431 } 432 433 DPRINTF(("ucycom_param: setting %d baud, %d-%c-%d (%d)\n", baud, 434 5 + (cfg & UCYCOM_DATA_MASK), 435 (cfg & UCYCOM_PARITY_MASK) ? 436 ((cfg & UCYCOM_PARITY_TYPE_MASK) ? 'O' : 'E') : 'N', 437 (cfg & UCYCOM_STOP_MASK) ? 2 : 1, cfg)); 438 439 report[0] = baud & 0xff; 440 report[1] = (baud >> 8) & 0xff; 441 report[2] = (baud >> 16) & 0xff; 442 report[3] = (baud >> 24) & 0xff; 443 report[4] = cfg; 444 rlen = MIN(sc->sc_flen, sizeof(report)); 445 if (uhidev_set_report(sc->sc_hdev.sc_parent, UHID_FEATURE_REPORT, 446 sc->sc_hdev.sc_report_id, report, rlen) != rlen) 447 return EIO; 448 sc->sc_baud = baud; 449 return (0); 450 } 451 452 void 453 ucycom_intr(struct uhidev *addr, void *ibuf, u_int len) 454 { 455 extern void ucomreadcb(struct usbd_xfer *, void *, usbd_status); 456 struct ucycom_softc *sc = (struct ucycom_softc *)addr; 457 uint8_t *cp = ibuf; 458 int n, st, s; 459 460 /* not accepting data anymore.. */ 461 if (sc->sc_ibuf == NULL) 462 return; 463 464 /* We understand 8 byte and 32 byte input records */ 465 switch (len) { 466 case 8: 467 n = cp[0] & UCYCOM_LMASK; 468 st = cp[0] & ~UCYCOM_LMASK; 469 cp++; 470 break; 471 472 case 32: 473 st = cp[0]; 474 n = cp[1]; 475 cp += 2; 476 break; 477 478 default: 479 DPRINTFN(3,("ucycom_intr: Unknown input report length\n")); 480 return; 481 } 482 483 #ifdef UCYCOM_DEBUG 484 if (ucycomdebug > 5) { 485 u_int32_t i; 486 487 if (n != 0) { 488 DPRINTF(("ucycom_intr: ibuf[0..%d) =", n)); 489 for (i = 0; i < n; i++) 490 DPRINTF((" %02x", cp[i])); 491 DPRINTF(("\n")); 492 } 493 } 494 #endif 495 496 if (n > 0 || st != sc->sc_msr) { 497 s = spltty(); 498 sc->sc_newmsr = st; 499 bcopy(cp, sc->sc_ibuf, n); 500 sc->sc_icnt = n; 501 ucomreadcb(addr->sc_parent->sc_ixfer, sc->sc_subdev, 502 USBD_NORMAL_COMPLETION); 503 splx(s); 504 } 505 } 506 507 void 508 ucycom_set(void *addr, int portno, int reg, int onoff) 509 { 510 struct ucycom_softc *sc = addr; 511 int err; 512 513 switch (reg) { 514 case UCOM_SET_DTR: 515 if (onoff) 516 SET(sc->sc_mcr, UCYCOM_DTR); 517 else 518 CLR(sc->sc_mcr, UCYCOM_DTR); 519 break; 520 case UCOM_SET_RTS: 521 if (onoff) 522 SET(sc->sc_mcr, UCYCOM_RTS); 523 else 524 CLR(sc->sc_mcr, UCYCOM_RTS); 525 break; 526 case UCOM_SET_BREAK: 527 break; 528 } 529 530 memset(sc->sc_obuf, 0, sc->sc_olen); 531 sc->sc_obuf[0] = sc->sc_mcr; 532 533 err = uhidev_write(sc->sc_hdev.sc_parent, sc->sc_obuf, sc->sc_olen); 534 if (err) 535 DPRINTF(("ucycom_set_status: err=%d\n", err)); 536 } 537 538 int 539 ucycom_detach(struct device *self, int flags) 540 { 541 struct ucycom_softc *sc = (struct ucycom_softc *)self; 542 543 DPRINTF(("ucycom_detach: sc=%p flags=%d\n", sc, flags)); 544 if (sc->sc_subdev != NULL) { 545 config_detach(sc->sc_subdev, flags); 546 sc->sc_subdev = NULL; 547 } 548 549 if (sc->sc_hdev.sc_state & UHIDEV_OPEN) 550 uhidev_close(&sc->sc_hdev); 551 552 return (0); 553 } 554