uirda.c revision 1.25
1 /* $NetBSD: uirda.c,v 1.25 2007/05/11 13:12:14 is 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.25 2007/05/11 13:12:14 is 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/lock.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 USB_DECLARE_DRIVER(uirda); 153 154 USB_MATCH(uirda) 155 { 156 USB_IFMATCH_START(uirda, uaa); 157 158 DPRINTFN(50,("uirda_match\n")); 159 160 if (uirda_lookup(uaa->vendor, uaa->product) != NULL) 161 return (UMATCH_VENDOR_PRODUCT); 162 163 if (uaa->class == UICLASS_APPL_SPEC && 164 uaa->subclass == UISUBCLASS_IRDA && 165 uaa->proto == UIPROTO_IRDA) 166 return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO); 167 return (UMATCH_NONE); 168 } 169 170 USB_ATTACH(uirda) 171 { 172 USB_IFATTACH_START(uirda, sc, uaa); 173 usbd_device_handle dev = uaa->device; 174 usbd_interface_handle iface = uaa->iface; 175 char *devinfop; 176 usb_endpoint_descriptor_t *ed; 177 usbd_status err; 178 u_int8_t epcount; 179 u_int specrev; 180 int i; 181 struct ir_attach_args ia; 182 183 DPRINTFN(10,("uirda_attach: sc=%p\n", sc)); 184 185 devinfop = usbd_devinfo_alloc(dev, 0); 186 USB_ATTACH_SETUP; 187 printf("%s: %s\n", USBDEVNAME(sc->sc_dev), devinfop); 188 usbd_devinfo_free(devinfop); 189 190 sc->sc_udev = dev; 191 sc->sc_iface = iface; 192 193 if (sc->sc_hdszi == 0) 194 sc->sc_hdszi = UIRDA_INPUT_HEADER_SIZE; 195 196 epcount = 0; 197 (void)usbd_endpoint_count(iface, &epcount); 198 199 sc->sc_rd_addr = -1; 200 sc->sc_wr_addr = -1; 201 for (i = 0; i < epcount; i++) { 202 ed = usbd_interface2endpoint_descriptor(iface, i); 203 if (ed == NULL) { 204 printf("%s: couldn't get ep %d\n", 205 USBDEVNAME(sc->sc_dev), i); 206 USB_ATTACH_ERROR_RETURN; 207 } 208 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 209 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 210 sc->sc_rd_addr = ed->bEndpointAddress; 211 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 212 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 213 sc->sc_wr_addr = ed->bEndpointAddress; 214 } 215 } 216 if (sc->sc_rd_addr == -1 || sc->sc_wr_addr == -1) { 217 printf("%s: missing endpoint\n", USBDEVNAME(sc->sc_dev)); 218 USB_ATTACH_ERROR_RETURN; 219 } 220 221 if (sc->sc_loadfw(sc) != 0) { 222 USB_ATTACH_ERROR_RETURN; 223 } 224 225 /* Get the IrDA descriptor */ 226 err = usbd_get_class_desc(sc->sc_udev, UDESC_IRDA, 0, 227 USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc); 228 printf("error %d reading class desc\n", err); 229 if (err) { 230 err = usbd_get_desc(sc->sc_udev, UDESC_IRDA, 0, 231 USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc); 232 } 233 printf("error %d reading desc\n", err); 234 if (err) { 235 /* maybe it's embedded in the config desc? */ 236 usbd_desc_iter_t iter; 237 const usb_descriptor_t *d; 238 usb_desc_iter_init(sc->sc_udev, &iter); 239 for (;;) { 240 d = usb_desc_iter_next(&iter); 241 if (!d || d->bDescriptorType == UDESC_IRDA) 242 break; 243 } 244 if (d == NULL) { 245 printf("%s: Cannot get IrDA descriptor\n", 246 USBDEVNAME(sc->sc_dev)); 247 USB_ATTACH_ERROR_RETURN; 248 } 249 memcpy(&sc->sc_irdadesc, d, USB_IRDA_DESCRIPTOR_SIZE); 250 } 251 DPRINTF(("uirda_attach: bDescriptorSize %d bDescriptorType 0x%x " 252 "bmDataSize=0x%02x bmWindowSize=0x%02x " 253 "bmMinTurnaroundTime=0x%02x wBaudRate=0x%04x " 254 "bmAdditionalBOFs=0x%02x bIrdaSniff=%d bMaxUnicastList=%d\n", 255 sc->sc_irdadesc.bLength, 256 sc->sc_irdadesc.bDescriptorType, 257 sc->sc_irdadesc.bmDataSize, 258 sc->sc_irdadesc.bmWindowSize, 259 sc->sc_irdadesc.bmMinTurnaroundTime, 260 UGETW(sc->sc_irdadesc.wBaudRate), 261 sc->sc_irdadesc.bmAdditionalBOFs, 262 sc->sc_irdadesc.bIrdaSniff, 263 sc->sc_irdadesc.bMaxUnicastList)); 264 265 specrev = UGETW(sc->sc_irdadesc.bcdSpecRevision); 266 printf("%s: USB-IrDA protocol version %x.%02x\n", 267 USBDEVNAME(sc->sc_dev), specrev >> 8, specrev & 0xff); 268 269 DPRINTFN(10, ("uirda_attach: %p\n", sc->sc_udev)); 270 271 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, 272 USBDEV(sc->sc_dev)); 273 274 lockinit(&sc->sc_wr_buf_lk, PZERO, "iirwrl", 0, 0); 275 lockinit(&sc->sc_rd_buf_lk, PZERO, "uirrdl", 0, 0); 276 277 ia.ia_type = IR_TYPE_IRFRAME; 278 ia.ia_methods = sc->sc_irm ? sc->sc_irm : &uirda_methods; 279 ia.ia_handle = sc; 280 281 sc->sc_child = config_found(self, &ia, ir_print); 282 283 USB_ATTACH_SUCCESS_RETURN; 284 } 285 286 USB_DETACH(uirda) 287 { 288 USB_DETACH_START(uirda, sc); 289 int s; 290 int rv = 0; 291 292 DPRINTF(("uirda_detach: sc=%p flags=%d\n", sc, flags)); 293 294 sc->sc_dying = 1; 295 /* Abort all pipes. Causes processes waiting for transfer to wake. */ 296 if (sc->sc_rd_pipe != NULL) { 297 usbd_abort_pipe(sc->sc_rd_pipe); 298 usbd_close_pipe(sc->sc_rd_pipe); 299 sc->sc_rd_pipe = NULL; 300 } 301 if (sc->sc_wr_pipe != NULL) { 302 usbd_abort_pipe(sc->sc_wr_pipe); 303 usbd_close_pipe(sc->sc_wr_pipe); 304 sc->sc_wr_pipe = NULL; 305 } 306 wakeup(&sc->sc_rd_count); 307 308 s = splusb(); 309 if (--sc->sc_refcnt >= 0) { 310 /* Wait for processes to go away. */ 311 usb_detach_wait(USBDEV(sc->sc_dev)); 312 } 313 splx(s); 314 315 if (sc->sc_child != NULL) { 316 rv = config_detach(sc->sc_child, flags); 317 sc->sc_child = NULL; 318 } 319 320 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 321 USBDEV(sc->sc_dev)); 322 323 return (rv); 324 } 325 326 int 327 uirda_activate(device_ptr_t self, enum devact act) 328 { 329 struct uirda_softc *sc = (struct uirda_softc *)self; 330 int error = 0; 331 332 switch (act) { 333 case DVACT_ACTIVATE: 334 return (EOPNOTSUPP); 335 break; 336 337 case DVACT_DEACTIVATE: 338 sc->sc_dying = 1; 339 if (sc->sc_child != NULL) 340 error = config_deactivate(sc->sc_child); 341 break; 342 } 343 return (error); 344 } 345 346 int 347 uirda_open(void *h, int flag, int mode, 348 struct lwp *l) 349 { 350 struct uirda_softc *sc = h; 351 int error; 352 usbd_status err; 353 354 DPRINTF(("%s: sc=%p\n", __func__, sc)); 355 356 err = usbd_open_pipe(sc->sc_iface, sc->sc_rd_addr, 0, &sc->sc_rd_pipe); 357 if (err) { 358 error = EIO; 359 goto bad1; 360 } 361 err = usbd_open_pipe(sc->sc_iface, sc->sc_wr_addr, 0, &sc->sc_wr_pipe); 362 if (err) { 363 error = EIO; 364 goto bad2; 365 } 366 sc->sc_rd_xfer = usbd_alloc_xfer(sc->sc_udev); 367 if (sc->sc_rd_xfer == NULL) { 368 error = ENOMEM; 369 goto bad3; 370 } 371 sc->sc_wr_xfer = usbd_alloc_xfer(sc->sc_udev); 372 if (sc->sc_wr_xfer == NULL) { 373 error = ENOMEM; 374 goto bad4; 375 } 376 sc->sc_rd_buf = usbd_alloc_buffer(sc->sc_rd_xfer, 377 IRDA_MAX_FRAME_SIZE + sc->sc_hdszi); 378 if (sc->sc_rd_buf == NULL) { 379 error = ENOMEM; 380 goto bad5; 381 } 382 sc->sc_wr_buf = usbd_alloc_buffer(sc->sc_wr_xfer, 383 IRDA_MAX_FRAME_SIZE + UIRDA_OUTPUT_HEADER_SIZE + 384 2 + 1 /* worst case ST-UIRDA */); 385 if (sc->sc_wr_buf == NULL) { 386 error = ENOMEM; 387 goto bad5; 388 } 389 sc->sc_rd_count = 0; 390 sc->sc_rd_err = 0; 391 sc->sc_params.speed = 0; 392 sc->sc_params.ebofs = 0; 393 sc->sc_params.maxsize = IRDA_MAX_FRAME_SIZE; 394 sc->sc_wr_hdr = -1; 395 396 err = uirda_start_read(sc); 397 /* XXX check err */ 398 399 return (0); 400 401 bad5: 402 usbd_free_xfer(sc->sc_wr_xfer); 403 sc->sc_wr_xfer = NULL; 404 bad4: 405 usbd_free_xfer(sc->sc_rd_xfer); 406 sc->sc_rd_xfer = NULL; 407 bad3: 408 usbd_close_pipe(sc->sc_wr_pipe); 409 sc->sc_wr_pipe = NULL; 410 bad2: 411 usbd_close_pipe(sc->sc_rd_pipe); 412 sc->sc_rd_pipe = NULL; 413 bad1: 414 return (error); 415 } 416 417 int 418 uirda_close(void *h, int flag, int mode, 419 struct lwp *l) 420 { 421 struct uirda_softc *sc = h; 422 423 DPRINTF(("%s: sc=%p\n", __func__, sc)); 424 425 if (sc->sc_rd_pipe != NULL) { 426 usbd_abort_pipe(sc->sc_rd_pipe); 427 usbd_close_pipe(sc->sc_rd_pipe); 428 sc->sc_rd_pipe = NULL; 429 } 430 if (sc->sc_wr_pipe != NULL) { 431 usbd_abort_pipe(sc->sc_wr_pipe); 432 usbd_close_pipe(sc->sc_wr_pipe); 433 sc->sc_wr_pipe = NULL; 434 } 435 if (sc->sc_rd_xfer != NULL) { 436 usbd_free_xfer(sc->sc_rd_xfer); 437 sc->sc_rd_xfer = NULL; 438 sc->sc_rd_buf = NULL; 439 } 440 if (sc->sc_wr_xfer != NULL) { 441 usbd_free_xfer(sc->sc_wr_xfer); 442 sc->sc_wr_xfer = NULL; 443 sc->sc_wr_buf = NULL; 444 } 445 446 return (0); 447 } 448 449 int 450 uirda_read(void *h, struct uio *uio, int flag) 451 { 452 struct uirda_softc *sc = h; 453 usbd_status err; 454 int s; 455 int error; 456 u_int n; 457 458 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 459 460 if (sc->sc_dying) 461 return (EIO); 462 463 #ifdef DIAGNOSTIC 464 if (sc->sc_rd_buf == NULL) 465 return (EINVAL); 466 #endif 467 468 sc->sc_refcnt++; 469 470 do { 471 s = splusb(); 472 while (sc->sc_rd_count == 0) { 473 DPRINTFN(5,("uirda_read: calling tsleep()\n")); 474 error = tsleep(&sc->sc_rd_count, PZERO | PCATCH, 475 "uirdrd", 0); 476 if (sc->sc_dying) 477 error = EIO; 478 if (error) { 479 splx(s); 480 DPRINTF(("uirda_read: tsleep() = %d\n", error)); 481 goto ret; 482 } 483 } 484 splx(s); 485 486 lockmgr(&sc->sc_rd_buf_lk, LK_EXCLUSIVE, NULL); 487 n = sc->sc_rd_count - sc->sc_hdszi; 488 DPRINTFN(1,("%s: sc=%p n=%u, hdr=0x%02x\n", __func__, 489 sc, n, sc->sc_rd_buf[0])); 490 if (n > uio->uio_resid) 491 error = EINVAL; 492 else 493 error = uiomove(sc->sc_rd_buf + sc->sc_hdszi, n, uio); 494 sc->sc_rd_count = 0; 495 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 496 497 err = uirda_start_read(sc); 498 /* XXX check err */ 499 500 } while (n == 0); 501 502 DPRINTFN(1,("uirda_read: return %d\n", error)); 503 504 ret: 505 if (--sc->sc_refcnt < 0) 506 usb_detach_wakeup(USBDEV(sc->sc_dev)); 507 return (error); 508 } 509 510 int 511 uirda_write(void *h, struct uio *uio, int flag) 512 { 513 struct uirda_softc *sc = h; 514 usbd_status err; 515 u_int32_t n; 516 int error = 0; 517 518 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 519 520 if (sc->sc_dying) 521 return (EIO); 522 523 #ifdef DIAGNOSTIC 524 if (sc->sc_wr_buf == NULL) 525 return (EINVAL); 526 #endif 527 528 n = uio->uio_resid; 529 if (n > sc->sc_params.maxsize) 530 return (EINVAL); 531 532 sc->sc_refcnt++; 533 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 534 535 sc->sc_wr_buf[0] = UIRDA_EB_NO_CHANGE | UIRDA_NO_SPEED; 536 error = uiomove(sc->sc_wr_buf + UIRDA_OUTPUT_HEADER_SIZE, n, uio); 537 if (!error) { 538 DPRINTFN(1, ("uirdawrite: transfer %d bytes\n", n)); 539 540 n += UIRDA_OUTPUT_HEADER_SIZE; 541 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 542 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 543 UIRDA_WR_TIMEOUT, 544 sc->sc_wr_buf, &n, "uirdawr"); 545 DPRINTFN(2, ("uirdawrite: err=%d\n", err)); 546 if (err) { 547 if (err == USBD_INTERRUPTED) 548 error = EINTR; 549 else if (err == USBD_TIMEOUT) 550 error = ETIMEDOUT; 551 else 552 error = EIO; 553 } 554 } 555 556 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 557 if (--sc->sc_refcnt < 0) 558 usb_detach_wakeup(USBDEV(sc->sc_dev)); 559 560 DPRINTFN(1,("%s: sc=%p done\n", __func__, sc)); 561 return (error); 562 } 563 564 int 565 uirda_poll(void *h, int events, struct lwp *l) 566 { 567 struct uirda_softc *sc = h; 568 int revents = 0; 569 int s; 570 571 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 572 573 s = splusb(); 574 if (events & (POLLOUT | POLLWRNORM)) 575 revents |= events & (POLLOUT | POLLWRNORM); 576 if (events & (POLLIN | POLLRDNORM)) { 577 if (sc->sc_rd_count != 0) { 578 DPRINTFN(2,("%s: have data\n", __func__)); 579 revents |= events & (POLLIN | POLLRDNORM); 580 } else { 581 DPRINTFN(2,("%s: recording select\n", __func__)); 582 selrecord(l, &sc->sc_rd_sel); 583 } 584 } 585 splx(s); 586 587 return (revents); 588 } 589 590 static void 591 filt_uirdardetach(struct knote *kn) 592 { 593 struct uirda_softc *sc = kn->kn_hook; 594 int s; 595 596 s = splusb(); 597 SLIST_REMOVE(&sc->sc_rd_sel.sel_klist, kn, knote, kn_selnext); 598 splx(s); 599 } 600 601 static int 602 filt_uirdaread(struct knote *kn, long hint) 603 { 604 struct uirda_softc *sc = kn->kn_hook; 605 606 kn->kn_data = sc->sc_rd_count; 607 return (kn->kn_data > 0); 608 } 609 610 static void 611 filt_uirdawdetach(struct knote *kn) 612 { 613 struct uirda_softc *sc = kn->kn_hook; 614 int s; 615 616 s = splusb(); 617 SLIST_REMOVE(&sc->sc_wr_sel.sel_klist, kn, knote, kn_selnext); 618 splx(s); 619 } 620 621 static const struct filterops uirdaread_filtops = 622 { 1, NULL, filt_uirdardetach, filt_uirdaread }; 623 static const struct filterops uirdawrite_filtops = 624 { 1, NULL, filt_uirdawdetach, filt_seltrue }; 625 626 int 627 uirda_kqfilter(void *h, struct knote *kn) 628 { 629 struct uirda_softc *sc = kn->kn_hook; 630 struct klist *klist; 631 int s; 632 633 switch (kn->kn_filter) { 634 case EVFILT_READ: 635 klist = &sc->sc_rd_sel.sel_klist; 636 kn->kn_fop = &uirdaread_filtops; 637 break; 638 case EVFILT_WRITE: 639 klist = &sc->sc_wr_sel.sel_klist; 640 kn->kn_fop = &uirdawrite_filtops; 641 break; 642 default: 643 return (1); 644 } 645 646 kn->kn_hook = sc; 647 648 s = splusb(); 649 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 650 splx(s); 651 652 return (0); 653 } 654 655 int 656 uirda_set_params(void *h, struct irda_params *p) 657 { 658 struct uirda_softc *sc = h; 659 usbd_status err; 660 int i; 661 u_int8_t hdr; 662 u_int32_t n; 663 u_int mask; 664 665 DPRINTF(("%s: sc=%p, speed=%d ebofs=%d maxsize=%d\n", __func__, 666 sc, p->speed, p->ebofs, p->maxsize)); 667 668 if (sc->sc_dying) 669 return (EIO); 670 671 hdr = 0; 672 if (p->ebofs != sc->sc_params.ebofs) { 673 /* round up ebofs */ 674 mask = 1 /* sc->sc_irdadesc.bmAdditionalBOFs*/; 675 DPRINTF(("u.s.p.: mask=0x%x, sc->ebofs=%d, p->ebofs=%d\n", 676 mask, sc->sc_params.ebofs, p->ebofs)); 677 for (i = 0; i < UIRDA_NEBOFS; i++) { 678 DPRINTF(("u.s.p.: u_e[%d].mask=0x%x, count=%d\n", 679 i, uirda_ebofs[i].mask, uirda_ebofs[i].count)); 680 if ((mask & uirda_ebofs[i].mask) && 681 uirda_ebofs[i].count >= p->ebofs) { 682 hdr = uirda_ebofs[i].header; 683 goto found1; 684 } 685 } 686 for (i = 0; i < UIRDA_NEBOFS; i++) { 687 DPRINTF(("u.s.p.: u_e[%d].mask=0x%x, count=%d\n", 688 i, uirda_ebofs[i].mask, uirda_ebofs[i].count)); 689 if ((mask & uirda_ebofs[i].mask)) { 690 hdr = uirda_ebofs[i].header; 691 goto found1; 692 } 693 } 694 /* no good value found */ 695 return (EINVAL); 696 found1: 697 DPRINTF(("uirda_set_params: ebofs hdr=0x%02x\n", hdr)); 698 ; 699 700 } 701 if (hdr != 0 || p->speed != sc->sc_params.speed) { 702 /* find speed */ 703 mask = UGETW(sc->sc_irdadesc.wBaudRate); 704 for (i = 0; i < UIRDA_NSPEEDS; i++) { 705 if ((mask & uirda_speeds[i].mask) && 706 uirda_speeds[i].speed == p->speed) { 707 hdr |= uirda_speeds[i].header; 708 goto found2; 709 } 710 } 711 /* no good value found */ 712 return (EINVAL); 713 found2: 714 DPRINTF(("uirda_set_params: speed hdr=0x%02x\n", hdr)); 715 ; 716 } 717 if (p->maxsize != sc->sc_params.maxsize) { 718 if (p->maxsize > IRDA_MAX_FRAME_SIZE) 719 return (EINVAL); 720 sc->sc_params.maxsize = p->maxsize; 721 #if 0 722 DPRINTF(("%s: new buffers, old size=%d\n", __func__, 723 sc->sc_params.maxsize)); 724 if (p->maxsize > 10000 || p < 0) /* XXX */ 725 return (EINVAL); 726 727 /* Change the write buffer */ 728 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 729 if (sc->sc_wr_buf != NULL) 730 usbd_free_buffer(sc->sc_wr_xfer); 731 sc->sc_wr_buf = usbd_alloc_buffer(sc->sc_wr_xfer, p->maxsize+1); 732 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 733 if (sc->sc_wr_buf == NULL) 734 return (ENOMEM); 735 736 /* Change the read buffer */ 737 lockmgr(&sc->sc_rd_buf_lk, LK_EXCLUSIVE, NULL); 738 usbd_abort_pipe(sc->sc_rd_pipe); 739 if (sc->sc_rd_buf != NULL) 740 usbd_free_buffer(sc->sc_rd_xfer); 741 sc->sc_rd_buf = usbd_alloc_buffer(sc->sc_rd_xfer, p->maxsize+1); 742 sc->sc_rd_count = 0; 743 if (sc->sc_rd_buf == NULL) { 744 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 745 return (ENOMEM); 746 } 747 sc->sc_params.maxsize = p->maxsize; 748 err = uirda_start_read(sc); /* XXX check */ 749 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 750 #endif 751 } 752 if (hdr != 0 && hdr != sc->sc_wr_hdr) { 753 /* 754 * A change has occurred, transmit a 0 length frame with 755 * the new settings. The 0 length frame is not sent to the 756 * device. 757 */ 758 DPRINTF(("%s: sc=%p setting header 0x%02x\n", 759 __func__, sc, hdr)); 760 sc->sc_wr_hdr = hdr; 761 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 762 sc->sc_wr_buf[0] = hdr; 763 n = UIRDA_OUTPUT_HEADER_SIZE; 764 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 765 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 766 UIRDA_WR_TIMEOUT, sc->sc_wr_buf, &n, "uirdast"); 767 if (err) { 768 printf("%s: set failed, err=%d\n", 769 USBDEVNAME(sc->sc_dev), err); 770 usbd_clear_endpoint_stall(sc->sc_wr_pipe); 771 } 772 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 773 } 774 775 sc->sc_params = *p; 776 777 return (0); 778 } 779 780 int 781 uirda_get_speeds(void *h, int *speeds) 782 { 783 struct uirda_softc *sc = h; 784 u_int isp; 785 u_int usp; 786 787 DPRINTF(("%s: sc=%p\n", __func__, sc)); 788 789 if (sc->sc_dying) 790 return (EIO); 791 792 usp = UGETW(sc->sc_irdadesc.wBaudRate); 793 isp = 0; 794 if (usp & UI_BR_4000000) isp |= IRDA_SPEED_4000000; 795 if (usp & UI_BR_1152000) isp |= IRDA_SPEED_1152000; 796 if (usp & UI_BR_576000) isp |= IRDA_SPEED_576000; 797 if (usp & UI_BR_115200) isp |= IRDA_SPEED_115200; 798 if (usp & UI_BR_57600) isp |= IRDA_SPEED_57600; 799 if (usp & UI_BR_38400) isp |= IRDA_SPEED_38400; 800 if (usp & UI_BR_19200) isp |= IRDA_SPEED_19200; 801 if (usp & UI_BR_9600) isp |= IRDA_SPEED_9600; 802 if (usp & UI_BR_2400) isp |= IRDA_SPEED_2400; 803 *speeds = isp; 804 DPRINTF(("%s: speeds = 0x%x\n", __func__, isp)); 805 return (0); 806 } 807 808 int 809 uirda_get_turnarounds(void *h, int *turnarounds) 810 { 811 struct uirda_softc *sc = h; 812 u_int ita; 813 u_int uta; 814 815 DPRINTF(("%s: sc=%p\n", __func__, sc)); 816 817 if (sc->sc_dying) 818 return (EIO); 819 820 uta = sc->sc_irdadesc.bmMinTurnaroundTime; 821 ita = 0; 822 if (uta & UI_TA_0) ita |= IRDA_TURNT_0; 823 if (uta & UI_TA_10) ita |= IRDA_TURNT_10; 824 if (uta & UI_TA_50) ita |= IRDA_TURNT_50; 825 if (uta & UI_TA_100) ita |= IRDA_TURNT_100; 826 if (uta & UI_TA_500) ita |= IRDA_TURNT_500; 827 if (uta & UI_TA_1000) ita |= IRDA_TURNT_1000; 828 if (uta & UI_TA_5000) ita |= IRDA_TURNT_5000; 829 if (uta & UI_TA_10000) ita |= IRDA_TURNT_10000; 830 *turnarounds = ita; 831 return (0); 832 } 833 834 void 835 uirda_rd_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 836 usbd_status status) 837 { 838 struct uirda_softc *sc = priv; 839 u_int32_t size; 840 841 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 842 843 if (status == USBD_CANCELLED) /* this is normal */ 844 return; 845 if (status) { 846 size = sc->sc_hdszi; 847 sc->sc_rd_err = 1; 848 } else { 849 usbd_get_xfer_status(xfer, NULL, NULL, &size, NULL); 850 } 851 DPRINTFN(1,("%s: sc=%p size=%u, err=%d\n", __func__, sc, size, 852 sc->sc_rd_err)); 853 sc->sc_rd_count = size; 854 wakeup(&sc->sc_rd_count); /* XXX should use flag */ 855 selnotify(&sc->sc_rd_sel, 0); 856 } 857 858 usbd_status 859 uirda_start_read(struct uirda_softc *sc) 860 { 861 usbd_status err; 862 863 DPRINTFN(1,("%s: sc=%p, size=%d\n", __func__, sc, 864 sc->sc_params.maxsize + UIRDA_INPUT_HEADER_SIZE)); 865 866 if (sc->sc_dying) 867 return (USBD_IOERROR); 868 869 if (sc->sc_rd_err) { 870 sc->sc_rd_err = 0; 871 DPRINTF(("uirda_start_read: clear stall\n")); 872 usbd_clear_endpoint_stall(sc->sc_rd_pipe); 873 } 874 875 usbd_setup_xfer(sc->sc_rd_xfer, sc->sc_rd_pipe, sc, sc->sc_rd_buf, 876 sc->sc_params.maxsize + sc->sc_hdszi, 877 USBD_SHORT_XFER_OK | USBD_NO_COPY, 878 USBD_NO_TIMEOUT, uirda_rd_cb); 879 err = usbd_transfer(sc->sc_rd_xfer); 880 if (err != USBD_IN_PROGRESS) { 881 DPRINTF(("uirda_start_read: err=%d\n", err)); 882 return (err); 883 } 884 return (USBD_NORMAL_COMPLETION); 885 } 886 887 usbd_status 888 usbd_get_class_desc(usbd_device_handle dev, int type, int index, int len, void *desc) 889 { 890 usb_device_request_t req; 891 892 DPRINTFN(3,("usbd_get_desc: type=%d, index=%d, len=%d\n", 893 type, index, len)); 894 895 req.bmRequestType = 0xa1; /* XXX ? */ 896 req.bRequest = UR_GET_DESCRIPTOR; 897 USETW2(req.wValue, type, index); 898 USETW(req.wIndex, 0); 899 USETW(req.wLength, len); 900 return (usbd_do_request(dev, &req, desc)); 901 } 902
Indexes created Thu Sep 25 16:09:42 GMT 2025