Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/dev/hid/hidmap.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
SearchContext: - none - 3 - 10
1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2020 Vladimir Kondratyev <wulf@FreeBSD.org> 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 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 /* 32 * Abstract 1 to 1 HID input usage to evdev event mapper driver. 33 */ 34 35 #include "opt_hid.h" 36 37 #include <sys/param.h> 38 #include <sys/bus.h> 39 #include <sys/kernel.h> 40 #include <sys/lock.h> 41 #include <sys/malloc.h> 42 #include <sys/module.h> 43 #include <sys/sysctl.h> 44 #include <sys/systm.h> 45 46 #include <dev/evdev/input.h> 47 #include <dev/evdev/evdev.h> 48 49 #include <dev/hid/hid.h> 50 #include <dev/hid/hidbus.h> 51 #include <dev/hid/hidmap.h> 52 53 #ifdef HID_DEBUG 54 #define DPRINTFN(hm, n, fmt, ...) do { \ 55 if ((hm)->debug_var != NULL && *(hm)->debug_var >= (n)) { \ 56 device_printf((hm)->dev, "%s: " fmt, \ 57 __FUNCTION__ ,##__VA_ARGS__); \ 58 } \ 59 } while (0) 60 #define DPRINTF(hm, ...) DPRINTFN(hm, 1, __VA_ARGS__) 61 #else 62 #define DPRINTF(...) do { } while (0) 63 #define DPRINTFN(...) do { } while (0) 64 #endif 65 66 static evdev_open_t hidmap_ev_open; 67 static evdev_close_t hidmap_ev_close; 68 69 #define HIDMAP_WANT_MERGE_KEYS(hm) ((hm)->key_rel != NULL) 70 71 #define HIDMAP_FOREACH_ITEM(hm, mi, uoff) \ 72 for (u_int _map = 0, _item = 0, _uoff_priv = -1; \ 73 ((mi) = hidmap_get_next_map_item( \ 74 (hm), &_map, &_item, &_uoff_priv, &(uoff))) != NULL;) 75 76 static inline bool 77 hidmap_get_next_map_index(const struct hidmap_item *map, int nmap_items, 78 uint32_t *index, uint16_t *usage_offset) 79 { 80 81 ++*usage_offset; 82 if ((*index != 0 || *usage_offset != 0) && 83 *usage_offset >= map[*index].nusages) { 84 ++*index; 85 *usage_offset = 0; 86 } 87 88 return (*index < nmap_items); 89 } 90 91 static inline const struct hidmap_item * 92 hidmap_get_next_map_item(struct hidmap *hm, u_int *map, u_int *item, 93 u_int *uoff_priv, uint16_t *uoff) 94 { 95 96 *uoff = *uoff_priv; 97 while (!hidmap_get_next_map_index( 98 hm->map[*map], hm->nmap_items[*map], item, uoff)) { 99 ++*map; 100 *item = 0; 101 *uoff = -1; 102 if (*map >= hm->nmaps) 103 return (NULL); 104 } 105 *uoff_priv = *uoff; 106 107 return (hm->map[*map] + *item); 108 } 109 110 void 111 _hidmap_set_debug_var(struct hidmap *hm, int *debug_var) 112 { 113 #ifdef HID_DEBUG 114 hm->debug_var = debug_var; 115 #endif 116 } 117 118 static int 119 hidmap_ev_close(struct evdev_dev *evdev) 120 { 121 return (hidbus_intr_stop(evdev_get_softc(evdev))); 122 } 123 124 static int 125 hidmap_ev_open(struct evdev_dev *evdev) 126 { 127 return (hidbus_intr_start(evdev_get_softc(evdev))); 128 } 129 130 void 131 hidmap_support_key(struct hidmap *hm, uint16_t key) 132 { 133 if (hm->key_press == NULL) { 134 hm->key_press = malloc(howmany(KEY_CNT, 8), M_DEVBUF, 135 M_ZERO | M_WAITOK); 136 evdev_support_event(hm->evdev, EV_KEY); 137 hm->key_min = key; 138 hm->key_max = key; 139 } 140 hm->key_min = MIN(hm->key_min, key); 141 hm->key_max = MAX(hm->key_max, key); 142 if (isset(hm->key_press, key)) { 143 if (hm->key_rel == NULL) 144 hm->key_rel = malloc(howmany(KEY_CNT, 8), M_DEVBUF, 145 M_ZERO | M_WAITOK); 146 } else { 147 setbit(hm->key_press, key); 148 evdev_support_key(hm->evdev, key); 149 } 150 } 151 152 void 153 hidmap_push_key(struct hidmap *hm, uint16_t key, int32_t value) 154 { 155 if (HIDMAP_WANT_MERGE_KEYS(hm)) 156 setbit(value != 0 ? hm->key_press : hm->key_rel, key); 157 else 158 evdev_push_key(hm->evdev, key, value); 159 } 160 161 static void 162 hidmap_sync_keys(struct hidmap *hm) 163 { 164 int i, j; 165 bool press, rel; 166 167 for (j = hm->key_min / 8; j <= hm->key_max / 8; j++) { 168 if (hm->key_press[j] != hm->key_rel[j]) { 169 for (i = j * 8; i < j * 8 + 8; i++) { 170 press = isset(hm->key_press, i); 171 rel = isset(hm->key_rel, i); 172 if (press != rel) 173 evdev_push_key(hm->evdev, i, press); 174 } 175 } 176 } 177 bzero(hm->key_press, howmany(KEY_CNT, 8)); 178 bzero(hm->key_rel, howmany(KEY_CNT, 8)); 179 } 180 181 void 182 hidmap_intr(void *context, void *buf, hid_size_t len) 183 { 184 struct hidmap *hm = context; 185 struct hidmap_hid_item *hi; 186 const struct hidmap_item *mi; 187 int32_t usage; 188 int32_t data; 189 uint16_t key, uoff; 190 uint8_t id = 0; 191 bool found, do_sync = false; 192 193 DPRINTFN(hm, 6, "hm=%p len=%d\n", hm, len); 194 DPRINTFN(hm, 6, "data = %*D\n", len, buf, " "); 195 196 /* Strip leading "report ID" byte */ 197 if (hm->hid_items[0].id) { 198 id = *(uint8_t *)buf; 199 len--; 200 buf = (uint8_t *)buf + 1; 201 } 202 203 hm->intr_buf = buf; 204 hm->intr_len = len; 205 206 for (hi = hm->hid_items; hi < hm->hid_items + hm->nhid_items; hi++) { 207 /* At first run callbacks that not tied to HID items */ 208 if (hi->type == HIDMAP_TYPE_FINALCB) { 209 DPRINTFN(hm, 6, "type=%d item=%*D\n", hi->type, 210 (int)sizeof(hi->cb), &hi->cb, " "); 211 if (hi->cb(hm, hi, (union hidmap_cb_ctx){.rid = id}) 212 == 0) 213 do_sync = true; 214 continue; 215 } 216 217 /* Ignore irrelevant reports */ 218 if (id != hi->id) 219 continue; 220 221 /* 222 * 5.8. If Logical Minimum and Logical Maximum are both 223 * positive values then the contents of a field can be assumed 224 * to be an unsigned value. Otherwise, all integer values are 225 * signed values represented in 2’s complement format. 226 */ 227 data = hi->lmin < 0 || hi->lmax < 0 228 ? hid_get_data(buf, len, &hi->loc) 229 : hid_get_udata(buf, len, &hi->loc); 230 231 DPRINTFN(hm, 6, "type=%d data=%d item=%*D\n", hi->type, data, 232 (int)sizeof(hi->cb), &hi->cb, " "); 233 234 if (hi->invert_value && hi->type < HIDMAP_TYPE_ARR_LIST) 235 data = hi->evtype == EV_REL 236 ? -data 237 : hi->lmin + hi->lmax - data; 238 239 switch (hi->type) { 240 case HIDMAP_TYPE_CALLBACK: 241 if (hi->cb(hm, hi, (union hidmap_cb_ctx){.data = data}) 242 != 0) 243 continue; 244 break; 245 246 case HIDMAP_TYPE_VAR_NULLST: 247 /* 248 * 5.10. If the host or the device receives an 249 * out-of-range value then the current value for the 250 * respective control will not be modified. 251 */ 252 if (data < hi->lmin || data > hi->lmax) 253 continue; 254 /* FALLTHROUGH */ 255 case HIDMAP_TYPE_VARIABLE: 256 /* 257 * Ignore reports for absolute data if the data did not 258 * change and for relative data if data is 0. 259 * Evdev layer filters out them anyway. 260 */ 261 if (data == (hi->evtype == EV_REL ? 0 : hi->last_val)) 262 continue; 263 if (hi->evtype == EV_KEY) 264 hidmap_push_key(hm, hi->code, data); 265 else 266 evdev_push_event(hm->evdev, hi->evtype, 267 hi->code, data); 268 hi->last_val = data; 269 break; 270 271 case HIDMAP_TYPE_ARR_LIST: 272 key = KEY_RESERVED; 273 /* 274 * 6.2.2.5. An out-of range value in an array field 275 * is considered no controls asserted. 276 */ 277 if (data < hi->lmin || data > hi->lmax) 278 goto report_key; 279 /* 280 * 6.2.2.5. Rather than returning a single bit for each 281 * button in the group, an array returns an index in 282 * each field that corresponds to the pressed button. 283 */ 284 key = hi->codes[data - hi->lmin]; 285 if (key == KEY_RESERVED) 286 DPRINTF(hm, "Can not map unknown HID " 287 "array index: %08x\n", data); 288 goto report_key; 289 290 case HIDMAP_TYPE_ARR_RANGE: 291 key = KEY_RESERVED; 292 /* 293 * 6.2.2.5. An out-of range value in an array field 294 * is considered no controls asserted. 295 */ 296 if (data < hi->lmin || data > hi->lmax) 297 goto report_key; 298 /* 299 * When the input field is an array and the usage is 300 * specified with a range instead of an ID, we have to 301 * derive the actual usage by using the item value as 302 * an index in the usage range list. 303 */ 304 usage = data - hi->lmin + hi->umin; 305 found = false; 306 HIDMAP_FOREACH_ITEM(hm, mi, uoff) { 307 if (usage == mi->usage + uoff && 308 mi->type == EV_KEY && !mi->has_cb) { 309 key = mi->code; 310 found = true; 311 break; 312 } 313 } 314 if (!found) 315 DPRINTF(hm, "Can not map unknown HID " 316 "usage: %08x\n", usage); 317 report_key: 318 if (key == HIDMAP_KEY_NULL || key == hi->last_key) 319 continue; 320 if (hi->last_key != KEY_RESERVED) 321 hidmap_push_key(hm, hi->last_key, 0); 322 if (key != KEY_RESERVED) 323 hidmap_push_key(hm, key, 1); 324 hi->last_key = key; 325 break; 326 327 default: 328 KASSERT(0, ("Unknown map type (%d)", hi->type)); 329 } 330 do_sync = true; 331 } 332 333 if (do_sync) { 334 if (HIDMAP_WANT_MERGE_KEYS(hm)) 335 hidmap_sync_keys(hm); 336 evdev_sync(hm->evdev); 337 } 338 } 339 340 static inline bool 341 can_map_callback(struct hid_item *hi, const struct hidmap_item *mi, 342 uint16_t usage_offset) 343 { 344 345 return (mi->has_cb && !mi->final_cb && 346 hi->usage == mi->usage + usage_offset && 347 (mi->relabs == HIDMAP_RELABS_ANY || 348 !(hi->flags & HIO_RELATIVE) == !(mi->relabs == HIDMAP_RELATIVE))); 349 } 350 351 static inline bool 352 can_map_variable(struct hid_item *hi, const struct hidmap_item *mi, 353 uint16_t usage_offset) 354 { 355 356 return ((hi->flags & HIO_VARIABLE) != 0 && !mi->has_cb && 357 hi->usage == mi->usage + usage_offset && 358 (mi->relabs == HIDMAP_RELABS_ANY || 359 !(hi->flags & HIO_RELATIVE) == !(mi->relabs == HIDMAP_RELATIVE))); 360 } 361 362 static inline bool 363 can_map_arr_range(struct hid_item *hi, const struct hidmap_item *mi, 364 uint16_t usage_offset) 365 { 366 367 return ((hi->flags & HIO_VARIABLE) == 0 && !mi->has_cb && 368 hi->usage_minimum <= mi->usage + usage_offset && 369 hi->usage_maximum >= mi->usage + usage_offset && 370 mi->type == EV_KEY && 371 (mi->code != KEY_RESERVED && mi->code != HIDMAP_KEY_NULL)); 372 } 373 374 static inline bool 375 can_map_arr_list(struct hid_item *hi, const struct hidmap_item *mi, 376 uint32_t usage, uint16_t usage_offset) 377 { 378 379 return ((hi->flags & HIO_VARIABLE) == 0 && !mi->has_cb && 380 usage == mi->usage + usage_offset && 381 mi->type == EV_KEY && 382 (mi->code != KEY_RESERVED && mi->code != HIDMAP_KEY_NULL)); 383 } 384 385 static bool 386 hidmap_probe_hid_item(struct hid_item *hi, const struct hidmap_item *map, 387 int nitems_map, hidmap_caps_t caps) 388 { 389 u_int i, j; 390 uint16_t uoff; 391 bool found = false; 392 393 #define HIDMAP_FOREACH_INDEX(map, nitems, idx, uoff) \ 394 for ((idx) = 0, (uoff) = -1; \ 395 hidmap_get_next_map_index((map), (nitems), &(idx), &(uoff));) 396 397 HIDMAP_FOREACH_INDEX(map, nitems_map, i, uoff) { 398 if (can_map_callback(hi, map + i, uoff)) { 399 if (map[i].cb(NULL, NULL, 400 (union hidmap_cb_ctx){.hi = hi}) != 0) 401 break; 402 setbit(caps, i); 403 return (true); 404 } 405 } 406 407 if (hi->flags & HIO_VARIABLE) { 408 HIDMAP_FOREACH_INDEX(map, nitems_map, i, uoff) { 409 if (can_map_variable(hi, map + i, uoff)) { 410 KASSERT(map[i].type == EV_KEY || 411 map[i].type == EV_REL || 412 map[i].type == EV_ABS || 413 map[i].type == EV_SW, 414 ("Unsupported event type")); 415 setbit(caps, i); 416 return (true); 417 } 418 } 419 return (false); 420 } 421 422 if (hi->usage_minimum != 0 || hi->usage_maximum != 0) { 423 HIDMAP_FOREACH_INDEX(map, nitems_map, i, uoff) { 424 if (can_map_arr_range(hi, map + i, uoff)) { 425 setbit(caps, i); 426 found = true; 427 } 428 } 429 return (found); 430 } 431 432 for (j = 0; j < hi->nusages; j++) { 433 HIDMAP_FOREACH_INDEX(map, nitems_map, i, uoff) { 434 if (can_map_arr_list(hi, map+i, hi->usages[j], uoff)) { 435 setbit(caps, i); 436 found = true; 437 } 438 } 439 } 440 441 return (found); 442 } 443 444 static uint32_t 445 hidmap_probe_hid_descr(void *d_ptr, hid_size_t d_len, uint8_t tlc_index, 446 const struct hidmap_item *map, int nitems_map, hidmap_caps_t caps) 447 { 448 struct hid_data *hd; 449 struct hid_item hi; 450 uint32_t i, items = 0; 451 bool do_free = false; 452 453 if (caps == NULL) { 454 caps = malloc(HIDMAP_CAPS_SZ(nitems_map), M_DEVBUF, M_WAITOK); 455 do_free = true; 456 } else 457 bzero (caps, HIDMAP_CAPS_SZ(nitems_map)); 458 459 /* Parse inputs */ 460 hd = hid_start_parse(d_ptr, d_len, 1 << hid_input); 461 HIDBUS_FOREACH_ITEM(hd, &hi, tlc_index) { 462 if (hi.kind != hid_input) 463 continue; 464 if (hi.flags & HIO_CONST) 465 continue; 466 for (i = 0; i < hi.loc.count; i++, hi.loc.pos += hi.loc.size) 467 if (hidmap_probe_hid_item(&hi, map, nitems_map, caps)) 468 items++; 469 } 470 hid_end_parse(hd); 471 472 /* Take finalizing callbacks in to account */ 473 for (i = 0; i < nitems_map; i++) { 474 if (map[i].has_cb && map[i].final_cb && 475 map[i].cb(NULL, NULL, (union hidmap_cb_ctx){}) == 0) { 476 setbit(caps, i); 477 items++; 478 } 479 } 480 481 /* Check that all mandatory usages are present in report descriptor */ 482 if (items != 0) { 483 for (i = 0; i < nitems_map; i++) { 484 if (map[i].required && isclr(caps, i)) { 485 items = 0; 486 break; 487 } 488 } 489 } 490 491 if (do_free) 492 free(caps, M_DEVBUF); 493 494 return (items); 495 } 496 497 uint32_t 498 hidmap_add_map(struct hidmap *hm, const struct hidmap_item *map, 499 int nitems_map, hidmap_caps_t caps) 500 { 501 void *d_ptr; 502 uint32_t items; 503 int i, error; 504 hid_size_t d_len; 505 uint8_t tlc_index = hidbus_get_index(hm->dev); 506 507 /* Avoid double-adding of map in probe() handler */ 508 for (i = 0; i < hm->nmaps; i++) 509 if (hm->map[i] == map) 510 return (0); 511 512 error = hid_get_report_descr(hm->dev, &d_ptr, &d_len); 513 if (error != 0) { 514 device_printf(hm->dev, "could not retrieve report descriptor " 515 "from device: %d\n", error); 516 return (error); 517 } 518 519 hm->cb_state = HIDMAP_CB_IS_PROBING; 520 items = hidmap_probe_hid_descr(d_ptr, d_len, tlc_index, map, 521 nitems_map, caps); 522 if (items == 0) 523 return (ENXIO); 524 525 KASSERT(hm->nmaps < HIDMAP_MAX_MAPS, 526 ("Not more than %d maps is supported", HIDMAP_MAX_MAPS)); 527 hm->nhid_items += items; 528 hm->map[hm->nmaps] = map; 529 hm->nmap_items[hm->nmaps] = nitems_map; 530 hm->nmaps++; 531 532 return (0); 533 } 534 535 static bool 536 hidmap_parse_hid_item(struct hidmap *hm, struct hid_item *hi, 537 struct hidmap_hid_item *item) 538 { 539 const struct hidmap_item *mi; 540 struct hidmap_hid_item hi_temp; 541 uint32_t i; 542 uint16_t uoff; 543 bool found = false; 544 545 HIDMAP_FOREACH_ITEM(hm, mi, uoff) { 546 if (can_map_callback(hi, mi, uoff)) { 547 bzero(&hi_temp, sizeof(hi_temp)); 548 hi_temp.cb = mi->cb; 549 hi_temp.type = HIDMAP_TYPE_CALLBACK; 550 /* 551 * Values returned by probe- and attach-stage 552 * callbacks MUST be identical. 553 */ 554 if (mi->cb(hm, &hi_temp, 555 (union hidmap_cb_ctx){.hi = hi}) != 0) 556 break; 557 bcopy(&hi_temp, item, sizeof(hi_temp)); 558 goto mapped; 559 } 560 } 561 562 if (hi->flags & HIO_VARIABLE) { 563 HIDMAP_FOREACH_ITEM(hm, mi, uoff) { 564 if (can_map_variable(hi, mi, uoff)) { 565 item->evtype = mi->type; 566 item->code = mi->code + uoff; 567 item->type = hi->flags & HIO_NULLSTATE 568 ? HIDMAP_TYPE_VAR_NULLST 569 : HIDMAP_TYPE_VARIABLE; 570 item->last_val = 0; 571 item->invert_value = mi->invert_value; 572 switch (mi->type) { 573 case EV_KEY: 574 hidmap_support_key(hm, item->code); 575 break; 576 case EV_REL: 577 evdev_support_event(hm->evdev, EV_REL); 578 evdev_support_rel(hm->evdev, 579 item->code); 580 break; 581 case EV_ABS: 582 evdev_support_event(hm->evdev, EV_ABS); 583 evdev_support_abs(hm->evdev, 584 item->code, 585 hi->logical_minimum, 586 hi->logical_maximum, 587 mi->fuzz, 588 mi->flat, 589 hid_item_resolution(hi)); 590 break; 591 case EV_SW: 592 evdev_support_event(hm->evdev, EV_SW); 593 evdev_support_sw(hm->evdev, 594 item->code); 595 break; 596 default: 597 KASSERT(0, ("Unsupported event type")); 598 } 599 goto mapped; 600 } 601 } 602 return (false); 603 } 604 605 if (hi->usage_minimum != 0 || hi->usage_maximum != 0) { 606 HIDMAP_FOREACH_ITEM(hm, mi, uoff) { 607 if (can_map_arr_range(hi, mi, uoff)) { 608 hidmap_support_key(hm, mi->code + uoff); 609 found = true; 610 } 611 } 612 if (!found) 613 return (false); 614 item->umin = hi->usage_minimum; 615 item->type = HIDMAP_TYPE_ARR_RANGE; 616 item->last_key = KEY_RESERVED; 617 goto mapped; 618 } 619 620 for (i = 0; i < hi->nusages; i++) { 621 HIDMAP_FOREACH_ITEM(hm, mi, uoff) { 622 if (can_map_arr_list(hi, mi, hi->usages[i], uoff)) { 623 hidmap_support_key(hm, mi->code + uoff); 624 if (item->codes == NULL) 625 item->codes = malloc( 626 hi->nusages * sizeof(uint16_t), 627 M_DEVBUF, M_WAITOK | M_ZERO); 628 item->codes[i] = mi->code + uoff; 629 found = true; 630 break; 631 } 632 } 633 } 634 if (!found) 635 return (false); 636 item->type = HIDMAP_TYPE_ARR_LIST; 637 item->last_key = KEY_RESERVED; 638 639 mapped: 640 item->id = hi->report_ID; 641 item->loc = hi->loc; 642 item->loc.count = 1; 643 item->lmin = hi->logical_minimum; 644 item->lmax = hi->logical_maximum; 645 646 DPRINTFN(hm, 6, "usage=%04x id=%d loc=%u/%u type=%d item=%*D\n", 647 hi->usage, hi->report_ID, hi->loc.pos, hi->loc.size, item->type, 648 (int)sizeof(item->cb), &item->cb, " "); 649 650 return (true); 651 } 652 653 static int 654 hidmap_parse_hid_descr(struct hidmap *hm, uint8_t tlc_index) 655 { 656 const struct hidmap_item *map; 657 struct hidmap_hid_item *item = hm->hid_items; 658 void *d_ptr; 659 struct hid_data *hd; 660 struct hid_item hi; 661 int i, error; 662 hid_size_t d_len; 663 664 error = hid_get_report_descr(hm->dev, &d_ptr, &d_len); 665 if (error != 0) { 666 DPRINTF(hm, "could not retrieve report descriptor from " 667 "device: %d\n", error); 668 return (error); 669 } 670 671 /* Parse inputs */ 672 hd = hid_start_parse(d_ptr, d_len, 1 << hid_input); 673 HIDBUS_FOREACH_ITEM(hd, &hi, tlc_index) { 674 if (hi.kind != hid_input) 675 continue; 676 if (hi.flags & HIO_CONST) 677 continue; 678 for (i = 0; i < hi.loc.count; i++, hi.loc.pos += hi.loc.size) 679 if (hidmap_parse_hid_item(hm, &hi, item)) 680 item++; 681 KASSERT(item <= hm->hid_items + hm->nhid_items, 682 ("Parsed HID item array overflow")); 683 } 684 hid_end_parse(hd); 685 686 /* Add finalizing callbacks to the end of list */ 687 for (i = 0; i < hm->nmaps; i++) { 688 for (map = hm->map[i]; 689 map < hm->map[i] + hm->nmap_items[i]; 690 map++) { 691 if (map->has_cb && map->final_cb && 692 map->cb(hm, item, (union hidmap_cb_ctx){}) == 0) { 693 item->cb = map->cb; 694 item->type = HIDMAP_TYPE_FINALCB; 695 item++; 696 } 697 } 698 } 699 700 /* 701 * Resulting number of parsed HID items can be less than expected as 702 * map items might be duplicated in different maps. Save real number. 703 */ 704 if (hm->nhid_items != item - hm->hid_items) 705 DPRINTF(hm, "Parsed HID item number mismatch: expected=%u " 706 "result=%td\n", hm->nhid_items, item - hm->hid_items); 707 hm->nhid_items = item - hm->hid_items; 708 709 if (HIDMAP_WANT_MERGE_KEYS(hm)) 710 bzero(hm->key_press, howmany(KEY_CNT, 8)); 711 712 return (0); 713 } 714 715 int 716 hidmap_probe(struct hidmap* hm, device_t dev, 717 const struct hid_device_id *id, int nitems_id, 718 const struct hidmap_item *map, int nitems_map, 719 const char *suffix, hidmap_caps_t caps) 720 { 721 int error; 722 723 error = hidbus_lookup_driver_info(dev, id, nitems_id); 724 if (error != 0) 725 return (error); 726 727 hidmap_set_dev(hm, dev); 728 729 error = hidmap_add_map(hm, map, nitems_map, caps); 730 if (error != 0) 731 return (error); 732 733 hidbus_set_desc(dev, suffix); 734 735 return (BUS_PROBE_DEFAULT); 736 } 737 738 int 739 hidmap_attach(struct hidmap* hm) 740 { 741 const struct hid_device_info *hw = hid_get_device_info(hm->dev); 742 #ifdef HID_DEBUG 743 char tunable[40]; 744 #endif 745 int error; 746 747 #ifdef HID_DEBUG 748 if (hm->debug_var == NULL) { 749 hm->debug_var = &hm->debug_level; 750 snprintf(tunable, sizeof(tunable), "hw.hid.%s.debug", 751 device_get_name(hm->dev)); 752 TUNABLE_INT_FETCH(tunable, &hm->debug_level); 753 SYSCTL_ADD_INT(device_get_sysctl_ctx(hm->dev), 754 SYSCTL_CHILDREN(device_get_sysctl_tree(hm->dev)), 755 OID_AUTO, "debug", CTLFLAG_RWTUN, 756 &hm->debug_level, 0, "Verbosity level"); 757 } 758 #endif 759 760 DPRINTFN(hm, 11, "hm=%p\n", hm); 761 762 hm->cb_state = HIDMAP_CB_IS_ATTACHING; 763 764 hm->hid_items = malloc(hm->nhid_items * sizeof(struct hid_item), 765 M_DEVBUF, M_WAITOK | M_ZERO); 766 767 hidbus_set_intr(hm->dev, hidmap_intr, hm); 768 hm->evdev_methods = (struct evdev_methods) { 769 .ev_open = &hidmap_ev_open, 770 .ev_close = &hidmap_ev_close, 771 }; 772 773 hm->evdev = evdev_alloc(); 774 evdev_set_name(hm->evdev, device_get_desc(hm->dev)); 775 evdev_set_phys(hm->evdev, device_get_nameunit(hm->dev)); 776 evdev_set_id(hm->evdev, hw->idBus, hw->idVendor, hw->idProduct, 777 hw->idVersion); 778 evdev_set_serial(hm->evdev, hw->serial); 779 evdev_set_flag(hm->evdev, EVDEV_FLAG_EXT_EPOCH); /* hidbus child */ 780 evdev_support_event(hm->evdev, EV_SYN); 781 error = hidmap_parse_hid_descr(hm, hidbus_get_index(hm->dev)); 782 if (error) { 783 DPRINTF(hm, "error=%d\n", error); 784 hidmap_detach(hm); 785 return (ENXIO); 786 } 787 788 evdev_set_methods(hm->evdev, hm->dev, &hm->evdev_methods); 789 hm->cb_state = HIDMAP_CB_IS_RUNNING; 790 791 error = evdev_register(hm->evdev); 792 if (error) { 793 DPRINTF(hm, "error=%d\n", error); 794 hidmap_detach(hm); 795 return (ENXIO); 796 } 797 798 return (0); 799 } 800 801 int 802 hidmap_detach(struct hidmap* hm) 803 { 804 struct hidmap_hid_item *hi; 805 806 DPRINTFN(hm, 11, "\n"); 807 808 hm->cb_state = HIDMAP_CB_IS_DETACHING; 809 810 evdev_free(hm->evdev); 811 if (hm->hid_items != NULL) { 812 for (hi = hm->hid_items; 813 hi < hm->hid_items + hm->nhid_items; 814 hi++) 815 if (hi->type == HIDMAP_TYPE_FINALCB || 816 hi->type == HIDMAP_TYPE_CALLBACK) 817 hi->cb(hm, hi, (union hidmap_cb_ctx){}); 818 else if (hi->type == HIDMAP_TYPE_ARR_LIST) 819 free(hi->codes, M_DEVBUF); 820 free(hm->hid_items, M_DEVBUF); 821 } 822 823 free(hm->key_press, M_DEVBUF); 824 free(hm->key_rel, M_DEVBUF); 825 826 return (0); 827 } 828 829 MODULE_DEPEND(hidmap, hid, 1, 1, 1); 830 MODULE_DEPEND(hidmap, hidbus, 1, 1, 1); 831 MODULE_DEPEND(hidmap, evdev, 1, 1, 1); 832 MODULE_VERSION(hidmap, 1);
Cache object: efcea73e8b6ad1d81f91a9903f42876e
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]