uirda.c revision 1.23.8.2
1 /* $NetBSD: uirda.c,v 1.23.8.2 2007/06/16 04:12:31 itohy 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.23.8.2 2007/06/16 04:12:31 itohy 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 #ifdef UIRDA_DEBUG 64 #define DPRINTF(x) if (uirdadebug) logprintf x 65 #define DPRINTFN(n,x) if (uirdadebug>(n)) logprintf x 66 int uirdadebug = 0; 67 #else 68 #define DPRINTF(x) 69 #define DPRINTFN(n,x) 70 #endif 71 72 /* 73 * Protocol related definitions 74 */ 75 76 #define UIRDA_INPUT_HEADER_SIZE 1 77 /* Inbound header byte */ 78 #define UIRDA_MEDIA_BUSY 0x80 79 #define UIRDA_SPEED_MASK 0x0f 80 #define UIRDA_NO_SPEED 0x00 81 #define UIRDA_2400 0x01 82 #define UIRDA_9600 0x02 83 #define UIRDA_19200 0x03 84 #define UIRDA_38400 0x04 85 #define UIRDA_57600 0x05 86 #define UIRDA_115200 0x06 87 #define UIRDA_576000 0x07 88 #define UIRDA_1152000 0x08 89 #define UIRDA_4000000 0x09 90 91 #define UIRDA_OUTPUT_HEADER_SIZE 1 92 /* Outbound header byte */ 93 #define UIRDA_EB_NO_CHANGE 0x00 94 #define UIRDA_EB_48 0x10 95 #define UIRDA_EB_24 0x20 96 #define UIRDA_EB_12 0x30 97 #define UIRDA_EB_6 0x40 98 #define UIRDA_EB_3 0x50 99 #define UIRDA_EB_2 0x60 100 #define UIRDA_EB_1 0x70 101 #define UIRDA_EB_0 0x80 102 /* Speeds as above */ 103 104 /* Class specific requests */ 105 #define UR_IRDA_RECEIVING 0x01 /* Receive in progress? */ 106 #define UR_IRDA_CHECK_MEDIA_BUSY 0x03 107 #define UR_IRDA_SET_RATE_SNIFF 0x04 /* opt */ 108 #define UR_IRDA_SET_UNICAST_LIST 0x05 /* opt */ 109 #define UR_IRDA_GET_DESC 0x06 110 111 typedef struct { 112 uByte bLength; 113 uByte bDescriptorType; 114 #define UDESC_IRDA 0x21 115 uWord bcdSpecRevision; 116 uByte bmDataSize; 117 #define UI_DS_2048 0x20 118 #define UI_DS_1024 0x10 119 #define UI_DS_512 0x08 120 #define UI_DS_256 0x04 121 #define UI_DS_128 0x02 122 #define UI_DS_64 0x01 123 uByte bmWindowSize; 124 #define UI_WS_7 0x40 125 #define UI_WS_6 0x20 126 #define UI_WS_5 0x10 127 #define UI_WS_4 0x08 128 #define UI_WS_3 0x04 129 #define UI_WS_2 0x02 130 #define UI_WS_1 0x01 131 uByte bmMinTurnaroundTime; 132 #define UI_TA_0 0x80 133 #define UI_TA_10 0x40 134 #define UI_TA_50 0x20 135 #define UI_TA_100 0x10 136 #define UI_TA_500 0x08 137 #define UI_TA_1000 0x04 138 #define UI_TA_5000 0x02 139 #define UI_TA_10000 0x01 140 uWord wBaudRate; 141 #define UI_BR_4000000 0x0100 142 #define UI_BR_1152000 0x0080 143 #define UI_BR_576000 0x0040 144 #define UI_BR_115200 0x0020 145 #define UI_BR_57600 0x0010 146 #define UI_BR_38400 0x0008 147 #define UI_BR_19200 0x0004 148 #define UI_BR_9600 0x0002 149 #define UI_BR_2400 0x0001 150 uByte bmAdditionalBOFs; 151 #define UI_EB_0 0x80 152 #define UI_EB_1 0x40 153 #define UI_EB_2 0x20 154 #define UI_EB_3 0x10 155 #define UI_EB_6 0x08 156 #define UI_EB_12 0x04 157 #define UI_EB_24 0x02 158 #define UI_EB_48 0x01 159 uByte bIrdaSniff; 160 uByte bMaxUnicastList; 161 } UPACKED usb_irda_descriptor_t; 162 #define USB_IRDA_DESCRIPTOR_SIZE 12 163 164 165 #define UIRDA_NEBOFS 8 166 static struct { 167 int count; 168 int mask; 169 int header; 170 } uirda_ebofs[UIRDA_NEBOFS] = { 171 { 0, UI_EB_0, UIRDA_EB_0 }, 172 { 1, UI_EB_1, UIRDA_EB_1 }, 173 { 2, UI_EB_2, UIRDA_EB_2 }, 174 { 3, UI_EB_3, UIRDA_EB_3 }, 175 { 6, UI_EB_6, UIRDA_EB_6 }, 176 { 12, UI_EB_12, UIRDA_EB_12 }, 177 { 24, UI_EB_24, UIRDA_EB_24 }, 178 { 48, UI_EB_48, UIRDA_EB_48 } 179 }; 180 181 #define UIRDA_NSPEEDS 9 182 static struct { 183 int speed; 184 int mask; 185 int header; 186 } uirda_speeds[UIRDA_NSPEEDS] = { 187 { 4000000, UI_BR_4000000, UIRDA_4000000 }, 188 { 1152000, UI_BR_1152000, UIRDA_1152000 }, 189 { 576000, UI_BR_576000, UIRDA_576000 }, 190 { 115200, UI_BR_115200, UIRDA_115200 }, 191 { 57600, UI_BR_57600, UIRDA_57600 }, 192 { 38400, UI_BR_38400, UIRDA_38400 }, 193 { 19200, UI_BR_19200, UIRDA_19200 }, 194 { 9600, UI_BR_9600, UIRDA_9600 }, 195 { 2400, UI_BR_2400, UIRDA_2400 }, 196 }; 197 198 struct uirda_softc { 199 USBBASEDEVICE sc_dev; 200 usbd_device_handle sc_udev; 201 usbd_interface_handle sc_iface; 202 203 struct lock sc_rd_buf_lk; 204 u_int8_t *sc_rd_buf; 205 int sc_rd_addr; 206 usbd_pipe_handle sc_rd_pipe; 207 usbd_xfer_handle sc_rd_xfer; 208 struct selinfo sc_rd_sel; 209 u_int sc_rd_count; 210 u_char sc_rd_err; 211 212 struct lock sc_wr_buf_lk; 213 u_int8_t *sc_wr_buf; 214 int sc_wr_addr; 215 usbd_xfer_handle sc_wr_xfer; 216 usbd_pipe_handle sc_wr_pipe; 217 int sc_wr_hdr; 218 struct selinfo sc_wr_sel; 219 220 struct device *sc_child; 221 struct irda_params sc_params; 222 usb_irda_descriptor_t sc_irdadesc; 223 224 int sc_refcnt; 225 char sc_dying; 226 }; 227 228 #define UIRDA_WR_TIMEOUT 200 229 230 int uirda_open(void *h, int flag, int mode, struct lwp *l); 231 int uirda_close(void *h, int flag, int mode, struct lwp *l); 232 int uirda_read(void *h, struct uio *uio, int flag); 233 int uirda_write(void *h, struct uio *uio, int flag); 234 int uirda_set_params(void *h, struct irda_params *params); 235 int uirda_get_speeds(void *h, int *speeds); 236 int uirda_get_turnarounds(void *h, int *times); 237 int uirda_poll(void *h, int events, struct lwp *l); 238 int uirda_kqfilter(void *h, struct knote *kn); 239 240 struct irframe_methods uirda_methods = { 241 uirda_open, uirda_close, uirda_read, uirda_write, uirda_poll, 242 uirda_kqfilter, uirda_set_params, uirda_get_speeds, 243 uirda_get_turnarounds 244 }; 245 246 void uirda_rd_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 247 usbd_status status); 248 usbd_status uirda_start_read(struct uirda_softc *sc); 249 250 /* 251 * These devices don't quite follow the spec. Speed changing is broken 252 * and they don't handle windows. 253 * But we change speed in a safe way, and don't use windows now. 254 * Some devices also seem to have an interrupt pipe that can be ignored. 255 * 256 * Table information taken from Linux driver. 257 */ 258 Static const struct usb_devno uirda_devs[] = { 259 { USB_VENDOR_ACTISYS, USB_PRODUCT_ACTISYS_IR2000U }, 260 { USB_VENDOR_EXTENDED, USB_PRODUCT_EXTENDED_XTNDACCESS }, 261 { USB_VENDOR_KAWATSU, USB_PRODUCT_KAWATSU_KC180 }, 262 }; 263 #define uirda_lookup(v, p) (usb_lookup(uirda_devs, v, p)) 264 265 USB_DECLARE_DRIVER(uirda); 266 267 USB_MATCH(uirda) 268 { 269 USB_MATCH_START(uirda, uaa); 270 usb_interface_descriptor_t *id; 271 272 DPRINTFN(50,("uirda_match\n")); 273 274 if (uaa->iface == NULL) 275 return (UMATCH_NONE); 276 277 if (uirda_lookup(uaa->vendor, uaa->product) != NULL) 278 return (UMATCH_VENDOR_PRODUCT); 279 280 id = usbd_get_interface_descriptor(uaa->iface); 281 if (id != NULL && 282 id->bInterfaceClass == UICLASS_APPL_SPEC && 283 id->bInterfaceSubClass == UISUBCLASS_IRDA && 284 id->bInterfaceProtocol == UIPROTO_IRDA) 285 return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO); 286 return (UMATCH_NONE); 287 } 288 289 USB_ATTACH(uirda) 290 { 291 USB_ATTACH_START(uirda, sc, uaa); 292 usbd_device_handle dev = uaa->device; 293 usbd_interface_handle iface = uaa->iface; 294 char *devinfop; 295 usb_endpoint_descriptor_t *ed; 296 usbd_status err; 297 u_int8_t epcount; 298 u_int specrev; 299 int i; 300 struct ir_attach_args ia; 301 302 DPRINTFN(10,("uirda_attach: sc=%p\n", sc)); 303 304 devinfop = usbd_devinfo_alloc(dev, 0); 305 USB_ATTACH_SETUP; 306 printf("%s: %s\n", USBDEVNAME(sc->sc_dev), devinfop); 307 usbd_devinfo_free(devinfop); 308 309 sc->sc_udev = dev; 310 sc->sc_iface = iface; 311 312 epcount = 0; 313 (void)usbd_endpoint_count(iface, &epcount); 314 315 sc->sc_rd_addr = -1; 316 sc->sc_wr_addr = -1; 317 for (i = 0; i < epcount; i++) { 318 ed = usbd_interface2endpoint_descriptor(iface, i); 319 if (ed == NULL) { 320 printf("%s: couldn't get ep %d\n", 321 USBDEVNAME(sc->sc_dev), i); 322 USB_ATTACH_ERROR_RETURN; 323 } 324 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 325 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 326 sc->sc_rd_addr = ed->bEndpointAddress; 327 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 328 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 329 sc->sc_wr_addr = ed->bEndpointAddress; 330 } 331 } 332 if (sc->sc_rd_addr == -1 || sc->sc_wr_addr == -1) { 333 printf("%s: missing endpoint\n", USBDEVNAME(sc->sc_dev)); 334 USB_ATTACH_ERROR_RETURN; 335 } 336 337 /* Get the IrDA descriptor */ 338 err = usbd_get_desc(sc->sc_udev, UDESC_IRDA, 0, 339 USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc); 340 if (err) { 341 /* maybe it's embedded in the config desc? */ 342 usbd_desc_iter_t iter; 343 const usb_descriptor_t *d; 344 usb_desc_iter_init(sc->sc_udev, &iter); 345 for (;;) { 346 d = usb_desc_iter_next(&iter); 347 if (!d || d->bDescriptorType == UDESC_IRDA) 348 break; 349 } 350 if (d == NULL) { 351 printf("%s: Cannot get IrDA descriptor\n", 352 USBDEVNAME(sc->sc_dev)); 353 USB_ATTACH_ERROR_RETURN; 354 } 355 memcpy(&sc->sc_irdadesc, d, USB_IRDA_DESCRIPTOR_SIZE); 356 } 357 DPRINTF(("uirda_attach: bmDataSize=0x%02x bmWindowSize=0x%02x " 358 "bmMinTurnaroundTime=0x%02x wBaudRate=0x%04x " 359 "bmAdditionalBOFs=0x%02x bIrdaSniff=%d bMaxUnicastList=%d\n", 360 sc->sc_irdadesc.bmDataSize, 361 sc->sc_irdadesc.bmWindowSize, 362 sc->sc_irdadesc.bmMinTurnaroundTime, 363 UGETW(sc->sc_irdadesc.wBaudRate), 364 sc->sc_irdadesc.bmAdditionalBOFs, 365 sc->sc_irdadesc.bIrdaSniff, 366 sc->sc_irdadesc.bMaxUnicastList)); 367 368 specrev = UGETW(sc->sc_irdadesc.bcdSpecRevision); 369 printf("%s: USB-IrDA protocol version %x.%02x\n", 370 USBDEVNAME(sc->sc_dev), specrev >> 8, specrev & 0xff); 371 372 DPRINTFN(10, ("uirda_attach: %p\n", sc->sc_udev)); 373 374 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, 375 USBDEV(sc->sc_dev)); 376 377 lockinit(&sc->sc_wr_buf_lk, PZERO, "iirwrl", 0, 0); 378 lockinit(&sc->sc_rd_buf_lk, PZERO, "uirrdl", 0, 0); 379 380 ia.ia_type = IR_TYPE_IRFRAME; 381 ia.ia_methods = &uirda_methods; 382 ia.ia_handle = sc; 383 384 sc->sc_child = config_found(self, &ia, ir_print); 385 386 USB_ATTACH_SUCCESS_RETURN; 387 } 388 389 USB_DETACH(uirda) 390 { 391 USB_DETACH_START(uirda, sc); 392 int s; 393 int rv = 0; 394 395 DPRINTF(("uirda_detach: sc=%p flags=%d\n", sc, flags)); 396 397 sc->sc_dying = 1; 398 /* Abort all pipes. Causes processes waiting for transfer to wake. */ 399 if (sc->sc_rd_pipe != NULL) { 400 usbd_abort_pipe(sc->sc_rd_pipe); 401 usbd_close_pipe(sc->sc_rd_pipe); 402 sc->sc_rd_pipe = NULL; 403 } 404 if (sc->sc_wr_pipe != NULL) { 405 usbd_abort_pipe(sc->sc_wr_pipe); 406 usbd_close_pipe(sc->sc_wr_pipe); 407 sc->sc_wr_pipe = NULL; 408 } 409 wakeup(&sc->sc_rd_count); 410 411 s = splusb(); 412 if (--sc->sc_refcnt >= 0) { 413 /* Wait for processes to go away. */ 414 usb_detach_wait(USBDEV(sc->sc_dev)); 415 } 416 splx(s); 417 418 if (sc->sc_child != NULL) { 419 rv = config_detach(sc->sc_child, flags); 420 sc->sc_child = NULL; 421 } 422 423 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 424 USBDEV(sc->sc_dev)); 425 426 return (rv); 427 } 428 429 int 430 uirda_activate(device_ptr_t self, enum devact act) 431 { 432 struct uirda_softc *sc = (struct uirda_softc *)self; 433 int error = 0; 434 435 switch (act) { 436 case DVACT_ACTIVATE: 437 return (EOPNOTSUPP); 438 break; 439 440 case DVACT_DEACTIVATE: 441 sc->sc_dying = 1; 442 if (sc->sc_child != NULL) 443 error = config_deactivate(sc->sc_child); 444 break; 445 } 446 return (error); 447 } 448 449 int 450 uirda_open(void *h, int flag, int mode, 451 struct lwp *l) 452 { 453 struct uirda_softc *sc = h; 454 int error; 455 usbd_status err; 456 457 DPRINTF(("%s: sc=%p\n", __func__, sc)); 458 459 err = usbd_open_pipe(sc->sc_iface, sc->sc_rd_addr, 0, &sc->sc_rd_pipe); 460 if (err) { 461 error = EIO; 462 goto bad1; 463 } 464 err = usbd_open_pipe(sc->sc_iface, sc->sc_wr_addr, 0, &sc->sc_wr_pipe); 465 if (err) { 466 error = EIO; 467 goto bad2; 468 } 469 sc->sc_rd_xfer = usbd_alloc_xfer(sc->sc_udev, sc->sc_rd_pipe); 470 if (sc->sc_rd_xfer == NULL) { 471 error = ENOMEM; 472 goto bad3; 473 } 474 sc->sc_wr_xfer = usbd_alloc_xfer(sc->sc_udev, sc->sc_wr_pipe); 475 if (sc->sc_wr_xfer == NULL) { 476 error = ENOMEM; 477 goto bad4; 478 } 479 sc->sc_rd_buf = usbd_alloc_buffer(sc->sc_rd_xfer, 480 IRDA_MAX_FRAME_SIZE + UIRDA_INPUT_HEADER_SIZE); 481 if (sc->sc_rd_buf == NULL) { 482 error = ENOMEM; 483 goto bad5; 484 } 485 sc->sc_wr_buf = usbd_alloc_buffer(sc->sc_wr_xfer, 486 IRDA_MAX_FRAME_SIZE + UIRDA_OUTPUT_HEADER_SIZE); 487 if (sc->sc_wr_buf == NULL) { 488 error = ENOMEM; 489 goto bad5; 490 } 491 sc->sc_rd_count = 0; 492 sc->sc_rd_err = 0; 493 sc->sc_params.speed = 0; 494 sc->sc_params.ebofs = 0; 495 sc->sc_params.maxsize = IRDA_MAX_FRAME_SIZE; 496 sc->sc_wr_hdr = -1; 497 498 err = uirda_start_read(sc); 499 /* XXX check err */ 500 501 return (0); 502 503 bad5: 504 usbd_free_xfer(sc->sc_wr_xfer); 505 sc->sc_wr_xfer = NULL; 506 bad4: 507 usbd_free_xfer(sc->sc_rd_xfer); 508 sc->sc_rd_xfer = NULL; 509 bad3: 510 usbd_close_pipe(sc->sc_wr_pipe); 511 sc->sc_wr_pipe = NULL; 512 bad2: 513 usbd_close_pipe(sc->sc_rd_pipe); 514 sc->sc_rd_pipe = NULL; 515 bad1: 516 return (error); 517 } 518 519 int 520 uirda_close(void *h, int flag, int mode, 521 struct lwp *l) 522 { 523 struct uirda_softc *sc = h; 524 525 DPRINTF(("%s: sc=%p\n", __func__, sc)); 526 527 if (sc->sc_rd_pipe != NULL) 528 usbd_abort_pipe(sc->sc_rd_pipe); 529 if (sc->sc_wr_pipe != NULL) 530 usbd_abort_pipe(sc->sc_wr_pipe); 531 if (sc->sc_rd_xfer != NULL) { 532 usbd_free_xfer(sc->sc_rd_xfer); 533 sc->sc_rd_xfer = NULL; 534 sc->sc_rd_buf = NULL; 535 } 536 if (sc->sc_wr_xfer != NULL) { 537 usbd_free_xfer(sc->sc_wr_xfer); 538 sc->sc_wr_xfer = NULL; 539 sc->sc_wr_buf = NULL; 540 } 541 if (sc->sc_rd_pipe != NULL) { 542 usbd_close_pipe(sc->sc_rd_pipe); 543 sc->sc_rd_pipe = NULL; 544 } 545 if (sc->sc_wr_pipe != NULL) { 546 usbd_close_pipe(sc->sc_wr_pipe); 547 sc->sc_wr_pipe = NULL; 548 } 549 550 return (0); 551 } 552 553 int 554 uirda_read(void *h, struct uio *uio, int flag) 555 { 556 struct uirda_softc *sc = h; 557 usbd_status err; 558 int s; 559 int error; 560 u_int n; 561 562 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 563 564 if (sc->sc_dying) 565 return (EIO); 566 567 #ifdef DIAGNOSTIC 568 if (sc->sc_rd_buf == NULL) 569 return (EINVAL); 570 #endif 571 572 sc->sc_refcnt++; 573 574 do { 575 s = splusb(); 576 while (sc->sc_rd_count == 0) { 577 DPRINTFN(5,("uirda_read: calling tsleep()\n")); 578 error = tsleep(&sc->sc_rd_count, PZERO | PCATCH, 579 "uirdrd", 0); 580 if (sc->sc_dying) 581 error = EIO; 582 if (error) { 583 splx(s); 584 DPRINTF(("uirda_read: tsleep() = %d\n", error)); 585 goto ret; 586 } 587 } 588 splx(s); 589 590 lockmgr(&sc->sc_rd_buf_lk, LK_EXCLUSIVE, NULL); 591 n = sc->sc_rd_count - UIRDA_INPUT_HEADER_SIZE; 592 DPRINTFN(1,("%s: sc=%p n=%u, hdr=0x%02x\n", __func__, 593 sc, n, sc->sc_rd_buf[0])); 594 if (n > uio->uio_resid) 595 error = EINVAL; 596 else 597 error = uiomove(sc->sc_rd_buf+UIRDA_INPUT_HEADER_SIZE, 598 n, uio); 599 sc->sc_rd_count = 0; 600 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 601 602 err = uirda_start_read(sc); 603 /* XXX check err */ 604 605 } while (n == 0); 606 607 DPRINTFN(1,("uirda_read: return %d\n", error)); 608 609 ret: 610 if (--sc->sc_refcnt < 0) 611 usb_detach_wakeup(USBDEV(sc->sc_dev)); 612 return (error); 613 } 614 615 int 616 uirda_write(void *h, struct uio *uio, int flag) 617 { 618 struct uirda_softc *sc = h; 619 usbd_status err; 620 u_int32_t n; 621 int error = 0; 622 623 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 624 625 if (sc->sc_dying) 626 return (EIO); 627 628 #ifdef DIAGNOSTIC 629 if (sc->sc_wr_buf == NULL) 630 return (EINVAL); 631 #endif 632 633 n = uio->uio_resid; 634 if (n > sc->sc_params.maxsize) 635 return (EINVAL); 636 637 sc->sc_refcnt++; 638 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 639 640 sc->sc_wr_buf[0] = UIRDA_EB_NO_CHANGE | UIRDA_NO_SPEED; 641 error = uiomove(sc->sc_wr_buf + UIRDA_OUTPUT_HEADER_SIZE, n, uio); 642 if (!error) { 643 DPRINTFN(1, ("uirdawrite: transfer %d bytes\n", n)); 644 645 n++; 646 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 647 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 648 UIRDA_WR_TIMEOUT, 649 sc->sc_wr_buf, &n, "uirdawr"); 650 DPRINTFN(2, ("uirdawrite: err=%d\n", err)); 651 if (err) { 652 if (err == USBD_INTERRUPTED) 653 error = EINTR; 654 else if (err == USBD_TIMEOUT) 655 error = ETIMEDOUT; 656 else 657 error = EIO; 658 } 659 } 660 661 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 662 if (--sc->sc_refcnt < 0) 663 usb_detach_wakeup(USBDEV(sc->sc_dev)); 664 665 DPRINTFN(1,("%s: sc=%p done\n", __func__, sc)); 666 return (error); 667 } 668 669 int 670 uirda_poll(void *h, int events, struct lwp *l) 671 { 672 struct uirda_softc *sc = h; 673 int revents = 0; 674 int s; 675 676 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 677 678 s = splusb(); 679 if (events & (POLLOUT | POLLWRNORM)) 680 revents |= events & (POLLOUT | POLLWRNORM); 681 if (events & (POLLIN | POLLRDNORM)) { 682 if (sc->sc_rd_count != 0) { 683 DPRINTFN(2,("%s: have data\n", __func__)); 684 revents |= events & (POLLIN | POLLRDNORM); 685 } else { 686 DPRINTFN(2,("%s: recording select\n", __func__)); 687 selrecord(l, &sc->sc_rd_sel); 688 } 689 } 690 splx(s); 691 692 return (revents); 693 } 694 695 static void 696 filt_uirdardetach(struct knote *kn) 697 { 698 struct uirda_softc *sc = kn->kn_hook; 699 int s; 700 701 s = splusb(); 702 SLIST_REMOVE(&sc->sc_rd_sel.sel_klist, kn, knote, kn_selnext); 703 splx(s); 704 } 705 706 static int 707 filt_uirdaread(struct knote *kn, long hint) 708 { 709 struct uirda_softc *sc = kn->kn_hook; 710 711 kn->kn_data = sc->sc_rd_count; 712 return (kn->kn_data > 0); 713 } 714 715 static void 716 filt_uirdawdetach(struct knote *kn) 717 { 718 struct uirda_softc *sc = kn->kn_hook; 719 int s; 720 721 s = splusb(); 722 SLIST_REMOVE(&sc->sc_wr_sel.sel_klist, kn, knote, kn_selnext); 723 splx(s); 724 } 725 726 static const struct filterops uirdaread_filtops = 727 { 1, NULL, filt_uirdardetach, filt_uirdaread }; 728 static const struct filterops uirdawrite_filtops = 729 { 1, NULL, filt_uirdawdetach, filt_seltrue }; 730 731 int 732 uirda_kqfilter(void *h, struct knote *kn) 733 { 734 struct uirda_softc *sc = kn->kn_hook; 735 struct klist *klist; 736 int s; 737 738 switch (kn->kn_filter) { 739 case EVFILT_READ: 740 klist = &sc->sc_rd_sel.sel_klist; 741 kn->kn_fop = &uirdaread_filtops; 742 break; 743 case EVFILT_WRITE: 744 klist = &sc->sc_wr_sel.sel_klist; 745 kn->kn_fop = &uirdawrite_filtops; 746 break; 747 default: 748 return (1); 749 } 750 751 kn->kn_hook = sc; 752 753 s = splusb(); 754 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 755 splx(s); 756 757 return (0); 758 } 759 760 int 761 uirda_set_params(void *h, struct irda_params *p) 762 { 763 struct uirda_softc *sc = h; 764 usbd_status err; 765 int i; 766 u_int8_t hdr; 767 u_int32_t n; 768 u_int mask; 769 770 DPRINTF(("%s: sc=%p, speed=%d ebofs=%d maxsize=%d\n", __func__, 771 sc, p->speed, p->ebofs, p->maxsize)); 772 773 if (sc->sc_dying) 774 return (EIO); 775 776 hdr = 0; 777 if (p->ebofs != sc->sc_params.ebofs) { 778 /* round up ebofs */ 779 mask = sc->sc_irdadesc.bmAdditionalBOFs; 780 for (i = 0; i < UIRDA_NEBOFS; i++) { 781 if ((mask & uirda_ebofs[i].mask) && 782 uirda_ebofs[i].count >= p->ebofs) { 783 hdr = uirda_ebofs[i].header; 784 goto found1; 785 } 786 } 787 /* no good value found */ 788 return (EINVAL); 789 found1: 790 DPRINTF(("uirda_set_params: ebofs hdr=0x%02x\n", hdr)); 791 ; 792 793 } 794 if (hdr != 0 || p->speed != sc->sc_params.speed) { 795 /* find speed */ 796 mask = UGETW(sc->sc_irdadesc.wBaudRate); 797 for (i = 0; i < UIRDA_NSPEEDS; i++) { 798 if ((mask & uirda_speeds[i].mask) && 799 uirda_speeds[i].speed == p->speed) { 800 hdr |= uirda_speeds[i].header; 801 goto found2; 802 } 803 } 804 /* no good value found */ 805 return (EINVAL); 806 found2: 807 DPRINTF(("uirda_set_params: speed hdr=0x%02x\n", hdr)); 808 ; 809 } 810 if (p->maxsize != sc->sc_params.maxsize) { 811 if (p->maxsize > IRDA_MAX_FRAME_SIZE) 812 return (EINVAL); 813 sc->sc_params.maxsize = p->maxsize; 814 #if 0 815 DPRINTF(("%s: new buffers, old size=%d\n", __func__, 816 sc->sc_params.maxsize)); 817 if (p->maxsize > 10000 || p < 0) /* XXX */ 818 return (EINVAL); 819 820 /* Change the write buffer */ 821 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 822 if (sc->sc_wr_buf != NULL) 823 usbd_free_buffer(sc->sc_wr_xfer); 824 sc->sc_wr_buf = usbd_alloc_buffer(sc->sc_wr_xfer, p->maxsize+1); 825 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 826 if (sc->sc_wr_buf == NULL) 827 return (ENOMEM); 828 829 /* Change the read buffer */ 830 lockmgr(&sc->sc_rd_buf_lk, LK_EXCLUSIVE, NULL); 831 usbd_abort_pipe(sc->sc_rd_pipe); 832 if (sc->sc_rd_buf != NULL) 833 usbd_free_buffer(sc->sc_rd_xfer); 834 sc->sc_rd_buf = usbd_alloc_buffer(sc->sc_rd_xfer, p->maxsize+1); 835 sc->sc_rd_count = 0; 836 if (sc->sc_rd_buf == NULL) { 837 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 838 return (ENOMEM); 839 } 840 sc->sc_params.maxsize = p->maxsize; 841 err = uirda_start_read(sc); /* XXX check */ 842 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 843 #endif 844 } 845 if (hdr != 0 && hdr != sc->sc_wr_hdr) { 846 /* 847 * A change has occurred, transmit a 0 length frame with 848 * the new settings. The 0 length frame is not sent to the 849 * device. 850 */ 851 DPRINTF(("%s: sc=%p setting header 0x%02x\n", 852 __func__, sc, hdr)); 853 sc->sc_wr_hdr = hdr; 854 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 855 sc->sc_wr_buf[0] = hdr; 856 n = UIRDA_OUTPUT_HEADER_SIZE; 857 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 858 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 859 UIRDA_WR_TIMEOUT, sc->sc_wr_buf, &n, "uirdast"); 860 if (err) { 861 printf("%s: set failed, err=%d\n", 862 USBDEVNAME(sc->sc_dev), err); 863 usbd_clear_endpoint_stall(sc->sc_wr_pipe); 864 } 865 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 866 } 867 868 sc->sc_params = *p; 869 870 return (0); 871 } 872 873 int 874 uirda_get_speeds(void *h, int *speeds) 875 { 876 struct uirda_softc *sc = h; 877 u_int isp; 878 u_int usp; 879 880 DPRINTF(("%s: sc=%p\n", __func__, sc)); 881 882 if (sc->sc_dying) 883 return (EIO); 884 885 usp = UGETW(sc->sc_irdadesc.wBaudRate); 886 isp = 0; 887 if (usp & UI_BR_4000000) isp |= IRDA_SPEED_4000000; 888 if (usp & UI_BR_1152000) isp |= IRDA_SPEED_1152000; 889 if (usp & UI_BR_576000) isp |= IRDA_SPEED_576000; 890 if (usp & UI_BR_115200) isp |= IRDA_SPEED_115200; 891 if (usp & UI_BR_57600) isp |= IRDA_SPEED_57600; 892 if (usp & UI_BR_38400) isp |= IRDA_SPEED_38400; 893 if (usp & UI_BR_19200) isp |= IRDA_SPEED_19200; 894 if (usp & UI_BR_9600) isp |= IRDA_SPEED_9600; 895 if (usp & UI_BR_2400) isp |= IRDA_SPEED_2400; 896 *speeds = isp; 897 return (0); 898 } 899 900 int 901 uirda_get_turnarounds(void *h, int *turnarounds) 902 { 903 struct uirda_softc *sc = h; 904 u_int ita; 905 u_int uta; 906 907 DPRINTF(("%s: sc=%p\n", __func__, sc)); 908 909 if (sc->sc_dying) 910 return (EIO); 911 912 uta = sc->sc_irdadesc.bmMinTurnaroundTime; 913 ita = 0; 914 if (uta & UI_TA_0) ita |= IRDA_TURNT_0; 915 if (uta & UI_TA_10) ita |= IRDA_TURNT_10; 916 if (uta & UI_TA_50) ita |= IRDA_TURNT_50; 917 if (uta & UI_TA_100) ita |= IRDA_TURNT_100; 918 if (uta & UI_TA_500) ita |= IRDA_TURNT_500; 919 if (uta & UI_TA_1000) ita |= IRDA_TURNT_1000; 920 if (uta & UI_TA_5000) ita |= IRDA_TURNT_5000; 921 if (uta & UI_TA_10000) ita |= IRDA_TURNT_10000; 922 *turnarounds = ita; 923 return (0); 924 } 925 926 void 927 uirda_rd_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 928 usbd_status status) 929 { 930 struct uirda_softc *sc = priv; 931 u_int32_t size; 932 933 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 934 935 if (status == USBD_CANCELLED) /* this is normal */ 936 return; 937 if (status) { 938 size = UIRDA_INPUT_HEADER_SIZE; 939 sc->sc_rd_err = 1; 940 } else { 941 usbd_get_xfer_status(xfer, NULL, NULL, &size, NULL); 942 } 943 DPRINTFN(1,("%s: sc=%p size=%u, err=%d\n", __func__, sc, size, 944 sc->sc_rd_err)); 945 sc->sc_rd_count = size; 946 wakeup(&sc->sc_rd_count); /* XXX should use flag */ 947 selnotify(&sc->sc_rd_sel, 0); 948 } 949 950 usbd_status 951 uirda_start_read(struct uirda_softc *sc) 952 { 953 usbd_status err; 954 955 DPRINTFN(1,("%s: sc=%p, size=%d\n", __func__, sc, 956 sc->sc_params.maxsize + UIRDA_INPUT_HEADER_SIZE)); 957 958 if (sc->sc_dying) 959 return (USBD_IOERROR); 960 961 if (sc->sc_rd_err) { 962 sc->sc_rd_err = 0; 963 DPRINTF(("uirda_start_read: clear stall\n")); 964 usbd_clear_endpoint_stall(sc->sc_rd_pipe); 965 } 966 967 usbd_setup_xfer(sc->sc_rd_xfer, sc->sc_rd_pipe, sc, sc->sc_rd_buf, 968 sc->sc_params.maxsize + UIRDA_INPUT_HEADER_SIZE, 969 USBD_SHORT_XFER_OK | USBD_NO_COPY, 970 USBD_NO_TIMEOUT, uirda_rd_cb); 971 err = usbd_transfer(sc->sc_rd_xfer); 972 if (err != USBD_IN_PROGRESS) { 973 DPRINTF(("uirda_start_read: err=%d\n", err)); 974 return (err); 975 } 976 return (USBD_NORMAL_COMPLETION); 977 } 978
Indexes created Mon Oct 20 20:10:13 GMT 2025