e00b3b5dfcf7b2c3cb87542e3b4bc8d763a6240f
[dragonfly.git] / sys / dev / usbmisc / ums / ums.c
1 /*
2  * $FreeBSD: src/sys/dev/usb/ums.c,v 1.64 2003/11/09 09:17:22 tanimura Exp $
3  * $DragonFly: src/sys/dev/usbmisc/ums/ums.c,v 1.24 2007/06/28 13:55:13 hasso Exp $
4  */
5
6 /*
7  * Copyright (c) 1998 The NetBSD Foundation, Inc.
8  * All rights reserved.
9  *
10  * This code is derived from software contributed to The NetBSD Foundation
11  * by Lennart Augustsson (lennart@augustsson.net) at
12  * Carlstedt Research & Technology.
13  *
14  * Redistribution and use in source and binary forms, with or without
15  * modification, are permitted provided that the following conditions
16  * are met:
17  * 1. Redistributions of source code must retain the above copyright
18  *    notice, this list of conditions and the following disclaimer.
19  * 2. Redistributions in binary form must reproduce the above copyright
20  *    notice, this list of conditions and the following disclaimer in the
21  *    documentation and/or other materials provided with the distribution.
22  * 3. All advertising materials mentioning features or use of this software
23  *    must display the following acknowledgement:
24  *        This product includes software developed by the NetBSD
25  *        Foundation, Inc. and its contributors.
26  * 4. Neither the name of The NetBSD Foundation nor the names of its
27  *    contributors may be used to endorse or promote products derived
28  *    from this software without specific prior written permission.
29  *
30  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
31  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
32  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
33  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
34  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
35  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
36  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
37  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
38  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
39  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
40  * POSSIBILITY OF SUCH DAMAGE.
41  */
42
43 /*
44  * HID spec: http://www.usb.org/developers/data/devclass/hid1_1.pdf
45  */
46
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/kernel.h>
50 #include <sys/malloc.h>
51 #include <sys/module.h>
52 #include <sys/bus.h>
53 #include <sys/ioccom.h>
54 #include <sys/conf.h>
55 #include <sys/tty.h>
56 #include <sys/file.h>
57 #include <sys/select.h>
58 #include <sys/vnode.h>
59 #include <sys/poll.h>
60 #include <sys/sysctl.h>
61 #include <sys/thread2.h>
62
63 #include <bus/usb/usb.h>
64 #include <bus/usb/usbhid.h>
65
66 #include <bus/usb/usbdi.h>
67 #include <bus/usb/usbdi_util.h>
68 #include <bus/usb/usbdevs.h>
69 #include <bus/usb/usb_quirks.h>
70 #include <bus/usb/hid.h>
71
72 #include <machine/mouse.h>
73
74 #ifdef USB_DEBUG
75 #define DPRINTF(x)      if (umsdebug) kprintf x
76 #define DPRINTFN(n,x)   if (umsdebug>(n)) kprintf x
77 int     umsdebug = 0;
78 SYSCTL_NODE(_hw_usb, OID_AUTO, ums, CTLFLAG_RW, 0, "USB ums");
79 SYSCTL_INT(_hw_usb_ums, OID_AUTO, debug, CTLFLAG_RW,
80            &umsdebug, 0, "ums debug level");
81 #else
82 #define DPRINTF(x)
83 #define DPRINTFN(n,x)
84 #endif
85
86 #define UMSUNIT(s)      (minor(s)&0x1f)
87
88 #define MS_TO_TICKS(ms) ((ms) * hz / 1000)
89
90 #define QUEUE_BUFSIZE   400     /* MUST be divisible by 5 _and_ 8 */
91
92 struct ums_softc {
93         device_t sc_dev;                /* base device */
94         usbd_interface_handle sc_iface; /* interface */
95         usbd_pipe_handle sc_intrpipe;   /* interrupt pipe */
96         int sc_ep_addr;
97
98         u_char *sc_ibuf;
99         u_int8_t sc_iid;
100         int sc_isize;
101         struct hid_location sc_loc_x, sc_loc_y, sc_loc_z;
102         struct hid_location *sc_loc_btn;
103
104         struct callout sc_timeout;      /* for spurious button ups */
105
106         int sc_enabled;
107         int sc_disconnected;    /* device is gone */
108
109         int flags;              /* device configuration */
110 #define UMS_Z           0x01    /* z direction available */
111 #define UMS_SPUR_BUT_UP 0x02    /* spurious button up events */
112         int nbuttons;
113 #define MAX_BUTTONS     31      /* must not exceed size of sc_buttons */
114
115         u_char          qbuf[QUEUE_BUFSIZE];    /* must be divisable by 3&4 */
116         u_char          dummy[100];     /* XXX just for safety and for now */
117         int             qcount, qhead, qtail;
118         mousehw_t       hw;
119         mousemode_t     mode;
120         mousestatus_t   status;
121
122         int             state;
123 #         define        UMS_ASLEEP      0x01    /* readFromDevice is waiting */
124 #         define        UMS_SELECT      0x02    /* select is waiting */
125         struct selinfo  rsel;           /* process waiting in select */
126 };
127
128 #define MOUSE_FLAGS_MASK (HIO_CONST|HIO_RELATIVE)
129 #define MOUSE_FLAGS (HIO_RELATIVE)
130
131 static void ums_intr(usbd_xfer_handle xfer,
132                           usbd_private_handle priv, usbd_status status);
133
134 static void ums_add_to_queue(struct ums_softc *sc,
135                                 int dx, int dy, int dz, int buttons);
136 static void ums_add_to_queue_timeout(void *priv);
137
138 static int  ums_enable(void *);
139 static void ums_disable(void *);
140
141 static d_open_t  ums_open;
142 static d_close_t ums_close;
143 static d_read_t  ums_read;
144 static d_ioctl_t ums_ioctl;
145 static d_poll_t  ums_poll;
146
147 #define UMS_CDEV_MAJOR  111
148
149 static struct dev_ops ums_ops = {
150         { "ums", UMS_CDEV_MAJOR, 0 },
151         .d_open =       ums_open,
152         .d_close =      ums_close,
153         .d_read =       ums_read,
154         .d_ioctl =      ums_ioctl,
155         .d_poll =       ums_poll,
156 };
157
158 USB_DECLARE_DRIVER(ums);
159
160 USB_MATCH(ums)
161 {
162         USB_MATCH_START(ums, uaa);
163         usb_interface_descriptor_t *id;
164         int size, ret;
165         void *desc;
166         usbd_status err;
167
168         if (!uaa->iface)
169                 return (UMATCH_NONE);
170         id = usbd_get_interface_descriptor(uaa->iface);
171         if (!id || id->bInterfaceClass != UICLASS_HID)
172                 return (UMATCH_NONE);
173
174         err = usbd_read_report_desc(uaa->iface, &desc, &size, M_TEMP);
175         if (err)
176                 return (UMATCH_NONE);
177
178         if (hid_is_collection(desc, size,
179                               HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_MOUSE)))
180                 ret = UMATCH_IFACECLASS;
181         else
182                 ret = UMATCH_NONE;
183
184         kfree(desc, M_TEMP);
185         return (ret);
186 }
187
188 USB_ATTACH(ums)
189 {
190         USB_ATTACH_START(ums, sc, uaa);
191         usbd_interface_handle iface = uaa->iface;
192         usb_interface_descriptor_t *id;
193         usb_endpoint_descriptor_t *ed;
194         int size;
195         void *desc;
196         usbd_status err;
197         char devinfo[1024];
198         u_int32_t flags;
199         int i;
200         struct hid_location loc_btn;
201
202         sc->sc_disconnected = 1;
203         sc->sc_iface = iface;
204         id = usbd_get_interface_descriptor(iface);
205         usbd_devinfo(uaa->device, 0, devinfo);
206         USB_ATTACH_SETUP;
207         kprintf("%s: %s, iclass %d/%d\n", device_get_nameunit(sc->sc_dev),
208                devinfo, id->bInterfaceClass, id->bInterfaceSubClass);
209         ed = usbd_interface2endpoint_descriptor(iface, 0);
210         if (!ed) {
211                 kprintf("%s: could not read endpoint descriptor\n",
212                        device_get_nameunit(sc->sc_dev));
213                 USB_ATTACH_ERROR_RETURN;
214         }
215
216         DPRINTFN(10,("ums_attach: bLength=%d bDescriptorType=%d "
217                      "bEndpointAddress=%d-%s bmAttributes=%d wMaxPacketSize=%d"
218                      " bInterval=%d\n",
219                      ed->bLength, ed->bDescriptorType,
220                      UE_GET_ADDR(ed->bEndpointAddress),
221                      UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN ? "in":"out",
222                      UE_GET_XFERTYPE(ed->bmAttributes),
223                      UGETW(ed->wMaxPacketSize), ed->bInterval));
224
225         if (UE_GET_DIR(ed->bEndpointAddress) != UE_DIR_IN ||
226             UE_GET_XFERTYPE(ed->bmAttributes) != UE_INTERRUPT) {
227                 kprintf("%s: unexpected endpoint\n",
228                        device_get_nameunit(sc->sc_dev));
229                 USB_ATTACH_ERROR_RETURN;
230         }
231
232         err = usbd_read_report_desc(uaa->iface, &desc, &size, M_TEMP);
233         if (err)
234                 USB_ATTACH_ERROR_RETURN;
235
236         if (!hid_locate(desc, size, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X),
237                        hid_input, &sc->sc_loc_x, &flags)) {
238                 kprintf("%s: mouse has no X report\n", device_get_nameunit(sc->sc_dev));
239                 USB_ATTACH_ERROR_RETURN;
240         }
241         if ((flags & MOUSE_FLAGS_MASK) != MOUSE_FLAGS) {
242                 kprintf("%s: X report 0x%04x not supported\n",
243                        device_get_nameunit(sc->sc_dev), flags);
244                 USB_ATTACH_ERROR_RETURN;
245         }
246
247         if (!hid_locate(desc, size, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y),
248                        hid_input, &sc->sc_loc_y, &flags)) {
249                 kprintf("%s: mouse has no Y report\n", device_get_nameunit(sc->sc_dev));
250                 USB_ATTACH_ERROR_RETURN;
251         }
252         if ((flags & MOUSE_FLAGS_MASK) != MOUSE_FLAGS) {
253                 kprintf("%s: Y report 0x%04x not supported\n",
254                        device_get_nameunit(sc->sc_dev), flags);
255                 USB_ATTACH_ERROR_RETURN;
256         }
257
258         /* try to guess the Z activator: first check Z, then WHEEL */
259         if (hid_locate(desc, size, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Z),
260                        hid_input, &sc->sc_loc_z, &flags) ||
261             hid_locate(desc, size, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_WHEEL),
262                        hid_input, &sc->sc_loc_z, &flags)) {
263                 if ((flags & MOUSE_FLAGS_MASK) != MOUSE_FLAGS) {
264                         sc->sc_loc_z.size = 0;  /* Bad Z coord, ignore it */
265                 } else {
266                         sc->flags |= UMS_Z;
267                 }
268         }
269
270         /* figure out the number of buttons */
271         for (i = 1; i <= MAX_BUTTONS; i++)
272                 if (!hid_locate(desc, size, HID_USAGE2(HUP_BUTTON, i),
273                                 hid_input, &loc_btn, 0))
274                         break;
275         sc->nbuttons = i - 1;
276         sc->sc_loc_btn = kmalloc(sizeof(struct hid_location)*sc->nbuttons,
277                                 M_USBDEV, M_INTWAIT);
278
279         kprintf("%s: %d buttons%s\n", device_get_nameunit(sc->sc_dev),
280                sc->nbuttons, sc->flags & UMS_Z? " and Z dir." : "");
281
282         for (i = 1; i <= sc->nbuttons; i++)
283                 hid_locate(desc, size, HID_USAGE2(HUP_BUTTON, i),
284                                 hid_input, &sc->sc_loc_btn[i-1], 0);
285
286         sc->sc_isize = hid_report_size(desc, size, hid_input, &sc->sc_iid);
287         sc->sc_ibuf = kmalloc(sc->sc_isize, M_USB, M_INTWAIT);
288         sc->sc_ep_addr = ed->bEndpointAddress;
289         sc->sc_disconnected = 0;
290         kfree(desc, M_TEMP);
291
292 #ifdef USB_DEBUG
293         DPRINTF(("ums_attach: sc=%p\n", sc));
294         DPRINTF(("ums_attach: X\t%d/%d\n",
295                  sc->sc_loc_x.pos, sc->sc_loc_x.size));
296         DPRINTF(("ums_attach: Y\t%d/%d\n",
297                  sc->sc_loc_y.pos, sc->sc_loc_y.size));
298         if (sc->flags & UMS_Z)
299                 DPRINTF(("ums_attach: Z\t%d/%d\n",
300                          sc->sc_loc_z.pos, sc->sc_loc_z.size));
301         for (i = 1; i <= sc->nbuttons; i++) {
302                 DPRINTF(("ums_attach: B%d\t%d/%d\n",
303                          i, sc->sc_loc_btn[i-1].pos,sc->sc_loc_btn[i-1].size));
304         }
305         DPRINTF(("ums_attach: size=%d, id=%d\n", sc->sc_isize, sc->sc_iid));
306 #endif
307
308         if (sc->nbuttons > MOUSE_MSC_MAXBUTTON)
309                 sc->hw.buttons = MOUSE_MSC_MAXBUTTON;
310         else
311                 sc->hw.buttons = sc->nbuttons;
312         sc->hw.iftype = MOUSE_IF_USB;
313         sc->hw.type = MOUSE_MOUSE;
314         sc->hw.model = MOUSE_MODEL_GENERIC;
315         sc->hw.hwid = 0;
316         sc->mode.protocol = MOUSE_PROTO_MSC;
317         sc->mode.rate = -1;
318         sc->mode.resolution = MOUSE_RES_UNKNOWN;
319         sc->mode.accelfactor = 0;
320         sc->mode.level = 0;
321         sc->mode.packetsize = MOUSE_MSC_PACKETSIZE;
322         sc->mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
323         sc->mode.syncmask[1] = MOUSE_MSC_SYNC;
324
325         sc->status.flags = 0;
326         sc->status.button = sc->status.obutton = 0;
327         sc->status.dx = sc->status.dy = sc->status.dz = 0;
328
329         dev_ops_add(&ums_ops, -1, device_get_unit(self));
330         make_dev(&ums_ops, device_get_unit(self),
331                 UID_ROOT, GID_OPERATOR,
332                 0644, "ums%d", device_get_unit(self));
333
334         if (usbd_get_quirks(uaa->device)->uq_flags & UQ_SPUR_BUT_UP) {
335                 DPRINTF(("%s: Spurious button up events\n",
336                         device_get_nameunit(sc->sc_dev)));
337                 sc->flags |= UMS_SPUR_BUT_UP;
338         }
339
340         USB_ATTACH_SUCCESS_RETURN;
341 }
342
343
344 static int
345 ums_detach(device_t self)
346 {
347         struct ums_softc *sc = device_get_softc(self);
348
349         if (sc->sc_enabled)
350                 ums_disable(sc);
351
352         DPRINTF(("%s: disconnected\n", device_get_nameunit(self)));
353
354         kfree(sc->sc_loc_btn, M_USB);
355         kfree(sc->sc_ibuf, M_USB);
356
357         /* someone waiting for data */
358         /*
359          * XXX If we wakeup the process here, the device will be gone by
360          * the time the process gets a chance to notice. *_close and friends
361          * should be fixed to handle this case.
362          * Or we should do a delayed detach for this.
363          * Does this delay now force tsleep to exit with an error?
364          */
365         if (sc->state & UMS_ASLEEP) {
366                 sc->state &= ~UMS_ASLEEP;
367                 wakeup(sc);
368         }
369         if (sc->state & UMS_SELECT) {
370                 sc->state &= ~UMS_SELECT;
371                 selwakeuppri(&sc->rsel, 0);
372         }
373         dev_ops_remove(&ums_ops, -1, device_get_unit(self));
374
375         return 0;
376 }
377
378 void
379 ums_intr(usbd_xfer_handle xfer, usbd_private_handle addr,
380          usbd_status status)
381 {
382         struct ums_softc *sc = addr;
383         u_char *ibuf;
384         int dx, dy, dz;
385         u_char buttons = 0;
386         int i;
387
388 #define UMS_BUT(i) ((i) < 3 ? (((i) + 2) % 3) : (i))
389
390         DPRINTFN(5, ("ums_intr: sc=%p status=%d\n", sc, status));
391         DPRINTFN(5, ("ums_intr: data = %02x %02x %02x\n",
392                      sc->sc_ibuf[0], sc->sc_ibuf[1], sc->sc_ibuf[2]));
393
394         if (status == USBD_CANCELLED)
395                 return;
396
397         if (status != USBD_NORMAL_COMPLETION) {
398                 DPRINTF(("ums_intr: status=%d\n", status));
399                 if (status == USBD_STALLED)
400                     usbd_clear_endpoint_stall_async(sc->sc_intrpipe);
401                 return;
402         }
403
404         ibuf = sc->sc_ibuf;
405         if (sc->sc_iid) {
406                 if (*ibuf++ != sc->sc_iid)
407                         return;
408         }
409
410         dx =  hid_get_data(ibuf, &sc->sc_loc_x);
411         dy = -hid_get_data(ibuf, &sc->sc_loc_y);
412         dz = -hid_get_data(ibuf, &sc->sc_loc_z);
413         for (i = 0; i < sc->nbuttons; i++)
414                 if (hid_get_data(ibuf, &sc->sc_loc_btn[i]))
415                         buttons |= (1 << UMS_BUT(i));
416
417         if (dx || dy || dz || (sc->flags & UMS_Z)
418             || buttons != sc->status.button) {
419                 DPRINTFN(5, ("ums_intr: x:%d y:%d z:%d buttons:0x%x\n",
420                         dx, dy, dz, buttons));
421
422                 sc->status.button = buttons;
423                 sc->status.dx += dx;
424                 sc->status.dy += dy;
425                 sc->status.dz += dz;
426
427                 /* Discard data in case of full buffer */
428                 if (sc->qcount == sizeof(sc->qbuf)) {
429                         DPRINTF(("Buffer full, discarded packet"));
430                         return;
431                 }
432
433                 /*
434                  * The Qtronix keyboard has a built in PS/2 port for a mouse.
435                  * The firmware once in a while posts a spurious button up
436                  * event. This event we ignore by doing a timeout for 50 msecs.
437                  * If we receive dx=dy=dz=buttons=0 before we add the event to
438                  * the queue.
439                  * In any other case we delete the timeout event.
440                  */
441                 if (sc->flags & UMS_SPUR_BUT_UP &&
442                     dx == 0 && dy == 0 && dz == 0 && buttons == 0) {
443                         callout_reset(&sc->sc_timeout, MS_TO_TICKS(50),
444                                     ums_add_to_queue_timeout, (void *) sc);
445                 } else {
446                         callout_stop(&sc->sc_timeout);
447                         ums_add_to_queue(sc, dx, dy, dz, buttons);
448                 }
449         }
450 }
451
452 static void
453 ums_add_to_queue_timeout(void *priv)
454 {
455         struct ums_softc *sc = priv;
456
457         crit_enter();
458         ums_add_to_queue(sc, 0, 0, 0, 0);
459         crit_exit();
460 }
461
462 static void
463 ums_add_to_queue(struct ums_softc *sc, int dx, int dy, int dz, int buttons)
464 {
465         /* Discard data in case of full buffer */
466         if (sc->qhead+sc->mode.packetsize > sizeof(sc->qbuf)) {
467                 DPRINTF(("Buffer full, discarded packet"));
468                 return;
469         }
470
471         if (dx >  254)          dx =  254;
472         if (dx < -256)          dx = -256;
473         if (dy >  254)          dy =  254;
474         if (dy < -256)          dy = -256;
475         if (dz >  126)          dz =  126;
476         if (dz < -128)          dz = -128;
477
478         sc->qbuf[sc->qhead] = sc->mode.syncmask[1];
479         sc->qbuf[sc->qhead] |= ~buttons & MOUSE_MSC_BUTTONS;
480         sc->qbuf[sc->qhead+1] = dx >> 1;
481         sc->qbuf[sc->qhead+2] = dy >> 1;
482         sc->qbuf[sc->qhead+3] = dx - (dx >> 1);
483         sc->qbuf[sc->qhead+4] = dy - (dy >> 1);
484
485         if (sc->mode.level == 1) {
486                 sc->qbuf[sc->qhead+5] = dz >> 1;
487                 sc->qbuf[sc->qhead+6] = dz - (dz >> 1);
488                 sc->qbuf[sc->qhead+7] = ((~buttons >> 3)
489                                          & MOUSE_SYS_EXTBUTTONS);
490         }
491
492         sc->qhead += sc->mode.packetsize;
493         sc->qcount += sc->mode.packetsize;
494         /* wrap round at end of buffer */
495         if (sc->qhead >= sizeof(sc->qbuf))
496                 sc->qhead = 0;
497
498         /* someone waiting for data */
499         if (sc->state & UMS_ASLEEP) {
500                 sc->state &= ~UMS_ASLEEP;
501                 wakeup(sc);
502         }
503         if (sc->state & UMS_SELECT) {
504                 sc->state &= ~UMS_SELECT;
505                 selwakeuppri(&sc->rsel, 0);
506         }
507 }
508
509 static int
510 ums_enable(void *v)
511 {
512         struct ums_softc *sc = v;
513
514         usbd_status err;
515
516         if (sc->sc_enabled)
517                 return EBUSY;
518
519         sc->sc_enabled = 1;
520         sc->qcount = 0;
521         sc->qhead = sc->qtail = 0;
522         sc->status.flags = 0;
523         sc->status.button = sc->status.obutton = 0;
524         sc->status.dx = sc->status.dy = sc->status.dz = 0;
525
526         callout_init(&sc->sc_timeout);
527
528         /* Set up interrupt pipe. */
529         err = usbd_open_pipe_intr(sc->sc_iface, sc->sc_ep_addr,
530                                 USBD_SHORT_XFER_OK, &sc->sc_intrpipe, sc,
531                                 sc->sc_ibuf, sc->sc_isize, ums_intr,
532                                 USBD_DEFAULT_INTERVAL);
533         if (err) {
534                 DPRINTF(("ums_enable: usbd_open_pipe_intr failed, error=%d\n",
535                          err));
536                 sc->sc_enabled = 0;
537                 return (EIO);
538         }
539         return (0);
540 }
541
542 static void
543 ums_disable(void *priv)
544 {
545         struct ums_softc *sc = priv;
546
547         callout_stop(&sc->sc_timeout);
548
549         /* Disable interrupts. */
550         usbd_abort_pipe(sc->sc_intrpipe);
551         usbd_close_pipe(sc->sc_intrpipe);
552
553         sc->sc_enabled = 0;
554
555         if (sc->qcount != 0)
556                 DPRINTF(("Discarded %d bytes in queue\n", sc->qcount));
557 }
558
559 static int
560 ums_open(struct dev_open_args *ap)
561 {
562         cdev_t dev = ap->a_head.a_dev;
563         struct ums_softc *sc;
564
565         USB_GET_SC_OPEN(ums, UMSUNIT(dev), sc);
566
567         return ums_enable(sc);
568 }
569
570 static int
571 ums_close(struct dev_close_args *ap)
572 {
573         cdev_t dev = ap->a_head.a_dev;
574         struct ums_softc *sc;
575
576         USB_GET_SC(ums, UMSUNIT(dev), sc);
577
578         if (!sc)
579                 return 0;
580
581         if (sc->sc_enabled)
582                 ums_disable(sc);
583
584         return 0;
585 }
586
587 static int
588 ums_read(struct dev_read_args *ap)
589 {
590         cdev_t dev = ap->a_head.a_dev;
591         struct uio *uio = ap->a_uio;
592         struct ums_softc *sc;
593         char buf[sizeof(sc->qbuf)];
594         int l = 0;
595         int error;
596
597         USB_GET_SC(ums, UMSUNIT(dev), sc);
598
599         crit_enter();
600         if (!sc) {
601                 crit_exit();
602                 return EIO;
603         }
604
605         while (sc->qcount == 0 )  {
606                 if (ap->a_ioflag & IO_NDELAY) {         /* non-blocking I/O */
607                         crit_exit();
608                         return EWOULDBLOCK;
609                 }
610
611                 sc->state |= UMS_ASLEEP;        /* blocking I/O */
612                 error = tsleep(sc, PCATCH, "umsrea", 0);
613                 if (error) {
614                         crit_exit();
615                         return error;
616                 } else if (!sc->sc_enabled) {
617                         crit_exit();
618                         return EINTR;
619                 }
620                 /* check whether the device is still there */
621
622                 sc = devclass_get_softc(ums_devclass, UMSUNIT(dev));
623                 if (!sc) {
624                         crit_exit();
625                         return EIO;
626                 }
627         }
628
629         /*
630          * The writer process only extends qcount and qtail. We could copy
631          * them and use the copies to do the copying out of the queue.
632          */
633
634         while ((sc->qcount > 0) && (uio->uio_resid > 0)) {
635                 l = (sc->qcount < uio->uio_resid? sc->qcount:uio->uio_resid);
636                 if (l > sizeof(buf))
637                         l = sizeof(buf);
638                 if (l > sizeof(sc->qbuf) - sc->qtail)           /* transfer till end of buf */
639                         l = sizeof(sc->qbuf) - sc->qtail;
640
641                 crit_exit();
642                 uiomove(&sc->qbuf[sc->qtail], l, uio);
643                 crit_enter();
644
645                 if ( sc->qcount - l < 0 ) {
646                         DPRINTF(("qcount below 0, count=%d l=%d\n", sc->qcount, l));
647                         sc->qcount = l;
648                 }
649                 sc->qcount -= l;        /* remove the bytes from the buffer */
650                 sc->qtail = (sc->qtail + l) % sizeof(sc->qbuf);
651         }
652         crit_exit();
653
654         return 0;
655 }
656
657 static int
658 ums_poll(struct dev_poll_args *ap)
659 {
660         cdev_t dev = ap->a_head.a_dev;
661         struct ums_softc *sc;
662         int revents = 0;
663
664         USB_GET_SC(ums, UMSUNIT(dev), sc);
665
666         if (!sc) {
667                 ap->a_events = 0;
668                 return 0;
669         }
670
671         crit_enter();
672         if (ap->a_events & (POLLIN | POLLRDNORM)) {
673                 if (sc->qcount) {
674                         revents = ap->a_events & (POLLIN | POLLRDNORM);
675                 } else {
676                         sc->state |= UMS_SELECT;
677                         selrecord(curthread, &sc->rsel);
678                 }
679         }
680         crit_exit();
681         ap->a_events = revents;
682         return (0);
683 }
684
685 int
686 ums_ioctl(struct dev_ioctl_args *ap)
687 {
688         cdev_t dev = ap->a_head.a_dev;
689         struct ums_softc *sc;
690         int error = 0;
691         mousemode_t mode;
692
693         USB_GET_SC(ums, UMSUNIT(dev), sc);
694
695         if (!sc)
696                 return EIO;
697
698         switch(ap->a_cmd) {
699         case MOUSE_GETHWINFO:
700                 *(mousehw_t *)ap->a_data = sc->hw;
701                 break;
702         case MOUSE_GETMODE:
703                 *(mousemode_t *)ap->a_data = sc->mode;
704                 break;
705         case MOUSE_SETMODE:
706                 mode = *(mousemode_t *)ap->a_data;
707
708                 if (mode.level == -1)
709                         /* don't change the current setting */
710                         ;
711                 else if ((mode.level < 0) || (mode.level > 1))
712                         return (EINVAL);
713
714                 crit_enter();
715                 sc->mode.level = mode.level;
716
717                 if (sc->mode.level == 0) {
718                         if (sc->nbuttons > MOUSE_MSC_MAXBUTTON)
719                                 sc->hw.buttons = MOUSE_MSC_MAXBUTTON;
720                         else
721                                 sc->hw.buttons = sc->nbuttons;
722                         sc->mode.protocol = MOUSE_PROTO_MSC;
723                         sc->mode.packetsize = MOUSE_MSC_PACKETSIZE;
724                         sc->mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
725                         sc->mode.syncmask[1] = MOUSE_MSC_SYNC;
726                 } else if (sc->mode.level == 1) {
727                         if (sc->nbuttons > MOUSE_SYS_MAXBUTTON)
728                                 sc->hw.buttons = MOUSE_SYS_MAXBUTTON;
729                         else
730                                 sc->hw.buttons = sc->nbuttons;
731                         sc->mode.protocol = MOUSE_PROTO_SYSMOUSE;
732                         sc->mode.packetsize = MOUSE_SYS_PACKETSIZE;
733                         sc->mode.syncmask[0] = MOUSE_SYS_SYNCMASK;
734                         sc->mode.syncmask[1] = MOUSE_SYS_SYNC;
735                 }
736
737                 bzero(sc->qbuf, sizeof(sc->qbuf));
738                 sc->qhead = sc->qtail = sc->qcount = 0;
739                 crit_exit();
740
741                 break;
742         case MOUSE_GETLEVEL:
743                 *(int *)ap->a_data = sc->mode.level;
744                 break;
745         case MOUSE_SETLEVEL:
746                 if (*(int *)ap->a_data < 0 || *(int *)ap->a_data > 1)
747                         return (EINVAL);
748
749                 crit_enter();
750                 sc->mode.level = *(int *)ap->a_data;
751
752                 if (sc->mode.level == 0) {
753                         if (sc->nbuttons > MOUSE_MSC_MAXBUTTON)
754                                 sc->hw.buttons = MOUSE_MSC_MAXBUTTON;
755                         else
756                                 sc->hw.buttons = sc->nbuttons;
757                         sc->mode.protocol = MOUSE_PROTO_MSC;
758                         sc->mode.packetsize = MOUSE_MSC_PACKETSIZE;
759                         sc->mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
760                         sc->mode.syncmask[1] = MOUSE_MSC_SYNC;
761                 } else if (sc->mode.level == 1) {
762                         if (sc->nbuttons > MOUSE_SYS_MAXBUTTON)
763                                 sc->hw.buttons = MOUSE_SYS_MAXBUTTON;
764                         else
765                                 sc->hw.buttons = sc->nbuttons;
766                         sc->mode.protocol = MOUSE_PROTO_SYSMOUSE;
767                         sc->mode.packetsize = MOUSE_SYS_PACKETSIZE;
768                         sc->mode.syncmask[0] = MOUSE_SYS_SYNCMASK;
769                         sc->mode.syncmask[1] = MOUSE_SYS_SYNC;
770                 }
771
772                 bzero(sc->qbuf, sizeof(sc->qbuf));
773                 sc->qhead = sc->qtail = sc->qcount = 0;
774                 crit_exit();
775
776                 break;
777         case MOUSE_GETSTATUS: {
778                 mousestatus_t *status = (mousestatus_t *) ap->a_data;
779
780                 crit_enter();
781                 *status = sc->status;
782                 sc->status.obutton = sc->status.button;
783                 sc->status.button = 0;
784                 sc->status.dx = sc->status.dy = sc->status.dz = 0;
785                 crit_exit();
786
787                 if (status->dx || status->dy || status->dz)
788                         status->flags |= MOUSE_POSCHANGED;
789                 if (status->button != status->obutton)
790                         status->flags |= MOUSE_BUTTONSCHANGED;
791                 break;
792                 }
793         default:
794                 error = ENOTTY;
795         }
796
797         return error;
798 }
799
800 DRIVER_MODULE(ums, uhub, ums_driver, ums_devclass, usbd_driver_load, 0);