uirda.c revision 1.39
1 /* $NetBSD: uirda.c,v 1.39 2016/04/23 10:15:32 skrll Exp $ */ 2 3 /* 4 * Copyright (c) 2001 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Lennart Augustsson (lennart (at) augustsson.net). 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: uirda.c,v 1.39 2016/04/23 10:15:32 skrll Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/device.h> 39 #include <sys/mutex.h> 40 #include <sys/ioctl.h> 41 #include <sys/conf.h> 42 #include <sys/file.h> 43 #include <sys/poll.h> 44 #include <sys/select.h> 45 #include <sys/proc.h> 46 47 #include <dev/usb/usb.h> 48 #include <dev/usb/usbdi.h> 49 #include <dev/usb/usbdi_util.h> 50 #include <dev/usb/usbdevs.h> 51 52 #include <dev/ir/ir.h> 53 #include <dev/ir/irdaio.h> 54 #include <dev/ir/irframevar.h> 55 56 #include <dev/usb/uirdavar.h> 57 58 #ifdef UIRDA_DEBUG 59 #define DPRINTF(x) if (uirdadebug) printf x 60 #define DPRINTFN(n,x) if (uirdadebug>(n)) printf x 61 int uirdadebug = 0; 62 #else 63 #define DPRINTF(x) 64 #define DPRINTFN(n,x) 65 #endif 66 67 68 /* Class specific requests */ 69 #define UR_IRDA_RECEIVING 0x01 /* Receive in progress? */ 70 #define UR_IRDA_CHECK_MEDIA_BUSY 0x03 71 #define UR_IRDA_SET_RATE_SNIFF 0x04 /* opt */ 72 #define UR_IRDA_SET_UNICAST_LIST 0x05 /* opt */ 73 #define UR_IRDA_GET_DESC 0x06 74 75 #define UIRDA_NEBOFS 8 76 static struct { 77 int count; 78 int mask; 79 int header; 80 } uirda_ebofs[UIRDA_NEBOFS] = { 81 { 0, UI_EB_0, UIRDA_EB_0 }, 82 { 1, UI_EB_1, UIRDA_EB_1 }, 83 { 2, UI_EB_2, UIRDA_EB_2 }, 84 { 3, UI_EB_3, UIRDA_EB_3 }, 85 { 6, UI_EB_6, UIRDA_EB_6 }, 86 { 12, UI_EB_12, UIRDA_EB_12 }, 87 { 24, UI_EB_24, UIRDA_EB_24 }, 88 { 48, UI_EB_48, UIRDA_EB_48 } 89 }; 90 91 #define UIRDA_NSPEEDS 9 92 static struct { 93 int speed; 94 int mask; 95 int header; 96 } uirda_speeds[UIRDA_NSPEEDS] = { 97 { 4000000, UI_BR_4000000, UIRDA_4000000 }, 98 { 1152000, UI_BR_1152000, UIRDA_1152000 }, 99 { 576000, UI_BR_576000, UIRDA_576000 }, 100 { 115200, UI_BR_115200, UIRDA_115200 }, 101 { 57600, UI_BR_57600, UIRDA_57600 }, 102 { 38400, UI_BR_38400, UIRDA_38400 }, 103 { 19200, UI_BR_19200, UIRDA_19200 }, 104 { 9600, UI_BR_9600, UIRDA_9600 }, 105 { 2400, UI_BR_2400, UIRDA_2400 }, 106 }; 107 108 109 110 int uirda_open(void *, int, int, struct lwp *); 111 int uirda_close(void *, int, int, struct lwp *); 112 int uirda_read(void *, struct uio *, int); 113 int uirda_write(void *, struct uio *, int); 114 int uirda_set_params(void *, struct irda_params *); 115 int uirda_get_speeds(void *, int *); 116 int uirda_get_turnarounds(void *, int *); 117 int uirda_poll(void *, int, struct lwp *); 118 int uirda_kqfilter(void *, struct knote *); 119 120 struct irframe_methods uirda_methods = { 121 uirda_open, uirda_close, uirda_read, uirda_write, uirda_poll, 122 uirda_kqfilter, uirda_set_params, uirda_get_speeds, 123 uirda_get_turnarounds 124 }; 125 126 void uirda_rd_cb(struct usbd_xfer *xfer, void *priv, 127 usbd_status status); 128 usbd_status uirda_start_read(struct uirda_softc *sc); 129 130 /* 131 * These devices don't quite follow the spec. Speed changing is broken 132 * and they don't handle windows. 133 * But we change speed in a safe way, and don't use windows now. 134 * Some devices also seem to have an interrupt pipe that can be ignored. 135 * 136 * Table information taken from Linux driver. 137 */ 138 Static const struct usb_devno uirda_devs[] = { 139 { USB_VENDOR_ACTISYS, USB_PRODUCT_ACTISYS_IR2000U }, 140 { USB_VENDOR_EXTENDED, USB_PRODUCT_EXTENDED_XTNDACCESS }, 141 { USB_VENDOR_KAWATSU, USB_PRODUCT_KAWATSU_KC180 }, 142 }; 143 #define uirda_lookup(v, p) (usb_lookup(uirda_devs, v, p)) 144 145 int uirda_match(device_t, cfdata_t, void *); 146 void uirda_attach(device_t, device_t, void *); 147 void uirda_childdet(device_t, device_t); 148 int uirda_detach(device_t, int); 149 int uirda_activate(device_t, enum devact); 150 extern struct cfdriver uirda_cd; 151 CFATTACH_DECL2_NEW(uirda, sizeof(struct uirda_softc), uirda_match, 152 uirda_attach, uirda_detach, uirda_activate, NULL, uirda_childdet); 153 154 int 155 uirda_match(device_t parent, cfdata_t match, void *aux) 156 { 157 struct usbif_attach_arg *uiaa = aux; 158 159 DPRINTFN(50,("uirda_match\n")); 160 161 if (uirda_lookup(uiaa->uiaa_vendor, uiaa->uiaa_product) != NULL) 162 return UMATCH_VENDOR_PRODUCT; 163 164 if (uiaa->uiaa_class == UICLASS_APPL_SPEC && 165 uiaa->uiaa_subclass == UISUBCLASS_IRDA && 166 uiaa->uiaa_proto == UIPROTO_IRDA) 167 return UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO; 168 return UMATCH_NONE; 169 } 170 171 void 172 uirda_attach(device_t parent, device_t self, void *aux) 173 { 174 struct uirda_softc *sc = device_private(self); 175 struct usbif_attach_arg *uiaa = aux; 176 struct usbd_device * dev = uiaa->uiaa_device; 177 struct usbd_interface *iface = uiaa->uiaa_iface; 178 char *devinfop; 179 usb_endpoint_descriptor_t *ed; 180 usbd_status err; 181 uint8_t epcount; 182 u_int specrev; 183 int i; 184 struct ir_attach_args ia; 185 186 DPRINTFN(10,("uirda_attach: sc=%p\n", sc)); 187 188 sc->sc_dev = self; 189 190 aprint_naive("\n"); 191 aprint_normal("\n"); 192 193 devinfop = usbd_devinfo_alloc(dev, 0); 194 aprint_normal_dev(self, "%s\n", devinfop); 195 usbd_devinfo_free(devinfop); 196 197 sc->sc_udev = dev; 198 sc->sc_iface = iface; 199 200 if (sc->sc_hdszi == 0) 201 sc->sc_hdszi = UIRDA_INPUT_HEADER_SIZE; 202 203 epcount = 0; 204 (void)usbd_endpoint_count(iface, &epcount); 205 206 sc->sc_rd_addr = -1; 207 sc->sc_wr_addr = -1; 208 for (i = 0; i < epcount; i++) { 209 ed = usbd_interface2endpoint_descriptor(iface, i); 210 if (ed == NULL) { 211 aprint_error_dev(self, "couldn't get ep %d\n", i); 212 return; 213 } 214 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 215 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 216 sc->sc_rd_addr = ed->bEndpointAddress; 217 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 218 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 219 sc->sc_wr_addr = ed->bEndpointAddress; 220 } 221 } 222 if (sc->sc_rd_addr == -1 || sc->sc_wr_addr == -1) { 223 aprint_error_dev(self, "missing endpoint\n"); 224 return; 225 } 226 227 if (sc->sc_loadfw(sc) != 0) { 228 return; 229 } 230 231 /* Get the IrDA descriptor */ 232 err = usbd_get_class_desc(sc->sc_udev, UDESC_IRDA, 0, 233 USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc); 234 aprint_error_dev(self, "error %d reading class desc\n", err); 235 if (err) { 236 err = usbd_get_desc(sc->sc_udev, UDESC_IRDA, 0, 237 USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc); 238 } 239 aprint_error_dev(self, "error %d reading desc\n", err); 240 if (err) { 241 /* maybe it's embedded in the config desc? */ 242 usbd_desc_iter_t iter; 243 const usb_descriptor_t *d; 244 usb_desc_iter_init(sc->sc_udev, &iter); 245 for (;;) { 246 d = usb_desc_iter_next(&iter); 247 if (!d || d->bDescriptorType == UDESC_IRDA) 248 break; 249 } 250 if (d == NULL) { 251 aprint_error_dev(self, 252 "Cannot get IrDA descriptor\n"); 253 return; 254 } 255 memcpy(&sc->sc_irdadesc, d, USB_IRDA_DESCRIPTOR_SIZE); 256 } 257 DPRINTF(("uirda_attach: bDescriptorSize %d bDescriptorType 0x%x " 258 "bmDataSize=0x%02x bmWindowSize=0x%02x " 259 "bmMinTurnaroundTime=0x%02x wBaudRate=0x%04x " 260 "bmAdditionalBOFs=0x%02x bIrdaSniff=%d bMaxUnicastList=%d\n", 261 sc->sc_irdadesc.bLength, 262 sc->sc_irdadesc.bDescriptorType, 263 sc->sc_irdadesc.bmDataSize, 264 sc->sc_irdadesc.bmWindowSize, 265 sc->sc_irdadesc.bmMinTurnaroundTime, 266 UGETW(sc->sc_irdadesc.wBaudRate), 267 sc->sc_irdadesc.bmAdditionalBOFs, 268 sc->sc_irdadesc.bIrdaSniff, 269 sc->sc_irdadesc.bMaxUnicastList)); 270 271 specrev = UGETW(sc->sc_irdadesc.bcdSpecRevision); 272 aprint_normal_dev(self, "USB-IrDA protocol version %x.%02x\n", 273 specrev >> 8, specrev & 0xff); 274 275 DPRINTFN(10, ("uirda_attach: %p\n", sc->sc_udev)); 276 277 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, 278 sc->sc_dev); 279 280 mutex_init(&sc->sc_wr_buf_lk, MUTEX_DEFAULT, IPL_NONE); 281 mutex_init(&sc->sc_rd_buf_lk, MUTEX_DEFAULT, IPL_NONE); 282 selinit(&sc->sc_rd_sel); 283 selinit(&sc->sc_wr_sel); 284 285 ia.ia_type = IR_TYPE_IRFRAME; 286 ia.ia_methods = sc->sc_irm ? sc->sc_irm : &uirda_methods; 287 ia.ia_handle = sc; 288 289 sc->sc_child = config_found(self, &ia, ir_print); 290 291 return; 292 } 293 294 int 295 uirda_detach(device_t self, int flags) 296 { 297 struct uirda_softc *sc = device_private(self); 298 int s; 299 int rv = 0; 300 301 DPRINTF(("uirda_detach: sc=%p flags=%d\n", sc, flags)); 302 303 sc->sc_dying = 1; 304 /* Abort all pipes. Causes processes waiting for transfer to wake. */ 305 if (sc->sc_rd_pipe != NULL) { 306 usbd_abort_pipe(sc->sc_rd_pipe); 307 } 308 if (sc->sc_wr_pipe != NULL) { 309 usbd_abort_pipe(sc->sc_wr_pipe); 310 } 311 if (sc->sc_rd_xfer != NULL) { 312 usbd_destroy_xfer(sc->sc_rd_xfer); 313 sc->sc_rd_xfer = NULL; 314 sc->sc_rd_buf = NULL; 315 } 316 if (sc->sc_wr_xfer != NULL) { 317 usbd_destroy_xfer(sc->sc_wr_xfer); 318 sc->sc_wr_xfer = NULL; 319 sc->sc_wr_buf = NULL; 320 } 321 if (sc->sc_rd_pipe != NULL) { 322 usbd_close_pipe(sc->sc_rd_pipe); 323 sc->sc_rd_pipe = NULL; 324 } 325 if (sc->sc_wr_pipe != NULL) { 326 usbd_close_pipe(sc->sc_wr_pipe); 327 sc->sc_wr_pipe = NULL; 328 } 329 wakeup(&sc->sc_rd_count); 330 331 s = splusb(); 332 if (--sc->sc_refcnt >= 0) { 333 /* Wait for processes to go away. */ 334 usb_detach_waitold(sc->sc_dev); 335 } 336 splx(s); 337 338 if (sc->sc_child != NULL) 339 rv = config_detach(sc->sc_child, flags); 340 341 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 342 sc->sc_dev); 343 344 mutex_destroy(&sc->sc_wr_buf_lk); 345 mutex_destroy(&sc->sc_rd_buf_lk); 346 seldestroy(&sc->sc_rd_sel); 347 seldestroy(&sc->sc_wr_sel); 348 349 return rv; 350 } 351 352 void 353 uirda_childdet(device_t self, device_t child) 354 { 355 struct uirda_softc *sc = device_private(self); 356 357 KASSERT(sc->sc_child == child); 358 sc->sc_child = NULL; 359 } 360 361 int 362 uirda_activate(device_t self, enum devact act) 363 { 364 struct uirda_softc *sc = device_private(self); 365 366 switch (act) { 367 case DVACT_DEACTIVATE: 368 sc->sc_dying = 1; 369 return 0; 370 default: 371 return EOPNOTSUPP; 372 } 373 } 374 375 int 376 uirda_open(void *h, int flag, int mode, 377 struct lwp *l) 378 { 379 struct uirda_softc *sc = h; 380 int error; 381 usbd_status err; 382 383 DPRINTF(("%s: sc=%p\n", __func__, sc)); 384 385 err = usbd_open_pipe(sc->sc_iface, sc->sc_rd_addr, 0, &sc->sc_rd_pipe); 386 if (err) { 387 error = EIO; 388 goto bad1; 389 } 390 err = usbd_open_pipe(sc->sc_iface, sc->sc_wr_addr, 0, &sc->sc_wr_pipe); 391 if (err) { 392 error = EIO; 393 goto bad2; 394 } 395 error = usbd_create_xfer(sc->sc_rd_pipe, 396 IRDA_MAX_FRAME_SIZE + sc->sc_hdszi, USBD_SHORT_XFER_OK, 0, 397 &sc->sc_rd_xfer); 398 if (error) 399 goto bad3; 400 sc->sc_rd_buf = usbd_get_buffer(sc->sc_rd_xfer); 401 402 /* worst case ST-UIRDA length */ 403 error = usbd_create_xfer(sc->sc_wr_pipe, 404 IRDA_MAX_FRAME_SIZE + UIRDA_OUTPUT_HEADER_SIZE + 2 + 1, 405 USBD_FORCE_SHORT_XFER, 0, &sc->sc_wr_xfer); 406 if (error) 407 goto bad4; 408 sc->sc_wr_buf = usbd_get_buffer(sc->sc_wr_xfer); 409 410 sc->sc_rd_count = 0; 411 sc->sc_rd_err = 0; 412 sc->sc_params.speed = 0; 413 sc->sc_params.ebofs = 0; 414 sc->sc_params.maxsize = IRDA_MAX_FRAME_SIZE; 415 sc->sc_wr_hdr = -1; 416 417 err = uirda_start_read(sc); 418 /* XXX check err */ 419 420 return 0; 421 422 bad4: 423 usbd_destroy_xfer(sc->sc_rd_xfer); 424 sc->sc_rd_xfer = NULL; 425 bad3: 426 usbd_close_pipe(sc->sc_wr_pipe); 427 sc->sc_wr_pipe = NULL; 428 bad2: 429 usbd_close_pipe(sc->sc_rd_pipe); 430 sc->sc_rd_pipe = NULL; 431 bad1: 432 return error; 433 } 434 435 int 436 uirda_close(void *h, int flag, int mode, 437 struct lwp *l) 438 { 439 struct uirda_softc *sc = h; 440 441 DPRINTF(("%s: sc=%p\n", __func__, sc)); 442 443 if (sc->sc_rd_pipe != NULL) { 444 usbd_abort_pipe(sc->sc_rd_pipe); 445 } 446 if (sc->sc_wr_pipe != NULL) { 447 usbd_abort_pipe(sc->sc_wr_pipe); 448 } 449 if (sc->sc_rd_xfer != NULL) { 450 usbd_destroy_xfer(sc->sc_rd_xfer); 451 sc->sc_rd_xfer = NULL; 452 sc->sc_rd_buf = NULL; 453 } 454 if (sc->sc_wr_xfer != NULL) { 455 usbd_destroy_xfer(sc->sc_wr_xfer); 456 sc->sc_wr_xfer = NULL; 457 sc->sc_wr_buf = NULL; 458 } 459 if (sc->sc_rd_pipe != NULL) { 460 usbd_close_pipe(sc->sc_rd_pipe); 461 sc->sc_rd_pipe = NULL; 462 } 463 if (sc->sc_wr_pipe != NULL) { 464 usbd_close_pipe(sc->sc_wr_pipe); 465 sc->sc_wr_pipe = NULL; 466 } 467 468 return 0; 469 } 470 471 int 472 uirda_read(void *h, struct uio *uio, int flag) 473 { 474 struct uirda_softc *sc = h; 475 int s; 476 int error; 477 u_int n; 478 479 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 480 481 if (sc->sc_dying) 482 return EIO; 483 484 #ifdef DIAGNOSTIC 485 if (sc->sc_rd_buf == NULL) 486 return EINVAL; 487 #endif 488 489 sc->sc_refcnt++; 490 491 do { 492 s = splusb(); 493 while (sc->sc_rd_count == 0) { 494 DPRINTFN(5,("uirda_read: calling tsleep()\n")); 495 error = tsleep(&sc->sc_rd_count, PZERO | PCATCH, 496 "uirdrd", 0); 497 if (sc->sc_dying) 498 error = EIO; 499 if (error) { 500 splx(s); 501 DPRINTF(("uirda_read: tsleep() = %d\n", error)); 502 goto ret; 503 } 504 } 505 splx(s); 506 507 mutex_enter(&sc->sc_rd_buf_lk); 508 n = sc->sc_rd_count - sc->sc_hdszi; 509 DPRINTFN(1,("%s: sc=%p n=%u, hdr=0x%02x\n", __func__, 510 sc, n, sc->sc_rd_buf[0])); 511 if (n > uio->uio_resid) 512 error = EINVAL; 513 else 514 error = uiomove(sc->sc_rd_buf + sc->sc_hdszi, n, uio); 515 sc->sc_rd_count = 0; 516 mutex_exit(&sc->sc_rd_buf_lk); 517 518 uirda_start_read(sc); 519 /* XXX check uirda_start_read() return value */ 520 521 } while (n == 0); 522 523 DPRINTFN(1,("uirda_read: return %d\n", error)); 524 525 ret: 526 if (--sc->sc_refcnt < 0) 527 usb_detach_wakeupold(sc->sc_dev); 528 return error; 529 } 530 531 int 532 uirda_write(void *h, struct uio *uio, int flag) 533 { 534 struct uirda_softc *sc = h; 535 usbd_status err; 536 uint32_t n; 537 int error = 0; 538 539 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 540 541 if (sc->sc_dying) 542 return EIO; 543 544 #ifdef DIAGNOSTIC 545 if (sc->sc_wr_buf == NULL) 546 return EINVAL; 547 #endif 548 549 n = uio->uio_resid; 550 if (n > sc->sc_params.maxsize) 551 return EINVAL; 552 553 sc->sc_refcnt++; 554 mutex_enter(&sc->sc_wr_buf_lk); 555 556 sc->sc_wr_buf[0] = UIRDA_EB_NO_CHANGE | UIRDA_NO_SPEED; 557 error = uiomove(sc->sc_wr_buf + UIRDA_OUTPUT_HEADER_SIZE, n, uio); 558 if (error) 559 goto done; 560 561 DPRINTFN(1, ("uirdawrite: transfer %d bytes\n", n)); 562 563 n += UIRDA_OUTPUT_HEADER_SIZE; 564 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 565 USBD_FORCE_SHORT_XFER, UIRDA_WR_TIMEOUT, sc->sc_wr_buf, &n); 566 DPRINTFN(2, ("uirdawrite: err=%d\n", err)); 567 if (err) { 568 if (err == USBD_INTERRUPTED) 569 error = EINTR; 570 else if (err == USBD_TIMEOUT) 571 error = ETIMEDOUT; 572 else 573 error = EIO; 574 } 575 done: 576 mutex_exit(&sc->sc_wr_buf_lk); 577 if (--sc->sc_refcnt < 0) 578 usb_detach_wakeupold(sc->sc_dev); 579 580 DPRINTFN(1,("%s: sc=%p done\n", __func__, sc)); 581 return error; 582 } 583 584 int 585 uirda_poll(void *h, int events, struct lwp *l) 586 { 587 struct uirda_softc *sc = h; 588 int revents = 0; 589 int s; 590 591 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 592 593 s = splusb(); 594 if (events & (POLLOUT | POLLWRNORM)) 595 revents |= events & (POLLOUT | POLLWRNORM); 596 if (events & (POLLIN | POLLRDNORM)) { 597 if (sc->sc_rd_count != 0) { 598 DPRINTFN(2,("%s: have data\n", __func__)); 599 revents |= events & (POLLIN | POLLRDNORM); 600 } else { 601 DPRINTFN(2,("%s: recording select\n", __func__)); 602 selrecord(l, &sc->sc_rd_sel); 603 } 604 } 605 splx(s); 606 607 return revents; 608 } 609 610 static void 611 filt_uirdardetach(struct knote *kn) 612 { 613 struct uirda_softc *sc = kn->kn_hook; 614 int s; 615 616 s = splusb(); 617 SLIST_REMOVE(&sc->sc_rd_sel.sel_klist, kn, knote, kn_selnext); 618 splx(s); 619 } 620 621 static int 622 filt_uirdaread(struct knote *kn, long hint) 623 { 624 struct uirda_softc *sc = kn->kn_hook; 625 626 kn->kn_data = sc->sc_rd_count; 627 return kn->kn_data > 0; 628 } 629 630 static void 631 filt_uirdawdetach(struct knote *kn) 632 { 633 struct uirda_softc *sc = kn->kn_hook; 634 int s; 635 636 s = splusb(); 637 SLIST_REMOVE(&sc->sc_wr_sel.sel_klist, kn, knote, kn_selnext); 638 splx(s); 639 } 640 641 static const struct filterops uirdaread_filtops = 642 { 1, NULL, filt_uirdardetach, filt_uirdaread }; 643 static const struct filterops uirdawrite_filtops = 644 { 1, NULL, filt_uirdawdetach, filt_seltrue }; 645 646 int 647 uirda_kqfilter(void *h, struct knote *kn) 648 { 649 struct uirda_softc *sc = kn->kn_hook; 650 struct klist *klist; 651 int s; 652 653 switch (kn->kn_filter) { 654 case EVFILT_READ: 655 klist = &sc->sc_rd_sel.sel_klist; 656 kn->kn_fop = &uirdaread_filtops; 657 break; 658 case EVFILT_WRITE: 659 klist = &sc->sc_wr_sel.sel_klist; 660 kn->kn_fop = &uirdawrite_filtops; 661 break; 662 default: 663 return EINVAL; 664 } 665 666 kn->kn_hook = sc; 667 668 s = splusb(); 669 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 670 splx(s); 671 672 return 0; 673 } 674 675 int 676 uirda_set_params(void *h, struct irda_params *p) 677 { 678 struct uirda_softc *sc = h; 679 usbd_status err; 680 int i; 681 uint8_t hdr; 682 uint32_t n; 683 u_int mask; 684 685 DPRINTF(("%s: sc=%p, speed=%d ebofs=%d maxsize=%d\n", __func__, 686 sc, p->speed, p->ebofs, p->maxsize)); 687 688 if (sc->sc_dying) 689 return EIO; 690 691 hdr = 0; 692 if (p->ebofs != sc->sc_params.ebofs) { 693 /* round up ebofs */ 694 mask = 1 /* sc->sc_irdadesc.bmAdditionalBOFs*/; 695 DPRINTF(("u.s.p.: mask=0x%x, sc->ebofs=%d, p->ebofs=%d\n", 696 mask, sc->sc_params.ebofs, p->ebofs)); 697 for (i = 0; i < UIRDA_NEBOFS; i++) { 698 DPRINTF(("u.s.p.: u_e[%d].mask=0x%x, count=%d\n", 699 i, uirda_ebofs[i].mask, uirda_ebofs[i].count)); 700 if ((mask & uirda_ebofs[i].mask) && 701 uirda_ebofs[i].count >= p->ebofs) { 702 hdr = uirda_ebofs[i].header; 703 goto found1; 704 } 705 } 706 for (i = 0; i < UIRDA_NEBOFS; i++) { 707 DPRINTF(("u.s.p.: u_e[%d].mask=0x%x, count=%d\n", 708 i, uirda_ebofs[i].mask, uirda_ebofs[i].count)); 709 if ((mask & uirda_ebofs[i].mask)) { 710 hdr = uirda_ebofs[i].header; 711 goto found1; 712 } 713 } 714 /* no good value found */ 715 return EINVAL; 716 found1: 717 DPRINTF(("uirda_set_params: ebofs hdr=0x%02x\n", hdr)); 718 ; 719 720 } 721 if (hdr != 0 || p->speed != sc->sc_params.speed) { 722 /* find speed */ 723 mask = UGETW(sc->sc_irdadesc.wBaudRate); 724 for (i = 0; i < UIRDA_NSPEEDS; i++) { 725 if ((mask & uirda_speeds[i].mask) && 726 uirda_speeds[i].speed == p->speed) { 727 hdr |= uirda_speeds[i].header; 728 goto found2; 729 } 730 } 731 /* no good value found */ 732 return EINVAL; 733 found2: 734 DPRINTF(("uirda_set_params: speed hdr=0x%02x\n", hdr)); 735 ; 736 } 737 if (p->maxsize != sc->sc_params.maxsize) { 738 if (p->maxsize > IRDA_MAX_FRAME_SIZE) 739 return EINVAL; 740 sc->sc_params.maxsize = p->maxsize; 741 #if 0 742 DPRINTF(("%s: new buffers, old size=%d\n", __func__, 743 sc->sc_params.maxsize)); 744 if (p->maxsize > 10000 || p < 0) /* XXX */ 745 return EINVAL; 746 747 /* Change the write buffer */ 748 mutex_enter(&sc->sc_wr_buf_lk); 749 if (sc->sc_wr_buf != NULL) 750 usbd_free_buffer(sc->sc_wr_xfer); 751 sc->sc_wr_buf = usbd_get_buffer(sc->sc_wr_xfer, p->maxsize+1); 752 mutex_exit(&sc->sc_wr_buf_lk); 753 if (sc->sc_wr_buf == NULL) 754 return ENOMEM; 755 756 /* Change the read buffer */ 757 mutex_enter(&sc->sc_rd_buf_lk); 758 usbd_abort_pipe(sc->sc_rd_pipe); 759 if (sc->sc_rd_buf != NULL) 760 usbd_free_buffer(sc->sc_rd_xfer); 761 sc->sc_rd_buf = usbd_get_buffer(sc->sc_rd_xfer, p->maxsize+1); 762 sc->sc_rd_count = 0; 763 if (sc->sc_rd_buf == NULL) { 764 mutex_exit(&sc->sc_rd_buf_lk); 765 return ENOMEM; 766 } 767 sc->sc_params.maxsize = p->maxsize; 768 err = uirda_start_read(sc); /* XXX check */ 769 mutex_exit(&sc->sc_rd_buf_lk); 770 #endif 771 } 772 if (hdr != 0 && hdr != sc->sc_wr_hdr) { 773 /* 774 * A change has occurred, transmit a 0 length frame with 775 * the new settings. The 0 length frame is not sent to the 776 * device. 777 */ 778 DPRINTF(("%s: sc=%p setting header 0x%02x\n", 779 __func__, sc, hdr)); 780 sc->sc_wr_hdr = hdr; 781 mutex_enter(&sc->sc_wr_buf_lk); 782 sc->sc_wr_buf[0] = hdr; 783 n = UIRDA_OUTPUT_HEADER_SIZE; 784 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 785 USBD_FORCE_SHORT_XFER, UIRDA_WR_TIMEOUT, 786 sc->sc_wr_buf, &n); 787 if (err) { 788 aprint_error_dev(sc->sc_dev, "set failed, err=%d\n", 789 err); 790 usbd_clear_endpoint_stall(sc->sc_wr_pipe); 791 } 792 mutex_exit(&sc->sc_wr_buf_lk); 793 } 794 795 sc->sc_params = *p; 796 797 return 0; 798 } 799 800 int 801 uirda_get_speeds(void *h, int *speeds) 802 { 803 struct uirda_softc *sc = h; 804 u_int isp; 805 u_int usp; 806 807 DPRINTF(("%s: sc=%p\n", __func__, sc)); 808 809 if (sc->sc_dying) 810 return EIO; 811 812 usp = UGETW(sc->sc_irdadesc.wBaudRate); 813 isp = 0; 814 if (usp & UI_BR_4000000) isp |= IRDA_SPEED_4000000; 815 if (usp & UI_BR_1152000) isp |= IRDA_SPEED_1152000; 816 if (usp & UI_BR_576000) isp |= IRDA_SPEED_576000; 817 if (usp & UI_BR_115200) isp |= IRDA_SPEED_115200; 818 if (usp & UI_BR_57600) isp |= IRDA_SPEED_57600; 819 if (usp & UI_BR_38400) isp |= IRDA_SPEED_38400; 820 if (usp & UI_BR_19200) isp |= IRDA_SPEED_19200; 821 if (usp & UI_BR_9600) isp |= IRDA_SPEED_9600; 822 if (usp & UI_BR_2400) isp |= IRDA_SPEED_2400; 823 *speeds = isp; 824 DPRINTF(("%s: speeds = 0x%x\n", __func__, isp)); 825 return 0; 826 } 827 828 int 829 uirda_get_turnarounds(void *h, int *turnarounds) 830 { 831 struct uirda_softc *sc = h; 832 u_int ita; 833 u_int uta; 834 835 DPRINTF(("%s: sc=%p\n", __func__, sc)); 836 837 if (sc->sc_dying) 838 return EIO; 839 840 uta = sc->sc_irdadesc.bmMinTurnaroundTime; 841 ita = 0; 842 if (uta & UI_TA_0) ita |= IRDA_TURNT_0; 843 if (uta & UI_TA_10) ita |= IRDA_TURNT_10; 844 if (uta & UI_TA_50) ita |= IRDA_TURNT_50; 845 if (uta & UI_TA_100) ita |= IRDA_TURNT_100; 846 if (uta & UI_TA_500) ita |= IRDA_TURNT_500; 847 if (uta & UI_TA_1000) ita |= IRDA_TURNT_1000; 848 if (uta & UI_TA_5000) ita |= IRDA_TURNT_5000; 849 if (uta & UI_TA_10000) ita |= IRDA_TURNT_10000; 850 *turnarounds = ita; 851 return 0; 852 } 853 854 void 855 uirda_rd_cb(struct usbd_xfer *xfer, void *priv, 856 usbd_status status) 857 { 858 struct uirda_softc *sc = priv; 859 uint32_t size; 860 861 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 862 863 if (status == USBD_CANCELLED) /* this is normal */ 864 return; 865 if (status) { 866 size = sc->sc_hdszi; 867 sc->sc_rd_err = 1; 868 } else { 869 usbd_get_xfer_status(xfer, NULL, NULL, &size, NULL); 870 } 871 DPRINTFN(1,("%s: sc=%p size=%u, err=%d\n", __func__, sc, size, 872 sc->sc_rd_err)); 873 sc->sc_rd_count = size; 874 wakeup(&sc->sc_rd_count); /* XXX should use flag */ 875 selnotify(&sc->sc_rd_sel, 0, 0); 876 } 877 878 usbd_status 879 uirda_start_read(struct uirda_softc *sc) 880 { 881 usbd_status err; 882 883 DPRINTFN(1,("%s: sc=%p, size=%d\n", __func__, sc, 884 sc->sc_params.maxsize + UIRDA_INPUT_HEADER_SIZE)); 885 886 if (sc->sc_dying) 887 return USBD_IOERROR; 888 889 if (sc->sc_rd_err) { 890 sc->sc_rd_err = 0; 891 DPRINTF(("uirda_start_read: clear stall\n")); 892 usbd_clear_endpoint_stall(sc->sc_rd_pipe); 893 } 894 895 usbd_setup_xfer(sc->sc_rd_xfer, sc, sc->sc_rd_buf, 896 sc->sc_params.maxsize + sc->sc_hdszi, USBD_SHORT_XFER_OK, 897 USBD_NO_TIMEOUT, uirda_rd_cb); 898 err = usbd_transfer(sc->sc_rd_xfer); 899 if (err != USBD_IN_PROGRESS) { 900 DPRINTF(("uirda_start_read: err=%d\n", err)); 901 return err; 902 } 903 return USBD_NORMAL_COMPLETION; 904 } 905 906 usbd_status 907 usbd_get_class_desc(struct usbd_device *dev, int type, int index, int len, void *desc) 908 { 909 usb_device_request_t req; 910 911 DPRINTFN(3,("usbd_get_desc: type=%d, index=%d, len=%d\n", 912 type, index, len)); 913 914 req.bmRequestType = 0xa1; /* XXX ? */ 915 req.bRequest = UR_GET_DESCRIPTOR; 916 USETW2(req.wValue, type, index); 917 USETW(req.wIndex, 0); 918 USETW(req.wLength, len); 919 return usbd_do_request(dev, &req, desc); 920 } 921
Indexes created Wed Sep 24 22:09:59 GMT 2025