1/* $NetBSD: uirda.c,v 1.35 2011/12/22 20:07:01 jakllsch 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@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 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32#include <sys/cdefs.h> 33__KERNEL_RCSID(0, "$NetBSD: uirda.c,v 1.35 2011/12/22 20:07:01 jakllsch Exp $"); 34 35#include <sys/param.h> 36#include <sys/systm.h> 37#include <sys/kernel.h> 38#include <sys/device.h> 39#include <sys/mutex.h> 40#include <sys/ioctl.h> 41#include <sys/conf.h> 42#include <sys/file.h> 43#include <sys/poll.h> 44#include <sys/select.h> 45#include <sys/proc.h> 46 47#include <dev/usb/usb.h> 48#include <dev/usb/usbdi.h> 49#include <dev/usb/usbdi_util.h> 50#include <dev/usb/usbdevs.h> 51 52#include <dev/ir/ir.h> 53#include <dev/ir/irdaio.h> 54#include <dev/ir/irframevar.h> 55 56#include <dev/usb/uirdavar.h> 57 58#ifdef UIRDA_DEBUG 59#define DPRINTF(x) if (uirdadebug) printf x 60#define DPRINTFN(n,x) if (uirdadebug>(n)) printf x 61int uirdadebug = 0; 62#else 63#define DPRINTF(x) 64#define DPRINTFN(n,x) 65#endif 66 67 68/* Class specific requests */ 69#define UR_IRDA_RECEIVING 0x01 /* Receive in progress? */ 70#define UR_IRDA_CHECK_MEDIA_BUSY 0x03 71#define UR_IRDA_SET_RATE_SNIFF 0x04 /* opt */ 72#define UR_IRDA_SET_UNICAST_LIST 0x05 /* opt */ 73#define UR_IRDA_GET_DESC 0x06 74 75#define UIRDA_NEBOFS 8 76static struct { 77 int count; 78 int mask; 79 int header; 80} uirda_ebofs[UIRDA_NEBOFS] = { 81 { 0, UI_EB_0, UIRDA_EB_0 }, 82 { 1, UI_EB_1, UIRDA_EB_1 }, 83 { 2, UI_EB_2, UIRDA_EB_2 }, 84 { 3, UI_EB_3, UIRDA_EB_3 }, 85 { 6, UI_EB_6, UIRDA_EB_6 }, 86 { 12, UI_EB_12, UIRDA_EB_12 }, 87 { 24, UI_EB_24, UIRDA_EB_24 }, 88 { 48, UI_EB_48, UIRDA_EB_48 } 89}; 90 91#define UIRDA_NSPEEDS 9 92static struct { 93 int speed; 94 int mask; 95 int header; 96} uirda_speeds[UIRDA_NSPEEDS] = { 97 { 4000000, UI_BR_4000000, UIRDA_4000000 }, 98 { 1152000, UI_BR_1152000, UIRDA_1152000 }, 99 { 576000, UI_BR_576000, UIRDA_576000 }, 100 { 115200, UI_BR_115200, UIRDA_115200 }, 101 { 57600, UI_BR_57600, UIRDA_57600 }, 102 { 38400, UI_BR_38400, UIRDA_38400 }, 103 { 19200, UI_BR_19200, UIRDA_19200 }, 104 { 9600, UI_BR_9600, UIRDA_9600 }, 105 { 2400, UI_BR_2400, UIRDA_2400 }, 106}; 107 108 109 110int uirda_open(void *h, int flag, int mode, struct lwp *l); 111int uirda_close(void *h, int flag, int mode, struct lwp *l); 112int uirda_read(void *h, struct uio *uio, int flag); 113int uirda_write(void *h, struct uio *uio, int flag); 114int uirda_set_params(void *h, struct irda_params *params); 115int uirda_get_speeds(void *h, int *speeds); 116int uirda_get_turnarounds(void *h, int *times); 117int uirda_poll(void *h, int events, struct lwp *l); 118int uirda_kqfilter(void *h, struct knote *kn); 119 120struct irframe_methods uirda_methods = { 121 uirda_open, uirda_close, uirda_read, uirda_write, uirda_poll, 122 uirda_kqfilter, uirda_set_params, uirda_get_speeds, 123 uirda_get_turnarounds 124}; 125 126void uirda_rd_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 127 usbd_status status); 128usbd_status uirda_start_read(struct uirda_softc *sc); 129 130/* 131 * These devices don't quite follow the spec. Speed changing is broken 132 * and they don't handle windows. 133 * But we change speed in a safe way, and don't use windows now. 134 * Some devices also seem to have an interrupt pipe that can be ignored. 135 * 136 * Table information taken from Linux driver. 137 */ 138Static const struct usb_devno uirda_devs[] = { 139 { USB_VENDOR_ACTISYS, USB_PRODUCT_ACTISYS_IR2000U }, 140 { USB_VENDOR_EXTENDED, USB_PRODUCT_EXTENDED_XTNDACCESS }, 141 { USB_VENDOR_KAWATSU, USB_PRODUCT_KAWATSU_KC180 }, 142}; 143#define uirda_lookup(v, p) (usb_lookup(uirda_devs, v, p)) 144 145int uirda_match(device_t, cfdata_t, void *); 146void uirda_attach(device_t, device_t, void *); 147void uirda_childdet(device_t, device_t); 148int uirda_detach(device_t, int); 149int uirda_activate(device_t, enum devact); 150extern struct cfdriver uirda_cd; 151CFATTACH_DECL2_NEW(uirda, sizeof(struct uirda_softc), uirda_match, 152 uirda_attach, uirda_detach, uirda_activate, NULL, uirda_childdet); 153 154int 155uirda_match(device_t parent, cfdata_t match, void *aux) 156{ 157 struct usbif_attach_arg *uaa = aux; 158 159 DPRINTFN(50,("uirda_match\n")); 160 161 if (uirda_lookup(uaa->vendor, uaa->product) != NULL) 162 return (UMATCH_VENDOR_PRODUCT); 163 164 if (uaa->class == UICLASS_APPL_SPEC && 165 uaa->subclass == UISUBCLASS_IRDA && 166 uaa->proto == UIPROTO_IRDA) 167 return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO); 168 return (UMATCH_NONE); 169} 170 171void 172uirda_attach(device_t parent, device_t self, void *aux) 173{ 174 struct uirda_softc *sc = device_private(self); 175 struct usbif_attach_arg *uaa = aux; 176 usbd_device_handle dev = uaa->device; 177 usbd_interface_handle iface = uaa->iface; 178 char *devinfop; 179 usb_endpoint_descriptor_t *ed; 180 usbd_status err; 181 u_int8_t epcount; 182 u_int specrev; 183 int i; 184 struct ir_attach_args ia; 185 186 DPRINTFN(10,("uirda_attach: sc=%p\n", sc)); 187 188 sc->sc_dev = self; 189 190 aprint_naive("\n"); 191 aprint_normal("\n"); 192 193 devinfop = usbd_devinfo_alloc(dev, 0); 194 aprint_normal_dev(self, "%s\n", devinfop); 195 usbd_devinfo_free(devinfop); 196 197 sc->sc_udev = dev; 198 sc->sc_iface = iface; 199 200 if (sc->sc_hdszi == 0) 201 sc->sc_hdszi = UIRDA_INPUT_HEADER_SIZE; 202 203 epcount = 0; 204 (void)usbd_endpoint_count(iface, &epcount); 205 206 sc->sc_rd_addr = -1; 207 sc->sc_wr_addr = -1; 208 for (i = 0; i < epcount; i++) { 209 ed = usbd_interface2endpoint_descriptor(iface, i); 210 if (ed == NULL) { 211 aprint_error_dev(self, "couldn't get ep %d\n", i); 212 return; 213 } 214 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 215 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 216 sc->sc_rd_addr = ed->bEndpointAddress; 217 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 218 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 219 sc->sc_wr_addr = ed->bEndpointAddress; 220 } 221 } 222 if (sc->sc_rd_addr == -1 || sc->sc_wr_addr == -1) { 223 aprint_error_dev(self, "missing endpoint\n"); 224 return; 225 } 226 227 if (sc->sc_loadfw(sc) != 0) { 228 return; 229 } 230 231 /* Get the IrDA descriptor */ 232 err = usbd_get_class_desc(sc->sc_udev, UDESC_IRDA, 0, 233 USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc); 234 aprint_error_dev(self, "error %d reading class desc\n", err); 235 if (err) { 236 err = usbd_get_desc(sc->sc_udev, UDESC_IRDA, 0, 237 USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc); 238 } 239 aprint_error_dev(self, "error %d reading desc\n", err); 240 if (err) { 241 /* maybe it's embedded in the config desc? */ 242 usbd_desc_iter_t iter; 243 const usb_descriptor_t *d; 244 usb_desc_iter_init(sc->sc_udev, &iter); 245 for (;;) { 246 d = usb_desc_iter_next(&iter); 247 if (!d || d->bDescriptorType == UDESC_IRDA) 248 break; 249 } 250 if (d == NULL) { 251 aprint_error_dev(self, 252 "Cannot get IrDA descriptor\n"); 253 return; 254 } 255 memcpy(&sc->sc_irdadesc, d, USB_IRDA_DESCRIPTOR_SIZE); 256 } 257 DPRINTF(("uirda_attach: bDescriptorSize %d bDescriptorType 0x%x " 258 "bmDataSize=0x%02x bmWindowSize=0x%02x " 259 "bmMinTurnaroundTime=0x%02x wBaudRate=0x%04x " 260 "bmAdditionalBOFs=0x%02x bIrdaSniff=%d bMaxUnicastList=%d\n", 261 sc->sc_irdadesc.bLength, 262 sc->sc_irdadesc.bDescriptorType, 263 sc->sc_irdadesc.bmDataSize, 264 sc->sc_irdadesc.bmWindowSize, 265 sc->sc_irdadesc.bmMinTurnaroundTime, 266 UGETW(sc->sc_irdadesc.wBaudRate), 267 sc->sc_irdadesc.bmAdditionalBOFs, 268 sc->sc_irdadesc.bIrdaSniff, 269 sc->sc_irdadesc.bMaxUnicastList)); 270 271 specrev = UGETW(sc->sc_irdadesc.bcdSpecRevision); 272 aprint_normal_dev(self, "USB-IrDA protocol version %x.%02x\n", 273 specrev >> 8, specrev & 0xff); 274 275 DPRINTFN(10, ("uirda_attach: %p\n", sc->sc_udev)); 276 277 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, 278 sc->sc_dev); 279 280 mutex_init(&sc->sc_wr_buf_lk, MUTEX_DEFAULT, IPL_NONE); 281 mutex_init(&sc->sc_rd_buf_lk, MUTEX_DEFAULT, IPL_NONE); 282 selinit(&sc->sc_rd_sel); 283 selinit(&sc->sc_wr_sel); 284 285 ia.ia_type = IR_TYPE_IRFRAME; 286 ia.ia_methods = sc->sc_irm ? sc->sc_irm : &uirda_methods; 287 ia.ia_handle = sc; 288 289 sc->sc_child = config_found(self, &ia, ir_print); 290 291 return; 292} 293 294int 295uirda_detach(device_t self, int flags) 296{ 297 struct uirda_softc *sc = device_private(self); 298 int s; 299 int rv = 0; 300 301 DPRINTF(("uirda_detach: sc=%p flags=%d\n", sc, flags)); 302 303 sc->sc_dying = 1; 304 /* Abort all pipes. Causes processes waiting for transfer to wake. */ 305 if (sc->sc_rd_pipe != NULL) { 306 usbd_abort_pipe(sc->sc_rd_pipe); 307 usbd_close_pipe(sc->sc_rd_pipe); 308 sc->sc_rd_pipe = NULL; 309 } 310 if (sc->sc_wr_pipe != NULL) { 311 usbd_abort_pipe(sc->sc_wr_pipe); 312 usbd_close_pipe(sc->sc_wr_pipe); 313 sc->sc_wr_pipe = NULL; 314 } 315 wakeup(&sc->sc_rd_count); 316 317 s = splusb(); 318 if (--sc->sc_refcnt >= 0) { 319 /* Wait for processes to go away. */ 320 usb_detach_wait(sc->sc_dev); 321 } 322 splx(s); 323 324 if (sc->sc_child != NULL) 325 rv = config_detach(sc->sc_child, flags); 326 327 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 328 sc->sc_dev); 329 330 mutex_destroy(&sc->sc_wr_buf_lk); 331 mutex_destroy(&sc->sc_rd_buf_lk); 332 seldestroy(&sc->sc_rd_sel); 333 seldestroy(&sc->sc_wr_sel); 334 335 return (rv); 336} 337 338void 339uirda_childdet(device_t self, device_t child) 340{ 341 struct uirda_softc *sc = device_private(self); 342 343 KASSERT(sc->sc_child == child); 344 sc->sc_child = NULL; 345} 346 347int 348uirda_activate(device_t self, enum devact act) 349{ 350 struct uirda_softc *sc = device_private(self); 351 352 switch (act) { 353 case DVACT_DEACTIVATE: 354 sc->sc_dying = 1; 355 return 0; 356 default: 357 return EOPNOTSUPP; 358 } 359} 360 361int 362uirda_open(void *h, int flag, int mode, 363 struct lwp *l) 364{ 365 struct uirda_softc *sc = h; 366 int error; 367 usbd_status err; 368 369 DPRINTF(("%s: sc=%p\n", __func__, sc)); 370 371 err = usbd_open_pipe(sc->sc_iface, sc->sc_rd_addr, 0, &sc->sc_rd_pipe); 372 if (err) { 373 error = EIO; 374 goto bad1; 375 } 376 err = usbd_open_pipe(sc->sc_iface, sc->sc_wr_addr, 0, &sc->sc_wr_pipe); 377 if (err) { 378 error = EIO; 379 goto bad2; 380 } 381 sc->sc_rd_xfer = usbd_alloc_xfer(sc->sc_udev); 382 if (sc->sc_rd_xfer == NULL) { 383 error = ENOMEM; 384 goto bad3; 385 } 386 sc->sc_wr_xfer = usbd_alloc_xfer(sc->sc_udev); 387 if (sc->sc_wr_xfer == NULL) { 388 error = ENOMEM; 389 goto bad4; 390 } 391 sc->sc_rd_buf = usbd_alloc_buffer(sc->sc_rd_xfer, 392 IRDA_MAX_FRAME_SIZE + sc->sc_hdszi); 393 if (sc->sc_rd_buf == NULL) { 394 error = ENOMEM; 395 goto bad5; 396 } 397 sc->sc_wr_buf = usbd_alloc_buffer(sc->sc_wr_xfer, 398 IRDA_MAX_FRAME_SIZE + UIRDA_OUTPUT_HEADER_SIZE + 399 2 + 1 /* worst case ST-UIRDA */); 400 if (sc->sc_wr_buf == NULL) { 401 error = ENOMEM; 402 goto bad5; 403 } 404 sc->sc_rd_count = 0; 405 sc->sc_rd_err = 0; 406 sc->sc_params.speed = 0; 407 sc->sc_params.ebofs = 0; 408 sc->sc_params.maxsize = IRDA_MAX_FRAME_SIZE; 409 sc->sc_wr_hdr = -1; 410 411 err = uirda_start_read(sc); 412 /* XXX check err */ 413 414 return (0); 415 416bad5: 417 usbd_free_xfer(sc->sc_wr_xfer); 418 sc->sc_wr_xfer = NULL; 419bad4: 420 usbd_free_xfer(sc->sc_rd_xfer); 421 sc->sc_rd_xfer = NULL; 422bad3: 423 usbd_close_pipe(sc->sc_wr_pipe); 424 sc->sc_wr_pipe = NULL; 425bad2: 426 usbd_close_pipe(sc->sc_rd_pipe); 427 sc->sc_rd_pipe = NULL; 428bad1: 429 return (error); 430} 431 432int 433uirda_close(void *h, int flag, int mode, 434 struct lwp *l) 435{ 436 struct uirda_softc *sc = h; 437 438 DPRINTF(("%s: sc=%p\n", __func__, sc)); 439 440 if (sc->sc_rd_pipe != NULL) { 441 usbd_abort_pipe(sc->sc_rd_pipe); 442 usbd_close_pipe(sc->sc_rd_pipe); 443 sc->sc_rd_pipe = NULL; 444 } 445 if (sc->sc_wr_pipe != NULL) { 446 usbd_abort_pipe(sc->sc_wr_pipe); 447 usbd_close_pipe(sc->sc_wr_pipe); 448 sc->sc_wr_pipe = NULL; 449 } 450 if (sc->sc_rd_xfer != NULL) { 451 usbd_free_xfer(sc->sc_rd_xfer); 452 sc->sc_rd_xfer = NULL; 453 sc->sc_rd_buf = NULL; 454 } 455 if (sc->sc_wr_xfer != NULL) { 456 usbd_free_xfer(sc->sc_wr_xfer); 457 sc->sc_wr_xfer = NULL; 458 sc->sc_wr_buf = NULL; 459 } 460 461 return (0); 462} 463 464int 465uirda_read(void *h, struct uio *uio, int flag) 466{ 467 struct uirda_softc *sc = h; 468 usbd_status err; 469 int s; 470 int error; 471 u_int n; 472 473 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 474 475 if (sc->sc_dying) 476 return (EIO); 477 478#ifdef DIAGNOSTIC 479 if (sc->sc_rd_buf == NULL) 480 return (EINVAL); 481#endif 482 483 sc->sc_refcnt++; 484 485 do { 486 s = splusb(); 487 while (sc->sc_rd_count == 0) { 488 DPRINTFN(5,("uirda_read: calling tsleep()\n")); 489 error = tsleep(&sc->sc_rd_count, PZERO | PCATCH, 490 "uirdrd", 0); 491 if (sc->sc_dying) 492 error = EIO; 493 if (error) { 494 splx(s); 495 DPRINTF(("uirda_read: tsleep() = %d\n", error)); 496 goto ret; 497 } 498 } 499 splx(s); 500 501 mutex_enter(&sc->sc_rd_buf_lk); 502 n = sc->sc_rd_count - sc->sc_hdszi; 503 DPRINTFN(1,("%s: sc=%p n=%u, hdr=0x%02x\n", __func__, 504 sc, n, sc->sc_rd_buf[0])); 505 if (n > uio->uio_resid) 506 error = EINVAL; 507 else 508 error = uiomove(sc->sc_rd_buf + sc->sc_hdszi, n, uio); 509 sc->sc_rd_count = 0; 510 mutex_exit(&sc->sc_rd_buf_lk); 511 512 err = uirda_start_read(sc); 513 /* XXX check err */ 514 515 } while (n == 0); 516 517 DPRINTFN(1,("uirda_read: return %d\n", error)); 518 519 ret: 520 if (--sc->sc_refcnt < 0) 521 usb_detach_wakeup(sc->sc_dev); 522 return (error); 523} 524 525int 526uirda_write(void *h, struct uio *uio, int flag) 527{ 528 struct uirda_softc *sc = h; 529 usbd_status err; 530 u_int32_t n; 531 int error = 0; 532 533 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 534 535 if (sc->sc_dying) 536 return (EIO); 537 538#ifdef DIAGNOSTIC 539 if (sc->sc_wr_buf == NULL) 540 return (EINVAL); 541#endif 542 543 n = uio->uio_resid; 544 if (n > sc->sc_params.maxsize) 545 return (EINVAL); 546 547 sc->sc_refcnt++; 548 mutex_enter(&sc->sc_wr_buf_lk); 549 550 sc->sc_wr_buf[0] = UIRDA_EB_NO_CHANGE | UIRDA_NO_SPEED; 551 error = uiomove(sc->sc_wr_buf + UIRDA_OUTPUT_HEADER_SIZE, n, uio); 552 if (!error) { 553 DPRINTFN(1, ("uirdawrite: transfer %d bytes\n", n)); 554 555 n += UIRDA_OUTPUT_HEADER_SIZE; 556 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 557 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 558 UIRDA_WR_TIMEOUT, 559 sc->sc_wr_buf, &n, "uirdawr"); 560 DPRINTFN(2, ("uirdawrite: err=%d\n", err)); 561 if (err) { 562 if (err == USBD_INTERRUPTED) 563 error = EINTR; 564 else if (err == USBD_TIMEOUT) 565 error = ETIMEDOUT; 566 else 567 error = EIO; 568 } 569 } 570 571 mutex_exit(&sc->sc_wr_buf_lk); 572 if (--sc->sc_refcnt < 0) 573 usb_detach_wakeup(sc->sc_dev); 574 575 DPRINTFN(1,("%s: sc=%p done\n", __func__, sc)); 576 return (error); 577} 578 579int 580uirda_poll(void *h, int events, struct lwp *l) 581{ 582 struct uirda_softc *sc = h; 583 int revents = 0; 584 int s; 585 586 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 587 588 s = splusb(); 589 if (events & (POLLOUT | POLLWRNORM)) 590 revents |= events & (POLLOUT | POLLWRNORM); 591 if (events & (POLLIN | POLLRDNORM)) { 592 if (sc->sc_rd_count != 0) { 593 DPRINTFN(2,("%s: have data\n", __func__)); 594 revents |= events & (POLLIN | POLLRDNORM); 595 } else { 596 DPRINTFN(2,("%s: recording select\n", __func__)); 597 selrecord(l, &sc->sc_rd_sel); 598 } 599 } 600 splx(s); 601 602 return (revents); 603} 604 605static void 606filt_uirdardetach(struct knote *kn) 607{ 608 struct uirda_softc *sc = kn->kn_hook; 609 int s; 610 611 s = splusb(); 612 SLIST_REMOVE(&sc->sc_rd_sel.sel_klist, kn, knote, kn_selnext); 613 splx(s); 614} 615 616static int 617filt_uirdaread(struct knote *kn, long hint) 618{ 619 struct uirda_softc *sc = kn->kn_hook; 620 621 kn->kn_data = sc->sc_rd_count; 622 return (kn->kn_data > 0); 623} 624 625static void 626filt_uirdawdetach(struct knote *kn) 627{ 628 struct uirda_softc *sc = kn->kn_hook; 629 int s; 630 631 s = splusb(); 632 SLIST_REMOVE(&sc->sc_wr_sel.sel_klist, kn, knote, kn_selnext); 633 splx(s); 634} 635 636static const struct filterops uirdaread_filtops = 637 { 1, NULL, filt_uirdardetach, filt_uirdaread }; 638static const struct filterops uirdawrite_filtops = 639 { 1, NULL, filt_uirdawdetach, filt_seltrue }; 640 641int 642uirda_kqfilter(void *h, struct knote *kn) 643{ 644 struct uirda_softc *sc = kn->kn_hook; 645 struct klist *klist; 646 int s; 647 648 switch (kn->kn_filter) { 649 case EVFILT_READ: 650 klist = &sc->sc_rd_sel.sel_klist; 651 kn->kn_fop = &uirdaread_filtops; 652 break; 653 case EVFILT_WRITE: 654 klist = &sc->sc_wr_sel.sel_klist; 655 kn->kn_fop = &uirdawrite_filtops; 656 break; 657 default: 658 return (EINVAL); 659 } 660 661 kn->kn_hook = sc; 662 663 s = splusb(); 664 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 665 splx(s); 666 667 return (0); 668} 669 670int 671uirda_set_params(void *h, struct irda_params *p) 672{ 673 struct uirda_softc *sc = h; 674 usbd_status err; 675 int i; 676 u_int8_t hdr; 677 u_int32_t n; 678 u_int mask; 679 680 DPRINTF(("%s: sc=%p, speed=%d ebofs=%d maxsize=%d\n", __func__, 681 sc, p->speed, p->ebofs, p->maxsize)); 682 683 if (sc->sc_dying) 684 return (EIO); 685 686 hdr = 0; 687 if (p->ebofs != sc->sc_params.ebofs) { 688 /* round up ebofs */ 689 mask = 1 /* sc->sc_irdadesc.bmAdditionalBOFs*/; 690 DPRINTF(("u.s.p.: mask=0x%x, sc->ebofs=%d, p->ebofs=%d\n", 691 mask, sc->sc_params.ebofs, p->ebofs)); 692 for (i = 0; i < UIRDA_NEBOFS; i++) { 693 DPRINTF(("u.s.p.: u_e[%d].mask=0x%x, count=%d\n", 694 i, uirda_ebofs[i].mask, uirda_ebofs[i].count)); 695 if ((mask & uirda_ebofs[i].mask) && 696 uirda_ebofs[i].count >= p->ebofs) { 697 hdr = uirda_ebofs[i].header; 698 goto found1; 699 } 700 } 701 for (i = 0; i < UIRDA_NEBOFS; i++) { 702 DPRINTF(("u.s.p.: u_e[%d].mask=0x%x, count=%d\n", 703 i, uirda_ebofs[i].mask, uirda_ebofs[i].count)); 704 if ((mask & uirda_ebofs[i].mask)) { 705 hdr = uirda_ebofs[i].header; 706 goto found1; 707 } 708 } 709 /* no good value found */ 710 return (EINVAL); 711 found1: 712 DPRINTF(("uirda_set_params: ebofs hdr=0x%02x\n", hdr)); 713 ; 714 715 } 716 if (hdr != 0 || p->speed != sc->sc_params.speed) { 717 /* find speed */ 718 mask = UGETW(sc->sc_irdadesc.wBaudRate); 719 for (i = 0; i < UIRDA_NSPEEDS; i++) { 720 if ((mask & uirda_speeds[i].mask) && 721 uirda_speeds[i].speed == p->speed) { 722 hdr |= uirda_speeds[i].header; 723 goto found2; 724 } 725 } 726 /* no good value found */ 727 return (EINVAL); 728 found2: 729 DPRINTF(("uirda_set_params: speed hdr=0x%02x\n", hdr)); 730 ; 731 } 732 if (p->maxsize != sc->sc_params.maxsize) { 733 if (p->maxsize > IRDA_MAX_FRAME_SIZE) 734 return (EINVAL); 735 sc->sc_params.maxsize = p->maxsize; 736#if 0 737 DPRINTF(("%s: new buffers, old size=%d\n", __func__, 738 sc->sc_params.maxsize)); 739 if (p->maxsize > 10000 || p < 0) /* XXX */ 740 return (EINVAL); 741 742 /* Change the write buffer */ 743 mutex_enter(&sc->sc_wr_buf_lk); 744 if (sc->sc_wr_buf != NULL) 745 usbd_free_buffer(sc->sc_wr_xfer); 746 sc->sc_wr_buf = usbd_alloc_buffer(sc->sc_wr_xfer, p->maxsize+1); 747 mutex_exit(&sc->sc_wr_buf_lk); 748 if (sc->sc_wr_buf == NULL) 749 return (ENOMEM); 750 751 /* Change the read buffer */ 752 mutex_enter(&sc->sc_rd_buf_lk); 753 usbd_abort_pipe(sc->sc_rd_pipe); 754 if (sc->sc_rd_buf != NULL) 755 usbd_free_buffer(sc->sc_rd_xfer); 756 sc->sc_rd_buf = usbd_alloc_buffer(sc->sc_rd_xfer, p->maxsize+1); 757 sc->sc_rd_count = 0; 758 if (sc->sc_rd_buf == NULL) { 759 mutex_exit(&sc->sc_rd_buf_lk); 760 return (ENOMEM); 761 } 762 sc->sc_params.maxsize = p->maxsize; 763 err = uirda_start_read(sc); /* XXX check */ 764 mutex_exit(&sc->sc_rd_buf_lk); 765#endif 766 } 767 if (hdr != 0 && hdr != sc->sc_wr_hdr) { 768 /* 769 * A change has occurred, transmit a 0 length frame with 770 * the new settings. The 0 length frame is not sent to the 771 * device. 772 */ 773 DPRINTF(("%s: sc=%p setting header 0x%02x\n", 774 __func__, sc, hdr)); 775 sc->sc_wr_hdr = hdr; 776 mutex_enter(&sc->sc_wr_buf_lk); 777 sc->sc_wr_buf[0] = hdr; 778 n = UIRDA_OUTPUT_HEADER_SIZE; 779 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe, 780 USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 781 UIRDA_WR_TIMEOUT, sc->sc_wr_buf, &n, "uirdast"); 782 if (err) { 783 aprint_error_dev(sc->sc_dev, "set failed, err=%d\n", 784 err); 785 usbd_clear_endpoint_stall(sc->sc_wr_pipe); 786 } 787 mutex_exit(&sc->sc_wr_buf_lk); 788 } 789 790 sc->sc_params = *p; 791 792 return (0); 793} 794 795int 796uirda_get_speeds(void *h, int *speeds) 797{ 798 struct uirda_softc *sc = h; 799 u_int isp; 800 u_int usp; 801 802 DPRINTF(("%s: sc=%p\n", __func__, sc)); 803 804 if (sc->sc_dying) 805 return (EIO); 806 807 usp = UGETW(sc->sc_irdadesc.wBaudRate); 808 isp = 0; 809 if (usp & UI_BR_4000000) isp |= IRDA_SPEED_4000000; 810 if (usp & UI_BR_1152000) isp |= IRDA_SPEED_1152000; 811 if (usp & UI_BR_576000) isp |= IRDA_SPEED_576000; 812 if (usp & UI_BR_115200) isp |= IRDA_SPEED_115200; 813 if (usp & UI_BR_57600) isp |= IRDA_SPEED_57600; 814 if (usp & UI_BR_38400) isp |= IRDA_SPEED_38400; 815 if (usp & UI_BR_19200) isp |= IRDA_SPEED_19200; 816 if (usp & UI_BR_9600) isp |= IRDA_SPEED_9600; 817 if (usp & UI_BR_2400) isp |= IRDA_SPEED_2400; 818 *speeds = isp; 819 DPRINTF(("%s: speeds = 0x%x\n", __func__, isp)); 820 return (0); 821} 822 823int 824uirda_get_turnarounds(void *h, int *turnarounds) 825{ 826 struct uirda_softc *sc = h; 827 u_int ita; 828 u_int uta; 829 830 DPRINTF(("%s: sc=%p\n", __func__, sc)); 831 832 if (sc->sc_dying) 833 return (EIO); 834 835 uta = sc->sc_irdadesc.bmMinTurnaroundTime; 836 ita = 0; 837 if (uta & UI_TA_0) ita |= IRDA_TURNT_0; 838 if (uta & UI_TA_10) ita |= IRDA_TURNT_10; 839 if (uta & UI_TA_50) ita |= IRDA_TURNT_50; 840 if (uta & UI_TA_100) ita |= IRDA_TURNT_100; 841 if (uta & UI_TA_500) ita |= IRDA_TURNT_500; 842 if (uta & UI_TA_1000) ita |= IRDA_TURNT_1000; 843 if (uta & UI_TA_5000) ita |= IRDA_TURNT_5000; 844 if (uta & UI_TA_10000) ita |= IRDA_TURNT_10000; 845 *turnarounds = ita; 846 return (0); 847} 848 849void 850uirda_rd_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 851 usbd_status status) 852{ 853 struct uirda_softc *sc = priv; 854 u_int32_t size; 855 856 DPRINTFN(1,("%s: sc=%p\n", __func__, sc)); 857 858 if (status == USBD_CANCELLED) /* this is normal */ 859 return; 860 if (status) { 861 size = sc->sc_hdszi; 862 sc->sc_rd_err = 1; 863 } else { 864 usbd_get_xfer_status(xfer, NULL, NULL, &size, NULL); 865 } 866 DPRINTFN(1,("%s: sc=%p size=%u, err=%d\n", __func__, sc, size, 867 sc->sc_rd_err)); 868 sc->sc_rd_count = size; 869 wakeup(&sc->sc_rd_count); /* XXX should use flag */ 870 selnotify(&sc->sc_rd_sel, 0, 0); 871} 872 873usbd_status 874uirda_start_read(struct uirda_softc *sc) 875{ 876 usbd_status err; 877 878 DPRINTFN(1,("%s: sc=%p, size=%d\n", __func__, sc, 879 sc->sc_params.maxsize + UIRDA_INPUT_HEADER_SIZE)); 880 881 if (sc->sc_dying) 882 return (USBD_IOERROR); 883 884 if (sc->sc_rd_err) { 885 sc->sc_rd_err = 0; 886 DPRINTF(("uirda_start_read: clear stall\n")); 887 usbd_clear_endpoint_stall(sc->sc_rd_pipe); 888 } 889 890 usbd_setup_xfer(sc->sc_rd_xfer, sc->sc_rd_pipe, sc, sc->sc_rd_buf, 891 sc->sc_params.maxsize + sc->sc_hdszi, 892 USBD_SHORT_XFER_OK | USBD_NO_COPY, 893 USBD_NO_TIMEOUT, uirda_rd_cb); 894 err = usbd_transfer(sc->sc_rd_xfer); 895 if (err != USBD_IN_PROGRESS) { 896 DPRINTF(("uirda_start_read: err=%d\n", err)); 897 return (err); 898 } 899 return (USBD_NORMAL_COMPLETION); 900} 901 902usbd_status 903usbd_get_class_desc(usbd_device_handle dev, int type, int index, int len, void *desc) 904{ 905 usb_device_request_t req; 906 907 DPRINTFN(3,("usbd_get_desc: type=%d, index=%d, len=%d\n", 908 type, index, len)); 909 910 req.bmRequestType = 0xa1; /* XXX ? */ 911 req.bRequest = UR_GET_DESCRIPTOR; 912 USETW2(req.wValue, type, index); 913 USETW(req.wIndex, 0); 914 USETW(req.wLength, len); 915 return (usbd_do_request(dev, &req, desc)); 916} 917