uirda.c revision 1.3
1 /* $NetBSD: uirda.c,v 1.3 2001/12/13 17:25:37 augustss 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) at 9 * Carlstedt Research & Technology. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 #include <sys/cdefs.h> 41 __KERNEL_RCSID(0, "$NetBSD: uirda.c,v 1.3 2001/12/13 17:25:37 augustss Exp $"); 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/kernel.h> 46 #include <sys/device.h> 47 #include <sys/lock.h> 48 #include <sys/ioctl.h> 49 #include <sys/conf.h> 50 #include <sys/file.h> 51 #include <sys/poll.h> 52 #include <sys/select.h> 53 #include <sys/proc.h> 54 55 #include <dev/usb/usb.h> 56 #include <dev/usb/usbdi.h> 57 #include <dev/usb/usbdi_util.h> 58 #include <dev/usb/usbdevs.h> 59 60 #include <dev/ir/ir.h> 61 #include <dev/ir/irdaio.h> 62 #include <dev/ir/irframevar.h> 63 64 #ifdef URIO_DEBUG 65 #define DPRINTF(x) if (uirdadebug) logprintf x 66 #define DPRINTFN(n,x) if (uirdadebug>(n)) logprintf x 67 int uirdadebug = 1; 68 #else 69 #define DPRINTF(x) 70 #define DPRINTFN(n,x) 71 #endif 72 73 /* 74 * Protocol related definitions 75 */ 76 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 /* Outbound header byte */ 92 #define UIRDA_EB_NO_CHANGE 0x00 93 #define UIRDA_EB_48 0x10 94 #define UIRDA_EB_24 0x20 95 #define UIRDA_EB_12 0x30 96 #define UIRDA_EB_6 0x40 97 #define UIRDA_EB_3 0x50 98 #define UIRDA_EB_2 0x60 99 #define UIRDA_EB_1 0x70 100 #define UIRDA_EB_0 0x80 101 /* Speeds as above */ 102 103 /* Class specific requests */ 104 #define UR_IRDA_RECEIVING 0x01 /* Receive in progress? */ 105 #define UR_IRDA_CHECK_MEDIA_BUSY 0x03 106 #define UR_IRDA_SET_RATE_SNIFF 0x04 /* opt */ 107 #define UR_IRDA_SET_UNICAST_LIST 0x05 /* opt */ 108 #define UR_IRDA_GET_DESC 0x06 109 110 typedef struct { 111 uByte bLength; 112 uByte bDescriptorType; 113 #define UDESC_IRDA 0x21 114 uByte bDescriptorSubtype; 115 uByte bmDataSize; 116 #define UI_DS_2048 0x20 117 #define UI_DS_1024 0x10 118 #define UI_DS_512 0x08 119 #define UI_DS_256 0x04 120 #define UI_DS_128 0x02 121 #define UI_DS_64 0x01 122 uByte bmWindowSize; 123 #define UI_WS_7 0x40 124 #define UI_WS_6 0x20 125 #define UI_WS_5 0x10 126 #define UI_WS_4 0x08 127 #define UI_WS_3 0x04 128 #define UI_WS_2 0x02 129 #define UI_WS_1 0x01 130 uByte bmMinTurnaroundTime; 131 #define UI_TA_0 0x80 132 #define UI_TA_10 0x40 133 #define UI_TA_50 0x20 134 #define UI_TA_100 0x10 135 #define UI_TA_500 0x08 136 #define UI_TA_1000 0x04 137 #define UI_TA_5000 0x02 138 #define UI_TA_10000 0x01 139 uWord wBaudRate; 140 #define UI_BR_4000000 0x0100 141 #define UI_BR_1152000 0x0080 142 #define UI_BR_576000 0x0040 143 #define UI_BR_115200 0x0020 144 #define UI_BR_57600 0x0010 145 #define UI_BR_38400 0x0008 146 #define UI_BR_19200 0x0004 147 #define UI_BR_9600 0x0002 148 #define UI_BR_2400 0x0001 149 uByte bmAdditionalBOFs; 150 #define UI_EB_0 0x80 151 #define UI_EB_1 0x40 152 #define UI_EB_2 0x20 153 #define UI_EB_3 0x10 154 #define UI_EB_6 0x08 155 #define UI_EB_12 0x04 156 #define UI_EB_24 0x02 157 #define UI_EB_48 0x01 158 uByte bIrdaSniff; 159 uByte bMaxUnicastList; 160 } UPACKED usb_irda_descriptor_t; 161 #define USB_IRDA_DESCRIPTOR_SIZE 12 162 163 164 #define UIRDA_NEBOFS 8 165 static struct { 166 int count; 167 int mask; 168 int header; 169 } uirda_ebofs[UIRDA_NEBOFS] = { 170 { 0, UI_EB_0, UIRDA_EB_0 }, 171 { 1, UI_EB_1, UIRDA_EB_1 }, 172 { 2, UI_EB_2, UIRDA_EB_2 }, 173 { 3, UI_EB_3, UIRDA_EB_3 }, 174 { 6, UI_EB_6, UIRDA_EB_6 }, 175 { 12, UI_EB_12, UIRDA_EB_12 }, 176 { 24, UI_EB_24, UIRDA_EB_24 }, 177 { 48, UI_EB_48, UIRDA_EB_48 } 178 }; 179 180 #define UIRDA_NSPEEDS 9 181 static struct { 182 int speed; 183 int mask; 184 int header; 185 } uirda_speeds[UIRDA_NSPEEDS] = { 186 { 4000000, UI_BR_4000000, UIRDA_4000000 }, 187 { 1152000, UI_BR_1152000, UIRDA_1152000 }, 188 { 576000, UI_BR_576000, UIRDA_576000 }, 189 { 115200, UI_BR_115200, UIRDA_115200 }, 190 { 57600, UI_BR_57600, UIRDA_57600 }, 191 { 38400, UI_BR_38400, UIRDA_38400 }, 192 { 19200, UI_BR_19200, UIRDA_19200 }, 193 { 9600, UI_BR_9600, UIRDA_9600 }, 194 { 2400, UI_BR_2400, UIRDA_2400 }, 195 }; 196 197 struct uirda_softc { 198 USBBASEDEVICE sc_dev; 199 usbd_device_handle sc_udev; 200 usbd_interface_handle sc_iface; 201 202 struct lock sc_rd_buf_lk; 203 u_int8_t *sc_rd_buf; 204 int sc_rd_addr; 205 usbd_pipe_handle sc_rd_pipe; 206 usbd_xfer_handle sc_rd_xfer; 207 struct selinfo sc_rd_sel; 208 u_int sc_rd_count; 209 210 struct lock sc_wr_buf_lk; 211 u_int8_t *sc_wr_buf; 212 int sc_wr_addr; 213 usbd_xfer_handle sc_wr_xfer; 214 usbd_pipe_handle sc_wr_pipe; 215 216 struct device *sc_child; 217 struct irda_params sc_params; 218 usb_irda_descriptor_t sc_irdadesc; 219 220 int sc_refcnt; 221 char sc_dying; 222 }; 223 224 #define UIRDA_WR_TIMEOUT 200 225 226 int uirda_open(void *h, int flag, int mode, struct proc *p); 227 int uirda_close(void *h, int flag, int mode, struct proc *p); 228 int uirda_read(void *h, struct uio *uio, int flag); 229 int uirda_write(void *h, struct uio *uio, int flag); 230 int uirda_set_params(void *h, struct irda_params *params); 231 int uirda_get_speeds(void *h, int *speeds); 232 int uirda_get_turnarounds(void *h, int *times); 233 int uirda_poll(void *h, int events, struct proc *p); 234 235 struct irframe_methods uirda_methods = { 236 uirda_open, uirda_close, uirda_read, uirda_write, uirda_poll, 237 uirda_set_params, uirda_get_speeds, uirda_get_turnarounds 238 }; 239 240 void uirda_rd_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 241 usbd_status status); 242 usbd_status uirda_start_read(struct uirda_softc *sc); 243 244 usb_descriptor_t *usb_find_desc(usbd_device_handle dev, int type); 245 246 /* 247 * These devices don't quite follow the spec. Speed changing is broken 248 * and they don't handle windows. 249 * But we change speed in a safe way, and don't use windows now. 250 * Some devices also seem to have an interrupt pipe that can be ignored. 251 * 252 * Table information taken from Linux driver. 253 */ 254 Static const struct usb_devno uirda_devs[] = { 255 { USB_VENDOR_ACTISYS, USB_PRODUCT_ACTISYS_IR2000U }, 256 { USB_VENDOR_EXTENDED, USB_PRODUCT_EXTENDED_XTNDACCESS }, 257 { USB_VENDOR_KAWATSU, USB_PRODUCT_KAWATSU_KC180 }, 258 }; 259 #define uirda_lookup(v, p) (usb_lookup(uirda_devs, v, p)) 260 261 USB_DECLARE_DRIVER(uirda); 262 263 USB_MATCH(uirda) 264 { 265 USB_MATCH_START(uirda, uaa); 266 usb_interface_descriptor_t *id; 267 268 DPRINTFN(50,("uirda_match\n")); 269 270 if (uaa->iface == NULL) 271 return (UMATCH_NONE); 272 273 if (uirda_lookup(uaa->vendor, uaa->product) != NULL) 274 return (UMATCH_VENDOR_PRODUCT); 275 276 id = usbd_get_interface_descriptor(uaa->iface); 277 if (id != NULL && 278 id->bInterfaceClass == UICLASS_APPL_SPEC && 279 id->bInterfaceSubClass == UISUBCLASS_IRDA && 280 id->bInterfaceProtocol == UIPROTO_IRDA) 281 return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO); 282 return (UMATCH_NONE); 283 } 284 285 USB_ATTACH(uirda) 286 { 287 USB_ATTACH_START(uirda, sc, uaa); 288 usbd_device_handle dev = uaa->device; 289 usbd_interface_handle iface = uaa->iface; 290 char devinfo[1024]; 291 usb_endpoint_descriptor_t *ed; 292 usbd_status err; 293 u_int8_t epcount; 294 int i; 295 struct ir_attach_args ia; 296 297 DPRINTFN(10,("uirda_attach: sc=%p\n", sc)); 298 299 usbd_devinfo(dev, 0, devinfo); 300 USB_ATTACH_SETUP; 301 printf("%s: %s\n", USBDEVNAME(sc->sc_dev), devinfo); 302 303 sc->sc_udev = dev; 304 sc->sc_iface = iface; 305 306 epcount = 0; 307 (void)usbd_endpoint_count(iface, &epcount); 308 309 sc->sc_rd_addr = -1; 310 sc->sc_wr_addr = -1; 311 for (i = 0; i < epcount; i++) { 312 ed = usbd_interface2endpoint_descriptor(iface, i); 313 if (ed == NULL) { 314 printf("%s: couldn't get ep %d\n", 315 USBDEVNAME(sc->sc_dev), i); 316 USB_ATTACH_ERROR_RETURN; 317 } 318 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 319 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 320 sc->sc_rd_addr = ed->bEndpointAddress; 321 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 322 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 323 sc->sc_wr_addr = ed->bEndpointAddress; 324 } 325 } 326 if (sc->sc_rd_addr == -1 || sc->sc_wr_addr == -1) { 327 printf("%s: missing endpoint\n", USBDEVNAME(sc->sc_dev)); 328 USB_ATTACH_ERROR_RETURN; 329 } 330 331 /* Get the IrDA descriptor */ 332 err = usbd_get_desc(sc->sc_udev, UDESC_IRDA, 0, 333 USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc); 334 if (err) { 335 /* maybe it's embedded in the config desc */ 336 void *d = usb_find_desc(sc->sc_udev, UDESC_IRDA); 337 if (d == NULL) { 338 printf("%s: Cannot get IrDA descriptor\n", 339 USBDEVNAME(sc->sc_dev)); 340 USB_ATTACH_ERROR_RETURN; 341 } 342 memcpy(&sc->sc_irdadesc, d, USB_IRDA_DESCRIPTOR_SIZE); 343 } 344 345 346 DPRINTFN(10, ("uirda_attach: %p\n", sc->sc_udev)); 347 348 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, 349 USBDEV(sc->sc_dev)); 350 351 lockinit(&sc->sc_wr_buf_lk, PZERO, "iirwrl", 0, 0); 352 lockinit(&sc->sc_rd_buf_lk, PZERO, "uirrdl", 0, 0); 353 354 ia.ia_type = IR_TYPE_IRFRAME; 355 ia.ia_methods = &uirda_methods; 356 ia.ia_handle = sc; 357 358 sc->sc_child = config_found(self, &ia, ir_print); 359 360 USB_ATTACH_SUCCESS_RETURN; 361 } 362 363 USB_DETACH(uirda) 364 { 365 USB_DETACH_START(uirda, sc); 366 int s; 367 int rv = 0; 368 369 DPRINTF(("uirda_detach: sc=%p flags=%d\n", sc, flags)); 370 371 sc->sc_dying = 1; 372 /* Abort all pipes. Causes processes waiting for transfer to wake. */ 373 if (sc->sc_rd_pipe != NULL) { 374 usbd_abort_pipe(sc->sc_rd_pipe); 375 usbd_close_pipe(sc->sc_rd_pipe); 376 sc->sc_rd_pipe = NULL; 377 } 378 if (sc->sc_wr_pipe != NULL) { 379 usbd_abort_pipe(sc->sc_wr_pipe); 380 usbd_close_pipe(sc->sc_wr_pipe); 381 sc->sc_wr_pipe = NULL; 382 } 383 wakeup(&sc->sc_rd_count); 384 385 s = splusb(); 386 if (--sc->sc_refcnt >= 0) { 387 /* Wait for processes to go away. */ 388 usb_detach_wait(USBDEV(sc->sc_dev)); 389 } 390 splx(s); 391 392 if (sc->sc_child != NULL) { 393 rv = config_detach(sc->sc_child, flags); 394 sc->sc_child = NULL; 395 } 396 397 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 398 USBDEV(sc->sc_dev)); 399 400 return (rv); 401 } 402 403 int 404 uirda_activate(device_ptr_t self, enum devact act) 405 { 406 struct uirda_softc *sc = (struct uirda_softc *)self; 407 int error = 0; 408 409 switch (act) { 410 case DVACT_ACTIVATE: 411 return (EOPNOTSUPP); 412 break; 413 414 case DVACT_DEACTIVATE: 415 sc->sc_dying = 1; 416 if (sc->sc_child != NULL) 417 error = config_deactivate(sc->sc_child); 418 break; 419 } 420 return (error); 421 } 422 423 int 424 uirda_open(void *h, int flag, int mode, struct proc *p) 425 { 426 struct uirda_softc *sc = h; 427 int error; 428 usbd_status err; 429 430 DPRINTF(("%s: sc=%p\n", __FUNCTION__, sc)); 431 432 err = usbd_open_pipe(sc->sc_iface, sc->sc_rd_addr, 0, &sc->sc_rd_pipe); 433 if (err) { 434 error = EIO; 435 goto bad1; 436 } 437 err = usbd_open_pipe(sc->sc_iface, sc->sc_wr_addr, 0, &sc->sc_wr_pipe); 438 if (err) { 439 error = EIO; 440 goto bad2; 441 } 442 sc->sc_rd_xfer = usbd_alloc_xfer(sc->sc_udev); 443 if (sc->sc_rd_xfer == NULL) { 444 error = ENOMEM; 445 goto bad3; 446 } 447 sc->sc_wr_xfer = usbd_alloc_xfer(sc->sc_udev); 448 if (sc->sc_wr_xfer == NULL) { 449 error = ENOMEM; 450 goto bad4; 451 } 452 453 sc->sc_rd_count = 0; 454 sc->sc_params.speed = 0; 455 sc->sc_params.ebofs = 0; 456 sc->sc_params.maxsize = 0; 457 458 return (0); 459 460 bad4: 461 usbd_free_xfer(sc->sc_rd_xfer); 462 sc->sc_rd_xfer = NULL; 463 bad3: 464 usbd_close_pipe(sc->sc_wr_pipe); 465 sc->sc_wr_pipe = NULL; 466 bad2: 467 usbd_close_pipe(sc->sc_rd_pipe); 468 sc->sc_rd_pipe = NULL; 469 bad1: 470 return (error); 471 } 472 473 int 474 uirda_close(void *h, int flag, int mode, struct proc *p) 475 { 476 struct uirda_softc *sc = h; 477 478 DPRINTF(("%s: sc=%p\n", __FUNCTION__, sc)); 479 480 if (sc->sc_rd_pipe != NULL) { 481 usbd_abort_pipe(sc->sc_rd_pipe); 482 usbd_close_pipe(sc->sc_rd_pipe); 483 sc->sc_rd_pipe = NULL; 484 } 485 if (sc->sc_wr_pipe != NULL) { 486 usbd_abort_pipe(sc->sc_wr_pipe); 487 usbd_close_pipe(sc->sc_wr_pipe); 488 sc->sc_wr_pipe = NULL; 489 } 490 if (sc->sc_rd_xfer != NULL) { 491 usbd_free_xfer(sc->sc_rd_xfer); 492 sc->sc_rd_xfer = NULL; 493 sc->sc_rd_buf = NULL; 494 } 495 if (sc->sc_wr_xfer != NULL) { 496 usbd_free_xfer(sc->sc_wr_xfer); 497 sc->sc_wr_xfer = NULL; 498 sc->sc_wr_buf = NULL; 499 } 500 501 return (0); 502 } 503 504 int 505 uirda_read(void *h, struct uio *uio, int flag) 506 { 507 struct uirda_softc *sc = h; 508 usbd_status err; 509 int s; 510 int error; 511 u_int n; 512 513 DPRINTFN(1,("%s: sc=%p\n", __FUNCTION__, sc)); 514 515 if (sc->sc_dying) 516 return (EIO); 517 518 if (sc->sc_rd_buf == NULL) 519 return (EINVAL); 520 521 sc->sc_refcnt++; 522 523 do { 524 s = splusb(); 525 while (sc->sc_rd_count == 0) { 526 error = tsleep(&sc->sc_rd_count, PZERO | PCATCH, 527 "uirdrd", 0); 528 if (sc->sc_dying) 529 error = EIO; 530 if (error) { 531 splx(s); 532 DPRINTF(("uirda_read: tsleep() = %d\n", error)); 533 goto ret; 534 } 535 } 536 splx(s); 537 538 lockmgr(&sc->sc_rd_buf_lk, LK_EXCLUSIVE, NULL); 539 n = sc->sc_rd_count - 1; 540 DPRINTFN(1,("%s: sc=%p n=%u\n", __FUNCTION__, sc, n)); 541 if (n > uio->uio_resid) 542 error = EINVAL; 543 else 544 error = uiomove(sc->sc_rd_buf+1, n, uio); 545 sc->sc_rd_count = 0; 546 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 547 548 err = uirda_start_read(sc); 549 /* XXX check err */ 550 551 } while (n == 0); 552 553 DPRINTFN(1,("uirda_read: return %d\n", error)); 554 555 ret: 556 if (--sc->sc_refcnt < 0) 557 usb_detach_wakeup(USBDEV(sc->sc_dev)); 558 return (error); 559 } 560 561 int 562 uirda_write(void *h, struct uio *uio, int flag) 563 { 564 struct uirda_softc *sc = h; 565 usbd_status err; 566 u_int32_t n; 567 int error = 0; 568 569 DPRINTFN(1,("%s: sc=%p\n", __FUNCTION__, sc)); 570 571 if (sc->sc_dying) 572 return (EIO); 573 574 n = uio->uio_resid; 575 if (n > sc->sc_params.maxsize || sc->sc_wr_buf == NULL) 576 return (EINVAL); 577 578 sc->sc_refcnt++; 579 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 580 581 sc->sc_wr_buf[0] = UIRDA_EB_NO_CHANGE | UIRDA_NO_SPEED; 582 error = uiomove(sc->sc_wr_buf+1, n, uio); 583 if (!error) { 584 DPRINTFN(1, ("uirdawrite: transfer %d bytes\n", n)); 585 586 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 587 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 588 UIRDA_WR_TIMEOUT, 589 sc->sc_wr_buf, &n, "uirdawr"); 590 DPRINTFN(2, ("uirdawrite: err=%d\n", err)); 591 if (err) { 592 if (err == USBD_INTERRUPTED) 593 error = EINTR; 594 else if (err == USBD_TIMEOUT) 595 error = ETIMEDOUT; 596 else 597 error = EIO; 598 } 599 } 600 601 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 602 if (--sc->sc_refcnt < 0) 603 usb_detach_wakeup(USBDEV(sc->sc_dev)); 604 605 DPRINTF(("%s: sc=%p done\n", __FUNCTION__, sc)); 606 return (error); 607 } 608 609 int 610 uirda_poll(void *h, int events, struct proc *p) 611 { 612 struct uirda_softc *sc = h; 613 int revents = 0; 614 int s; 615 616 DPRINTFN(1,("%s: sc=%p\n", __FUNCTION__, sc)); 617 618 s = splusb(); 619 if (events & (POLLOUT | POLLWRNORM)) 620 revents |= events & (POLLOUT | POLLWRNORM); 621 if (events & (POLLIN | POLLRDNORM)) { 622 if (sc->sc_rd_count != 0) { 623 DPRINTF(("%s: have data\n", __FUNCTION__)); 624 revents |= events & (POLLIN | POLLRDNORM); 625 } else { 626 DPRINTF(("%s: recording select\n", __FUNCTION__)); 627 selrecord(p, &sc->sc_rd_sel); 628 } 629 } 630 splx(s); 631 632 return (revents); 633 } 634 635 int 636 uirda_set_params(void *h, struct irda_params *p) 637 { 638 struct uirda_softc *sc = h; 639 usbd_status err; 640 int i; 641 u_int8_t hdr; 642 u_int32_t n; 643 u_int mask; 644 645 DPRINTF(("%s: sc=%p, speed=%d ebofs=%d maxsize=%d\n", __FUNCTION__, 646 sc, p->speed, p->ebofs, p->maxsize)); 647 648 if (sc->sc_dying) 649 return (EIO); 650 651 hdr = 0; 652 if (p->ebofs != sc->sc_params.ebofs) { 653 /* round up ebofs */ 654 mask = sc->sc_irdadesc.bmAdditionalBOFs; 655 for (i = 0; i < UIRDA_NEBOFS; i++) { 656 if ((mask & uirda_ebofs[i].mask) && 657 uirda_ebofs[i].count >= p->ebofs) { 658 hdr = uirda_ebofs[i].header; 659 goto found1; 660 } 661 } 662 /* no good value found */ 663 return (EINVAL); 664 found1: 665 ; 666 667 } 668 if (p->speed != sc->sc_params.speed) { 669 /* find speed */ 670 mask = UGETW(sc->sc_irdadesc.wBaudRate); 671 for (i = 0; i < UIRDA_NSPEEDS; i++) { 672 if ((mask & uirda_speeds[i].mask) && 673 uirda_speeds[i].speed == p->speed) { 674 hdr |= uirda_speeds[i].header; 675 goto found2; 676 } 677 } 678 /* no good value found */ 679 return (EINVAL); 680 found2: 681 ; 682 } 683 if (p->maxsize != sc->sc_params.maxsize) { 684 DPRINTF(("%s: new buffers, old size=%d\n", __FUNCTION__, 685 sc->sc_params.maxsize)); 686 if (p->maxsize > 10000 || p < 0) /* XXX */ 687 return (EINVAL); 688 689 /* Change the write buffer */ 690 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 691 if (sc->sc_wr_buf != NULL) 692 usbd_free_buffer(sc->sc_wr_xfer); 693 sc->sc_wr_buf = usbd_alloc_buffer(sc->sc_wr_xfer, p->maxsize+1); 694 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 695 if (sc->sc_wr_buf == NULL) 696 return (ENOMEM); 697 698 /* Change the read buffer */ 699 lockmgr(&sc->sc_rd_buf_lk, LK_EXCLUSIVE, NULL); 700 usbd_abort_pipe(sc->sc_rd_pipe); 701 if (sc->sc_rd_buf != NULL) 702 usbd_free_buffer(sc->sc_rd_xfer); 703 sc->sc_rd_buf = usbd_alloc_buffer(sc->sc_rd_xfer, p->maxsize+1); 704 sc->sc_rd_count = 0; 705 if (sc->sc_rd_buf == NULL) { 706 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 707 return (ENOMEM); 708 } 709 err = uirda_start_read(sc); /* XXX check */ 710 lockmgr(&sc->sc_rd_buf_lk, LK_RELEASE, NULL); 711 } 712 if (hdr != 0) { 713 /* 714 * A change has occurred, transmit a 0 length frame with 715 * the new settings. The 0 length frame is not sent to the 716 * device. 717 */ 718 DPRINTFN(1,("%s: sc=%p setting speed\n", __FUNCTION__, sc)); 719 lockmgr(&sc->sc_wr_buf_lk, LK_EXCLUSIVE, NULL); 720 sc->sc_wr_buf[0] = hdr; 721 n = 1; 722 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 723 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 724 UIRDA_WR_TIMEOUT, sc->sc_wr_buf, &n, "uirdast"); 725 lockmgr(&sc->sc_wr_buf_lk, LK_RELEASE, NULL); 726 if (err) { 727 printf("%s: set failed, err=%d\n", 728 USBDEVNAME(sc->sc_dev), err); 729 usbd_clear_endpoint_stall(sc->sc_wr_pipe); 730 } 731 } 732 733 sc->sc_params = *p; 734 735 return (0); 736 } 737 738 int 739 uirda_get_speeds(void *h, int *speeds) 740 { 741 struct uirda_softc *sc = h; 742 u_int isp; 743 u_int usp; 744 745 DPRINTF(("%s: sc=%p\n", __FUNCTION__, sc)); 746 747 if (sc->sc_dying) 748 return (EIO); 749 750 usp = UGETW(sc->sc_irdadesc.wBaudRate); 751 isp = 0; 752 if (usp & UI_BR_4000000) isp |= IRDA_SPEED_4000000; 753 if (usp & UI_BR_1152000) isp |= IRDA_SPEED_1152000; 754 if (usp & UI_BR_576000) isp |= IRDA_SPEED_576000; 755 if (usp & UI_BR_115200) isp |= IRDA_SPEED_115200; 756 if (usp & UI_BR_57600) isp |= IRDA_SPEED_57600; 757 if (usp & UI_BR_38400) isp |= IRDA_SPEED_38400; 758 if (usp & UI_BR_19200) isp |= IRDA_SPEED_19200; 759 if (usp & UI_BR_9600) isp |= IRDA_SPEED_9600; 760 if (usp & UI_BR_2400) isp |= IRDA_SPEED_2400; 761 *speeds = isp; 762 return (0); 763 } 764 765 int 766 uirda_get_turnarounds(void *h, int *turnarounds) 767 { 768 struct uirda_softc *sc = h; 769 u_int ita; 770 u_int uta; 771 772 DPRINTF(("%s: sc=%p\n", __FUNCTION__, sc)); 773 774 if (sc->sc_dying) 775 return (EIO); 776 777 uta = sc->sc_irdadesc.bmMinTurnaroundTime; 778 ita = 0; 779 if (uta & UI_TA_0) ita |= IRDA_TURNT_0; 780 if (uta & UI_TA_10) ita |= IRDA_TURNT_10; 781 if (uta & UI_TA_50) ita |= IRDA_TURNT_50; 782 if (uta & UI_TA_100) ita |= IRDA_TURNT_100; 783 if (uta & UI_TA_500) ita |= IRDA_TURNT_500; 784 if (uta & UI_TA_1000) ita |= IRDA_TURNT_1000; 785 if (uta & UI_TA_5000) ita |= IRDA_TURNT_5000; 786 if (uta & UI_TA_10000) ita |= IRDA_TURNT_10000; 787 *turnarounds = ita; 788 return (0); 789 } 790 791 void 792 uirda_rd_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 793 usbd_status status) 794 { 795 struct uirda_softc *sc = priv; 796 u_int32_t size; 797 798 DPRINTFN(1,("%s: sc=%p\n", __FUNCTION__, sc)); 799 800 if (status == USBD_CANCELLED) /* this is normal */ 801 return; 802 if (status) { 803 /* what can we do? */ 804 } 805 806 usbd_get_xfer_status(xfer, NULL, NULL, &size, NULL); 807 DPRINTFN(1,("%s: sc=%p size=%u\n", __FUNCTION__, sc, size)); 808 sc->sc_rd_count = size; 809 wakeup(&sc->sc_rd_count); /* XXX should use flag */ 810 selwakeup(&sc->sc_rd_sel); 811 } 812 813 usbd_status 814 uirda_start_read(struct uirda_softc *sc) 815 { 816 usbd_status err; 817 818 DPRINTFN(1,("%s: sc=%p\n", __FUNCTION__, sc)); 819 820 if (sc->sc_dying) 821 return (USBD_IOERROR); 822 823 usbd_setup_xfer(sc->sc_rd_xfer, sc->sc_rd_pipe, sc, sc->sc_rd_buf, 824 sc->sc_params.maxsize+1, 825 USBD_SHORT_XFER_OK | USBD_NO_COPY, 826 USBD_NO_TIMEOUT, uirda_rd_cb); 827 err = usbd_transfer(sc->sc_rd_xfer); 828 if (err != USBD_IN_PROGRESS) 829 return (err); 830 return (USBD_NORMAL_COMPLETION); 831 } 832 833 834 835 836 usb_descriptor_t * 837 usb_find_desc(usbd_device_handle dev, int type) 838 { 839 usb_descriptor_t *desc; 840 usb_config_descriptor_t *cd = usbd_get_config_descriptor(dev); 841 uByte *p = (uByte *)cd; 842 uByte *end = p + UGETW(cd->wTotalLength); 843 844 while (p < end) { 845 desc = (usb_descriptor_t *)p; 846 if (desc->bDescriptorType == type) 847 return (desc); 848 p += desc->bLength; 849 } 850 851 return (NULL); 852 } 853
Indexes created Wed Oct 15 16:09:53 GMT 2025