uirda.c revision 1.14
1 /* $NetBSD: uirda.c,v 1.14 2002/11/26 18:49:49 christos 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.14 2002/11/26 18:49:49 christos 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, usb_proc_ptr p); 231 int uirda_close(void *h, int flag, int mode, usb_proc_ptr p); 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, usb_proc_ptr p); 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 usb_descriptor_t *usb_find_desc(usbd_device_handle dev, int type); 251 252 /* 253 * These devices don't quite follow the spec. Speed changing is broken 254 * and they don't handle windows. 255 * But we change speed in a safe way, and don't use windows now. 256 * Some devices also seem to have an interrupt pipe that can be ignored. 257 * 258 * Table information taken from Linux driver. 259 */ 260 Static const struct usb_devno uirda_devs[] = { 261 { USB_VENDOR_ACTISYS, USB_PRODUCT_ACTISYS_IR2000U }, 262 { USB_VENDOR_EXTENDED, USB_PRODUCT_EXTENDED_XTNDACCESS }, 263 { USB_VENDOR_KAWATSU, USB_PRODUCT_KAWATSU_KC180 }, 264 }; 265 #define uirda_lookup(v, p) (usb_lookup(uirda_devs, v, p)) 266 267 USB_DECLARE_DRIVER(uirda); 268 269 USB_MATCH(uirda) 270 { 271 USB_MATCH_START(uirda, uaa); 272 usb_interface_descriptor_t *id; 273 274 DPRINTFN(50,("uirda_match\n")); 275 276 if (uaa->iface == NULL) 277 return (UMATCH_NONE); 278 279 if (uirda_lookup(uaa->vendor, uaa->product) != NULL) 280 return (UMATCH_VENDOR_PRODUCT); 281 282 id = usbd_get_interface_descriptor(uaa->iface); 283 if (id != NULL && 284 id->bInterfaceClass == UICLASS_APPL_SPEC && 285 id->bInterfaceSubClass == UISUBCLASS_IRDA && 286 id->bInterfaceProtocol == UIPROTO_IRDA) 287 return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO); 288 return (UMATCH_NONE); 289 } 290 291 USB_ATTACH(uirda) 292 { 293 USB_ATTACH_START(uirda, sc, uaa); 294 usbd_device_handle dev = uaa->device; 295 usbd_interface_handle iface = uaa->iface; 296 char devinfo[1024]; 297 usb_endpoint_descriptor_t *ed; 298 usbd_status err; 299 u_int8_t epcount; 300 u_int specrev; 301 int i; 302 struct ir_attach_args ia; 303 304 DPRINTFN(10,("uirda_attach: sc=%p\n", sc)); 305 306 usbd_devinfo(dev, 0, devinfo); 307 USB_ATTACH_SETUP; 308 printf("%s: %s\n", USBDEVNAME(sc->sc_dev), devinfo); 309 310 sc->sc_udev = dev; 311 sc->sc_iface = iface; 312 313 epcount = 0; 314 (void)usbd_endpoint_count(iface, &epcount); 315 316 sc->sc_rd_addr = -1; 317 sc->sc_wr_addr = -1; 318 for (i = 0; i < epcount; i++) { 319 ed = usbd_interface2endpoint_descriptor(iface, i); 320 if (ed == NULL) { 321 printf("%s: couldn't get ep %d\n", 322 USBDEVNAME(sc->sc_dev), i); 323 USB_ATTACH_ERROR_RETURN; 324 } 325 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 326 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 327 sc->sc_rd_addr = ed->bEndpointAddress; 328 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 329 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 330 sc->sc_wr_addr = ed->bEndpointAddress; 331 } 332 } 333 if (sc->sc_rd_addr == -1 || sc->sc_wr_addr == -1) { 334 printf("%s: missing endpoint\n", USBDEVNAME(sc->sc_dev)); 335 USB_ATTACH_ERROR_RETURN; 336 } 337 338 /* Get the IrDA descriptor */ 339 err = usbd_get_desc(sc->sc_udev, UDESC_IRDA, 0, 340 USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc); 341 if (err) { 342 /* maybe it's embedded in the config desc? */ 343 void *d = usb_find_desc(sc->sc_udev, UDESC_IRDA); 344 if (d == NULL) { 345 printf("%s: Cannot get IrDA descriptor\n", 346 USBDEVNAME(sc->sc_dev)); 347 USB_ATTACH_ERROR_RETURN; 348 } 349 memcpy(&sc->sc_irdadesc, d, USB_IRDA_DESCRIPTOR_SIZE); 350 } 351 DPRINTF(("uirda_attach: bmDataSize=0x%02x bmWindowSize=0x%02x " 352 "bmMinTurnaroundTime=0x%02x wBaudRate=0x%04x " 353 "bmAdditionalBOFs=0x%02x bIrdaSniff=%d bMaxUnicastList=%d\n", 354 sc->sc_irdadesc.bmDataSize, 355 sc->sc_irdadesc.bmWindowSize, 356 sc->sc_irdadesc.bmMinTurnaroundTime, 357 UGETW(sc->sc_irdadesc.wBaudRate), 358 sc->sc_irdadesc.bmAdditionalBOFs, 359 sc->sc_irdadesc.bIrdaSniff, 360 sc->sc_irdadesc.bMaxUnicastList)); 361 362 specrev = UGETW(sc->sc_irdadesc.bcdSpecRevision); 363 printf("%s: USB-IrDA protocol version %x.%02x\n", 364 USBDEVNAME(sc->sc_dev), specrev >> 8, specrev & 0xff); 365 366 DPRINTFN(10, ("uirda_attach: %p\n", sc->sc_udev)); 367 368 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, 369 USBDEV(sc->sc_dev)); 370 371 lockinit(&sc->sc_wr_buf_lk, PZERO, "iirwrl", 0, 0); 372 lockinit(&sc->sc_rd_buf_lk, PZERO, "uirrdl", 0, 0); 373 374 ia.ia_type = IR_TYPE_IRFRAME; 375 ia.ia_methods = &uirda_methods; 376 ia.ia_handle = sc; 377 378 sc->sc_child = config_found(self, &ia, ir_print); 379 380 USB_ATTACH_SUCCESS_RETURN; 381 } 382 383 USB_DETACH(uirda) 384 { 385 USB_DETACH_START(uirda, sc); 386 int s; 387 int rv = 0; 388 389 DPRINTF(("uirda_detach: sc=%p flags=%d\n", sc, flags)); 390 391 sc->sc_dying = 1; 392 /* Abort all pipes. Causes processes waiting for transfer to wake. */ 393 if (sc->sc_rd_pipe != NULL) { 394 usbd_abort_pipe(sc->sc_rd_pipe); 395 usbd_close_pipe(sc->sc_rd_pipe); 396 sc->sc_rd_pipe = NULL; 397 } 398 if (sc->sc_wr_pipe != NULL) { 399 usbd_abort_pipe(sc->sc_wr_pipe); 400 usbd_close_pipe(sc->sc_wr_pipe); 401 sc->sc_wr_pipe = NULL; 402 } 403 wakeup(&sc->sc_rd_count); 404 405 s = splusb(); 406 if (--sc->sc_refcnt >= 0) { 407 /* Wait for processes to go away. */ 408 usb_detach_wait(USBDEV(sc->sc_dev)); 409 } 410 splx(s); 411 412 if (sc->sc_child != NULL) { 413 rv = config_detach(sc->sc_child, flags); 414 sc->sc_child = NULL; 415 } 416 417 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 418 USBDEV(sc->sc_dev)); 419 420 return (rv); 421 } 422 423 int 424 uirda_activate(device_ptr_t self, enum devact act) 425 { 426 struct uirda_softc *sc = (struct uirda_softc *)self; 427 int error = 0; 428 429 switch (act) { 430 case DVACT_ACTIVATE: 431 return (EOPNOTSUPP); 432 break; 433 434 case DVACT_DEACTIVATE: 435 sc->sc_dying = 1; 436 if (sc->sc_child != NULL) 437 error = config_deactivate(sc->sc_child); 438 break; 439 } 440 return (error); 441 } 442 443 int 444 uirda_open(void *h, int flag, int mode, usb_proc_ptr p) 445 { 446 struct uirda_softc *sc = h; 447 int error; 448 usbd_status err; 449 450 DPRINTF(("%s: sc=%p\n", __func__, sc)); 451 452 err = usbd_open_pipe(sc->sc_iface, sc->sc_rd_addr, 0, &sc->sc_rd_pipe); 453 if (err) { 454 error = EIO; 455 goto bad1; 456 } 457 err = usbd_open_pipe(sc->sc_iface, sc->sc_wr_addr, 0, &sc->sc_wr_pipe); 458 if (err) { 459 error = EIO; 460 goto bad2; 461 } 462 sc->sc_rd_xfer = usbd_alloc_xfer(sc->sc_udev); 463 if (sc->sc_rd_xfer == NULL) { 464 error = ENOMEM; 465 goto bad3; 466 } 467 sc->sc_wr_xfer = usbd_alloc_xfer(sc->sc_udev); 468 if (sc->sc_wr_xfer == NULL) { 469 error = ENOMEM; 470 goto bad4; 471 } 472 sc->sc_rd_buf = usbd_alloc_buffer(sc->sc_rd_xfer, 473 IRDA_MAX_FRAME_SIZE + UIRDA_INPUT_HEADER_SIZE); 474 if (sc->sc_rd_buf == NULL) { 475 error = ENOMEM; 476 goto bad5; 477 } 478 sc->sc_wr_buf = usbd_alloc_buffer(sc->sc_wr_xfer, 479 IRDA_MAX_FRAME_SIZE + UIRDA_OUTPUT_HEADER_SIZE); 480 if (sc->sc_wr_buf == NULL) { 481 error = ENOMEM; 482 goto bad5; 483 } 484 sc->sc_rd_count = 0; 485 sc->sc_rd_err = 0; 486 sc->sc_params.speed = 0; 487 sc->sc_params.ebofs = 0; 488 sc->sc_params.maxsize = IRDA_MAX_FRAME_SIZE; 489 sc->sc_wr_hdr = -1; 490 491 err = uirda_start_read(sc); 492 /* XXX check err */ 493 494 return (0); 495 496 bad5: 497 usbd_free_xfer(sc->sc_wr_xfer); 498 sc->sc_wr_xfer = NULL; 499 bad4: 500 usbd_free_xfer(sc->sc_rd_xfer); 501 sc->sc_rd_xfer = NULL; 502 bad3: 503 usbd_close_pipe(sc->sc_wr_pipe); 504 sc->sc_wr_pipe = NULL; 505 bad2: 506 usbd_close_pipe(sc->sc_rd_pipe); 507 sc->sc_rd_pipe = NULL; 508 bad1: 509 return (error); 510 } 511 512 int 513 uirda_close(void *h, int flag, int mode, usb_proc_ptr p) 514 { 515 struct uirda_softc *sc = h; 516 517 DPRINTF(("%s: sc=%p\n", __func__, sc)); 518 519 if (sc->sc_rd_pipe != NULL) { 520 usbd_abort_pipe(sc->sc_rd_pipe); 521 usbd_close_pipe(sc->sc_rd_pipe); 522 sc->sc_rd_pipe = NULL; 523 } 524 if (sc->sc_wr_pipe != NULL) { 525 usbd_abort_pipe(sc->sc_wr_pipe); 526 usbd_close_pipe(sc->sc_wr_pipe); 527 sc->sc_wr_pipe = NULL; 528 } 529 if (sc->sc_rd_xfer != NULL) { 530 usbd_free_xfer(sc->sc_rd_xfer); 531 sc->sc_rd_xfer = NULL; 532 sc->sc_rd_buf = NULL; 533 } 534 if (sc->sc_wr_xfer != NULL) { 535 usbd_free_xfer(sc->sc_wr_xfer); 536 sc->sc_wr_xfer = NULL; 537 sc->sc_wr_buf = NULL; 538 } 539 540 return (0); 541 } 542 543 int 544 uirda_read(void *h, struct uio *uio, int flag) 545 { 546 struct uirda_softc *sc = h; 547 usbd_status err; 548 int s; 549 int error; 550 u_int n; 551 552 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 553 554 if (sc->sc_dying) 555 return (EIO); 556 557 #ifdef DIAGNOSTIC 558 if (sc->sc_rd_buf == NULL) 559 return (EINVAL); 560 #endif 561 562 sc->sc_refcnt++; 563 564 do { 565 s = splusb(); 566 while (sc->sc_rd_count == 0) { 567 DPRINTFN(5,("uirda_read: calling tsleep()\n")); 568 error = tsleep(&sc->sc_rd_count, PZERO | PCATCH, 569 "uirdrd", 0); 570 if (sc->sc_dying) 571 error = EIO; 572 if (error) { 573 splx(s); 574 DPRINTF(("uirda_read: tsleep() = %d\n", error)); 575 goto ret; 576 } 577 } 578 splx(s); 579 580 lockmgr(&sc->sc_rd_buf_lk, LK_EXCLUSIVE, NULL); 581 n = sc->sc_rd_count - UIRDA_INPUT_HEADER_SIZE; 582 DPRINTFN(1,("%s: sc=%p n=%u, hdr=0x%02x\n", __func__, 583 sc, n, sc->sc_rd_buf[0])); 584 if (n > uio->uio_resid) 585 error = EINVAL; 586 else 587 error = uiomove(sc->sc_rd_buf+UIRDA_INPUT_HEADER_SIZE, 588 n, uio); 589 sc->sc_rd_count = 0; 590 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 591 592 err = uirda_start_read(sc); 593 /* XXX check err */ 594 595 } while (n == 0); 596 597 DPRINTFN(1,("uirda_read: return %d\n", error)); 598 599 ret: 600 if (--sc->sc_refcnt < 0) 601 usb_detach_wakeup(USBDEV(sc->sc_dev)); 602 return (error); 603 } 604 605 int 606 uirda_write(void *h, struct uio *uio, int flag) 607 { 608 struct uirda_softc *sc = h; 609 usbd_status err; 610 u_int32_t n; 611 int error = 0; 612 613 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 614 615 if (sc->sc_dying) 616 return (EIO); 617 618 #ifdef DIAGNOSTIC 619 if (sc->sc_wr_buf == NULL) 620 return (EINVAL); 621 #endif 622 623 n = uio->uio_resid; 624 if (n > sc->sc_params.maxsize) 625 return (EINVAL); 626 627 sc->sc_refcnt++; 628 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 629 630 sc->sc_wr_buf[0] = UIRDA_EB_NO_CHANGE | UIRDA_NO_SPEED; 631 error = uiomove(sc->sc_wr_buf + UIRDA_OUTPUT_HEADER_SIZE, n, uio); 632 if (!error) { 633 DPRINTFN(1, ("uirdawrite: transfer %d bytes\n", n)); 634 635 n++; 636 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 637 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 638 UIRDA_WR_TIMEOUT, 639 sc->sc_wr_buf, &n, "uirdawr"); 640 DPRINTFN(2, ("uirdawrite: err=%d\n", err)); 641 if (err) { 642 if (err == USBD_INTERRUPTED) 643 error = EINTR; 644 else if (err == USBD_TIMEOUT) 645 error = ETIMEDOUT; 646 else 647 error = EIO; 648 } 649 } 650 651 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 652 if (--sc->sc_refcnt < 0) 653 usb_detach_wakeup(USBDEV(sc->sc_dev)); 654 655 DPRINTFN(1,("%s: sc=%p done\n", __func__, sc)); 656 return (error); 657 } 658 659 int 660 uirda_poll(void *h, int events, usb_proc_ptr p) 661 { 662 struct uirda_softc *sc = h; 663 int revents = 0; 664 int s; 665 666 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 667 668 s = splusb(); 669 if (events & (POLLOUT | POLLWRNORM)) 670 revents |= events & (POLLOUT | POLLWRNORM); 671 if (events & (POLLIN | POLLRDNORM)) { 672 if (sc->sc_rd_count != 0) { 673 DPRINTFN(2,("%s: have data\n", __func__)); 674 revents |= events & (POLLIN | POLLRDNORM); 675 } else { 676 DPRINTFN(2,("%s: recording select\n", __func__)); 677 selrecord(p, &sc->sc_rd_sel); 678 } 679 } 680 splx(s); 681 682 return (revents); 683 } 684 685 static void 686 filt_uirdardetach(struct knote *kn) 687 { 688 struct uirda_softc *sc = kn->kn_hook; 689 int s; 690 691 s = splusb(); 692 SLIST_REMOVE(&sc->sc_rd_sel.sel_klist, kn, knote, kn_selnext); 693 splx(s); 694 } 695 696 static int 697 filt_uirdaread(struct knote *kn, long hint) 698 { 699 struct uirda_softc *sc = kn->kn_hook; 700 701 kn->kn_data = sc->sc_rd_count; 702 return (kn->kn_data > 0); 703 } 704 705 static void 706 filt_uirdawdetach(struct knote *kn) 707 { 708 struct uirda_softc *sc = kn->kn_hook; 709 int s; 710 711 s = splusb(); 712 SLIST_REMOVE(&sc->sc_wr_sel.sel_klist, kn, knote, kn_selnext); 713 splx(s); 714 } 715 716 static const struct filterops uirdaread_filtops = 717 { 1, NULL, filt_uirdardetach, filt_uirdaread }; 718 static const struct filterops uirdawrite_filtops = 719 { 1, NULL, filt_uirdawdetach, filt_seltrue }; 720 721 int 722 uirda_kqfilter(void *h, struct knote *kn) 723 { 724 struct uirda_softc *sc = kn->kn_hook; 725 struct klist *klist; 726 int s; 727 728 switch (kn->kn_filter) { 729 case EVFILT_READ: 730 klist = &sc->sc_rd_sel.sel_klist; 731 kn->kn_fop = &uirdaread_filtops; 732 break; 733 case EVFILT_WRITE: 734 klist = &sc->sc_wr_sel.sel_klist; 735 kn->kn_fop = &uirdawrite_filtops; 736 break; 737 default: 738 return (1); 739 } 740 741 kn->kn_hook = sc; 742 743 s = splusb(); 744 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 745 splx(s); 746 747 return (0); 748 } 749 750 int 751 uirda_set_params(void *h, struct irda_params *p) 752 { 753 struct uirda_softc *sc = h; 754 usbd_status err; 755 int i; 756 u_int8_t hdr; 757 u_int32_t n; 758 u_int mask; 759 760 DPRINTF(("%s: sc=%p, speed=%d ebofs=%d maxsize=%d\n", __func__, 761 sc, p->speed, p->ebofs, p->maxsize)); 762 763 if (sc->sc_dying) 764 return (EIO); 765 766 hdr = 0; 767 if (p->ebofs != sc->sc_params.ebofs) { 768 /* round up ebofs */ 769 mask = sc->sc_irdadesc.bmAdditionalBOFs; 770 for (i = 0; i < UIRDA_NEBOFS; i++) { 771 if ((mask & uirda_ebofs[i].mask) && 772 uirda_ebofs[i].count >= p->ebofs) { 773 hdr = uirda_ebofs[i].header; 774 goto found1; 775 } 776 } 777 /* no good value found */ 778 return (EINVAL); 779 found1: 780 DPRINTF(("uirda_set_params: ebofs hdr=0x%02x\n", hdr)); 781 ; 782 783 } 784 if (hdr != 0 || p->speed != sc->sc_params.speed) { 785 /* find speed */ 786 mask = UGETW(sc->sc_irdadesc.wBaudRate); 787 for (i = 0; i < UIRDA_NSPEEDS; i++) { 788 if ((mask & uirda_speeds[i].mask) && 789 uirda_speeds[i].speed == p->speed) { 790 hdr |= uirda_speeds[i].header; 791 goto found2; 792 } 793 } 794 /* no good value found */ 795 return (EINVAL); 796 found2: 797 DPRINTF(("uirda_set_params: speed hdr=0x%02x\n", hdr)); 798 ; 799 } 800 if (p->maxsize != sc->sc_params.maxsize) { 801 if (p->maxsize > IRDA_MAX_FRAME_SIZE) 802 return (EINVAL); 803 sc->sc_params.maxsize = p->maxsize; 804 #if 0 805 DPRINTF(("%s: new buffers, old size=%d\n", __func__, 806 sc->sc_params.maxsize)); 807 if (p->maxsize > 10000 || p < 0) /* XXX */ 808 return (EINVAL); 809 810 /* Change the write buffer */ 811 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 812 if (sc->sc_wr_buf != NULL) 813 usbd_free_buffer(sc->sc_wr_xfer); 814 sc->sc_wr_buf = usbd_alloc_buffer(sc->sc_wr_xfer, p->maxsize+1); 815 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 816 if (sc->sc_wr_buf == NULL) 817 return (ENOMEM); 818 819 /* Change the read buffer */ 820 lockmgr(&sc->sc_rd_buf_lk, LK_EXCLUSIVE, NULL); 821 usbd_abort_pipe(sc->sc_rd_pipe); 822 if (sc->sc_rd_buf != NULL) 823 usbd_free_buffer(sc->sc_rd_xfer); 824 sc->sc_rd_buf = usbd_alloc_buffer(sc->sc_rd_xfer, p->maxsize+1); 825 sc->sc_rd_count = 0; 826 if (sc->sc_rd_buf == NULL) { 827 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 828 return (ENOMEM); 829 } 830 sc->sc_params.maxsize = p->maxsize; 831 err = uirda_start_read(sc); /* XXX check */ 832 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 833 #endif 834 } 835 if (hdr != 0 && hdr != sc->sc_wr_hdr) { 836 /* 837 * A change has occurred, transmit a 0 length frame with 838 * the new settings. The 0 length frame is not sent to the 839 * device. 840 */ 841 DPRINTF(("%s: sc=%p setting header 0x%02x\n", 842 __func__, sc, hdr)); 843 sc->sc_wr_hdr = hdr; 844 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 845 sc->sc_wr_buf[0] = hdr; 846 n = UIRDA_OUTPUT_HEADER_SIZE; 847 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 848 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 849 UIRDA_WR_TIMEOUT, sc->sc_wr_buf, &n, "uirdast"); 850 if (err) { 851 printf("%s: set failed, err=%d\n", 852 USBDEVNAME(sc->sc_dev), err); 853 usbd_clear_endpoint_stall(sc->sc_wr_pipe); 854 } 855 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 856 } 857 858 sc->sc_params = *p; 859 860 return (0); 861 } 862 863 int 864 uirda_get_speeds(void *h, int *speeds) 865 { 866 struct uirda_softc *sc = h; 867 u_int isp; 868 u_int usp; 869 870 DPRINTF(("%s: sc=%p\n", __func__, sc)); 871 872 if (sc->sc_dying) 873 return (EIO); 874 875 usp = UGETW(sc->sc_irdadesc.wBaudRate); 876 isp = 0; 877 if (usp & UI_BR_4000000) isp |= IRDA_SPEED_4000000; 878 if (usp & UI_BR_1152000) isp |= IRDA_SPEED_1152000; 879 if (usp & UI_BR_576000) isp |= IRDA_SPEED_576000; 880 if (usp & UI_BR_115200) isp |= IRDA_SPEED_115200; 881 if (usp & UI_BR_57600) isp |= IRDA_SPEED_57600; 882 if (usp & UI_BR_38400) isp |= IRDA_SPEED_38400; 883 if (usp & UI_BR_19200) isp |= IRDA_SPEED_19200; 884 if (usp & UI_BR_9600) isp |= IRDA_SPEED_9600; 885 if (usp & UI_BR_2400) isp |= IRDA_SPEED_2400; 886 *speeds = isp; 887 return (0); 888 } 889 890 int 891 uirda_get_turnarounds(void *h, int *turnarounds) 892 { 893 struct uirda_softc *sc = h; 894 u_int ita; 895 u_int uta; 896 897 DPRINTF(("%s: sc=%p\n", __func__, sc)); 898 899 if (sc->sc_dying) 900 return (EIO); 901 902 uta = sc->sc_irdadesc.bmMinTurnaroundTime; 903 ita = 0; 904 if (uta & UI_TA_0) ita |= IRDA_TURNT_0; 905 if (uta & UI_TA_10) ita |= IRDA_TURNT_10; 906 if (uta & UI_TA_50) ita |= IRDA_TURNT_50; 907 if (uta & UI_TA_100) ita |= IRDA_TURNT_100; 908 if (uta & UI_TA_500) ita |= IRDA_TURNT_500; 909 if (uta & UI_TA_1000) ita |= IRDA_TURNT_1000; 910 if (uta & UI_TA_5000) ita |= IRDA_TURNT_5000; 911 if (uta & UI_TA_10000) ita |= IRDA_TURNT_10000; 912 *turnarounds = ita; 913 return (0); 914 } 915 916 void 917 uirda_rd_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 918 usbd_status status) 919 { 920 struct uirda_softc *sc = priv; 921 u_int32_t size; 922 923 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 924 925 if (status == USBD_CANCELLED) /* this is normal */ 926 return; 927 if (status) { 928 size = UIRDA_INPUT_HEADER_SIZE; 929 sc->sc_rd_err = 1; 930 } else { 931 usbd_get_xfer_status(xfer, NULL, NULL, &size, NULL); 932 } 933 DPRINTFN(1,("%s: sc=%p size=%u, err=%d\n", __func__, sc, size, 934 sc->sc_rd_err)); 935 sc->sc_rd_count = size; 936 wakeup(&sc->sc_rd_count); /* XXX should use flag */ 937 selnotify(&sc->sc_rd_sel, 0); 938 } 939 940 usbd_status 941 uirda_start_read(struct uirda_softc *sc) 942 { 943 usbd_status err; 944 945 DPRINTFN(1,("%s: sc=%p, size=%d\n", __func__, sc, 946 sc->sc_params.maxsize + UIRDA_INPUT_HEADER_SIZE)); 947 948 if (sc->sc_dying) 949 return (USBD_IOERROR); 950 951 if (sc->sc_rd_err) { 952 sc->sc_rd_err = 0; 953 DPRINTF(("uirda_start_read: clear stall\n")); 954 usbd_clear_endpoint_stall(sc->sc_rd_pipe); 955 } 956 957 usbd_setup_xfer(sc->sc_rd_xfer, sc->sc_rd_pipe, sc, sc->sc_rd_buf, 958 sc->sc_params.maxsize + UIRDA_INPUT_HEADER_SIZE, 959 USBD_SHORT_XFER_OK | USBD_NO_COPY, 960 USBD_NO_TIMEOUT, uirda_rd_cb); 961 err = usbd_transfer(sc->sc_rd_xfer); 962 if (err != USBD_IN_PROGRESS) { 963 DPRINTF(("uirda_start_read: err=%d\n", err)); 964 return (err); 965 } 966 return (USBD_NORMAL_COMPLETION); 967 } 968
Indexes created Mon Sep 22 13:09:51 GMT 2025