g_mouse.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2010 Hans Petter Selasky. All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25  * SUCH DAMAGE.
   26  */
   27 
   28 /*
   29  * HID spec: http://www.usb.org/developers/devclass_docs/HID1_11.pdf
   30  */
   31 
   32 #include <sys/param.h>
   33 __FBSDID("$FreeBSD$");
   34 
   35 #include <sys/stdint.h>
   36 #include <sys/stddef.h>
   37 #include <sys/queue.h>
   38 #include <sys/systm.h>
   39 #include <sys/kernel.h>
   40 #include <sys/bus.h>
   41 #include <sys/linker_set.h>
   42 #include <sys/module.h>
   43 #include <sys/lock.h>
   44 #include <sys/mutex.h>
   45 #include <sys/condvar.h>
   46 #include <sys/sysctl.h>
   47 #include <sys/sx.h>
   48 #include <sys/unistd.h>
   49 #include <sys/callout.h>
   50 #include <sys/malloc.h>
   51 #include <sys/priv.h>
   52 
   53 #include <dev/usb/usb.h>
   54 #include <dev/usb/usbdi.h>
   55 #include <dev/usb/usbdi_util.h>
   56 #include <dev/usb/usbhid.h>
   57 #include "usb_if.h"
   58 
   59 #define USB_DEBUG_VAR g_mouse_debug
   60 #include <dev/usb/usb_debug.h>
   61 
   62 #include <dev/usb/gadget/g_mouse.h>
   63 
   64 static SYSCTL_NODE(_hw_usb, OID_AUTO, g_mouse, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
   65     "USB mouse gadget");
   66 
   67 #ifdef USB_DEBUG
   68 static int g_mouse_debug = 0;
   69 
   70 SYSCTL_INT(_hw_usb_g_mouse, OID_AUTO, debug, CTLFLAG_RWTUN,
   71     &g_mouse_debug, 0, "Debug level");
   72 #endif
   73 
   74 static int g_mouse_mode = 0;
   75 
   76 SYSCTL_INT(_hw_usb_g_mouse, OID_AUTO, mode, CTLFLAG_RWTUN,
   77     &g_mouse_mode, 0, "Mode selection");
   78 
   79 static int g_mouse_button_press_interval = 0;
   80 
   81 SYSCTL_INT(_hw_usb_g_mouse, OID_AUTO, button_press_interval, CTLFLAG_RWTUN,
   82     &g_mouse_button_press_interval, 0, "Mouse button update interval in milliseconds");
   83 
   84 static int g_mouse_cursor_update_interval = 1023;
   85 
   86 SYSCTL_INT(_hw_usb_g_mouse, OID_AUTO, cursor_update_interval, CTLFLAG_RWTUN,
   87     &g_mouse_cursor_update_interval, 0, "Mouse cursor update interval in milliseconds");
   88 
   89 static int g_mouse_cursor_radius = 128;
   90 
   91 SYSCTL_INT(_hw_usb_g_mouse, OID_AUTO, cursor_radius, CTLFLAG_RWTUN,
   92     &g_mouse_cursor_radius, 0, "Mouse cursor radius in pixels");
   93 
   94 struct g_mouse_data {
   95         uint8_t buttons;
   96 #define BUT_0 0x01
   97 #define BUT_1 0x02
   98 #define BUT_2 0x04
   99         int8_t dx;
  100         int8_t dy;
  101         int8_t dz;
  102 };
  103 
  104 enum {
  105         G_MOUSE_INTR_DT,
  106         G_MOUSE_N_TRANSFER,
  107 };
  108 
  109 struct g_mouse_softc {
  110         struct mtx sc_mtx;
  111         struct usb_callout sc_button_press_callout;
  112         struct usb_callout sc_cursor_update_callout;
  113         struct g_mouse_data sc_data;
  114         struct usb_xfer *sc_xfer[G_MOUSE_N_TRANSFER];
  115 
  116         int     sc_mode;
  117         int     sc_radius;
  118         int     sc_last_x_state;
  119         int     sc_last_y_state;
  120         int     sc_curr_x_state;
  121         int     sc_curr_y_state;
  122         int     sc_tick;
  123 
  124         uint8_t sc_do_cursor_update;
  125         uint8_t sc_do_button_update;
  126 };
  127 
  128 static device_probe_t g_mouse_probe;
  129 static device_attach_t g_mouse_attach;
  130 static device_detach_t g_mouse_detach;
  131 static usb_handle_request_t g_mouse_handle_request;
  132 static usb_callback_t g_mouse_intr_callback;
  133 
  134 static device_method_t g_mouse_methods[] = {
  135         /* USB interface */
  136         DEVMETHOD(usb_handle_request, g_mouse_handle_request),
  137 
  138         /* Device interface */
  139         DEVMETHOD(device_probe, g_mouse_probe),
  140         DEVMETHOD(device_attach, g_mouse_attach),
  141         DEVMETHOD(device_detach, g_mouse_detach),
  142 
  143         DEVMETHOD_END
  144 };
  145 
  146 static driver_t g_mouse_driver = {
  147         .name = "g_mouse",
  148         .methods = g_mouse_methods,
  149         .size = sizeof(struct g_mouse_softc),
  150 };
  151 
  152 DRIVER_MODULE(g_mouse, uhub, g_mouse_driver, 0, 0);
  153 MODULE_DEPEND(g_mouse, usb, 1, 1, 1);
  154 
  155 static const struct usb_config g_mouse_config[G_MOUSE_N_TRANSFER] = {
  156         [G_MOUSE_INTR_DT] = {
  157                 .type = UE_INTERRUPT,
  158                 .endpoint = UE_ADDR_ANY,
  159                 .direction = UE_DIR_IN,
  160                 .flags = {.ext_buffer = 1,.pipe_bof = 1,},
  161                 .bufsize = sizeof(struct g_mouse_data),
  162                 .callback = &g_mouse_intr_callback,
  163                 .frames = 1,
  164                 .usb_mode = USB_MODE_DEVICE,
  165         },
  166 };
  167 
  168 static void g_mouse_button_press_timeout(void *arg);
  169 static void g_mouse_cursor_update_timeout(void *arg);
  170 
  171 static void
  172 g_mouse_button_press_timeout_reset(struct g_mouse_softc *sc)
  173 {
  174         int i = g_mouse_button_press_interval;
  175 
  176         if (i <= 0) {
  177                 sc->sc_data.buttons = 0;
  178                 sc->sc_do_button_update = 0;
  179         } else {
  180                 sc->sc_do_button_update = 1;
  181         }
  182 
  183         if ((i <= 0) || (i > 1023))
  184                 i = 1023;
  185 
  186         i = USB_MS_TO_TICKS(i);
  187 
  188         usb_callout_reset(&sc->sc_button_press_callout, i, 
  189             &g_mouse_button_press_timeout, sc);
  190 }
  191 
  192 static void
  193 g_mouse_cursor_update_timeout_reset(struct g_mouse_softc *sc)
  194 {
  195         int i = g_mouse_cursor_update_interval;
  196 
  197         if (i <= 0) {
  198                 sc->sc_data.dx = 0;
  199                 sc->sc_data.dy = 0;
  200                 sc->sc_do_cursor_update = 0;
  201                 sc->sc_tick = 0;
  202         } else {
  203                 sc->sc_do_cursor_update = 1;
  204         }
  205 
  206         if ((i <= 0) || (i > 1023))
  207                 i = 1023;
  208 
  209         i = USB_MS_TO_TICKS(i);
  210 
  211         usb_callout_reset(&sc->sc_cursor_update_callout, i, 
  212             &g_mouse_cursor_update_timeout, sc);
  213 }
  214 
  215 static void
  216 g_mouse_update_mode_radius(struct g_mouse_softc *sc)
  217 {
  218         sc->sc_mode = g_mouse_mode;
  219         sc->sc_radius = g_mouse_cursor_radius;
  220 
  221         if (sc->sc_radius < 0)
  222                 sc->sc_radius = 0;
  223         else if (sc->sc_radius > 1023)
  224                 sc->sc_radius = 1023;
  225 }
  226 
  227 static void
  228 g_mouse_button_press_timeout(void *arg)
  229 {
  230         struct g_mouse_softc *sc = arg;
  231 
  232         g_mouse_update_mode_radius(sc);
  233 
  234         DPRINTFN(11, "Timeout %p (button press)\n", sc->sc_xfer[G_MOUSE_INTR_DT]);
  235 
  236         g_mouse_button_press_timeout_reset(sc);
  237 
  238         usbd_transfer_start(sc->sc_xfer[G_MOUSE_INTR_DT]);
  239 }
  240 
  241 static void
  242 g_mouse_cursor_update_timeout(void *arg)
  243 {
  244         struct g_mouse_softc *sc = arg;
  245 
  246         g_mouse_update_mode_radius(sc);
  247 
  248         DPRINTFN(11, "Timeout %p (cursor update)\n", sc->sc_xfer[G_MOUSE_INTR_DT]);
  249 
  250         g_mouse_cursor_update_timeout_reset(sc);
  251 
  252         usbd_transfer_start(sc->sc_xfer[G_MOUSE_INTR_DT]);
  253 }
  254 
  255 static int
  256 g_mouse_probe(device_t dev)
  257 {
  258         struct usb_attach_arg *uaa = device_get_ivars(dev);
  259 
  260         DPRINTFN(11, "\n");
  261 
  262         if (uaa->usb_mode != USB_MODE_DEVICE)
  263                 return (ENXIO);
  264 
  265         if ((uaa->info.bInterfaceClass == UICLASS_HID) &&
  266             (uaa->info.bInterfaceSubClass == UISUBCLASS_BOOT) &&
  267             (uaa->info.bInterfaceProtocol == UIPROTO_MOUSE))
  268                 return (0);
  269 
  270         return (ENXIO);
  271 }
  272 
  273 static int
  274 g_mouse_attach(device_t dev)
  275 {
  276         struct g_mouse_softc *sc = device_get_softc(dev);
  277         struct usb_attach_arg *uaa = device_get_ivars(dev);
  278         int error;
  279 
  280         DPRINTFN(11, "\n");
  281 
  282         device_set_usb_desc(dev);
  283 
  284         mtx_init(&sc->sc_mtx, "g_mouse", NULL, MTX_DEF);
  285 
  286         usb_callout_init_mtx(&sc->sc_button_press_callout, &sc->sc_mtx, 0);
  287         usb_callout_init_mtx(&sc->sc_cursor_update_callout, &sc->sc_mtx, 0);
  288 
  289         sc->sc_mode = G_MOUSE_MODE_SILENT;
  290 
  291         error = usbd_transfer_setup(uaa->device,
  292             &uaa->info.bIfaceIndex, sc->sc_xfer, g_mouse_config,
  293             G_MOUSE_N_TRANSFER, sc, &sc->sc_mtx);
  294 
  295         if (error) {
  296                 DPRINTF("error=%s\n", usbd_errstr(error));
  297                 goto detach;
  298         }
  299 
  300         mtx_lock(&sc->sc_mtx);
  301         g_mouse_button_press_timeout_reset(sc);
  302         g_mouse_cursor_update_timeout_reset(sc);
  303         mtx_unlock(&sc->sc_mtx);
  304 
  305         return (0);                     /* success */
  306 
  307 detach:
  308         g_mouse_detach(dev);
  309 
  310         return (ENXIO);                 /* error */
  311 }
  312 
  313 static int
  314 g_mouse_detach(device_t dev)
  315 {
  316         struct g_mouse_softc *sc = device_get_softc(dev);
  317 
  318         DPRINTF("\n");
  319 
  320         mtx_lock(&sc->sc_mtx);
  321         usb_callout_stop(&sc->sc_button_press_callout);
  322         usb_callout_stop(&sc->sc_cursor_update_callout);
  323         mtx_unlock(&sc->sc_mtx);
  324 
  325         usbd_transfer_unsetup(sc->sc_xfer, G_MOUSE_N_TRANSFER);
  326 
  327         usb_callout_drain(&sc->sc_button_press_callout);
  328         usb_callout_drain(&sc->sc_cursor_update_callout);
  329 
  330         mtx_destroy(&sc->sc_mtx);
  331 
  332         return (0);
  333 }
  334 
  335 static void
  336 g_mouse_intr_callback(struct usb_xfer *xfer, usb_error_t error)
  337 {
  338         struct g_mouse_softc *sc = usbd_xfer_softc(xfer);
  339         int actlen;
  340         int aframes;
  341         int dx;
  342         int dy;
  343         int radius;
  344 
  345         usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL);
  346 
  347         DPRINTF("st=%d aframes=%d actlen=%d bytes\n",
  348             USB_GET_STATE(xfer), aframes, actlen);
  349 
  350         switch (USB_GET_STATE(xfer)) {
  351         case USB_ST_TRANSFERRED:
  352                 if (!(sc->sc_do_cursor_update || sc->sc_do_button_update))
  353                         break;
  354 
  355         case USB_ST_SETUP:
  356 tr_setup:
  357 
  358           if (sc->sc_do_cursor_update) {
  359                 sc->sc_do_cursor_update = 0;
  360                 sc->sc_tick += 80;
  361                 if ((sc->sc_tick < 0) || (sc->sc_tick > 7999))
  362                         sc->sc_tick = 0;
  363           }
  364 
  365           if (sc->sc_do_button_update) {
  366                         sc->sc_do_button_update = 0;
  367                         sc->sc_data.buttons ^= BUT_0;
  368           }
  369 
  370           radius = sc->sc_radius;
  371 
  372                 switch (sc->sc_mode) {
  373                 case G_MOUSE_MODE_SILENT:
  374                         sc->sc_data.buttons = 0;
  375                         break;
  376                 case G_MOUSE_MODE_SPIRAL:
  377                         radius = (radius * (8000-sc->sc_tick)) / 8000;
  378                 case G_MOUSE_MODE_CIRCLE:
  379                         /* TODO */
  380                         sc->sc_curr_y_state = 0;
  381                         sc->sc_curr_x_state = 0;
  382                         break;
  383                 case G_MOUSE_MODE_BOX:
  384                         if (sc->sc_tick < 2000) {
  385                                 sc->sc_curr_x_state = (sc->sc_tick * radius) / 2000;
  386                                 sc->sc_curr_y_state = 0;
  387                         } else if (sc->sc_tick < 4000) {
  388                                 sc->sc_curr_x_state = radius;
  389                                 sc->sc_curr_y_state = -(((sc->sc_tick - 2000) * radius) / 2000);
  390                         } else if (sc->sc_tick < 6000) {
  391                                 sc->sc_curr_x_state = radius - (((sc->sc_tick - 4000) * radius) / 2000);
  392                                 sc->sc_curr_y_state = -radius;
  393                         } else {
  394                                 sc->sc_curr_x_state = 0;
  395                                 sc->sc_curr_y_state = -radius + (((sc->sc_tick - 6000) * radius) / 2000);
  396                         }
  397                         break;
  398                 default:
  399                         break;
  400                 }
  401 
  402                 dx = sc->sc_curr_x_state - sc->sc_last_x_state;
  403                 dy = sc->sc_curr_y_state - sc->sc_last_y_state;
  404 
  405                 if (dx < -63)
  406                   dx = -63;
  407                 else if (dx > 63)
  408                   dx = 63;
  409 
  410                 if (dy < -63)
  411                   dy = -63;
  412                 else if (dy > 63)
  413                   dy = 63;
  414 
  415                 sc->sc_last_x_state += dx;
  416                 sc->sc_last_y_state += dy;
  417 
  418                 sc->sc_data.dx = dx;
  419                 sc->sc_data.dy = dy;
  420 
  421                 usbd_xfer_set_frame_data(xfer, 0, &sc->sc_data, sizeof(sc->sc_data));
  422                 usbd_xfer_set_frames(xfer, 1);
  423                 usbd_transfer_submit(xfer);
  424                 break;
  425 
  426         default:                        /* Error */
  427                 DPRINTF("error=%s\n", usbd_errstr(error));
  428 
  429                 if (error != USB_ERR_CANCELLED) {
  430                         /* try to clear stall first */
  431                         usbd_xfer_set_stall(xfer);
  432                         goto tr_setup;
  433                 }
  434                 break;
  435         }
  436 }
  437 
  438 static int
  439 g_mouse_handle_request(device_t dev,
  440     const void *preq, void **pptr, uint16_t *plen,
  441     uint16_t offset, uint8_t *pstate)
  442 {
  443         const struct usb_device_request *req = preq;
  444         uint8_t is_complete = *pstate;
  445 
  446         if (!is_complete) {
  447                 if ((req->bmRequestType == UT_WRITE_CLASS_INTERFACE) &&
  448                     (req->bRequest == UR_SET_PROTOCOL) &&
  449                     (req->wValue[0] == 0x00) &&
  450                     (req->wValue[1] == 0x00)) {
  451                         *plen = 0;
  452                         return (0);
  453                 }
  454         }
  455         return (ENXIO);                 /* use builtin handler */
  456 }
Cache object: db17958685f0033589a9f4391eec8218
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/usb/gadget/g_mouse.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/usb/gadget/g_mouse.c
