112bd3c8bSSascha Wildner /*-
212bd3c8bSSascha Wildner * Copyright (c) 1998 The NetBSD Foundation, Inc.
312bd3c8bSSascha Wildner * All rights reserved.
412bd3c8bSSascha Wildner *
512bd3c8bSSascha Wildner * This code is derived from software contributed to The NetBSD Foundation
612bd3c8bSSascha Wildner * by Lennart Augustsson (lennart@augustsson.net) at
712bd3c8bSSascha Wildner * Carlstedt Research & Technology.
812bd3c8bSSascha Wildner *
912bd3c8bSSascha Wildner * Redistribution and use in source and binary forms, with or without
1012bd3c8bSSascha Wildner * modification, are permitted provided that the following conditions
1112bd3c8bSSascha Wildner * are met:
1212bd3c8bSSascha Wildner * 1. Redistributions of source code must retain the above copyright
1312bd3c8bSSascha Wildner * notice, this list of conditions and the following disclaimer.
1412bd3c8bSSascha Wildner * 2. Redistributions in binary form must reproduce the above copyright
1512bd3c8bSSascha Wildner * notice, this list of conditions and the following disclaimer in the
1612bd3c8bSSascha Wildner * documentation and/or other materials provided with the distribution.
1712bd3c8bSSascha Wildner *
1812bd3c8bSSascha Wildner * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
1912bd3c8bSSascha Wildner * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
2012bd3c8bSSascha Wildner * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
2112bd3c8bSSascha Wildner * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
2212bd3c8bSSascha Wildner * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
2312bd3c8bSSascha Wildner * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
2412bd3c8bSSascha Wildner * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
2512bd3c8bSSascha Wildner * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
2612bd3c8bSSascha Wildner * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
2712bd3c8bSSascha Wildner * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
2812bd3c8bSSascha Wildner * POSSIBILITY OF SUCH DAMAGE.
2912bd3c8bSSascha Wildner */
3012bd3c8bSSascha Wildner
3112bd3c8bSSascha Wildner /*
3212bd3c8bSSascha Wildner * HID spec: http://www.usb.org/developers/devclass_docs/HID1_11.pdf
3312bd3c8bSSascha Wildner */
3412bd3c8bSSascha Wildner
353d1294c7SPeeter Must #include "opt_evdev.h"
363d1294c7SPeeter Must
3712bd3c8bSSascha Wildner #include <sys/stdint.h>
3812bd3c8bSSascha Wildner #include <sys/param.h>
3912bd3c8bSSascha Wildner #include <sys/queue.h>
4012bd3c8bSSascha Wildner #include <sys/types.h>
4112bd3c8bSSascha Wildner #include <sys/systm.h>
4212bd3c8bSSascha Wildner #include <sys/kernel.h>
4312bd3c8bSSascha Wildner #include <sys/bus.h>
4412bd3c8bSSascha Wildner #include <sys/module.h>
4512bd3c8bSSascha Wildner #include <sys/lock.h>
4612bd3c8bSSascha Wildner #include <sys/condvar.h>
4712bd3c8bSSascha Wildner #include <sys/sysctl.h>
4812bd3c8bSSascha Wildner #include <sys/unistd.h>
4912bd3c8bSSascha Wildner #include <sys/callout.h>
5012bd3c8bSSascha Wildner #include <sys/malloc.h>
512b3f93eaSMatthew Dillon #include <sys/caps.h>
5212bd3c8bSSascha Wildner #include <sys/conf.h>
5312bd3c8bSSascha Wildner #include <sys/fcntl.h>
5412bd3c8bSSascha Wildner #include <sys/sbuf.h>
5512bd3c8bSSascha Wildner
568d7664cbSSascha Wildner #include <bus/u4b/usb.h>
578d7664cbSSascha Wildner #include <bus/u4b/usbdi.h>
588d7664cbSSascha Wildner #include <bus/u4b/usbdi_util.h>
598d7664cbSSascha Wildner #include <bus/u4b/usbhid.h>
60ef4aa9ffSSascha Wildner #include "usbdevs.h"
6112bd3c8bSSascha Wildner
6212bd3c8bSSascha Wildner #define USB_DEBUG_VAR ums_debug
638d7664cbSSascha Wildner #include <bus/u4b/usb_debug.h>
6412bd3c8bSSascha Wildner
658d7664cbSSascha Wildner #include <bus/u4b/quirk/usb_quirk.h>
6612bd3c8bSSascha Wildner
673d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
683d1294c7SPeeter Must #include <dev/misc/evdev/input.h>
693d1294c7SPeeter Must #include <dev/misc/evdev/evdev.h>
703d1294c7SPeeter Must #endif
713d1294c7SPeeter Must
7212bd3c8bSSascha Wildner #include <sys/filio.h>
7312bd3c8bSSascha Wildner #include <sys/tty.h>
7412bd3c8bSSascha Wildner #include <sys/mouse.h>
7512bd3c8bSSascha Wildner
7612bd3c8bSSascha Wildner #ifdef USB_DEBUG
7712bd3c8bSSascha Wildner static int ums_debug = 0;
7812bd3c8bSSascha Wildner
7912bd3c8bSSascha Wildner static SYSCTL_NODE(_hw_usb, OID_AUTO, ums, CTLFLAG_RW, 0, "USB ums");
80a9b765b7SSascha Wildner SYSCTL_INT(_hw_usb_ums, OID_AUTO, debug, CTLFLAG_RW,
8112bd3c8bSSascha Wildner &ums_debug, 0, "Debug level");
8212bd3c8bSSascha Wildner #endif
8312bd3c8bSSascha Wildner
8412bd3c8bSSascha Wildner #define MOUSE_FLAGS_MASK (HIO_CONST|HIO_RELATIVE)
8512bd3c8bSSascha Wildner #define MOUSE_FLAGS (HIO_RELATIVE)
8612bd3c8bSSascha Wildner
8712bd3c8bSSascha Wildner #define UMS_BUF_SIZE 8 /* bytes */
8812bd3c8bSSascha Wildner #define UMS_IFQ_MAXLEN 50 /* units */
8912bd3c8bSSascha Wildner #define UMS_BUTTON_MAX 31 /* exclusive, must be less than 32 */
9012bd3c8bSSascha Wildner #define UMS_BUT(i) ((i) < 3 ? (((i) + 2) % 3) : (i))
9112bd3c8bSSascha Wildner #define UMS_INFO_MAX 2 /* maximum number of HID sets */
9212bd3c8bSSascha Wildner
9312bd3c8bSSascha Wildner enum {
9412bd3c8bSSascha Wildner UMS_INTR_DT,
9512bd3c8bSSascha Wildner UMS_N_TRANSFER,
9612bd3c8bSSascha Wildner };
9712bd3c8bSSascha Wildner
9812bd3c8bSSascha Wildner struct ums_info {
9912bd3c8bSSascha Wildner struct hid_location sc_loc_w;
10012bd3c8bSSascha Wildner struct hid_location sc_loc_x;
10112bd3c8bSSascha Wildner struct hid_location sc_loc_y;
10212bd3c8bSSascha Wildner struct hid_location sc_loc_z;
10312bd3c8bSSascha Wildner struct hid_location sc_loc_t;
10412bd3c8bSSascha Wildner struct hid_location sc_loc_btn[UMS_BUTTON_MAX];
10512bd3c8bSSascha Wildner
10612bd3c8bSSascha Wildner uint32_t sc_flags;
10712bd3c8bSSascha Wildner #define UMS_FLAG_X_AXIS 0x0001
10812bd3c8bSSascha Wildner #define UMS_FLAG_Y_AXIS 0x0002
10912bd3c8bSSascha Wildner #define UMS_FLAG_Z_AXIS 0x0004
11012bd3c8bSSascha Wildner #define UMS_FLAG_T_AXIS 0x0008
11112bd3c8bSSascha Wildner #define UMS_FLAG_SBU 0x0010 /* spurious button up events */
11212bd3c8bSSascha Wildner #define UMS_FLAG_REVZ 0x0020 /* Z-axis is reversed */
11312bd3c8bSSascha Wildner #define UMS_FLAG_W_AXIS 0x0040
11412bd3c8bSSascha Wildner
11512bd3c8bSSascha Wildner uint8_t sc_iid_w;
11612bd3c8bSSascha Wildner uint8_t sc_iid_x;
11712bd3c8bSSascha Wildner uint8_t sc_iid_y;
11812bd3c8bSSascha Wildner uint8_t sc_iid_z;
11912bd3c8bSSascha Wildner uint8_t sc_iid_t;
12012bd3c8bSSascha Wildner uint8_t sc_iid_btn[UMS_BUTTON_MAX];
12112bd3c8bSSascha Wildner uint8_t sc_buttons;
12212bd3c8bSSascha Wildner };
12312bd3c8bSSascha Wildner
12412bd3c8bSSascha Wildner struct ums_softc {
12512bd3c8bSSascha Wildner struct usb_fifo_sc sc_fifo;
1268d7664cbSSascha Wildner struct lock sc_lock;
12712bd3c8bSSascha Wildner struct usb_callout sc_callout;
12812bd3c8bSSascha Wildner struct ums_info sc_info[UMS_INFO_MAX];
12912bd3c8bSSascha Wildner
13012bd3c8bSSascha Wildner mousehw_t sc_hw;
13112bd3c8bSSascha Wildner mousemode_t sc_mode;
13212bd3c8bSSascha Wildner mousestatus_t sc_status;
13312bd3c8bSSascha Wildner
13412bd3c8bSSascha Wildner struct usb_xfer *sc_xfer[UMS_N_TRANSFER];
13512bd3c8bSSascha Wildner
13612bd3c8bSSascha Wildner int sc_pollrate;
13757bed822SMarkus Pfeiffer int sc_fflags;
1384bcecc80SMatthew Dillon int sc_read_running;
1393d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
1403d1294c7SPeeter Must int sc_evflags;
1413d1294c7SPeeter Must #define UMS_EVDEV_OPENED 1
1423d1294c7SPeeter Must #endif
14312bd3c8bSSascha Wildner
14412bd3c8bSSascha Wildner uint8_t sc_buttons;
14512bd3c8bSSascha Wildner uint8_t sc_iid;
14612bd3c8bSSascha Wildner uint8_t sc_temp[64];
1473d1294c7SPeeter Must
1483d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
1493d1294c7SPeeter Must struct evdev_dev *sc_evdev;
1503d1294c7SPeeter Must #endif
15112bd3c8bSSascha Wildner };
15212bd3c8bSSascha Wildner
15312bd3c8bSSascha Wildner static void ums_put_queue_timeout(void *__sc);
15412bd3c8bSSascha Wildner
15512bd3c8bSSascha Wildner static usb_callback_t ums_intr_callback;
15612bd3c8bSSascha Wildner
15712bd3c8bSSascha Wildner static device_probe_t ums_probe;
15812bd3c8bSSascha Wildner static device_attach_t ums_attach;
15912bd3c8bSSascha Wildner static device_detach_t ums_detach;
16012bd3c8bSSascha Wildner
1613d1294c7SPeeter Must static usb_fifo_cmd_t ums_fifo_start_read;
1623d1294c7SPeeter Must static usb_fifo_cmd_t ums_fifo_stop_read;
1633d1294c7SPeeter Must static usb_fifo_open_t ums_fifo_open;
1643d1294c7SPeeter Must static usb_fifo_close_t ums_fifo_close;
1653d1294c7SPeeter Must static usb_fifo_ioctl_t ums_fifo_ioctl;
16612bd3c8bSSascha Wildner
1673d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
1683d1294c7SPeeter Must static evdev_open_t ums_ev_open;
1693d1294c7SPeeter Must static evdev_close_t ums_ev_close;
1703d1294c7SPeeter Must static void ums_evdev_push(struct ums_softc *, int32_t, int32_t,
1713d1294c7SPeeter Must int32_t, int32_t, int32_t);
1723d1294c7SPeeter Must #endif
1733d1294c7SPeeter Must
1743d1294c7SPeeter Must static void ums_start_rx(struct ums_softc *);
1753d1294c7SPeeter Must static void ums_stop_rx(struct ums_softc *);
17612bd3c8bSSascha Wildner static void ums_put_queue(struct ums_softc *, int32_t, int32_t,
17712bd3c8bSSascha Wildner int32_t, int32_t, int32_t);
178b7abfd18SSascha Wildner #if 0 /* XXX */
17912bd3c8bSSascha Wildner static int ums_sysctl_handler_parseinfo(SYSCTL_HANDLER_ARGS);
180b7abfd18SSascha Wildner #endif
18112bd3c8bSSascha Wildner
18212bd3c8bSSascha Wildner static struct usb_fifo_methods ums_fifo_methods = {
1833d1294c7SPeeter Must .f_open = &ums_fifo_open,
1843d1294c7SPeeter Must .f_close = &ums_fifo_close,
1853d1294c7SPeeter Must .f_ioctl = &ums_fifo_ioctl,
1863d1294c7SPeeter Must .f_start_read = &ums_fifo_start_read,
1873d1294c7SPeeter Must .f_stop_read = &ums_fifo_stop_read,
18812bd3c8bSSascha Wildner .basename[0] = "ums",
18912bd3c8bSSascha Wildner };
19012bd3c8bSSascha Wildner
1913d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
1923d1294c7SPeeter Must static const struct evdev_methods ums_evdev_methods = {
1933d1294c7SPeeter Must .ev_open = &ums_ev_open,
1943d1294c7SPeeter Must .ev_close = &ums_ev_close,
1953d1294c7SPeeter Must };
1963d1294c7SPeeter Must #endif
1973d1294c7SPeeter Must
19812bd3c8bSSascha Wildner static void
ums_put_queue_timeout(void * __sc)19912bd3c8bSSascha Wildner ums_put_queue_timeout(void *__sc)
20012bd3c8bSSascha Wildner {
20112bd3c8bSSascha Wildner struct ums_softc *sc = __sc;
20212bd3c8bSSascha Wildner
2038d7664cbSSascha Wildner KKASSERT(lockowned(&sc->sc_lock));
20412bd3c8bSSascha Wildner
20512bd3c8bSSascha Wildner ums_put_queue(sc, 0, 0, 0, 0, 0);
2063d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
2073d1294c7SPeeter Must ums_evdev_push(sc, 0, 0, 0, 0, 0);
2083d1294c7SPeeter Must #endif
20912bd3c8bSSascha Wildner }
21012bd3c8bSSascha Wildner
21112bd3c8bSSascha Wildner static void
ums_intr_callback(struct usb_xfer * xfer,usb_error_t error)21212bd3c8bSSascha Wildner ums_intr_callback(struct usb_xfer *xfer, usb_error_t error)
21312bd3c8bSSascha Wildner {
21412bd3c8bSSascha Wildner struct ums_softc *sc = usbd_xfer_softc(xfer);
21512bd3c8bSSascha Wildner struct ums_info *info = &sc->sc_info[0];
21612bd3c8bSSascha Wildner struct usb_page_cache *pc;
21712bd3c8bSSascha Wildner uint8_t *buf = sc->sc_temp;
21812bd3c8bSSascha Wildner int32_t buttons = 0;
21912bd3c8bSSascha Wildner int32_t buttons_found = 0;
2203d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
2213d1294c7SPeeter Must int32_t buttons_reported = 0;
2223d1294c7SPeeter Must #endif
22312bd3c8bSSascha Wildner int32_t dw = 0;
22412bd3c8bSSascha Wildner int32_t dx = 0;
22512bd3c8bSSascha Wildner int32_t dy = 0;
22612bd3c8bSSascha Wildner int32_t dz = 0;
22712bd3c8bSSascha Wildner int32_t dt = 0;
22812bd3c8bSSascha Wildner uint8_t i;
22912bd3c8bSSascha Wildner uint8_t id;
23012bd3c8bSSascha Wildner int len;
23112bd3c8bSSascha Wildner
23212bd3c8bSSascha Wildner usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
23312bd3c8bSSascha Wildner
23412bd3c8bSSascha Wildner switch (USB_GET_STATE(xfer)) {
23512bd3c8bSSascha Wildner case USB_ST_TRANSFERRED:
23612bd3c8bSSascha Wildner DPRINTFN(6, "sc=%p actlen=%d\n", sc, len);
23712bd3c8bSSascha Wildner
23857bed822SMarkus Pfeiffer if (len > (int)sizeof(sc->sc_temp)) {
23912bd3c8bSSascha Wildner DPRINTFN(6, "truncating large packet to %zu bytes\n",
24012bd3c8bSSascha Wildner sizeof(sc->sc_temp));
24112bd3c8bSSascha Wildner len = sizeof(sc->sc_temp);
24212bd3c8bSSascha Wildner }
24312bd3c8bSSascha Wildner if (len == 0)
24412bd3c8bSSascha Wildner goto tr_setup;
24512bd3c8bSSascha Wildner
24612bd3c8bSSascha Wildner pc = usbd_xfer_get_frame(xfer, 0);
24712bd3c8bSSascha Wildner usbd_copy_out(pc, 0, buf, len);
24812bd3c8bSSascha Wildner
24912bd3c8bSSascha Wildner DPRINTFN(6, "data = %02x %02x %02x %02x "
25012bd3c8bSSascha Wildner "%02x %02x %02x %02x\n",
25112bd3c8bSSascha Wildner (len > 0) ? buf[0] : 0, (len > 1) ? buf[1] : 0,
25212bd3c8bSSascha Wildner (len > 2) ? buf[2] : 0, (len > 3) ? buf[3] : 0,
25312bd3c8bSSascha Wildner (len > 4) ? buf[4] : 0, (len > 5) ? buf[5] : 0,
25412bd3c8bSSascha Wildner (len > 6) ? buf[6] : 0, (len > 7) ? buf[7] : 0);
25512bd3c8bSSascha Wildner
25612bd3c8bSSascha Wildner if (sc->sc_iid) {
25712bd3c8bSSascha Wildner id = *buf;
25812bd3c8bSSascha Wildner
25912bd3c8bSSascha Wildner len--;
26012bd3c8bSSascha Wildner buf++;
26112bd3c8bSSascha Wildner
26212bd3c8bSSascha Wildner } else {
26312bd3c8bSSascha Wildner id = 0;
26412bd3c8bSSascha Wildner if (sc->sc_info[0].sc_flags & UMS_FLAG_SBU) {
26512bd3c8bSSascha Wildner if ((*buf == 0x14) || (*buf == 0x15)) {
26612bd3c8bSSascha Wildner goto tr_setup;
26712bd3c8bSSascha Wildner }
26812bd3c8bSSascha Wildner }
26912bd3c8bSSascha Wildner }
27012bd3c8bSSascha Wildner
27112bd3c8bSSascha Wildner repeat:
27212bd3c8bSSascha Wildner if ((info->sc_flags & UMS_FLAG_W_AXIS) &&
27312bd3c8bSSascha Wildner (id == info->sc_iid_w))
27412bd3c8bSSascha Wildner dw += hid_get_data(buf, len, &info->sc_loc_w);
27512bd3c8bSSascha Wildner
27612bd3c8bSSascha Wildner if ((info->sc_flags & UMS_FLAG_X_AXIS) &&
27712bd3c8bSSascha Wildner (id == info->sc_iid_x))
27812bd3c8bSSascha Wildner dx += hid_get_data(buf, len, &info->sc_loc_x);
27912bd3c8bSSascha Wildner
28012bd3c8bSSascha Wildner if ((info->sc_flags & UMS_FLAG_Y_AXIS) &&
28112bd3c8bSSascha Wildner (id == info->sc_iid_y))
28212bd3c8bSSascha Wildner dy = -hid_get_data(buf, len, &info->sc_loc_y);
28312bd3c8bSSascha Wildner
28412bd3c8bSSascha Wildner if ((info->sc_flags & UMS_FLAG_Z_AXIS) &&
28512bd3c8bSSascha Wildner (id == info->sc_iid_z)) {
28612bd3c8bSSascha Wildner int32_t temp;
28712bd3c8bSSascha Wildner temp = hid_get_data(buf, len, &info->sc_loc_z);
28812bd3c8bSSascha Wildner if (info->sc_flags & UMS_FLAG_REVZ)
28912bd3c8bSSascha Wildner temp = -temp;
29012bd3c8bSSascha Wildner dz -= temp;
29112bd3c8bSSascha Wildner }
29212bd3c8bSSascha Wildner
29312bd3c8bSSascha Wildner if ((info->sc_flags & UMS_FLAG_T_AXIS) &&
29412bd3c8bSSascha Wildner (id == info->sc_iid_t))
29512bd3c8bSSascha Wildner dt -= hid_get_data(buf, len, &info->sc_loc_t);
29612bd3c8bSSascha Wildner
29712bd3c8bSSascha Wildner for (i = 0; i < info->sc_buttons; i++) {
29812bd3c8bSSascha Wildner uint32_t mask;
29912bd3c8bSSascha Wildner mask = 1UL << UMS_BUT(i);
30012bd3c8bSSascha Wildner /* check for correct button ID */
30112bd3c8bSSascha Wildner if (id != info->sc_iid_btn[i])
30212bd3c8bSSascha Wildner continue;
30312bd3c8bSSascha Wildner /* check for button pressed */
30412bd3c8bSSascha Wildner if (hid_get_data(buf, len, &info->sc_loc_btn[i]))
30512bd3c8bSSascha Wildner buttons |= mask;
30612bd3c8bSSascha Wildner /* register button mask */
30712bd3c8bSSascha Wildner buttons_found |= mask;
30812bd3c8bSSascha Wildner }
30912bd3c8bSSascha Wildner
31012bd3c8bSSascha Wildner if (++info != &sc->sc_info[UMS_INFO_MAX])
31112bd3c8bSSascha Wildner goto repeat;
31212bd3c8bSSascha Wildner
3133d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
3143d1294c7SPeeter Must buttons_reported = buttons;
3153d1294c7SPeeter Must #endif
31612bd3c8bSSascha Wildner /* keep old button value(s) for non-detected buttons */
31712bd3c8bSSascha Wildner buttons |= sc->sc_status.button & ~buttons_found;
31812bd3c8bSSascha Wildner
31912bd3c8bSSascha Wildner if (dx || dy || dz || dt || dw ||
32012bd3c8bSSascha Wildner (buttons != sc->sc_status.button)) {
3213b964699Szrj
32212bd3c8bSSascha Wildner DPRINTFN(6, "x:%d y:%d z:%d t:%d w:%d buttons:0x%08x\n",
32312bd3c8bSSascha Wildner dx, dy, dz, dt, dw, buttons);
32412bd3c8bSSascha Wildner
32512bd3c8bSSascha Wildner /* translate T-axis into button presses until further */
32612bd3c8bSSascha Wildner if (dt > 0)
32712bd3c8bSSascha Wildner buttons |= 1UL << 3;
32812bd3c8bSSascha Wildner else if (dt < 0)
32912bd3c8bSSascha Wildner buttons |= 1UL << 4;
33012bd3c8bSSascha Wildner
33112bd3c8bSSascha Wildner sc->sc_status.button = buttons;
33212bd3c8bSSascha Wildner sc->sc_status.dx += dx;
33312bd3c8bSSascha Wildner sc->sc_status.dy += dy;
33412bd3c8bSSascha Wildner sc->sc_status.dz += dz;
33512bd3c8bSSascha Wildner /*
33612bd3c8bSSascha Wildner * sc->sc_status.dt += dt;
33712bd3c8bSSascha Wildner * no way to export this yet
33812bd3c8bSSascha Wildner */
33912bd3c8bSSascha Wildner
34012bd3c8bSSascha Wildner /*
34112bd3c8bSSascha Wildner * The Qtronix keyboard has a built in PS/2
34212bd3c8bSSascha Wildner * port for a mouse. The firmware once in a
34312bd3c8bSSascha Wildner * while posts a spurious button up
34412bd3c8bSSascha Wildner * event. This event we ignore by doing a
34512bd3c8bSSascha Wildner * timeout for 50 msecs. If we receive
34612bd3c8bSSascha Wildner * dx=dy=dz=buttons=0 before we add the event
34712bd3c8bSSascha Wildner * to the queue. In any other case we delete
34812bd3c8bSSascha Wildner * the timeout event.
34912bd3c8bSSascha Wildner */
35012bd3c8bSSascha Wildner if ((sc->sc_info[0].sc_flags & UMS_FLAG_SBU) &&
35112bd3c8bSSascha Wildner (dx == 0) && (dy == 0) && (dz == 0) && (dt == 0) &&
35212bd3c8bSSascha Wildner (dw == 0) && (buttons == 0)) {
35312bd3c8bSSascha Wildner
35412bd3c8bSSascha Wildner usb_callout_reset(&sc->sc_callout, hz / 20,
35512bd3c8bSSascha Wildner &ums_put_queue_timeout, sc);
35612bd3c8bSSascha Wildner } else {
35712bd3c8bSSascha Wildner
35812bd3c8bSSascha Wildner usb_callout_stop(&sc->sc_callout);
35912bd3c8bSSascha Wildner
36012bd3c8bSSascha Wildner ums_put_queue(sc, dx, dy, dz, dt, buttons);
3613d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
3623d1294c7SPeeter Must ums_evdev_push(sc, dx, dy, dz, dt,
3633d1294c7SPeeter Must buttons_reported);
3643d1294c7SPeeter Must #endif
36512bd3c8bSSascha Wildner }
36612bd3c8bSSascha Wildner }
36712bd3c8bSSascha Wildner case USB_ST_SETUP:
36812bd3c8bSSascha Wildner tr_setup:
36912bd3c8bSSascha Wildner /* check if we can put more data into the FIFO */
3703d1294c7SPeeter Must if (usb_fifo_put_bytes_max(sc->sc_fifo.fp[USB_FIFO_RX]) == 0) {
37101bbe85eSMatthew Dillon /*
37201bbe85eSMatthew Dillon * When the FIFO becomes full we stop cycling the
37301bbe85eSMatthew Dillon * poll and must clear sc_read_running. The next
37401bbe85eSMatthew Dillon * userland read/select/kqueue request will call
37501bbe85eSMatthew Dillon * f_start_read to get it going again.
37601bbe85eSMatthew Dillon */
37701bbe85eSMatthew Dillon sc->sc_read_running = 0;
3783d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
3793d1294c7SPeeter Must /* XXX check logic. */
3803d1294c7SPeeter Must if (sc->sc_evflags == 0)
3813d1294c7SPeeter Must break;
3823d1294c7SPeeter Must #else
3833d1294c7SPeeter Must break;
3843d1294c7SPeeter Must #endif
38512bd3c8bSSascha Wildner }
3863d1294c7SPeeter Must
3873d1294c7SPeeter Must usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
3883d1294c7SPeeter Must usbd_transfer_submit(xfer);
38912bd3c8bSSascha Wildner break;
39012bd3c8bSSascha Wildner
39112bd3c8bSSascha Wildner default: /* Error */
39212bd3c8bSSascha Wildner if (error != USB_ERR_CANCELLED) {
39312bd3c8bSSascha Wildner /* try clear stall first */
39412bd3c8bSSascha Wildner usbd_xfer_set_stall(xfer);
39512bd3c8bSSascha Wildner goto tr_setup;
39612bd3c8bSSascha Wildner }
39712bd3c8bSSascha Wildner break;
39812bd3c8bSSascha Wildner }
39912bd3c8bSSascha Wildner }
40012bd3c8bSSascha Wildner
40112bd3c8bSSascha Wildner static const struct usb_config ums_config[UMS_N_TRANSFER] = {
40212bd3c8bSSascha Wildner
40312bd3c8bSSascha Wildner [UMS_INTR_DT] = {
40412bd3c8bSSascha Wildner .type = UE_INTERRUPT,
40512bd3c8bSSascha Wildner .endpoint = UE_ADDR_ANY,
40612bd3c8bSSascha Wildner .direction = UE_DIR_IN,
40712bd3c8bSSascha Wildner .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
40812bd3c8bSSascha Wildner .bufsize = 0, /* use wMaxPacketSize */
40912bd3c8bSSascha Wildner .callback = &ums_intr_callback,
41012bd3c8bSSascha Wildner },
41112bd3c8bSSascha Wildner };
41212bd3c8bSSascha Wildner
41312bd3c8bSSascha Wildner /* A match on these entries will load ums */
41412bd3c8bSSascha Wildner static const STRUCT_USB_HOST_ID __used ums_devs[] = {
41512bd3c8bSSascha Wildner {USB_IFACE_CLASS(UICLASS_HID),
41612bd3c8bSSascha Wildner USB_IFACE_SUBCLASS(UISUBCLASS_BOOT),
41712bd3c8bSSascha Wildner USB_IFACE_PROTOCOL(UIPROTO_MOUSE),},
41812bd3c8bSSascha Wildner };
41912bd3c8bSSascha Wildner
42012bd3c8bSSascha Wildner static int
ums_probe(device_t dev)42112bd3c8bSSascha Wildner ums_probe(device_t dev)
42212bd3c8bSSascha Wildner {
42312bd3c8bSSascha Wildner struct usb_attach_arg *uaa = device_get_ivars(dev);
42412bd3c8bSSascha Wildner void *d_ptr;
42557bed822SMarkus Pfeiffer int error;
42612bd3c8bSSascha Wildner uint16_t d_len;
42712bd3c8bSSascha Wildner
42812bd3c8bSSascha Wildner DPRINTFN(11, "\n");
42912bd3c8bSSascha Wildner
43012bd3c8bSSascha Wildner if (uaa->usb_mode != USB_MODE_HOST)
43112bd3c8bSSascha Wildner return (ENXIO);
43212bd3c8bSSascha Wildner
43312bd3c8bSSascha Wildner if (uaa->info.bInterfaceClass != UICLASS_HID)
43412bd3c8bSSascha Wildner return (ENXIO);
43512bd3c8bSSascha Wildner
43657bed822SMarkus Pfeiffer if (usb_test_quirk(uaa, UQ_UMS_IGNORE))
43757bed822SMarkus Pfeiffer return (ENXIO);
43857bed822SMarkus Pfeiffer
43912bd3c8bSSascha Wildner if ((uaa->info.bInterfaceSubClass == UISUBCLASS_BOOT) &&
44012bd3c8bSSascha Wildner (uaa->info.bInterfaceProtocol == UIPROTO_MOUSE))
44112bd3c8bSSascha Wildner return (BUS_PROBE_DEFAULT);
44212bd3c8bSSascha Wildner
44312bd3c8bSSascha Wildner error = usbd_req_get_hid_desc(uaa->device, NULL,
44412bd3c8bSSascha Wildner &d_ptr, &d_len, M_TEMP, uaa->info.bIfaceIndex);
44512bd3c8bSSascha Wildner
44612bd3c8bSSascha Wildner if (error)
44712bd3c8bSSascha Wildner return (ENXIO);
44812bd3c8bSSascha Wildner
44957bed822SMarkus Pfeiffer if (hid_is_mouse(d_ptr, d_len))
45057bed822SMarkus Pfeiffer error = BUS_PROBE_DEFAULT;
45157bed822SMarkus Pfeiffer else
45257bed822SMarkus Pfeiffer error = ENXIO;
45357bed822SMarkus Pfeiffer
4548d7664cbSSascha Wildner kfree(d_ptr, M_TEMP);
45557bed822SMarkus Pfeiffer return (error);
45612bd3c8bSSascha Wildner }
45712bd3c8bSSascha Wildner
45812bd3c8bSSascha Wildner static void
ums_hid_parse(struct ums_softc * sc,device_t dev,const uint8_t * buf,uint16_t len,uint8_t index)45912bd3c8bSSascha Wildner ums_hid_parse(struct ums_softc *sc, device_t dev, const uint8_t *buf,
46012bd3c8bSSascha Wildner uint16_t len, uint8_t index)
46112bd3c8bSSascha Wildner {
46212bd3c8bSSascha Wildner struct ums_info *info = &sc->sc_info[index];
46312bd3c8bSSascha Wildner uint32_t flags;
46412bd3c8bSSascha Wildner uint8_t i;
46512bd3c8bSSascha Wildner uint8_t j;
46612bd3c8bSSascha Wildner
46712bd3c8bSSascha Wildner if (hid_locate(buf, len, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X),
46812bd3c8bSSascha Wildner hid_input, index, &info->sc_loc_x, &flags, &info->sc_iid_x)) {
46912bd3c8bSSascha Wildner
47012bd3c8bSSascha Wildner if ((flags & MOUSE_FLAGS_MASK) == MOUSE_FLAGS) {
47112bd3c8bSSascha Wildner info->sc_flags |= UMS_FLAG_X_AXIS;
47212bd3c8bSSascha Wildner }
47312bd3c8bSSascha Wildner }
47412bd3c8bSSascha Wildner if (hid_locate(buf, len, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y),
47512bd3c8bSSascha Wildner hid_input, index, &info->sc_loc_y, &flags, &info->sc_iid_y)) {
47612bd3c8bSSascha Wildner
47712bd3c8bSSascha Wildner if ((flags & MOUSE_FLAGS_MASK) == MOUSE_FLAGS) {
47812bd3c8bSSascha Wildner info->sc_flags |= UMS_FLAG_Y_AXIS;
47912bd3c8bSSascha Wildner }
48012bd3c8bSSascha Wildner }
48112bd3c8bSSascha Wildner /* Try the wheel first as the Z activator since it's tradition. */
48212bd3c8bSSascha Wildner if (hid_locate(buf, len, HID_USAGE2(HUP_GENERIC_DESKTOP,
48312bd3c8bSSascha Wildner HUG_WHEEL), hid_input, index, &info->sc_loc_z, &flags,
48412bd3c8bSSascha Wildner &info->sc_iid_z) ||
48512bd3c8bSSascha Wildner hid_locate(buf, len, HID_USAGE2(HUP_GENERIC_DESKTOP,
48612bd3c8bSSascha Wildner HUG_TWHEEL), hid_input, index, &info->sc_loc_z, &flags,
48712bd3c8bSSascha Wildner &info->sc_iid_z)) {
48812bd3c8bSSascha Wildner if ((flags & MOUSE_FLAGS_MASK) == MOUSE_FLAGS) {
48912bd3c8bSSascha Wildner info->sc_flags |= UMS_FLAG_Z_AXIS;
49012bd3c8bSSascha Wildner }
49112bd3c8bSSascha Wildner /*
49212bd3c8bSSascha Wildner * We might have both a wheel and Z direction, if so put
49312bd3c8bSSascha Wildner * put the Z on the W coordinate.
49412bd3c8bSSascha Wildner */
49512bd3c8bSSascha Wildner if (hid_locate(buf, len, HID_USAGE2(HUP_GENERIC_DESKTOP,
49612bd3c8bSSascha Wildner HUG_Z), hid_input, index, &info->sc_loc_w, &flags,
49712bd3c8bSSascha Wildner &info->sc_iid_w)) {
49812bd3c8bSSascha Wildner
49912bd3c8bSSascha Wildner if ((flags & MOUSE_FLAGS_MASK) == MOUSE_FLAGS) {
50012bd3c8bSSascha Wildner info->sc_flags |= UMS_FLAG_W_AXIS;
50112bd3c8bSSascha Wildner }
50212bd3c8bSSascha Wildner }
50312bd3c8bSSascha Wildner } else if (hid_locate(buf, len, HID_USAGE2(HUP_GENERIC_DESKTOP,
50412bd3c8bSSascha Wildner HUG_Z), hid_input, index, &info->sc_loc_z, &flags,
50512bd3c8bSSascha Wildner &info->sc_iid_z)) {
50612bd3c8bSSascha Wildner
50712bd3c8bSSascha Wildner if ((flags & MOUSE_FLAGS_MASK) == MOUSE_FLAGS) {
50812bd3c8bSSascha Wildner info->sc_flags |= UMS_FLAG_Z_AXIS;
50912bd3c8bSSascha Wildner }
51012bd3c8bSSascha Wildner }
51112bd3c8bSSascha Wildner /*
51212bd3c8bSSascha Wildner * The Microsoft Wireless Intellimouse 2.0 reports it's wheel
51312bd3c8bSSascha Wildner * using 0x0048, which is HUG_TWHEEL, and seems to expect you
51412bd3c8bSSascha Wildner * to know that the byte after the wheel is the tilt axis.
51512bd3c8bSSascha Wildner * There are no other HID axis descriptors other than X,Y and
51612bd3c8bSSascha Wildner * TWHEEL
51712bd3c8bSSascha Wildner */
51812bd3c8bSSascha Wildner if (hid_locate(buf, len, HID_USAGE2(HUP_GENERIC_DESKTOP,
51912bd3c8bSSascha Wildner HUG_TWHEEL), hid_input, index, &info->sc_loc_t,
52012bd3c8bSSascha Wildner &flags, &info->sc_iid_t)) {
52112bd3c8bSSascha Wildner
52212bd3c8bSSascha Wildner info->sc_loc_t.pos += 8;
52312bd3c8bSSascha Wildner
52412bd3c8bSSascha Wildner if ((flags & MOUSE_FLAGS_MASK) == MOUSE_FLAGS) {
52512bd3c8bSSascha Wildner info->sc_flags |= UMS_FLAG_T_AXIS;
52612bd3c8bSSascha Wildner }
52712bd3c8bSSascha Wildner } else if (hid_locate(buf, len, HID_USAGE2(HUP_CONSUMER,
52812bd3c8bSSascha Wildner HUC_AC_PAN), hid_input, index, &info->sc_loc_t,
52912bd3c8bSSascha Wildner &flags, &info->sc_iid_t)) {
53012bd3c8bSSascha Wildner
53112bd3c8bSSascha Wildner if ((flags & MOUSE_FLAGS_MASK) == MOUSE_FLAGS)
53212bd3c8bSSascha Wildner info->sc_flags |= UMS_FLAG_T_AXIS;
53312bd3c8bSSascha Wildner }
53412bd3c8bSSascha Wildner /* figure out the number of buttons */
53512bd3c8bSSascha Wildner
53612bd3c8bSSascha Wildner for (i = 0; i < UMS_BUTTON_MAX; i++) {
53712bd3c8bSSascha Wildner if (!hid_locate(buf, len, HID_USAGE2(HUP_BUTTON, (i + 1)),
53812bd3c8bSSascha Wildner hid_input, index, &info->sc_loc_btn[i], NULL,
53912bd3c8bSSascha Wildner &info->sc_iid_btn[i])) {
54012bd3c8bSSascha Wildner break;
54112bd3c8bSSascha Wildner }
54212bd3c8bSSascha Wildner }
54312bd3c8bSSascha Wildner
54412bd3c8bSSascha Wildner /* detect other buttons */
54512bd3c8bSSascha Wildner
54612bd3c8bSSascha Wildner for (j = 0; (i < UMS_BUTTON_MAX) && (j < 2); i++, j++) {
54712bd3c8bSSascha Wildner if (!hid_locate(buf, len, HID_USAGE2(HUP_MICROSOFT, (j + 1)),
54812bd3c8bSSascha Wildner hid_input, index, &info->sc_loc_btn[i], NULL,
54912bd3c8bSSascha Wildner &info->sc_iid_btn[i])) {
55012bd3c8bSSascha Wildner break;
55112bd3c8bSSascha Wildner }
55212bd3c8bSSascha Wildner }
55312bd3c8bSSascha Wildner
55412bd3c8bSSascha Wildner info->sc_buttons = i;
55512bd3c8bSSascha Wildner
55612bd3c8bSSascha Wildner if (i > sc->sc_buttons)
55712bd3c8bSSascha Wildner sc->sc_buttons = i;
55812bd3c8bSSascha Wildner
55912bd3c8bSSascha Wildner if (info->sc_flags == 0)
56012bd3c8bSSascha Wildner return;
56112bd3c8bSSascha Wildner
56212bd3c8bSSascha Wildner /* announce information about the mouse */
56312bd3c8bSSascha Wildner device_printf(dev, "%d buttons and [%s%s%s%s%s] coordinates ID=%u\n",
56412bd3c8bSSascha Wildner (info->sc_buttons),
56512bd3c8bSSascha Wildner (info->sc_flags & UMS_FLAG_X_AXIS) ? "X" : "",
56612bd3c8bSSascha Wildner (info->sc_flags & UMS_FLAG_Y_AXIS) ? "Y" : "",
56712bd3c8bSSascha Wildner (info->sc_flags & UMS_FLAG_Z_AXIS) ? "Z" : "",
56812bd3c8bSSascha Wildner (info->sc_flags & UMS_FLAG_T_AXIS) ? "T" : "",
56912bd3c8bSSascha Wildner (info->sc_flags & UMS_FLAG_W_AXIS) ? "W" : "",
57012bd3c8bSSascha Wildner info->sc_iid_x);
57112bd3c8bSSascha Wildner }
57212bd3c8bSSascha Wildner
57312bd3c8bSSascha Wildner static int
ums_attach(device_t dev)57412bd3c8bSSascha Wildner ums_attach(device_t dev)
57512bd3c8bSSascha Wildner {
57612bd3c8bSSascha Wildner struct usb_attach_arg *uaa = device_get_ivars(dev);
57712bd3c8bSSascha Wildner struct ums_softc *sc = device_get_softc(dev);
57812bd3c8bSSascha Wildner struct ums_info *info;
57912bd3c8bSSascha Wildner void *d_ptr = NULL;
58012bd3c8bSSascha Wildner int isize;
58112bd3c8bSSascha Wildner int err;
58212bd3c8bSSascha Wildner uint16_t d_len;
58312bd3c8bSSascha Wildner uint8_t i;
58412bd3c8bSSascha Wildner #ifdef USB_DEBUG
58512bd3c8bSSascha Wildner uint8_t j;
58612bd3c8bSSascha Wildner #endif
58712bd3c8bSSascha Wildner
58812bd3c8bSSascha Wildner DPRINTFN(11, "sc=%p\n", sc);
58912bd3c8bSSascha Wildner
59012bd3c8bSSascha Wildner device_set_usb_desc(dev);
59112bd3c8bSSascha Wildner
5928d7664cbSSascha Wildner lockinit(&sc->sc_lock, "ums lock", 0, LK_CANRECURSE);
59312bd3c8bSSascha Wildner
5948d7664cbSSascha Wildner usb_callout_init_mtx(&sc->sc_callout, &sc->sc_lock, 0);
59512bd3c8bSSascha Wildner
59612bd3c8bSSascha Wildner /*
59712bd3c8bSSascha Wildner * Force the report (non-boot) protocol.
59812bd3c8bSSascha Wildner *
59912bd3c8bSSascha Wildner * Mice without boot protocol support may choose not to implement
60012bd3c8bSSascha Wildner * Set_Protocol at all; Ignore any error.
60112bd3c8bSSascha Wildner */
60212bd3c8bSSascha Wildner err = usbd_req_set_protocol(uaa->device, NULL,
60312bd3c8bSSascha Wildner uaa->info.bIfaceIndex, 1);
60412bd3c8bSSascha Wildner
60512bd3c8bSSascha Wildner err = usbd_transfer_setup(uaa->device,
60612bd3c8bSSascha Wildner &uaa->info.bIfaceIndex, sc->sc_xfer, ums_config,
6078d7664cbSSascha Wildner UMS_N_TRANSFER, sc, &sc->sc_lock);
60812bd3c8bSSascha Wildner
60912bd3c8bSSascha Wildner if (err) {
61012bd3c8bSSascha Wildner DPRINTF("error=%s\n", usbd_errstr(err));
61112bd3c8bSSascha Wildner goto detach;
61212bd3c8bSSascha Wildner }
61312bd3c8bSSascha Wildner
61412bd3c8bSSascha Wildner /* Get HID descriptor */
61512bd3c8bSSascha Wildner err = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr,
61612bd3c8bSSascha Wildner &d_len, M_TEMP, uaa->info.bIfaceIndex);
61712bd3c8bSSascha Wildner
61812bd3c8bSSascha Wildner if (err) {
61912bd3c8bSSascha Wildner device_printf(dev, "error reading report description\n");
62012bd3c8bSSascha Wildner goto detach;
62112bd3c8bSSascha Wildner }
62212bd3c8bSSascha Wildner
62312bd3c8bSSascha Wildner isize = hid_report_size(d_ptr, d_len, hid_input, &sc->sc_iid);
62412bd3c8bSSascha Wildner
62512bd3c8bSSascha Wildner /*
62612bd3c8bSSascha Wildner * The Microsoft Wireless Notebook Optical Mouse seems to be in worse
62712bd3c8bSSascha Wildner * shape than the Wireless Intellimouse 2.0, as its X, Y, wheel, and
62812bd3c8bSSascha Wildner * all of its other button positions are all off. It also reports that
62912bd3c8bSSascha Wildner * it has two addional buttons and a tilt wheel.
63012bd3c8bSSascha Wildner */
63112bd3c8bSSascha Wildner if (usb_test_quirk(uaa, UQ_MS_BAD_CLASS)) {
63212bd3c8bSSascha Wildner
63312bd3c8bSSascha Wildner sc->sc_iid = 0;
63412bd3c8bSSascha Wildner
63512bd3c8bSSascha Wildner info = &sc->sc_info[0];
63612bd3c8bSSascha Wildner info->sc_flags = (UMS_FLAG_X_AXIS |
63712bd3c8bSSascha Wildner UMS_FLAG_Y_AXIS |
63812bd3c8bSSascha Wildner UMS_FLAG_Z_AXIS |
63912bd3c8bSSascha Wildner UMS_FLAG_SBU);
64012bd3c8bSSascha Wildner info->sc_buttons = 3;
64112bd3c8bSSascha Wildner isize = 5;
64212bd3c8bSSascha Wildner /* 1st byte of descriptor report contains garbage */
64312bd3c8bSSascha Wildner info->sc_loc_x.pos = 16;
64412bd3c8bSSascha Wildner info->sc_loc_x.size = 8;
64512bd3c8bSSascha Wildner info->sc_loc_y.pos = 24;
64612bd3c8bSSascha Wildner info->sc_loc_y.size = 8;
64712bd3c8bSSascha Wildner info->sc_loc_z.pos = 32;
64812bd3c8bSSascha Wildner info->sc_loc_z.size = 8;
64912bd3c8bSSascha Wildner info->sc_loc_btn[0].pos = 8;
65012bd3c8bSSascha Wildner info->sc_loc_btn[0].size = 1;
65112bd3c8bSSascha Wildner info->sc_loc_btn[1].pos = 9;
65212bd3c8bSSascha Wildner info->sc_loc_btn[1].size = 1;
65312bd3c8bSSascha Wildner info->sc_loc_btn[2].pos = 10;
65412bd3c8bSSascha Wildner info->sc_loc_btn[2].size = 1;
65512bd3c8bSSascha Wildner
65612bd3c8bSSascha Wildner /* Announce device */
65712bd3c8bSSascha Wildner device_printf(dev, "3 buttons and [XYZ] "
65812bd3c8bSSascha Wildner "coordinates ID=0\n");
65912bd3c8bSSascha Wildner
66012bd3c8bSSascha Wildner } else {
66112bd3c8bSSascha Wildner /* Search the HID descriptor and announce device */
66212bd3c8bSSascha Wildner for (i = 0; i < UMS_INFO_MAX; i++) {
66312bd3c8bSSascha Wildner ums_hid_parse(sc, dev, d_ptr, d_len, i);
66412bd3c8bSSascha Wildner }
66512bd3c8bSSascha Wildner }
66612bd3c8bSSascha Wildner
66712bd3c8bSSascha Wildner if (usb_test_quirk(uaa, UQ_MS_REVZ)) {
66812bd3c8bSSascha Wildner info = &sc->sc_info[0];
66912bd3c8bSSascha Wildner /* Some wheels need the Z axis reversed. */
67012bd3c8bSSascha Wildner info->sc_flags |= UMS_FLAG_REVZ;
67112bd3c8bSSascha Wildner }
67257bed822SMarkus Pfeiffer if (isize > (int)usbd_xfer_max_framelen(sc->sc_xfer[UMS_INTR_DT])) {
67312bd3c8bSSascha Wildner DPRINTF("WARNING: report size, %d bytes, is larger "
67412bd3c8bSSascha Wildner "than interrupt size, %d bytes!\n", isize,
67512bd3c8bSSascha Wildner usbd_xfer_max_framelen(sc->sc_xfer[UMS_INTR_DT]));
67612bd3c8bSSascha Wildner }
6778d7664cbSSascha Wildner kfree(d_ptr, M_TEMP);
67812bd3c8bSSascha Wildner d_ptr = NULL;
67912bd3c8bSSascha Wildner
68012bd3c8bSSascha Wildner #ifdef USB_DEBUG
68112bd3c8bSSascha Wildner for (j = 0; j < UMS_INFO_MAX; j++) {
68212bd3c8bSSascha Wildner info = &sc->sc_info[j];
68312bd3c8bSSascha Wildner
68412bd3c8bSSascha Wildner DPRINTF("sc=%p, index=%d\n", sc, j);
68512bd3c8bSSascha Wildner DPRINTF("X\t%d/%d id=%d\n", info->sc_loc_x.pos,
68612bd3c8bSSascha Wildner info->sc_loc_x.size, info->sc_iid_x);
68712bd3c8bSSascha Wildner DPRINTF("Y\t%d/%d id=%d\n", info->sc_loc_y.pos,
68812bd3c8bSSascha Wildner info->sc_loc_y.size, info->sc_iid_y);
68912bd3c8bSSascha Wildner DPRINTF("Z\t%d/%d id=%d\n", info->sc_loc_z.pos,
69012bd3c8bSSascha Wildner info->sc_loc_z.size, info->sc_iid_z);
69112bd3c8bSSascha Wildner DPRINTF("T\t%d/%d id=%d\n", info->sc_loc_t.pos,
69212bd3c8bSSascha Wildner info->sc_loc_t.size, info->sc_iid_t);
69312bd3c8bSSascha Wildner DPRINTF("W\t%d/%d id=%d\n", info->sc_loc_w.pos,
69412bd3c8bSSascha Wildner info->sc_loc_w.size, info->sc_iid_w);
69512bd3c8bSSascha Wildner
69612bd3c8bSSascha Wildner for (i = 0; i < info->sc_buttons; i++) {
69712bd3c8bSSascha Wildner DPRINTF("B%d\t%d/%d id=%d\n",
69812bd3c8bSSascha Wildner i + 1, info->sc_loc_btn[i].pos,
69912bd3c8bSSascha Wildner info->sc_loc_btn[i].size, info->sc_iid_btn[i]);
70012bd3c8bSSascha Wildner }
70112bd3c8bSSascha Wildner }
70212bd3c8bSSascha Wildner DPRINTF("size=%d, id=%d\n", isize, sc->sc_iid);
70312bd3c8bSSascha Wildner #endif
70412bd3c8bSSascha Wildner
7058d7664cbSSascha Wildner err = usb_fifo_attach(uaa->device, sc, &sc->sc_lock,
70612bd3c8bSSascha Wildner &ums_fifo_methods, &sc->sc_fifo,
70757bed822SMarkus Pfeiffer device_get_unit(dev), -1, uaa->info.bIfaceIndex,
70812bd3c8bSSascha Wildner UID_ROOT, GID_OPERATOR, 0644);
70957bed822SMarkus Pfeiffer if (err)
71012bd3c8bSSascha Wildner goto detach;
7113d1294c7SPeeter Must
7123d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
7133d1294c7SPeeter Must sc->sc_evdev = evdev_alloc();
7143d1294c7SPeeter Must evdev_set_name(sc->sc_evdev, device_get_desc(dev));
7153d1294c7SPeeter Must evdev_set_phys(sc->sc_evdev, device_get_nameunit(dev));
7163d1294c7SPeeter Must evdev_set_id(sc->sc_evdev, BUS_USB, uaa->info.idVendor,
7173d1294c7SPeeter Must uaa->info.idProduct, 0);
7183d1294c7SPeeter Must evdev_set_serial(sc->sc_evdev, usb_get_serial(uaa->device));
7193d1294c7SPeeter Must evdev_set_methods(sc->sc_evdev, sc, &ums_evdev_methods);
7203d1294c7SPeeter Must evdev_support_prop(sc->sc_evdev, INPUT_PROP_POINTER);
7213d1294c7SPeeter Must evdev_support_event(sc->sc_evdev, EV_SYN);
7223d1294c7SPeeter Must evdev_support_event(sc->sc_evdev, EV_REL);
7233d1294c7SPeeter Must evdev_support_event(sc->sc_evdev, EV_KEY);
7243d1294c7SPeeter Must
7253d1294c7SPeeter Must info = &sc->sc_info[0];
7263d1294c7SPeeter Must
7273d1294c7SPeeter Must if (info->sc_flags & UMS_FLAG_X_AXIS)
7283d1294c7SPeeter Must evdev_support_rel(sc->sc_evdev, REL_X);
7293d1294c7SPeeter Must
7303d1294c7SPeeter Must if (info->sc_flags & UMS_FLAG_Y_AXIS)
7313d1294c7SPeeter Must evdev_support_rel(sc->sc_evdev, REL_Y);
7323d1294c7SPeeter Must
7333d1294c7SPeeter Must if (info->sc_flags & UMS_FLAG_Z_AXIS)
7343d1294c7SPeeter Must evdev_support_rel(sc->sc_evdev, REL_WHEEL);
7353d1294c7SPeeter Must
7363d1294c7SPeeter Must if (info->sc_flags & UMS_FLAG_T_AXIS)
7373d1294c7SPeeter Must evdev_support_rel(sc->sc_evdev, REL_HWHEEL);
7383d1294c7SPeeter Must
7393d1294c7SPeeter Must for (i = 0; i < info->sc_buttons; i++)
7403d1294c7SPeeter Must evdev_support_key(sc->sc_evdev, BTN_MOUSE + i);
7413d1294c7SPeeter Must
742a1d6eba4SPeeter Must err = evdev_register(sc->sc_evdev);
7433d1294c7SPeeter Must if (err)
7443d1294c7SPeeter Must goto detach;
7453d1294c7SPeeter Must #endif
7463d1294c7SPeeter Must
74757bed822SMarkus Pfeiffer #if 0
74812bd3c8bSSascha Wildner SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
74912bd3c8bSSascha Wildner SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
75012bd3c8bSSascha Wildner OID_AUTO, "parseinfo", CTLTYPE_STRING|CTLFLAG_RD,
75112bd3c8bSSascha Wildner sc, 0, ums_sysctl_handler_parseinfo,
75212bd3c8bSSascha Wildner "", "Dump of parsed HID report descriptor");
7538d7664cbSSascha Wildner #endif
75412bd3c8bSSascha Wildner
75512bd3c8bSSascha Wildner return (0);
75612bd3c8bSSascha Wildner
75712bd3c8bSSascha Wildner detach:
75812bd3c8bSSascha Wildner if (d_ptr) {
7598d7664cbSSascha Wildner kfree(d_ptr, M_TEMP);
76012bd3c8bSSascha Wildner }
76112bd3c8bSSascha Wildner ums_detach(dev);
76212bd3c8bSSascha Wildner return (ENOMEM);
76312bd3c8bSSascha Wildner }
76412bd3c8bSSascha Wildner
76512bd3c8bSSascha Wildner static int
ums_detach(device_t self)76612bd3c8bSSascha Wildner ums_detach(device_t self)
76712bd3c8bSSascha Wildner {
76812bd3c8bSSascha Wildner struct ums_softc *sc = device_get_softc(self);
76912bd3c8bSSascha Wildner
77012bd3c8bSSascha Wildner DPRINTF("sc=%p\n", sc);
77112bd3c8bSSascha Wildner
77212bd3c8bSSascha Wildner usb_fifo_detach(&sc->sc_fifo);
77312bd3c8bSSascha Wildner
7743d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
7753d1294c7SPeeter Must evdev_free(sc->sc_evdev);
776493442f3SMatthew Dillon sc->sc_evdev = NULL;
7773d1294c7SPeeter Must #endif
7783d1294c7SPeeter Must
77912bd3c8bSSascha Wildner usbd_transfer_unsetup(sc->sc_xfer, UMS_N_TRANSFER);
78012bd3c8bSSascha Wildner
78112bd3c8bSSascha Wildner usb_callout_drain(&sc->sc_callout);
78212bd3c8bSSascha Wildner
7838d7664cbSSascha Wildner lockuninit(&sc->sc_lock);
78412bd3c8bSSascha Wildner
78512bd3c8bSSascha Wildner return (0);
78612bd3c8bSSascha Wildner }
78712bd3c8bSSascha Wildner
78812bd3c8bSSascha Wildner static void
ums_reset(struct ums_softc * sc)7893d1294c7SPeeter Must ums_reset(struct ums_softc *sc)
79012bd3c8bSSascha Wildner {
7913d1294c7SPeeter Must
7923d1294c7SPeeter Must /* reset all USB mouse parameters */
7933d1294c7SPeeter Must
7943d1294c7SPeeter Must if (sc->sc_buttons > MOUSE_MSC_MAXBUTTON)
7953d1294c7SPeeter Must sc->sc_hw.buttons = MOUSE_MSC_MAXBUTTON;
7963d1294c7SPeeter Must else
7973d1294c7SPeeter Must sc->sc_hw.buttons = sc->sc_buttons;
7983d1294c7SPeeter Must
7993d1294c7SPeeter Must sc->sc_hw.iftype = MOUSE_IF_USB;
8003d1294c7SPeeter Must sc->sc_hw.type = MOUSE_MOUSE;
8013d1294c7SPeeter Must sc->sc_hw.model = MOUSE_MODEL_GENERIC;
8023d1294c7SPeeter Must sc->sc_hw.hwid = 0;
8033d1294c7SPeeter Must
8043d1294c7SPeeter Must sc->sc_mode.protocol = MOUSE_PROTO_MSC;
8053d1294c7SPeeter Must sc->sc_mode.rate = -1;
8063d1294c7SPeeter Must sc->sc_mode.resolution = MOUSE_RES_UNKNOWN;
8073d1294c7SPeeter Must sc->sc_mode.accelfactor = 0;
8083d1294c7SPeeter Must sc->sc_mode.level = 0;
8093d1294c7SPeeter Must sc->sc_mode.packetsize = MOUSE_MSC_PACKETSIZE;
8103d1294c7SPeeter Must sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
8113d1294c7SPeeter Must sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC;
8123d1294c7SPeeter Must
8133d1294c7SPeeter Must /* reset status */
8143d1294c7SPeeter Must
8153d1294c7SPeeter Must sc->sc_status.flags = 0;
8163d1294c7SPeeter Must sc->sc_status.button = 0;
8173d1294c7SPeeter Must sc->sc_status.obutton = 0;
8183d1294c7SPeeter Must sc->sc_status.dx = 0;
8193d1294c7SPeeter Must sc->sc_status.dy = 0;
8203d1294c7SPeeter Must sc->sc_status.dz = 0;
8213d1294c7SPeeter Must /* sc->sc_status.dt = 0; */
8223d1294c7SPeeter Must }
8233d1294c7SPeeter Must
8243d1294c7SPeeter Must static void
ums_start_rx(struct ums_softc * sc)8253d1294c7SPeeter Must ums_start_rx(struct ums_softc *sc)
8263d1294c7SPeeter Must {
82712bd3c8bSSascha Wildner int rate;
82812bd3c8bSSascha Wildner
82912bd3c8bSSascha Wildner /* Check if we should override the default polling interval */
83012bd3c8bSSascha Wildner rate = sc->sc_pollrate;
83112bd3c8bSSascha Wildner /* Range check rate */
83212bd3c8bSSascha Wildner if (rate > 1000)
83312bd3c8bSSascha Wildner rate = 1000;
83412bd3c8bSSascha Wildner /* Check for set rate */
83512bd3c8bSSascha Wildner if ((rate > 0) && (sc->sc_xfer[UMS_INTR_DT] != NULL)) {
83612bd3c8bSSascha Wildner DPRINTF("Setting pollrate = %d\n", rate);
83712bd3c8bSSascha Wildner /* Stop current transfer, if any */
8384bcecc80SMatthew Dillon if (sc->sc_read_running) {
83912bd3c8bSSascha Wildner usbd_transfer_stop(sc->sc_xfer[UMS_INTR_DT]);
8404bcecc80SMatthew Dillon sc->sc_read_running = 0;
8414bcecc80SMatthew Dillon }
84212bd3c8bSSascha Wildner /* Set new interval */
84312bd3c8bSSascha Wildner usbd_xfer_set_interval(sc->sc_xfer[UMS_INTR_DT], 1000 / rate);
84412bd3c8bSSascha Wildner /* Only set pollrate once */
84512bd3c8bSSascha Wildner sc->sc_pollrate = 0;
84612bd3c8bSSascha Wildner }
8474bcecc80SMatthew Dillon if (sc->sc_read_running == 0) {
8484bcecc80SMatthew Dillon sc->sc_read_running = 1;
84912bd3c8bSSascha Wildner usbd_transfer_start(sc->sc_xfer[UMS_INTR_DT]);
85012bd3c8bSSascha Wildner }
8514bcecc80SMatthew Dillon }
85212bd3c8bSSascha Wildner
85312bd3c8bSSascha Wildner static void
ums_stop_rx(struct ums_softc * sc)8543d1294c7SPeeter Must ums_stop_rx(struct ums_softc *sc)
85512bd3c8bSSascha Wildner {
8564bcecc80SMatthew Dillon if (sc->sc_read_running) {
85712bd3c8bSSascha Wildner usbd_transfer_stop(sc->sc_xfer[UMS_INTR_DT]);
8584bcecc80SMatthew Dillon sc->sc_read_running = 0;
85912bd3c8bSSascha Wildner usb_callout_stop(&sc->sc_callout);
86012bd3c8bSSascha Wildner }
8614bcecc80SMatthew Dillon }
86212bd3c8bSSascha Wildner
8633d1294c7SPeeter Must static void
ums_fifo_start_read(struct usb_fifo * fifo)8643d1294c7SPeeter Must ums_fifo_start_read(struct usb_fifo *fifo)
8653d1294c7SPeeter Must {
8663d1294c7SPeeter Must struct ums_softc *sc = usb_fifo_softc(fifo);
8673d1294c7SPeeter Must
8683d1294c7SPeeter Must ums_start_rx(sc);
8693d1294c7SPeeter Must }
8703d1294c7SPeeter Must
8713d1294c7SPeeter Must static void
ums_fifo_stop_read(struct usb_fifo * fifo)8723d1294c7SPeeter Must ums_fifo_stop_read(struct usb_fifo *fifo)
8733d1294c7SPeeter Must {
8743d1294c7SPeeter Must struct ums_softc *sc = usb_fifo_softc(fifo);
8753d1294c7SPeeter Must
8763d1294c7SPeeter Must ums_stop_rx(sc);
8773d1294c7SPeeter Must }
87812bd3c8bSSascha Wildner
87912bd3c8bSSascha Wildner #if ((MOUSE_SYS_PACKETSIZE != 8) || \
88012bd3c8bSSascha Wildner (MOUSE_MSC_PACKETSIZE != 5))
88112bd3c8bSSascha Wildner #error "Software assumptions are not met. Please update code."
88212bd3c8bSSascha Wildner #endif
88312bd3c8bSSascha Wildner
88412bd3c8bSSascha Wildner static void
ums_put_queue(struct ums_softc * sc,int32_t dx,int32_t dy,int32_t dz,int32_t dt,int32_t buttons)88512bd3c8bSSascha Wildner ums_put_queue(struct ums_softc *sc, int32_t dx, int32_t dy,
88612bd3c8bSSascha Wildner int32_t dz, int32_t dt, int32_t buttons)
88712bd3c8bSSascha Wildner {
88812bd3c8bSSascha Wildner uint8_t buf[8];
88912bd3c8bSSascha Wildner
89012bd3c8bSSascha Wildner if (1) {
89112bd3c8bSSascha Wildner
89212bd3c8bSSascha Wildner if (dx > 254)
89312bd3c8bSSascha Wildner dx = 254;
89412bd3c8bSSascha Wildner if (dx < -256)
89512bd3c8bSSascha Wildner dx = -256;
89612bd3c8bSSascha Wildner if (dy > 254)
89712bd3c8bSSascha Wildner dy = 254;
89812bd3c8bSSascha Wildner if (dy < -256)
89912bd3c8bSSascha Wildner dy = -256;
90012bd3c8bSSascha Wildner if (dz > 126)
90112bd3c8bSSascha Wildner dz = 126;
90212bd3c8bSSascha Wildner if (dz < -128)
90312bd3c8bSSascha Wildner dz = -128;
90412bd3c8bSSascha Wildner if (dt > 126)
90512bd3c8bSSascha Wildner dt = 126;
90612bd3c8bSSascha Wildner if (dt < -128)
90712bd3c8bSSascha Wildner dt = -128;
90812bd3c8bSSascha Wildner
90912bd3c8bSSascha Wildner buf[0] = sc->sc_mode.syncmask[1];
91012bd3c8bSSascha Wildner buf[0] |= (~buttons) & MOUSE_MSC_BUTTONS;
91112bd3c8bSSascha Wildner buf[1] = dx >> 1;
91212bd3c8bSSascha Wildner buf[2] = dy >> 1;
91312bd3c8bSSascha Wildner buf[3] = dx - (dx >> 1);
91412bd3c8bSSascha Wildner buf[4] = dy - (dy >> 1);
91512bd3c8bSSascha Wildner
91612bd3c8bSSascha Wildner if (sc->sc_mode.level == 1) {
91712bd3c8bSSascha Wildner buf[5] = dz >> 1;
91812bd3c8bSSascha Wildner buf[6] = dz - (dz >> 1);
91912bd3c8bSSascha Wildner buf[7] = (((~buttons) >> 3) & MOUSE_SYS_EXTBUTTONS);
92012bd3c8bSSascha Wildner }
92112bd3c8bSSascha Wildner usb_fifo_put_data_linear(sc->sc_fifo.fp[USB_FIFO_RX], buf,
92212bd3c8bSSascha Wildner sc->sc_mode.packetsize, 1);
92312bd3c8bSSascha Wildner
92412bd3c8bSSascha Wildner } else {
92512bd3c8bSSascha Wildner DPRINTF("Buffer full, discarded packet\n");
92612bd3c8bSSascha Wildner }
92712bd3c8bSSascha Wildner }
92812bd3c8bSSascha Wildner
9293d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
9303d1294c7SPeeter Must static void
ums_evdev_push(struct ums_softc * sc,int32_t dx,int32_t dy,int32_t dz,int32_t dt,int32_t buttons)9313d1294c7SPeeter Must ums_evdev_push(struct ums_softc *sc, int32_t dx, int32_t dy,
9323d1294c7SPeeter Must int32_t dz, int32_t dt, int32_t buttons)
9333d1294c7SPeeter Must {
9343d1294c7SPeeter Must if (evdev_rcpt_mask & EVDEV_RCPT_HW_MOUSE) {
9353d1294c7SPeeter Must /* Push evdev event */
9363d1294c7SPeeter Must evdev_push_rel(sc->sc_evdev, REL_X, dx);
9373d1294c7SPeeter Must evdev_push_rel(sc->sc_evdev, REL_Y, -dy);
9383d1294c7SPeeter Must evdev_push_rel(sc->sc_evdev, REL_WHEEL, -dz);
9393d1294c7SPeeter Must evdev_push_rel(sc->sc_evdev, REL_HWHEEL, dt);
9403d1294c7SPeeter Must evdev_push_mouse_btn(sc->sc_evdev,
9413d1294c7SPeeter Must (buttons & ~MOUSE_STDBUTTONS) |
9423d1294c7SPeeter Must (buttons & (1 << 2) ? MOUSE_BUTTON1DOWN : 0) |
9433d1294c7SPeeter Must (buttons & (1 << 1) ? MOUSE_BUTTON2DOWN : 0) |
9443d1294c7SPeeter Must (buttons & (1 << 0) ? MOUSE_BUTTON3DOWN : 0));
9453d1294c7SPeeter Must evdev_sync(sc->sc_evdev);
9463d1294c7SPeeter Must }
9473d1294c7SPeeter Must }
9483d1294c7SPeeter Must #endif
9493d1294c7SPeeter Must
95012bd3c8bSSascha Wildner static void
ums_reset_buf(struct ums_softc * sc)95112bd3c8bSSascha Wildner ums_reset_buf(struct ums_softc *sc)
95212bd3c8bSSascha Wildner {
95357bed822SMarkus Pfeiffer /* reset read queue, must be called locked */
95412bd3c8bSSascha Wildner usb_fifo_reset(sc->sc_fifo.fp[USB_FIFO_RX]);
95512bd3c8bSSascha Wildner }
95612bd3c8bSSascha Wildner
9573d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
95812bd3c8bSSascha Wildner static int
ums_ev_open(struct evdev_dev * evdev)959*a162a738SMichael Neumann ums_ev_open(struct evdev_dev *evdev)
9603d1294c7SPeeter Must {
961*a162a738SMichael Neumann struct ums_softc *sc = (struct ums_softc *)evdev_get_softc(evdev);
9623d1294c7SPeeter Must
963a1d6eba4SPeeter Must lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
9643d1294c7SPeeter Must
9653d1294c7SPeeter Must sc->sc_evflags = UMS_EVDEV_OPENED;
9663d1294c7SPeeter Must
9673d1294c7SPeeter Must if (sc->sc_fflags == 0) {
9683d1294c7SPeeter Must ums_reset(sc);
9693d1294c7SPeeter Must ums_start_rx(sc);
9703d1294c7SPeeter Must }
9713d1294c7SPeeter Must
972a1d6eba4SPeeter Must lockmgr(&sc->sc_lock, LK_RELEASE);
973a1d6eba4SPeeter Must
9743d1294c7SPeeter Must return (0);
9753d1294c7SPeeter Must }
9763d1294c7SPeeter Must
977*a162a738SMichael Neumann static int
ums_ev_close(struct evdev_dev * evdev)978*a162a738SMichael Neumann ums_ev_close(struct evdev_dev *evdev)
9793d1294c7SPeeter Must {
980*a162a738SMichael Neumann struct ums_softc *sc = (struct ums_softc *)evdev_get_softc(evdev);
9813d1294c7SPeeter Must
982a1d6eba4SPeeter Must lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
9833d1294c7SPeeter Must
9843d1294c7SPeeter Must sc->sc_evflags = 0;
9853d1294c7SPeeter Must
9863d1294c7SPeeter Must if (sc->sc_fflags == 0)
9873d1294c7SPeeter Must ums_stop_rx(sc);
988a1d6eba4SPeeter Must
989a1d6eba4SPeeter Must lockmgr(&sc->sc_lock, LK_RELEASE);
990*a162a738SMichael Neumann
991*a162a738SMichael Neumann return (0);
9923d1294c7SPeeter Must }
9933d1294c7SPeeter Must #endif
9943d1294c7SPeeter Must
9953d1294c7SPeeter Must static int
ums_fifo_open(struct usb_fifo * fifo,int fflags)9963d1294c7SPeeter Must ums_fifo_open(struct usb_fifo *fifo, int fflags)
99712bd3c8bSSascha Wildner {
99812bd3c8bSSascha Wildner struct ums_softc *sc = usb_fifo_softc(fifo);
99912bd3c8bSSascha Wildner
100012bd3c8bSSascha Wildner DPRINTFN(2, "\n");
100112bd3c8bSSascha Wildner
100257bed822SMarkus Pfeiffer /* check for duplicate open, should not happen */
100357bed822SMarkus Pfeiffer if (sc->sc_fflags & fflags)
100457bed822SMarkus Pfeiffer return (EBUSY);
100557bed822SMarkus Pfeiffer
100657bed822SMarkus Pfeiffer /* check for first open */
10073d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
10083d1294c7SPeeter Must if (sc->sc_fflags == 0 && sc->sc_evflags == 0)
10093d1294c7SPeeter Must ums_reset(sc);
10103d1294c7SPeeter Must #else
10113d1294c7SPeeter Must if (sc->sc_fflags == 0)
10123d1294c7SPeeter Must ums_reset(sc);
10133d1294c7SPeeter Must #endif
101412bd3c8bSSascha Wildner
101557bed822SMarkus Pfeiffer if (fflags & FREAD) {
101657bed822SMarkus Pfeiffer /* allocate RX buffer */
101712bd3c8bSSascha Wildner if (usb_fifo_alloc_buffer(fifo,
101812bd3c8bSSascha Wildner UMS_BUF_SIZE, UMS_IFQ_MAXLEN)) {
101912bd3c8bSSascha Wildner return (ENOMEM);
102012bd3c8bSSascha Wildner }
102112bd3c8bSSascha Wildner }
102257bed822SMarkus Pfeiffer
102357bed822SMarkus Pfeiffer sc->sc_fflags |= fflags & (FREAD | FWRITE);
102412bd3c8bSSascha Wildner return (0);
102512bd3c8bSSascha Wildner }
102612bd3c8bSSascha Wildner
102712bd3c8bSSascha Wildner static void
ums_fifo_close(struct usb_fifo * fifo,int fflags)10283d1294c7SPeeter Must ums_fifo_close(struct usb_fifo *fifo, int fflags)
102912bd3c8bSSascha Wildner {
103057bed822SMarkus Pfeiffer struct ums_softc *sc = usb_fifo_softc(fifo);
103157bed822SMarkus Pfeiffer
103257bed822SMarkus Pfeiffer DPRINTFN(2, "\n");
103357bed822SMarkus Pfeiffer
103457bed822SMarkus Pfeiffer if (fflags & FREAD)
103512bd3c8bSSascha Wildner usb_fifo_free_buffer(fifo);
103657bed822SMarkus Pfeiffer
103757bed822SMarkus Pfeiffer sc->sc_fflags &= ~(fflags & (FREAD | FWRITE));
103812bd3c8bSSascha Wildner }
103912bd3c8bSSascha Wildner
104012bd3c8bSSascha Wildner static int
ums_fifo_ioctl(struct usb_fifo * fifo,u_long cmd,void * addr,int fflags)10413d1294c7SPeeter Must ums_fifo_ioctl(struct usb_fifo *fifo, u_long cmd, void *addr, int fflags)
104212bd3c8bSSascha Wildner {
104312bd3c8bSSascha Wildner struct ums_softc *sc = usb_fifo_softc(fifo);
104412bd3c8bSSascha Wildner mousemode_t mode;
104512bd3c8bSSascha Wildner int error = 0;
104612bd3c8bSSascha Wildner
104712bd3c8bSSascha Wildner DPRINTFN(2, "\n");
104812bd3c8bSSascha Wildner
10498d7664cbSSascha Wildner lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
105012bd3c8bSSascha Wildner
105112bd3c8bSSascha Wildner switch (cmd) {
105212bd3c8bSSascha Wildner case MOUSE_GETHWINFO:
105312bd3c8bSSascha Wildner *(mousehw_t *)addr = sc->sc_hw;
105412bd3c8bSSascha Wildner break;
105512bd3c8bSSascha Wildner
105612bd3c8bSSascha Wildner case MOUSE_GETMODE:
105712bd3c8bSSascha Wildner *(mousemode_t *)addr = sc->sc_mode;
105812bd3c8bSSascha Wildner break;
105912bd3c8bSSascha Wildner
106012bd3c8bSSascha Wildner case MOUSE_SETMODE:
106112bd3c8bSSascha Wildner mode = *(mousemode_t *)addr;
106212bd3c8bSSascha Wildner
106312bd3c8bSSascha Wildner if (mode.level == -1) {
106412bd3c8bSSascha Wildner /* don't change the current setting */
106512bd3c8bSSascha Wildner } else if ((mode.level < 0) || (mode.level > 1)) {
106612bd3c8bSSascha Wildner error = EINVAL;
106757bed822SMarkus Pfeiffer break;
106812bd3c8bSSascha Wildner } else {
106912bd3c8bSSascha Wildner sc->sc_mode.level = mode.level;
107012bd3c8bSSascha Wildner }
107112bd3c8bSSascha Wildner
107212bd3c8bSSascha Wildner /* store polling rate */
107312bd3c8bSSascha Wildner sc->sc_pollrate = mode.rate;
107412bd3c8bSSascha Wildner
107512bd3c8bSSascha Wildner if (sc->sc_mode.level == 0) {
107612bd3c8bSSascha Wildner if (sc->sc_buttons > MOUSE_MSC_MAXBUTTON)
107712bd3c8bSSascha Wildner sc->sc_hw.buttons = MOUSE_MSC_MAXBUTTON;
107812bd3c8bSSascha Wildner else
107912bd3c8bSSascha Wildner sc->sc_hw.buttons = sc->sc_buttons;
108012bd3c8bSSascha Wildner sc->sc_mode.protocol = MOUSE_PROTO_MSC;
108112bd3c8bSSascha Wildner sc->sc_mode.packetsize = MOUSE_MSC_PACKETSIZE;
108212bd3c8bSSascha Wildner sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
108312bd3c8bSSascha Wildner sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC;
108412bd3c8bSSascha Wildner } else if (sc->sc_mode.level == 1) {
108512bd3c8bSSascha Wildner if (sc->sc_buttons > MOUSE_SYS_MAXBUTTON)
108612bd3c8bSSascha Wildner sc->sc_hw.buttons = MOUSE_SYS_MAXBUTTON;
108712bd3c8bSSascha Wildner else
108812bd3c8bSSascha Wildner sc->sc_hw.buttons = sc->sc_buttons;
108912bd3c8bSSascha Wildner sc->sc_mode.protocol = MOUSE_PROTO_SYSMOUSE;
109012bd3c8bSSascha Wildner sc->sc_mode.packetsize = MOUSE_SYS_PACKETSIZE;
109112bd3c8bSSascha Wildner sc->sc_mode.syncmask[0] = MOUSE_SYS_SYNCMASK;
109212bd3c8bSSascha Wildner sc->sc_mode.syncmask[1] = MOUSE_SYS_SYNC;
109312bd3c8bSSascha Wildner }
109412bd3c8bSSascha Wildner ums_reset_buf(sc);
109512bd3c8bSSascha Wildner break;
109612bd3c8bSSascha Wildner
109712bd3c8bSSascha Wildner case MOUSE_GETLEVEL:
109812bd3c8bSSascha Wildner *(int *)addr = sc->sc_mode.level;
109912bd3c8bSSascha Wildner break;
110012bd3c8bSSascha Wildner
110112bd3c8bSSascha Wildner case MOUSE_SETLEVEL:
110212bd3c8bSSascha Wildner if (*(int *)addr < 0 || *(int *)addr > 1) {
110312bd3c8bSSascha Wildner error = EINVAL;
110457bed822SMarkus Pfeiffer break;
110512bd3c8bSSascha Wildner }
110612bd3c8bSSascha Wildner sc->sc_mode.level = *(int *)addr;
110712bd3c8bSSascha Wildner
110812bd3c8bSSascha Wildner if (sc->sc_mode.level == 0) {
110912bd3c8bSSascha Wildner if (sc->sc_buttons > MOUSE_MSC_MAXBUTTON)
111012bd3c8bSSascha Wildner sc->sc_hw.buttons = MOUSE_MSC_MAXBUTTON;
111112bd3c8bSSascha Wildner else
111212bd3c8bSSascha Wildner sc->sc_hw.buttons = sc->sc_buttons;
111312bd3c8bSSascha Wildner sc->sc_mode.protocol = MOUSE_PROTO_MSC;
111412bd3c8bSSascha Wildner sc->sc_mode.packetsize = MOUSE_MSC_PACKETSIZE;
111512bd3c8bSSascha Wildner sc->sc_mode.syncmask[0] = MOUSE_MSC_SYNCMASK;
111612bd3c8bSSascha Wildner sc->sc_mode.syncmask[1] = MOUSE_MSC_SYNC;
111712bd3c8bSSascha Wildner } else if (sc->sc_mode.level == 1) {
111812bd3c8bSSascha Wildner if (sc->sc_buttons > MOUSE_SYS_MAXBUTTON)
111912bd3c8bSSascha Wildner sc->sc_hw.buttons = MOUSE_SYS_MAXBUTTON;
112012bd3c8bSSascha Wildner else
112112bd3c8bSSascha Wildner sc->sc_hw.buttons = sc->sc_buttons;
112212bd3c8bSSascha Wildner sc->sc_mode.protocol = MOUSE_PROTO_SYSMOUSE;
112312bd3c8bSSascha Wildner sc->sc_mode.packetsize = MOUSE_SYS_PACKETSIZE;
112412bd3c8bSSascha Wildner sc->sc_mode.syncmask[0] = MOUSE_SYS_SYNCMASK;
112512bd3c8bSSascha Wildner sc->sc_mode.syncmask[1] = MOUSE_SYS_SYNC;
112612bd3c8bSSascha Wildner }
112712bd3c8bSSascha Wildner ums_reset_buf(sc);
112812bd3c8bSSascha Wildner break;
112912bd3c8bSSascha Wildner
113012bd3c8bSSascha Wildner case MOUSE_GETSTATUS:{
113112bd3c8bSSascha Wildner mousestatus_t *status = (mousestatus_t *)addr;
113212bd3c8bSSascha Wildner
113312bd3c8bSSascha Wildner *status = sc->sc_status;
113412bd3c8bSSascha Wildner sc->sc_status.obutton = sc->sc_status.button;
113512bd3c8bSSascha Wildner sc->sc_status.button = 0;
113612bd3c8bSSascha Wildner sc->sc_status.dx = 0;
113712bd3c8bSSascha Wildner sc->sc_status.dy = 0;
113812bd3c8bSSascha Wildner sc->sc_status.dz = 0;
113912bd3c8bSSascha Wildner /* sc->sc_status.dt = 0; */
114012bd3c8bSSascha Wildner
114112bd3c8bSSascha Wildner if (status->dx || status->dy || status->dz /* || status->dt */ ) {
114212bd3c8bSSascha Wildner status->flags |= MOUSE_POSCHANGED;
114312bd3c8bSSascha Wildner }
114412bd3c8bSSascha Wildner if (status->button != status->obutton) {
114512bd3c8bSSascha Wildner status->flags |= MOUSE_BUTTONSCHANGED;
114612bd3c8bSSascha Wildner }
114712bd3c8bSSascha Wildner break;
114812bd3c8bSSascha Wildner }
114912bd3c8bSSascha Wildner default:
115012bd3c8bSSascha Wildner error = ENOTTY;
115157bed822SMarkus Pfeiffer break;
115212bd3c8bSSascha Wildner }
115312bd3c8bSSascha Wildner
11548d7664cbSSascha Wildner lockmgr(&sc->sc_lock, LK_RELEASE);
115512bd3c8bSSascha Wildner return (error);
115612bd3c8bSSascha Wildner }
115712bd3c8bSSascha Wildner
1158b7abfd18SSascha Wildner #if 0 /* XXX */
115912bd3c8bSSascha Wildner static int
116012bd3c8bSSascha Wildner ums_sysctl_handler_parseinfo(SYSCTL_HANDLER_ARGS)
116112bd3c8bSSascha Wildner {
116212bd3c8bSSascha Wildner struct ums_softc *sc = arg1;
116312bd3c8bSSascha Wildner struct ums_info *info;
116412bd3c8bSSascha Wildner struct sbuf *sb;
116512bd3c8bSSascha Wildner int i, j, err, had_output;
116612bd3c8bSSascha Wildner
116712bd3c8bSSascha Wildner sb = sbuf_new_auto();
116812bd3c8bSSascha Wildner for (i = 0, had_output = 0; i < UMS_INFO_MAX; i++) {
116912bd3c8bSSascha Wildner info = &sc->sc_info[i];
117012bd3c8bSSascha Wildner
117112bd3c8bSSascha Wildner /* Don't emit empty info */
117212bd3c8bSSascha Wildner if ((info->sc_flags &
117312bd3c8bSSascha Wildner (UMS_FLAG_X_AXIS | UMS_FLAG_Y_AXIS | UMS_FLAG_Z_AXIS |
117412bd3c8bSSascha Wildner UMS_FLAG_T_AXIS | UMS_FLAG_W_AXIS)) == 0 &&
117512bd3c8bSSascha Wildner info->sc_buttons == 0)
117612bd3c8bSSascha Wildner continue;
117712bd3c8bSSascha Wildner
117812bd3c8bSSascha Wildner if (had_output)
117912bd3c8bSSascha Wildner sbuf_printf(sb, "\n");
118012bd3c8bSSascha Wildner had_output = 1;
118112bd3c8bSSascha Wildner sbuf_printf(sb, "i%d:", i + 1);
118212bd3c8bSSascha Wildner if (info->sc_flags & UMS_FLAG_X_AXIS)
118312bd3c8bSSascha Wildner sbuf_printf(sb, " X:r%d, p%d, s%d;",
118412bd3c8bSSascha Wildner (int)info->sc_iid_x,
118512bd3c8bSSascha Wildner (int)info->sc_loc_x.pos,
118612bd3c8bSSascha Wildner (int)info->sc_loc_x.size);
118712bd3c8bSSascha Wildner if (info->sc_flags & UMS_FLAG_Y_AXIS)
118812bd3c8bSSascha Wildner sbuf_printf(sb, " Y:r%d, p%d, s%d;",
118912bd3c8bSSascha Wildner (int)info->sc_iid_y,
119012bd3c8bSSascha Wildner (int)info->sc_loc_y.pos,
119112bd3c8bSSascha Wildner (int)info->sc_loc_y.size);
119212bd3c8bSSascha Wildner if (info->sc_flags & UMS_FLAG_Z_AXIS)
119312bd3c8bSSascha Wildner sbuf_printf(sb, " Z:r%d, p%d, s%d;",
119412bd3c8bSSascha Wildner (int)info->sc_iid_z,
119512bd3c8bSSascha Wildner (int)info->sc_loc_z.pos,
119612bd3c8bSSascha Wildner (int)info->sc_loc_z.size);
119712bd3c8bSSascha Wildner if (info->sc_flags & UMS_FLAG_T_AXIS)
119812bd3c8bSSascha Wildner sbuf_printf(sb, " T:r%d, p%d, s%d;",
119912bd3c8bSSascha Wildner (int)info->sc_iid_t,
120012bd3c8bSSascha Wildner (int)info->sc_loc_t.pos,
120112bd3c8bSSascha Wildner (int)info->sc_loc_t.size);
120212bd3c8bSSascha Wildner if (info->sc_flags & UMS_FLAG_W_AXIS)
120312bd3c8bSSascha Wildner sbuf_printf(sb, " W:r%d, p%d, s%d;",
120412bd3c8bSSascha Wildner (int)info->sc_iid_w,
120512bd3c8bSSascha Wildner (int)info->sc_loc_w.pos,
120612bd3c8bSSascha Wildner (int)info->sc_loc_w.size);
120712bd3c8bSSascha Wildner
120812bd3c8bSSascha Wildner for (j = 0; j < info->sc_buttons; j++) {
120912bd3c8bSSascha Wildner sbuf_printf(sb, " B%d:r%d, p%d, s%d;", j + 1,
121012bd3c8bSSascha Wildner (int)info->sc_iid_btn[j],
121112bd3c8bSSascha Wildner (int)info->sc_loc_btn[j].pos,
121212bd3c8bSSascha Wildner (int)info->sc_loc_btn[j].size);
121312bd3c8bSSascha Wildner }
121412bd3c8bSSascha Wildner }
121512bd3c8bSSascha Wildner sbuf_finish(sb);
121612bd3c8bSSascha Wildner err = SYSCTL_OUT(req, sbuf_data(sb), sbuf_len(sb) + 1);
121712bd3c8bSSascha Wildner sbuf_delete(sb);
121812bd3c8bSSascha Wildner
121912bd3c8bSSascha Wildner return (err);
122012bd3c8bSSascha Wildner }
1221b7abfd18SSascha Wildner #endif
122212bd3c8bSSascha Wildner
122312bd3c8bSSascha Wildner static devclass_t ums_devclass;
122412bd3c8bSSascha Wildner
122512bd3c8bSSascha Wildner static device_method_t ums_methods[] = {
122612bd3c8bSSascha Wildner DEVMETHOD(device_probe, ums_probe),
122712bd3c8bSSascha Wildner DEVMETHOD(device_attach, ums_attach),
122812bd3c8bSSascha Wildner DEVMETHOD(device_detach, ums_detach),
1229d3c9c58eSSascha Wildner DEVMETHOD_END
123012bd3c8bSSascha Wildner };
123112bd3c8bSSascha Wildner
123212bd3c8bSSascha Wildner static driver_t ums_driver = {
123312bd3c8bSSascha Wildner .name = "ums",
123412bd3c8bSSascha Wildner .methods = ums_methods,
123512bd3c8bSSascha Wildner .size = sizeof(struct ums_softc),
123612bd3c8bSSascha Wildner };
123712bd3c8bSSascha Wildner
123815f415f6SSascha Wildner DRIVER_MODULE(ums, uhub, ums_driver, ums_devclass, NULL, NULL);
123912bd3c8bSSascha Wildner MODULE_DEPEND(ums, usb, 1, 1, 1);
12403d1294c7SPeeter Must #ifdef EVDEV_SUPPORT
12413d1294c7SPeeter Must MODULE_DEPEND(ums, evdev, 1, 1, 1);
12423d1294c7SPeeter Must #endif
124312bd3c8bSSascha Wildner MODULE_VERSION(ums, 1);
1244