uirda.c revision 1.22.4.1
1 /* $NetBSD: uirda.c,v 1.22.4.1 2007/02/27 16:54:08 yamt 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.22.4.1 2007/02/27 16:54:08 yamt 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); 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); 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 usbd_close_pipe(sc->sc_rd_pipe); 530 sc->sc_rd_pipe = NULL; 531 } 532 if (sc->sc_wr_pipe != NULL) { 533 usbd_abort_pipe(sc->sc_wr_pipe); 534 usbd_close_pipe(sc->sc_wr_pipe); 535 sc->sc_wr_pipe = NULL; 536 } 537 if (sc->sc_rd_xfer != NULL) { 538 usbd_free_xfer(sc->sc_rd_xfer); 539 sc->sc_rd_xfer = NULL; 540 sc->sc_rd_buf = NULL; 541 } 542 if (sc->sc_wr_xfer != NULL) { 543 usbd_free_xfer(sc->sc_wr_xfer); 544 sc->sc_wr_xfer = NULL; 545 sc->sc_wr_buf = NULL; 546 } 547 548 return (0); 549 } 550 551 int 552 uirda_read(void *h, struct uio *uio, int flag) 553 { 554 struct uirda_softc *sc = h; 555 usbd_status err; 556 int s; 557 int error; 558 u_int n; 559 560 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 561 562 if (sc->sc_dying) 563 return (EIO); 564 565 #ifdef DIAGNOSTIC 566 if (sc->sc_rd_buf == NULL) 567 return (EINVAL); 568 #endif 569 570 sc->sc_refcnt++; 571 572 do { 573 s = splusb(); 574 while (sc->sc_rd_count == 0) { 575 DPRINTFN(5,("uirda_read: calling tsleep()\n")); 576 error = tsleep(&sc->sc_rd_count, PZERO | PCATCH, 577 "uirdrd", 0); 578 if (sc->sc_dying) 579 error = EIO; 580 if (error) { 581 splx(s); 582 DPRINTF(("uirda_read: tsleep() = %d\n", error)); 583 goto ret; 584 } 585 } 586 splx(s); 587 588 lockmgr(&sc->sc_rd_buf_lk, LK_EXCLUSIVE, NULL); 589 n = sc->sc_rd_count - UIRDA_INPUT_HEADER_SIZE; 590 DPRINTFN(1,("%s: sc=%p n=%u, hdr=0x%02x\n", __func__, 591 sc, n, sc->sc_rd_buf[0])); 592 if (n > uio->uio_resid) 593 error = EINVAL; 594 else 595 error = uiomove(sc->sc_rd_buf+UIRDA_INPUT_HEADER_SIZE, 596 n, uio); 597 sc->sc_rd_count = 0; 598 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 599 600 err = uirda_start_read(sc); 601 /* XXX check err */ 602 603 } while (n == 0); 604 605 DPRINTFN(1,("uirda_read: return %d\n", error)); 606 607 ret: 608 if (--sc->sc_refcnt < 0) 609 usb_detach_wakeup(USBDEV(sc->sc_dev)); 610 return (error); 611 } 612 613 int 614 uirda_write(void *h, struct uio *uio, int flag) 615 { 616 struct uirda_softc *sc = h; 617 usbd_status err; 618 u_int32_t n; 619 int error = 0; 620 621 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 622 623 if (sc->sc_dying) 624 return (EIO); 625 626 #ifdef DIAGNOSTIC 627 if (sc->sc_wr_buf == NULL) 628 return (EINVAL); 629 #endif 630 631 n = uio->uio_resid; 632 if (n > sc->sc_params.maxsize) 633 return (EINVAL); 634 635 sc->sc_refcnt++; 636 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 637 638 sc->sc_wr_buf[0] = UIRDA_EB_NO_CHANGE | UIRDA_NO_SPEED; 639 error = uiomove(sc->sc_wr_buf + UIRDA_OUTPUT_HEADER_SIZE, n, uio); 640 if (!error) { 641 DPRINTFN(1, ("uirdawrite: transfer %d bytes\n", n)); 642 643 n++; 644 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 645 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 646 UIRDA_WR_TIMEOUT, 647 sc->sc_wr_buf, &n, "uirdawr"); 648 DPRINTFN(2, ("uirdawrite: err=%d\n", err)); 649 if (err) { 650 if (err == USBD_INTERRUPTED) 651 error = EINTR; 652 else if (err == USBD_TIMEOUT) 653 error = ETIMEDOUT; 654 else 655 error = EIO; 656 } 657 } 658 659 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 660 if (--sc->sc_refcnt < 0) 661 usb_detach_wakeup(USBDEV(sc->sc_dev)); 662 663 DPRINTFN(1,("%s: sc=%p done\n", __func__, sc)); 664 return (error); 665 } 666 667 int 668 uirda_poll(void *h, int events, struct lwp *l) 669 { 670 struct uirda_softc *sc = h; 671 int revents = 0; 672 int s; 673 674 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 675 676 s = splusb(); 677 if (events & (POLLOUT | POLLWRNORM)) 678 revents |= events & (POLLOUT | POLLWRNORM); 679 if (events & (POLLIN | POLLRDNORM)) { 680 if (sc->sc_rd_count != 0) { 681 DPRINTFN(2,("%s: have data\n", __func__)); 682 revents |= events & (POLLIN | POLLRDNORM); 683 } else { 684 DPRINTFN(2,("%s: recording select\n", __func__)); 685 selrecord(l, &sc->sc_rd_sel); 686 } 687 } 688 splx(s); 689 690 return (revents); 691 } 692 693 static void 694 filt_uirdardetach(struct knote *kn) 695 { 696 struct uirda_softc *sc = kn->kn_hook; 697 int s; 698 699 s = splusb(); 700 SLIST_REMOVE(&sc->sc_rd_sel.sel_klist, kn, knote, kn_selnext); 701 splx(s); 702 } 703 704 static int 705 filt_uirdaread(struct knote *kn, long hint) 706 { 707 struct uirda_softc *sc = kn->kn_hook; 708 709 kn->kn_data = sc->sc_rd_count; 710 return (kn->kn_data > 0); 711 } 712 713 static void 714 filt_uirdawdetach(struct knote *kn) 715 { 716 struct uirda_softc *sc = kn->kn_hook; 717 int s; 718 719 s = splusb(); 720 SLIST_REMOVE(&sc->sc_wr_sel.sel_klist, kn, knote, kn_selnext); 721 splx(s); 722 } 723 724 static const struct filterops uirdaread_filtops = 725 { 1, NULL, filt_uirdardetach, filt_uirdaread }; 726 static const struct filterops uirdawrite_filtops = 727 { 1, NULL, filt_uirdawdetach, filt_seltrue }; 728 729 int 730 uirda_kqfilter(void *h, struct knote *kn) 731 { 732 struct uirda_softc *sc = kn->kn_hook; 733 struct klist *klist; 734 int s; 735 736 switch (kn->kn_filter) { 737 case EVFILT_READ: 738 klist = &sc->sc_rd_sel.sel_klist; 739 kn->kn_fop = &uirdaread_filtops; 740 break; 741 case EVFILT_WRITE: 742 klist = &sc->sc_wr_sel.sel_klist; 743 kn->kn_fop = &uirdawrite_filtops; 744 break; 745 default: 746 return (1); 747 } 748 749 kn->kn_hook = sc; 750 751 s = splusb(); 752 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 753 splx(s); 754 755 return (0); 756 } 757 758 int 759 uirda_set_params(void *h, struct irda_params *p) 760 { 761 struct uirda_softc *sc = h; 762 usbd_status err; 763 int i; 764 u_int8_t hdr; 765 u_int32_t n; 766 u_int mask; 767 768 DPRINTF(("%s: sc=%p, speed=%d ebofs=%d maxsize=%d\n", __func__, 769 sc, p->speed, p->ebofs, p->maxsize)); 770 771 if (sc->sc_dying) 772 return (EIO); 773 774 hdr = 0; 775 if (p->ebofs != sc->sc_params.ebofs) { 776 /* round up ebofs */ 777 mask = sc->sc_irdadesc.bmAdditionalBOFs; 778 for (i = 0; i < UIRDA_NEBOFS; i++) { 779 if ((mask & uirda_ebofs[i].mask) && 780 uirda_ebofs[i].count >= p->ebofs) { 781 hdr = uirda_ebofs[i].header; 782 goto found1; 783 } 784 } 785 /* no good value found */ 786 return (EINVAL); 787 found1: 788 DPRINTF(("uirda_set_params: ebofs hdr=0x%02x\n", hdr)); 789 ; 790 791 } 792 if (hdr != 0 || p->speed != sc->sc_params.speed) { 793 /* find speed */ 794 mask = UGETW(sc->sc_irdadesc.wBaudRate); 795 for (i = 0; i < UIRDA_NSPEEDS; i++) { 796 if ((mask & uirda_speeds[i].mask) && 797 uirda_speeds[i].speed == p->speed) { 798 hdr |= uirda_speeds[i].header; 799 goto found2; 800 } 801 } 802 /* no good value found */ 803 return (EINVAL); 804 found2: 805 DPRINTF(("uirda_set_params: speed hdr=0x%02x\n", hdr)); 806 ; 807 } 808 if (p->maxsize != sc->sc_params.maxsize) { 809 if (p->maxsize > IRDA_MAX_FRAME_SIZE) 810 return (EINVAL); 811 sc->sc_params.maxsize = p->maxsize; 812 #if 0 813 DPRINTF(("%s: new buffers, old size=%d\n", __func__, 814 sc->sc_params.maxsize)); 815 if (p->maxsize > 10000 || p < 0) /* XXX */ 816 return (EINVAL); 817 818 /* Change the write buffer */ 819 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 820 if (sc->sc_wr_buf != NULL) 821 usbd_free_buffer(sc->sc_wr_xfer); 822 sc->sc_wr_buf = usbd_alloc_buffer(sc->sc_wr_xfer, p->maxsize+1); 823 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 824 if (sc->sc_wr_buf == NULL) 825 return (ENOMEM); 826 827 /* Change the read buffer */ 828 lockmgr(&sc->sc_rd_buf_lk, LK_EXCLUSIVE, NULL); 829 usbd_abort_pipe(sc->sc_rd_pipe); 830 if (sc->sc_rd_buf != NULL) 831 usbd_free_buffer(sc->sc_rd_xfer); 832 sc->sc_rd_buf = usbd_alloc_buffer(sc->sc_rd_xfer, p->maxsize+1); 833 sc->sc_rd_count = 0; 834 if (sc->sc_rd_buf == NULL) { 835 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 836 return (ENOMEM); 837 } 838 sc->sc_params.maxsize = p->maxsize; 839 err = uirda_start_read(sc); /* XXX check */ 840 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 841 #endif 842 } 843 if (hdr != 0 && hdr != sc->sc_wr_hdr) { 844 /* 845 * A change has occurred, transmit a 0 length frame with 846 * the new settings. The 0 length frame is not sent to the 847 * device. 848 */ 849 DPRINTF(("%s: sc=%p setting header 0x%02x\n", 850 __func__, sc, hdr)); 851 sc->sc_wr_hdr = hdr; 852 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 853 sc->sc_wr_buf[0] = hdr; 854 n = UIRDA_OUTPUT_HEADER_SIZE; 855 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 856 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 857 UIRDA_WR_TIMEOUT, sc->sc_wr_buf, &n, "uirdast"); 858 if (err) { 859 printf("%s: set failed, err=%d\n", 860 USBDEVNAME(sc->sc_dev), err); 861 usbd_clear_endpoint_stall(sc->sc_wr_pipe); 862 } 863 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 864 } 865 866 sc->sc_params = *p; 867 868 return (0); 869 } 870 871 int 872 uirda_get_speeds(void *h, int *speeds) 873 { 874 struct uirda_softc *sc = h; 875 u_int isp; 876 u_int usp; 877 878 DPRINTF(("%s: sc=%p\n", __func__, sc)); 879 880 if (sc->sc_dying) 881 return (EIO); 882 883 usp = UGETW(sc->sc_irdadesc.wBaudRate); 884 isp = 0; 885 if (usp & UI_BR_4000000) isp |= IRDA_SPEED_4000000; 886 if (usp & UI_BR_1152000) isp |= IRDA_SPEED_1152000; 887 if (usp & UI_BR_576000) isp |= IRDA_SPEED_576000; 888 if (usp & UI_BR_115200) isp |= IRDA_SPEED_115200; 889 if (usp & UI_BR_57600) isp |= IRDA_SPEED_57600; 890 if (usp & UI_BR_38400) isp |= IRDA_SPEED_38400; 891 if (usp & UI_BR_19200) isp |= IRDA_SPEED_19200; 892 if (usp & UI_BR_9600) isp |= IRDA_SPEED_9600; 893 if (usp & UI_BR_2400) isp |= IRDA_SPEED_2400; 894 *speeds = isp; 895 return (0); 896 } 897 898 int 899 uirda_get_turnarounds(void *h, int *turnarounds) 900 { 901 struct uirda_softc *sc = h; 902 u_int ita; 903 u_int uta; 904 905 DPRINTF(("%s: sc=%p\n", __func__, sc)); 906 907 if (sc->sc_dying) 908 return (EIO); 909 910 uta = sc->sc_irdadesc.bmMinTurnaroundTime; 911 ita = 0; 912 if (uta & UI_TA_0) ita |= IRDA_TURNT_0; 913 if (uta & UI_TA_10) ita |= IRDA_TURNT_10; 914 if (uta & UI_TA_50) ita |= IRDA_TURNT_50; 915 if (uta & UI_TA_100) ita |= IRDA_TURNT_100; 916 if (uta & UI_TA_500) ita |= IRDA_TURNT_500; 917 if (uta & UI_TA_1000) ita |= IRDA_TURNT_1000; 918 if (uta & UI_TA_5000) ita |= IRDA_TURNT_5000; 919 if (uta & UI_TA_10000) ita |= IRDA_TURNT_10000; 920 *turnarounds = ita; 921 return (0); 922 } 923 924 void 925 uirda_rd_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 926 usbd_status status) 927 { 928 struct uirda_softc *sc = priv; 929 u_int32_t size; 930 931 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 932 933 if (status == USBD_CANCELLED) /* this is normal */ 934 return; 935 if (status) { 936 size = UIRDA_INPUT_HEADER_SIZE; 937 sc->sc_rd_err = 1; 938 } else { 939 usbd_get_xfer_status(xfer, NULL, NULL, &size, NULL); 940 } 941 DPRINTFN(1,("%s: sc=%p size=%u, err=%d\n", __func__, sc, size, 942 sc->sc_rd_err)); 943 sc->sc_rd_count = size; 944 wakeup(&sc->sc_rd_count); /* XXX should use flag */ 945 selnotify(&sc->sc_rd_sel, 0); 946 } 947 948 usbd_status 949 uirda_start_read(struct uirda_softc *sc) 950 { 951 usbd_status err; 952 953 DPRINTFN(1,("%s: sc=%p, size=%d\n", __func__, sc, 954 sc->sc_params.maxsize + UIRDA_INPUT_HEADER_SIZE)); 955 956 if (sc->sc_dying) 957 return (USBD_IOERROR); 958 959 if (sc->sc_rd_err) { 960 sc->sc_rd_err = 0; 961 DPRINTF(("uirda_start_read: clear stall\n")); 962 usbd_clear_endpoint_stall(sc->sc_rd_pipe); 963 } 964 965 usbd_setup_xfer(sc->sc_rd_xfer, sc->sc_rd_pipe, sc, sc->sc_rd_buf, 966 sc->sc_params.maxsize + UIRDA_INPUT_HEADER_SIZE, 967 USBD_SHORT_XFER_OK | USBD_NO_COPY, 968 USBD_NO_TIMEOUT, uirda_rd_cb); 969 err = usbd_transfer(sc->sc_rd_xfer); 970 if (err != USBD_IN_PROGRESS) { 971 DPRINTF(("uirda_start_read: err=%d\n", err)); 972 return (err); 973 } 974 return (USBD_NORMAL_COMPLETION); 975 } 976
Indexes created Tue Oct 14 21:09:58 GMT 2025