?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync usage with man page.
[netbsd-mini2440.git] / sys / dev / usb / uirda.c
blob277d7b5afe7359be23ddfd4cf401285c147b1514
1 /* $NetBSD: uirda.c,v 1.32 2009/09/23 19:07:19 plunky 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.32 2009/09/23 19:07:19 plunky 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) logprintf x
60 #define DPRINTFN(n,x) if (uirdadebug>(n)) logprintf x
61 int 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
76 static 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
92 static 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
110 int uirda_open(void *h, int flag, int mode, struct lwp *l);
111 int uirda_close(void *h, int flag, int mode, struct lwp *l);
112 int uirda_read(void *h, struct uio *uio, int flag);
113 int uirda_write(void *h, struct uio *uio, int flag);
114 int uirda_set_params(void *h, struct irda_params *params);
115 int uirda_get_speeds(void *h, int *speeds);
116 int uirda_get_turnarounds(void *h, int *times);
117 int uirda_poll(void *h, int events, struct lwp *l);
118 int uirda_kqfilter(void *h, struct knote *kn);
119
120 struct 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
126 void uirda_rd_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
127 usbd_status status);
128 usbd_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 */
138 Static 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
145 int uirda_match(device_t, cfdata_t, void *);
146 void uirda_attach(device_t, device_t, void *);
147 void uirda_childdet(device_t, device_t);
148 int uirda_detach(device_t, int);
149 int uirda_activate(device_t, enum devact);
150 extern struct cfdriver uirda_cd;
151 CFATTACH_DECL2_NEW(uirda, sizeof(struct uirda_softc), uirda_match,
152 uirda_attach, uirda_detach, uirda_activate, NULL, uirda_childdet);
153
154 USB_MATCH(uirda)
155 {
156 USB_IFMATCH_START(uirda, uaa);
157
158 DPRINTFN(50,("uirda_match\n"));
159
160 if (uirda_lookup(uaa->vendor, uaa->product) != NULL)
161 return (UMATCH_VENDOR_PRODUCT);
162
163 if (uaa->class == UICLASS_APPL_SPEC &&
164 uaa->subclass == UISUBCLASS_IRDA &&
165 uaa->proto == UIPROTO_IRDA)
166 return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO);
167 return (UMATCH_NONE);
168 }
169
170 USB_ATTACH(uirda)
171 {
172 USB_IFATTACH_START(uirda, sc, uaa);
173 usbd_device_handle dev = uaa->device;
174 usbd_interface_handle iface = uaa->iface;
175 char *devinfop;
176 usb_endpoint_descriptor_t *ed;
177 usbd_status err;
178 u_int8_t epcount;
179 u_int specrev;
180 int i;
181 struct ir_attach_args ia;
182
183 DPRINTFN(10,("uirda_attach: sc=%p\n", sc));
184
185 sc->sc_dev = self;
186
187 aprint_naive("\n");
188 aprint_normal("\n");
189
190 devinfop = usbd_devinfo_alloc(dev, 0);
191 aprint_normal_dev(self, "%s\n", devinfop);
192 usbd_devinfo_free(devinfop);
193
194 sc->sc_udev = dev;
195 sc->sc_iface = iface;
196
197 if (sc->sc_hdszi == 0)
198 sc->sc_hdszi = UIRDA_INPUT_HEADER_SIZE;
199
200 epcount = 0;
201 (void)usbd_endpoint_count(iface, &epcount);
202
203 sc->sc_rd_addr = -1;
204 sc->sc_wr_addr = -1;
205 for (i = 0; i < epcount; i++) {
206 ed = usbd_interface2endpoint_descriptor(iface, i);
207 if (ed == NULL) {
208 aprint_error_dev(self, "couldn't get ep %d\n", i);
209 USB_ATTACH_ERROR_RETURN;
210 }
211 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
212 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
213 sc->sc_rd_addr = ed->bEndpointAddress;
214 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
215 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
216 sc->sc_wr_addr = ed->bEndpointAddress;
217 }
218 }
219 if (sc->sc_rd_addr == -1 || sc->sc_wr_addr == -1) {
220 aprint_error_dev(self, "missing endpoint\n");
221 USB_ATTACH_ERROR_RETURN;
222 }
223
224 if (sc->sc_loadfw(sc) != 0) {
225 USB_ATTACH_ERROR_RETURN;
226 }
227
228 /* Get the IrDA descriptor */
229 err = usbd_get_class_desc(sc->sc_udev, UDESC_IRDA, 0,
230 USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc);
231 aprint_error_dev(self, "error %d reading class desc\n", err);
232 if (err) {
233 err = usbd_get_desc(sc->sc_udev, UDESC_IRDA, 0,
234 USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc);
235 }
236 aprint_error_dev(self, "error %d reading desc\n", err);
237 if (err) {
238 /* maybe it's embedded in the config desc? */
239 usbd_desc_iter_t iter;
240 const usb_descriptor_t *d;
241 usb_desc_iter_init(sc->sc_udev, &iter);
242 for (;;) {
243 d = usb_desc_iter_next(&iter);
244 if (!d || d->bDescriptorType == UDESC_IRDA)
245 break;
246 }
247 if (d == NULL) {
248 aprint_error_dev(self,
249 "Cannot get IrDA descriptor\n");
250 USB_ATTACH_ERROR_RETURN;
251 }
252 memcpy(&sc->sc_irdadesc, d, USB_IRDA_DESCRIPTOR_SIZE);
253 }
254 DPRINTF(("uirda_attach: bDescriptorSize %d bDescriptorType 0x%x "
255 "bmDataSize=0x%02x bmWindowSize=0x%02x "
256 "bmMinTurnaroundTime=0x%02x wBaudRate=0x%04x "
257 "bmAdditionalBOFs=0x%02x bIrdaSniff=%d bMaxUnicastList=%d\n",
258 sc->sc_irdadesc.bLength,
259 sc->sc_irdadesc.bDescriptorType,
260 sc->sc_irdadesc.bmDataSize,
261 sc->sc_irdadesc.bmWindowSize,
262 sc->sc_irdadesc.bmMinTurnaroundTime,
263 UGETW(sc->sc_irdadesc.wBaudRate),
264 sc->sc_irdadesc.bmAdditionalBOFs,
265 sc->sc_irdadesc.bIrdaSniff,
266 sc->sc_irdadesc.bMaxUnicastList));
267
268 specrev = UGETW(sc->sc_irdadesc.bcdSpecRevision);
269 aprint_normal_dev(self, "USB-IrDA protocol version %x.%02x\n",
270 specrev >> 8, specrev & 0xff);
271
272 DPRINTFN(10, ("uirda_attach: %p\n", sc->sc_udev));
273
274 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
275 USBDEV(sc->sc_dev));
276
277 mutex_init(&sc->sc_wr_buf_lk, MUTEX_DEFAULT, IPL_NONE);
278 mutex_init(&sc->sc_rd_buf_lk, MUTEX_DEFAULT, IPL_NONE);
279 selinit(&sc->sc_rd_sel);
280 selinit(&sc->sc_wr_sel);
281
282 ia.ia_type = IR_TYPE_IRFRAME;
283 ia.ia_methods = sc->sc_irm ? sc->sc_irm : &uirda_methods;
284 ia.ia_handle = sc;
285
286 sc->sc_child = config_found(self, &ia, ir_print);
287
288 USB_ATTACH_SUCCESS_RETURN;
289 }
290
291 USB_DETACH(uirda)
292 {
293 USB_DETACH_START(uirda, sc);
294 int s;
295 int rv = 0;
296
297 DPRINTF(("uirda_detach: sc=%p flags=%d\n", sc, flags));
298
299 sc->sc_dying = 1;
300 /* Abort all pipes. Causes processes waiting for transfer to wake. */
301 if (sc->sc_rd_pipe != NULL) {
302 usbd_abort_pipe(sc->sc_rd_pipe);
303 usbd_close_pipe(sc->sc_rd_pipe);
304 sc->sc_rd_pipe = NULL;
305 }
306 if (sc->sc_wr_pipe != NULL) {
307 usbd_abort_pipe(sc->sc_wr_pipe);
308 usbd_close_pipe(sc->sc_wr_pipe);
309 sc->sc_wr_pipe = NULL;
310 }
311 wakeup(&sc->sc_rd_count);
312
313 s = splusb();
314 if (--sc->sc_refcnt >= 0) {
315 /* Wait for processes to go away. */
316 usb_detach_wait(USBDEV(sc->sc_dev));
317 }
318 splx(s);
319
320 if (sc->sc_child != NULL)
321 rv = config_detach(sc->sc_child, flags);
322
323 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
324 USBDEV(sc->sc_dev));
325
326 mutex_destroy(&sc->sc_wr_buf_lk);
327 mutex_destroy(&sc->sc_rd_buf_lk);
328 seldestroy(&sc->sc_rd_sel);
329 seldestroy(&sc->sc_wr_sel);
330
331 return (rv);
332 }
333
334 void
335 uirda_childdet(device_t self, device_t child)
336 {
337 struct uirda_softc *sc = device_private(self);
338
339 KASSERT(sc->sc_child == child);
340 sc->sc_child = NULL;
341 }
342
343 int
344 uirda_activate(device_t self, enum devact act)
345 {
346 struct uirda_softc *sc = device_private(self);
347
348 switch (act) {
349 case DVACT_DEACTIVATE:
350 sc->sc_dying = 1;
351 return 0;
352 default:
353 return EOPNOTSUPP;
354 }
355 }
356
357 int
358 uirda_open(void *h, int flag, int mode,
359 struct lwp *l)
360 {
361 struct uirda_softc *sc = h;
362 int error;
363 usbd_status err;
364
365 DPRINTF(("%s: sc=%p\n", __func__, sc));
366
367 err = usbd_open_pipe(sc->sc_iface, sc->sc_rd_addr, 0, &sc->sc_rd_pipe);
368 if (err) {
369 error = EIO;
370 goto bad1;
371 }
372 err = usbd_open_pipe(sc->sc_iface, sc->sc_wr_addr, 0, &sc->sc_wr_pipe);
373 if (err) {
374 error = EIO;
375 goto bad2;
376 }
377 sc->sc_rd_xfer = usbd_alloc_xfer(sc->sc_udev);
378 if (sc->sc_rd_xfer == NULL) {
379 error = ENOMEM;
380 goto bad3;
381 }
382 sc->sc_wr_xfer = usbd_alloc_xfer(sc->sc_udev);
383 if (sc->sc_wr_xfer == NULL) {
384 error = ENOMEM;
385 goto bad4;
386 }
387 sc->sc_rd_buf = usbd_alloc_buffer(sc->sc_rd_xfer,
388 IRDA_MAX_FRAME_SIZE + sc->sc_hdszi);
389 if (sc->sc_rd_buf == NULL) {
390 error = ENOMEM;
391 goto bad5;
392 }
393 sc->sc_wr_buf = usbd_alloc_buffer(sc->sc_wr_xfer,
394 IRDA_MAX_FRAME_SIZE + UIRDA_OUTPUT_HEADER_SIZE +
395 2 + 1 /* worst case ST-UIRDA */);
396 if (sc->sc_wr_buf == NULL) {
397 error = ENOMEM;
398 goto bad5;
399 }
400 sc->sc_rd_count = 0;
401 sc->sc_rd_err = 0;
402 sc->sc_params.speed = 0;
403 sc->sc_params.ebofs = 0;
404 sc->sc_params.maxsize = IRDA_MAX_FRAME_SIZE;
405 sc->sc_wr_hdr = -1;
406
407 err = uirda_start_read(sc);
408 /* XXX check err */
409
410 return (0);
411
412 bad5:
413 usbd_free_xfer(sc->sc_wr_xfer);
414 sc->sc_wr_xfer = NULL;
415 bad4:
416 usbd_free_xfer(sc->sc_rd_xfer);
417 sc->sc_rd_xfer = NULL;
418 bad3:
419 usbd_close_pipe(sc->sc_wr_pipe);
420 sc->sc_wr_pipe = NULL;
421 bad2:
422 usbd_close_pipe(sc->sc_rd_pipe);
423 sc->sc_rd_pipe = NULL;
424 bad1:
425 return (error);
426 }
427
428 int
429 uirda_close(void *h, int flag, int mode,
430 struct lwp *l)
431 {
432 struct uirda_softc *sc = h;
433
434 DPRINTF(("%s: sc=%p\n", __func__, sc));
435
436 if (sc->sc_rd_pipe != NULL) {
437 usbd_abort_pipe(sc->sc_rd_pipe);
438 usbd_close_pipe(sc->sc_rd_pipe);
439 sc->sc_rd_pipe = NULL;
440 }
441 if (sc->sc_wr_pipe != NULL) {
442 usbd_abort_pipe(sc->sc_wr_pipe);
443 usbd_close_pipe(sc->sc_wr_pipe);
444 sc->sc_wr_pipe = NULL;
445 }
446 if (sc->sc_rd_xfer != NULL) {
447 usbd_free_xfer(sc->sc_rd_xfer);
448 sc->sc_rd_xfer = NULL;
449 sc->sc_rd_buf = NULL;
450 }
451 if (sc->sc_wr_xfer != NULL) {
452 usbd_free_xfer(sc->sc_wr_xfer);
453 sc->sc_wr_xfer = NULL;
454 sc->sc_wr_buf = NULL;
455 }
456
457 return (0);
458 }
459
460 int
461 uirda_read(void *h, struct uio *uio, int flag)
462 {
463 struct uirda_softc *sc = h;
464 usbd_status err;
465 int s;
466 int error;
467 u_int n;
468
469 DPRINTFN(1,("%s: sc=%p\n", __func__, sc));
470
471 if (sc->sc_dying)
472 return (EIO);
473
474 #ifdef DIAGNOSTIC
475 if (sc->sc_rd_buf == NULL)
476 return (EINVAL);
477 #endif
478
479 sc->sc_refcnt++;
480
481 do {
482 s = splusb();
483 while (sc->sc_rd_count == 0) {
484 DPRINTFN(5,("uirda_read: calling tsleep()\n"));
485 error = tsleep(&sc->sc_rd_count, PZERO | PCATCH,
486 "uirdrd", 0);
487 if (sc->sc_dying)
488 error = EIO;
489 if (error) {
490 splx(s);
491 DPRINTF(("uirda_read: tsleep() = %d\n", error));
492 goto ret;
493 }
494 }
495 splx(s);
496
497 mutex_enter(&sc->sc_rd_buf_lk);
498 n = sc->sc_rd_count - sc->sc_hdszi;
499 DPRINTFN(1,("%s: sc=%p n=%u, hdr=0x%02x\n", __func__,
500 sc, n, sc->sc_rd_buf[0]));
501 if (n > uio->uio_resid)
502 error = EINVAL;
503 else
504 error = uiomove(sc->sc_rd_buf + sc->sc_hdszi, n, uio);
505 sc->sc_rd_count = 0;
506 mutex_exit(&sc->sc_rd_buf_lk);
507
508 err = uirda_start_read(sc);
509 /* XXX check err */
510
511 } while (n == 0);
512
513 DPRINTFN(1,("uirda_read: return %d\n", error));
514
515 ret:
516 if (--sc->sc_refcnt < 0)
517 usb_detach_wakeup(USBDEV(sc->sc_dev));
518 return (error);
519 }
520
521 int
522 uirda_write(void *h, struct uio *uio, int flag)
523 {
524 struct uirda_softc *sc = h;
525 usbd_status err;
526 u_int32_t n;
527 int error = 0;
528
529 DPRINTFN(1,("%s: sc=%p\n", __func__, sc));
530
531 if (sc->sc_dying)
532 return (EIO);
533
534 #ifdef DIAGNOSTIC
535 if (sc->sc_wr_buf == NULL)
536 return (EINVAL);
537 #endif
538
539 n = uio->uio_resid;
540 if (n > sc->sc_params.maxsize)
541 return (EINVAL);
542
543 sc->sc_refcnt++;
544 mutex_enter(&sc->sc_wr_buf_lk);
545
546 sc->sc_wr_buf[0] = UIRDA_EB_NO_CHANGE | UIRDA_NO_SPEED;
547 error = uiomove(sc->sc_wr_buf + UIRDA_OUTPUT_HEADER_SIZE, n, uio);
548 if (!error) {
549 DPRINTFN(1, ("uirdawrite: transfer %d bytes\n", n));
550
551 n += UIRDA_OUTPUT_HEADER_SIZE;
552 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe,
553 USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
554 UIRDA_WR_TIMEOUT,
555 sc->sc_wr_buf, &n, "uirdawr");
556 DPRINTFN(2, ("uirdawrite: err=%d\n", err));
557 if (err) {
558 if (err == USBD_INTERRUPTED)
559 error = EINTR;
560 else if (err == USBD_TIMEOUT)
561 error = ETIMEDOUT;
562 else
563 error = EIO;
564 }
565 }
566
567 mutex_exit(&sc->sc_wr_buf_lk);
568 if (--sc->sc_refcnt < 0)
569 usb_detach_wakeup(USBDEV(sc->sc_dev));
570
571 DPRINTFN(1,("%s: sc=%p done\n", __func__, sc));
572 return (error);
573 }
574
575 int
576 uirda_poll(void *h, int events, struct lwp *l)
577 {
578 struct uirda_softc *sc = h;
579 int revents = 0;
580 int s;
581
582 DPRINTFN(1,("%s: sc=%p\n", __func__, sc));
583
584 s = splusb();
585 if (events & (POLLOUT | POLLWRNORM))
586 revents |= events & (POLLOUT | POLLWRNORM);
587 if (events & (POLLIN | POLLRDNORM)) {
588 if (sc->sc_rd_count != 0) {
589 DPRINTFN(2,("%s: have data\n", __func__));
590 revents |= events & (POLLIN | POLLRDNORM);
591 } else {
592 DPRINTFN(2,("%s: recording select\n", __func__));
593 selrecord(l, &sc->sc_rd_sel);
594 }
595 }
596 splx(s);
597
598 return (revents);
599 }
600
601 static void
602 filt_uirdardetach(struct knote *kn)
603 {
604 struct uirda_softc *sc = kn->kn_hook;
605 int s;
606
607 s = splusb();
608 SLIST_REMOVE(&sc->sc_rd_sel.sel_klist, kn, knote, kn_selnext);
609 splx(s);
610 }
611
612 static int
613 filt_uirdaread(struct knote *kn, long hint)
614 {
615 struct uirda_softc *sc = kn->kn_hook;
616
617 kn->kn_data = sc->sc_rd_count;
618 return (kn->kn_data > 0);
619 }
620
621 static void
622 filt_uirdawdetach(struct knote *kn)
623 {
624 struct uirda_softc *sc = kn->kn_hook;
625 int s;
626
627 s = splusb();
628 SLIST_REMOVE(&sc->sc_wr_sel.sel_klist, kn, knote, kn_selnext);
629 splx(s);
630 }
631
632 static const struct filterops uirdaread_filtops =
633 { 1, NULL, filt_uirdardetach, filt_uirdaread };
634 static const struct filterops uirdawrite_filtops =
635 { 1, NULL, filt_uirdawdetach, filt_seltrue };
636
637 int
638 uirda_kqfilter(void *h, struct knote *kn)
639 {
640 struct uirda_softc *sc = kn->kn_hook;
641 struct klist *klist;
642 int s;
643
644 switch (kn->kn_filter) {
645 case EVFILT_READ:
646 klist = &sc->sc_rd_sel.sel_klist;
647 kn->kn_fop = &uirdaread_filtops;
648 break;
649 case EVFILT_WRITE:
650 klist = &sc->sc_wr_sel.sel_klist;
651 kn->kn_fop = &uirdawrite_filtops;
652 break;
653 default:
654 return (EINVAL);
655 }
656
657 kn->kn_hook = sc;
658
659 s = splusb();
660 SLIST_INSERT_HEAD(klist, kn, kn_selnext);
661 splx(s);
662
663 return (0);
664 }
665
666 int
667 uirda_set_params(void *h, struct irda_params *p)
668 {
669 struct uirda_softc *sc = h;
670 usbd_status err;
671 int i;
672 u_int8_t hdr;
673 u_int32_t n;
674 u_int mask;
675
676 DPRINTF(("%s: sc=%p, speed=%d ebofs=%d maxsize=%d\n", __func__,
677 sc, p->speed, p->ebofs, p->maxsize));
678
679 if (sc->sc_dying)
680 return (EIO);
681
682 hdr = 0;
683 if (p->ebofs != sc->sc_params.ebofs) {
684 /* round up ebofs */
685 mask = 1 /* sc->sc_irdadesc.bmAdditionalBOFs*/;
686 DPRINTF(("u.s.p.: mask=0x%x, sc->ebofs=%d, p->ebofs=%d\n",
687 mask, sc->sc_params.ebofs, p->ebofs));
688 for (i = 0; i < UIRDA_NEBOFS; i++) {
689 DPRINTF(("u.s.p.: u_e[%d].mask=0x%x, count=%d\n",
690 i, uirda_ebofs[i].mask, uirda_ebofs[i].count));
691 if ((mask & uirda_ebofs[i].mask) &&
692 uirda_ebofs[i].count >= p->ebofs) {
693 hdr = uirda_ebofs[i].header;
694 goto found1;
695 }
696 }
697 for (i = 0; i < UIRDA_NEBOFS; i++) {
698 DPRINTF(("u.s.p.: u_e[%d].mask=0x%x, count=%d\n",
699 i, uirda_ebofs[i].mask, uirda_ebofs[i].count));
700 if ((mask & uirda_ebofs[i].mask)) {
701 hdr = uirda_ebofs[i].header;
702 goto found1;
703 }
704 }
705 /* no good value found */
706 return (EINVAL);
707 found1:
708 DPRINTF(("uirda_set_params: ebofs hdr=0x%02x\n", hdr));
709 ;
710
711 }
712 if (hdr != 0 || p->speed != sc->sc_params.speed) {
713 /* find speed */
714 mask = UGETW(sc->sc_irdadesc.wBaudRate);
715 for (i = 0; i < UIRDA_NSPEEDS; i++) {
716 if ((mask & uirda_speeds[i].mask) &&
717 uirda_speeds[i].speed == p->speed) {
718 hdr |= uirda_speeds[i].header;
719 goto found2;
720 }
721 }
722 /* no good value found */
723 return (EINVAL);
724 found2:
725 DPRINTF(("uirda_set_params: speed hdr=0x%02x\n", hdr));
726 ;
727 }
728 if (p->maxsize != sc->sc_params.maxsize) {
729 if (p->maxsize > IRDA_MAX_FRAME_SIZE)
730 return (EINVAL);
731 sc->sc_params.maxsize = p->maxsize;
732 #if 0
733 DPRINTF(("%s: new buffers, old size=%d\n", __func__,
734 sc->sc_params.maxsize));
735 if (p->maxsize > 10000 || p < 0) /* XXX */
736 return (EINVAL);
737
738 /* Change the write buffer */
739 mutex_enter(&sc->sc_wr_buf_lk);
740 if (sc->sc_wr_buf != NULL)
741 usbd_free_buffer(sc->sc_wr_xfer);
742 sc->sc_wr_buf = usbd_alloc_buffer(sc->sc_wr_xfer, p->maxsize+1);
743 mutex_exit(&sc->sc_wr_buf_lk);
744 if (sc->sc_wr_buf == NULL)
745 return (ENOMEM);
746
747 /* Change the read buffer */
748 mutex_enter(&sc->sc_rd_buf_lk);
749 usbd_abort_pipe(sc->sc_rd_pipe);
750 if (sc->sc_rd_buf != NULL)
751 usbd_free_buffer(sc->sc_rd_xfer);
752 sc->sc_rd_buf = usbd_alloc_buffer(sc->sc_rd_xfer, p->maxsize+1);
753 sc->sc_rd_count = 0;
754 if (sc->sc_rd_buf == NULL) {
755 mutex_exit(&sc->sc_rd_buf_lk);
756 return (ENOMEM);
757 }
758 sc->sc_params.maxsize = p->maxsize;
759 err = uirda_start_read(sc); /* XXX check */
760 mutex_exit(&sc->sc_rd_buf_lk);
761 #endif
762 }
763 if (hdr != 0 && hdr != sc->sc_wr_hdr) {
764 /*
765 * A change has occurred, transmit a 0 length frame with
766 * the new settings. The 0 length frame is not sent to the
767 * device.
768 */
769 DPRINTF(("%s: sc=%p setting header 0x%02x\n",
770 __func__, sc, hdr));
771 sc->sc_wr_hdr = hdr;
772 mutex_enter(&sc->sc_wr_buf_lk);
773 sc->sc_wr_buf[0] = hdr;
774 n = UIRDA_OUTPUT_HEADER_SIZE;
775 err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe,
776 USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
777 UIRDA_WR_TIMEOUT, sc->sc_wr_buf, &n, "uirdast");
778 if (err) {
779 aprint_error_dev(sc->sc_dev, "set failed, err=%d\n",
780 err);
781 usbd_clear_endpoint_stall(sc->sc_wr_pipe);
782 }
783 mutex_exit(&sc->sc_wr_buf_lk);
784 }
785
786 sc->sc_params = *p;
787
788 return (0);
789 }
790
791 int
792 uirda_get_speeds(void *h, int *speeds)
793 {
794 struct uirda_softc *sc = h;
795 u_int isp;
796 u_int usp;
797
798 DPRINTF(("%s: sc=%p\n", __func__, sc));
799
800 if (sc->sc_dying)
801 return (EIO);
802
803 usp = UGETW(sc->sc_irdadesc.wBaudRate);
804 isp = 0;
805 if (usp & UI_BR_4000000) isp |= IRDA_SPEED_4000000;
806 if (usp & UI_BR_1152000) isp |= IRDA_SPEED_1152000;
807 if (usp & UI_BR_576000) isp |= IRDA_SPEED_576000;
808 if (usp & UI_BR_115200) isp |= IRDA_SPEED_115200;
809 if (usp & UI_BR_57600) isp |= IRDA_SPEED_57600;
810 if (usp & UI_BR_38400) isp |= IRDA_SPEED_38400;
811 if (usp & UI_BR_19200) isp |= IRDA_SPEED_19200;
812 if (usp & UI_BR_9600) isp |= IRDA_SPEED_9600;
813 if (usp & UI_BR_2400) isp |= IRDA_SPEED_2400;
814 *speeds = isp;
815 DPRINTF(("%s: speeds = 0x%x\n", __func__, isp));
816 return (0);
817 }
818
819 int
820 uirda_get_turnarounds(void *h, int *turnarounds)
821 {
822 struct uirda_softc *sc = h;
823 u_int ita;
824 u_int uta;
825
826 DPRINTF(("%s: sc=%p\n", __func__, sc));
827
828 if (sc->sc_dying)
829 return (EIO);
830
831 uta = sc->sc_irdadesc.bmMinTurnaroundTime;
832 ita = 0;
833 if (uta & UI_TA_0) ita |= IRDA_TURNT_0;
834 if (uta & UI_TA_10) ita |= IRDA_TURNT_10;
835 if (uta & UI_TA_50) ita |= IRDA_TURNT_50;
836 if (uta & UI_TA_100) ita |= IRDA_TURNT_100;
837 if (uta & UI_TA_500) ita |= IRDA_TURNT_500;
838 if (uta & UI_TA_1000) ita |= IRDA_TURNT_1000;
839 if (uta & UI_TA_5000) ita |= IRDA_TURNT_5000;
840 if (uta & UI_TA_10000) ita |= IRDA_TURNT_10000;
841 *turnarounds = ita;
842 return (0);
843 }
844
845 void
846 uirda_rd_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
847 usbd_status status)
848 {
849 struct uirda_softc *sc = priv;
850 u_int32_t size;
851
852 DPRINTFN(1,("%s: sc=%p\n", __func__, sc));
853
854 if (status == USBD_CANCELLED) /* this is normal */
855 return;
856 if (status) {
857 size = sc->sc_hdszi;
858 sc->sc_rd_err = 1;
859 } else {
860 usbd_get_xfer_status(xfer, NULL, NULL, &size, NULL);
861 }
862 DPRINTFN(1,("%s: sc=%p size=%u, err=%d\n", __func__, sc, size,
863 sc->sc_rd_err));
864 sc->sc_rd_count = size;
865 wakeup(&sc->sc_rd_count); /* XXX should use flag */
866 selnotify(&sc->sc_rd_sel, 0, 0);
867 }
868
869 usbd_status
870 uirda_start_read(struct uirda_softc *sc)
871 {
872 usbd_status err;
873
874 DPRINTFN(1,("%s: sc=%p, size=%d\n", __func__, sc,
875 sc->sc_params.maxsize + UIRDA_INPUT_HEADER_SIZE));
876
877 if (sc->sc_dying)
878 return (USBD_IOERROR);
879
880 if (sc->sc_rd_err) {
881 sc->sc_rd_err = 0;
882 DPRINTF(("uirda_start_read: clear stall\n"));
883 usbd_clear_endpoint_stall(sc->sc_rd_pipe);
884 }
885
886 usbd_setup_xfer(sc->sc_rd_xfer, sc->sc_rd_pipe, sc, sc->sc_rd_buf,
887 sc->sc_params.maxsize + sc->sc_hdszi,
888 USBD_SHORT_XFER_OK | USBD_NO_COPY,
889 USBD_NO_TIMEOUT, uirda_rd_cb);
890 err = usbd_transfer(sc->sc_rd_xfer);
891 if (err != USBD_IN_PROGRESS) {
892 DPRINTF(("uirda_start_read: err=%d\n", err));
893 return (err);
894 }
895 return (USBD_NORMAL_COMPLETION);
896 }
897
898 usbd_status
899 usbd_get_class_desc(usbd_device_handle dev, int type, int index, int len, void *desc)
900 {
901 usb_device_request_t req;
902
903 DPRINTFN(3,("usbd_get_desc: type=%d, index=%d, len=%d\n",
904 type, index, len));
905
906 req.bmRequestType = 0xa1; /* XXX ? */
907 req.bRequest = UR_GET_DESCRIPTOR;
908 USETW2(req.wValue, type, index);
909 USETW(req.wIndex, 0);
910 USETW(req.wLength, len);
911 return (usbd_do_request(dev, &req, desc));
912 }
NetBSD on the FriendlyARM MINI2440