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