sys/dev/hid/hconf.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2019 Vladimir Kondratyev <wulf@FreeBSD.org>
   5  * Copyright (c) 2020 Andriy Gapon <avg@FreeBSD.org>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 /*
  33  * Digitizer configuration top-level collection support.
  34  * https://docs.microsoft.com/en-us/windows-hardware/design/component-guidelines/windows-precision-touchpad-required-hid-top-level-collections
  35  */
  36
  37 #include "opt_hid.h"
  38
  39 #include <sys/param.h>
  40 #include <sys/bus.h>
  41 #include <sys/kernel.h>
  42 #include <sys/lock.h>
  43 #include <sys/malloc.h>
  44 #include <sys/module.h>
  45 #include <sys/sysctl.h>
  46 #include <sys/systm.h>
  47 #include <sys/sx.h>
  48
  49 #define HID_DEBUG_VAR   hconf_debug
  50 #include <dev/hid/hid.h>
  51 #include <dev/hid/hidbus.h>
  52
  53 #include <dev/hid/hconf.h>
  54
  55 #ifdef HID_DEBUG
  56 static int hconf_debug = 0;
  57
  58 static SYSCTL_NODE(_hw_hid, OID_AUTO, hconf, CTLFLAG_RW, 0,
  59     "Digitizer configuration top-level collection");
  60 SYSCTL_INT(_hw_hid_hconf, OID_AUTO, debug, CTLFLAG_RWTUN,
  61     &hconf_debug, 1, "Debug level");
  62 #endif
  63
  64 enum feature_control_type {
  65         INPUT_MODE = 0,
  66         SURFACE_SWITCH,
  67         BUTTONS_SWITCH,
  68         CONTROLS_COUNT
  69 };
  70
  71 struct feature_control_descr {
  72         const char      *name;
  73         const char      *descr;
  74         uint16_t        usage;
  75         u_int           value;
  76 } feature_control_descrs[] = {
  77         [INPUT_MODE] = {
  78                 .name = "input_mode",
  79                 .descr = "HID device input mode: 0 = mouse, 3 = touchpad",
  80                 .usage = HUD_INPUT_MODE,
  81                 .value = HCONF_INPUT_MODE_MOUSE,
  82         },
  83         [SURFACE_SWITCH] = {
  84                 .name = "surface_switch",
  85                 .descr = "Enable / disable switch for surface: 1 = on, 0 = off",
  86                 .usage = HUD_SURFACE_SWITCH,
  87                 .value = 1,
  88         },
  89         [BUTTONS_SWITCH] = {
  90                 .name = "buttons_switch",
  91                 .descr = "Enable / disable switch for buttons: 1 = on, 0 = off",
  92                 .usage = HUD_BUTTONS_SWITCH,
  93                 .value = 1,
  94         },
  95 };
  96
  97 struct feature_control {
  98         u_int                   val;
  99         struct hid_location     loc;
 100         hid_size_t              rlen;
 101         uint8_t                 rid;
 102 };
 103
 104 struct hconf_softc {
 105         device_t                dev;
 106         struct sx               lock;
 107
 108         struct feature_control  feature_controls[CONTROLS_COUNT];
 109 };
 110
 111 static device_probe_t           hconf_probe;
 112 static device_attach_t          hconf_attach;
 113 static device_detach_t          hconf_detach;
 114 static device_resume_t          hconf_resume;
 115
 116 static devclass_t hconf_devclass;
 117
 118 static device_method_t hconf_methods[] = {
 119
 120         DEVMETHOD(device_probe,         hconf_probe),
 121         DEVMETHOD(device_attach,        hconf_attach),
 122         DEVMETHOD(device_detach,        hconf_detach),
 123         DEVMETHOD(device_resume,        hconf_resume),
 124
 125         DEVMETHOD_END
 126 };
 127
 128 static driver_t hconf_driver = {
 129         .name = "hconf",
 130         .methods = hconf_methods,
 131         .size = sizeof(struct hconf_softc),
 132 };
 133
 134 static const struct hid_device_id hconf_devs[] = {
 135         { HID_TLC(HUP_DIGITIZERS, HUD_CONFIG) },
 136 };
 137
 138 static int
 139 hconf_set_feature_control(struct hconf_softc *sc, int ctrl_id, u_int val)
 140 {
 141         struct feature_control *fc;
 142         uint8_t *fbuf;
 143         int error;
 144         int i;
 145
 146         KASSERT(ctrl_id >= 0 && ctrl_id < CONTROLS_COUNT,
 147             ("impossible ctrl id %d", ctrl_id));
 148         fc = &sc->feature_controls[ctrl_id];
 149         if (fc->rlen <= 1)
 150                 return (ENXIO);
 151
 152         fbuf = malloc(fc->rlen, M_TEMP, M_WAITOK | M_ZERO);
 153         sx_xlock(&sc->lock);
 154
 155         /*
 156          * Assume the report is write-only. Then we have to check for other
 157          * controls that may share the same report and set their bits as well.
 158          */
 159         bzero(fbuf + 1, fc->rlen - 1);
 160         for (i = 0; i < nitems(sc->feature_controls); i++) {
 161                 struct feature_control *ofc = &sc->feature_controls[i];
 162
 163                 /* Skip unrelated report IDs. */
 164                 if (ofc->rid != fc->rid)
 165                         continue;
 166                 KASSERT(fc->rlen == ofc->rlen,
 167                     ("different lengths for report %d: %d vs %d\n",
 168                     fc->rid, fc->rlen, ofc->rlen));
 169                 hid_put_udata(fbuf + 1, ofc->rlen - 1, &ofc->loc,
 170                     i == ctrl_id ? val : ofc->val);
 171         }
 172
 173         fbuf[0] = fc->rid;
 174
 175         error = hid_set_report(sc->dev, fbuf, fc->rlen,
 176             HID_FEATURE_REPORT, fc->rid);
 177         if (error == 0)
 178                 fc->val = val;
 179
 180         sx_unlock(&sc->lock);
 181         free(fbuf, M_TEMP);
 182
 183         return (error);
 184 }
 185
 186 static int
 187 hconf_feature_control_handler(SYSCTL_HANDLER_ARGS)
 188 {
 189         struct feature_control *fc;
 190         struct hconf_softc *sc = arg1;
 191         int ctrl_id = arg2;
 192         u_int value;
 193         int error;
 194
 195         if (ctrl_id < 0 || ctrl_id >= CONTROLS_COUNT)
 196                 return (ENXIO);
 197
 198         fc = &sc->feature_controls[ctrl_id];
 199         value = fc->val;
 200         error = sysctl_handle_int(oidp, &value, 0, req);
 201         if (error != 0 || req->newptr == NULL)
 202                 return (error);
 203
 204         error = hconf_set_feature_control(sc, ctrl_id, value);
 205         if (error != 0) {
 206                 DPRINTF("Failed to set %s: %d\n",
 207                     feature_control_descrs[ctrl_id].name, error);
 208         }
 209         return (0);
 210 }
 211
 212
 213 static int
 214 hconf_parse_feature(struct feature_control *fc, uint8_t tlc_index,
 215     uint16_t usage, void *d_ptr, hid_size_t d_len)
 216 {
 217         uint32_t flags;
 218
 219         if (!hidbus_locate(d_ptr, d_len, HID_USAGE2(HUP_DIGITIZERS, usage),
 220             hid_feature, tlc_index, 0, &fc->loc, &flags, &fc->rid, NULL))
 221                 return (ENOENT);
 222
 223         if ((flags & (HIO_VARIABLE | HIO_RELATIVE)) != HIO_VARIABLE)
 224                 return (EINVAL);
 225
 226         fc->rlen = hid_report_size(d_ptr, d_len, hid_feature, fc->rid);
 227         return (0);
 228 }
 229
 230 static int
 231 hconf_probe(device_t dev)
 232 {
 233         int error;
 234
 235         error = HIDBUS_LOOKUP_DRIVER_INFO(dev, hconf_devs);
 236         if (error != 0)
 237                 return (error);
 238
 239         hidbus_set_desc(dev, "Configuration");
 240
 241         return (BUS_PROBE_DEFAULT);
 242 }
 243
 244 static int
 245 hconf_attach(device_t dev)
 246 {
 247         struct hconf_softc *sc = device_get_softc(dev);
 248         struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
 249         struct sysctl_oid *tree = device_get_sysctl_tree(dev);
 250         void *d_ptr;
 251         hid_size_t d_len;
 252         uint8_t tlc_index;
 253         int error;
 254         int i;
 255
 256         error = hid_get_report_descr(dev, &d_ptr, &d_len);
 257         if (error) {
 258                 device_printf(dev, "could not retrieve report descriptor from "
 259                     "device: %d\n", error);
 260                 return (ENXIO);
 261         }
 262
 263         sc->dev = dev;
 264         sx_init(&sc->lock, device_get_nameunit(dev));
 265
 266         tlc_index = hidbus_get_index(dev);
 267         for (i = 0; i < nitems(sc->feature_controls); i++) {
 268                 (void)hconf_parse_feature(&sc->feature_controls[i], tlc_index,
 269                     feature_control_descrs[i].usage, d_ptr, d_len);
 270                 if (sc->feature_controls[i].rlen > 1) {
 271                         SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
 272                             feature_control_descrs[i].name,
 273                             CTLTYPE_UINT | CTLFLAG_RW,
 274                             sc, i, hconf_feature_control_handler, "I",
 275                             feature_control_descrs[i].descr);
 276                 }
 277                 sc->feature_controls[i].val = feature_control_descrs[i].value;
 278         }
 279
 280         return (0);
 281 }
 282
 283 static int
 284 hconf_detach(device_t dev)
 285 {
 286         struct hconf_softc *sc = device_get_softc(dev);
 287
 288         sx_destroy(&sc->lock);
 289
 290         return (0);
 291 }
 292
 293 static int
 294 hconf_resume(device_t dev)
 295 {
 296         struct hconf_softc *sc = device_get_softc(dev);
 297         int error;
 298         int i;
 299
 300         for (i = 0; i < nitems(sc->feature_controls); i++) {
 301                 if (sc->feature_controls[i].rlen < 2)
 302                         continue;
 303                 /* Do not update usages to default value */
 304                 if (sc->feature_controls[i].val ==
 305                     feature_control_descrs[i].value)
 306                         continue;
 307                 error = hconf_set_feature_control(sc, i,
 308                     sc->feature_controls[i].val);
 309                 if (error != 0) {
 310                         DPRINTF("Failed to restore %s: %d\n",
 311                             feature_control_descrs[i].name, error);
 312                 }
 313         }
 314
 315         return (0);
 316 }
 317
 318 int
 319 hconf_set_input_mode(device_t dev, enum hconf_input_mode mode)
 320 {
 321         struct hconf_softc *sc = device_get_softc(dev);
 322
 323         return (hconf_set_feature_control(sc, INPUT_MODE, mode));
 324 }
 325
 326 DRIVER_MODULE(hconf, hidbus, hconf_driver, hconf_devclass, NULL, 0);
 327 MODULE_DEPEND(hconf, hidbus, 1, 1, 1);
 328 MODULE_DEPEND(hconf, hid, 1, 1, 1);
 329 MODULE_VERSION(hconf, 1);
 330 HID_PNP_INFO(hconf_devs);