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