LXR linux/drivers/hid/hid-core.c

   1/*
   2 *  HID support for Linux
   3 *
   4 *  Copyright (c) 1999 Andreas Gal
   5 *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
   6 *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
   7 *  Copyright (c) 2006-2012 Jiri Kosina
   8 */
   9
  10/*
  11 * This program is free software; you can redistribute it and/or modify it
  12 * under the terms of the GNU General Public License as published by the Free
  13 * Software Foundation; either version 2 of the License, or (at your option)
  14 * any later version.
  15 */
  16
  17#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  18
  19#include <linux/module.h>
  20#include <linux/slab.h>
  21#include <linux/init.h>
  22#include <linux/kernel.h>
  23#include <linux/list.h>
  24#include <linux/mm.h>
  25#include <linux/spinlock.h>
  26#include <asm/unaligned.h>
  27#include <asm/byteorder.h>
  28#include <linux/input.h>
  29#include <linux/wait.h>
  30#include <linux/vmalloc.h>
  31#include <linux/sched.h>
  32#include <linux/semaphore.h>
  33
  34#include <linux/hid.h>
  35#include <linux/hiddev.h>
  36#include <linux/hid-debug.h>
  37#include <linux/hidraw.h>
  38
  39#include "hid-ids.h"
  40
  41/*
  42 * Version Information
  43 */
  44
  45#define DRIVER_DESC "HID core driver"
  46
  47int hid_debug = 0;
  48module_param_named(debug, hid_debug, int, 0600);
  49MODULE_PARM_DESC(debug, "toggle HID debugging messages");
  50EXPORT_SYMBOL_GPL(hid_debug);
  51
  52static int hid_ignore_special_drivers = 0;
  53module_param_named(ignore_special_drivers, hid_ignore_special_drivers, int, 0600);
  54MODULE_PARM_DESC(ignore_special_drivers, "Ignore any special drivers and handle all devices by generic driver");
  55
  56/*
  57 * Register a new report for a device.
  58 */
  59
  60struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id)
  61{
  62        struct hid_report_enum *report_enum = device->report_enum + type;
  63        struct hid_report *report;
  64
  65        if (id >= HID_MAX_IDS)
  66                return NULL;
  67        if (report_enum->report_id_hash[id])
  68                return report_enum->report_id_hash[id];
  69
  70        report = kzalloc(sizeof(struct hid_report), GFP_KERNEL);
  71        if (!report)
  72                return NULL;
  73
  74        if (id != 0)
  75                report_enum->numbered = 1;
  76
  77        report->id = id;
  78        report->type = type;
  79        report->size = 0;
  80        report->device = device;
  81        report_enum->report_id_hash[id] = report;
  82
  83        list_add_tail(&report->list, &report_enum->report_list);
  84
  85        return report;
  86}
  87EXPORT_SYMBOL_GPL(hid_register_report);
  88
  89/*
  90 * Register a new field for this report.
  91 */
  92
  93static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages, unsigned values)
  94{
  95        struct hid_field *field;
  96
  97        if (report->maxfield == HID_MAX_FIELDS) {
  98                hid_err(report->device, "too many fields in report\n");
  99                return NULL;
 100        }
 101
 102        field = kzalloc((sizeof(struct hid_field) +
 103                         usages * sizeof(struct hid_usage) +
 104                         values * sizeof(unsigned)), GFP_KERNEL);
 105        if (!field)
 106                return NULL;
 107
 108        field->index = report->maxfield++;
 109        report->field[field->index] = field;
 110        field->usage = (struct hid_usage *)(field + 1);
 111        field->value = (s32 *)(field->usage + usages);
 112        field->report = report;
 113
 114        return field;
 115}
 116
 117/*
 118 * Open a collection. The type/usage is pushed on the stack.
 119 */
 120
 121static int open_collection(struct hid_parser *parser, unsigned type)
 122{
 123        struct hid_collection *collection;
 124        unsigned usage;
 125
 126        usage = parser->local.usage[0];
 127
 128        if (parser->collection_stack_ptr == HID_COLLECTION_STACK_SIZE) {
 129                hid_err(parser->device, "collection stack overflow\n");
 130                return -EINVAL;
 131        }
 132
 133        if (parser->device->maxcollection == parser->device->collection_size) {
 134                collection = kmalloc(sizeof(struct hid_collection) *
 135                                parser->device->collection_size * 2, GFP_KERNEL);
 136                if (collection == NULL) {
 137                        hid_err(parser->device, "failed to reallocate collection array\n");
 138                        return -ENOMEM;
 139                }
 140                memcpy(collection, parser->device->collection,
 141                        sizeof(struct hid_collection) *
 142                        parser->device->collection_size);
 143                memset(collection + parser->device->collection_size, 0,
 144                        sizeof(struct hid_collection) *
 145                        parser->device->collection_size);
 146                kfree(parser->device->collection);
 147                parser->device->collection = collection;
 148                parser->device->collection_size *= 2;
 149        }
 150
 151        parser->collection_stack[parser->collection_stack_ptr++] =
 152                parser->device->maxcollection;
 153
 154        collection = parser->device->collection +
 155                parser->device->maxcollection++;
 156        collection->type = type;
 157        collection->usage = usage;
 158        collection->level = parser->collection_stack_ptr - 1;
 159
 160        if (type == HID_COLLECTION_APPLICATION)
 161                parser->device->maxapplication++;
 162
 163        return 0;
 164}
 165
 166/*
 167 * Close a collection.
 168 */
 169
 170static int close_collection(struct hid_parser *parser)
 171{
 172        if (!parser->collection_stack_ptr) {
 173                hid_err(parser->device, "collection stack underflow\n");
 174                return -EINVAL;
 175        }
 176        parser->collection_stack_ptr--;
 177        return 0;
 178}
 179
 180/*
 181 * Climb up the stack, search for the specified collection type
 182 * and return the usage.
 183 */
 184
 185static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
 186{
 187        struct hid_collection *collection = parser->device->collection;
 188        int n;
 189
 190        for (n = parser->collection_stack_ptr - 1; n >= 0; n--) {
 191                unsigned index = parser->collection_stack[n];
 192                if (collection[index].type == type)
 193                        return collection[index].usage;
 194        }
 195        return 0; /* we know nothing about this usage type */
 196}
 197
 198/*
 199 * Add a usage to the temporary parser table.
 200 */
 201
 202static int hid_add_usage(struct hid_parser *parser, unsigned usage)
 203{
 204        if (parser->local.usage_index >= HID_MAX_USAGES) {
 205                hid_err(parser->device, "usage index exceeded\n");
 206                return -1;
 207        }
 208        parser->local.usage[parser->local.usage_index] = usage;
 209        parser->local.collection_index[parser->local.usage_index] =
 210                parser->collection_stack_ptr ?
 211                parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
 212        parser->local.usage_index++;
 213        return 0;
 214}
 215
 216/*
 217 * Register a new field for this report.
 218 */
 219
 220static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)
 221{
 222        struct hid_report *report;
 223        struct hid_field *field;
 224        unsigned usages;
 225        unsigned offset;
 226        unsigned i;
 227
 228        report = hid_register_report(parser->device, report_type, parser->global.report_id);
 229        if (!report) {
 230                hid_err(parser->device, "hid_register_report failed\n");
 231                return -1;
 232        }
 233
 234        /* Handle both signed and unsigned cases properly */
 235        if ((parser->global.logical_minimum < 0 &&
 236                parser->global.logical_maximum <
 237                parser->global.logical_minimum) ||
 238                (parser->global.logical_minimum >= 0 &&
 239                (__u32)parser->global.logical_maximum <
 240                (__u32)parser->global.logical_minimum)) {
 241                dbg_hid("logical range invalid 0x%x 0x%x\n",
 242                        parser->global.logical_minimum,
 243                        parser->global.logical_maximum);
 244                return -1;
 245        }
 246
 247        offset = report->size;
 248        report->size += parser->global.report_size * parser->global.report_count;
 249
 250        if (!parser->local.usage_index) /* Ignore padding fields */
 251                return 0;
 252
 253        usages = max_t(unsigned, parser->local.usage_index,
 254                                 parser->global.report_count);
 255
 256        field = hid_register_field(report, usages, parser->global.report_count);
 257        if (!field)
 258                return 0;
 259
 260        field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);
 261        field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);
 262        field->application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);
 263
 264        for (i = 0; i < usages; i++) {
 265                unsigned j = i;
 266                /* Duplicate the last usage we parsed if we have excess values */
 267                if (i >= parser->local.usage_index)
 268                        j = parser->local.usage_index - 1;
 269                field->usage[i].hid = parser->local.usage[j];
 270                field->usage[i].collection_index =
 271                        parser->local.collection_index[j];
 272                field->usage[i].usage_index = i;
 273        }
 274
 275        field->maxusage = usages;
 276        field->flags = flags;
 277        field->report_offset = offset;
 278        field->report_type = report_type;
 279        field->report_size = parser->global.report_size;
 280        field->report_count = parser->global.report_count;
 281        field->logical_minimum = parser->global.logical_minimum;
 282        field->logical_maximum = parser->global.logical_maximum;
 283        field->physical_minimum = parser->global.physical_minimum;
 284        field->physical_maximum = parser->global.physical_maximum;
 285        field->unit_exponent = parser->global.unit_exponent;
 286        field->unit = parser->global.unit;
 287
 288        return 0;
 289}
 290
 291/*
 292 * Read data value from item.
 293 */
 294
 295static u32 item_udata(struct hid_item *item)
 296{
 297        switch (item->size) {
 298        case 1: return item->data.u8;
 299        case 2: return item->data.u16;
 300        case 4: return item->data.u32;
 301        }
 302        return 0;
 303}
 304
 305static s32 item_sdata(struct hid_item *item)
 306{
 307        switch (item->size) {
 308        case 1: return item->data.s8;
 309        case 2: return item->data.s16;
 310        case 4: return item->data.s32;
 311        }
 312        return 0;
 313}
 314
 315/*
 316 * Process a global item.
 317 */
 318
 319static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
 320{
 321        __s32 raw_value;
 322        switch (item->tag) {
 323        case HID_GLOBAL_ITEM_TAG_PUSH:
 324
 325                if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
 326                        hid_err(parser->device, "global environment stack overflow\n");
 327                        return -1;
 328                }
 329
 330                memcpy(parser->global_stack + parser->global_stack_ptr++,
 331                        &parser->global, sizeof(struct hid_global));
 332                return 0;
 333
 334        case HID_GLOBAL_ITEM_TAG_POP:
 335
 336                if (!parser->global_stack_ptr) {
 337                        hid_err(parser->device, "global environment stack underflow\n");
 338                        return -1;
 339                }
 340
 341                memcpy(&parser->global, parser->global_stack +
 342                        --parser->global_stack_ptr, sizeof(struct hid_global));
 343                return 0;
 344
 345        case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
 346                parser->global.usage_page = item_udata(item);
 347                return 0;
 348
 349        case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
 350                parser->global.logical_minimum = item_sdata(item);
 351                return 0;
 352
 353        case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
 354                if (parser->global.logical_minimum < 0)
 355                        parser->global.logical_maximum = item_sdata(item);
 356                else
 357                        parser->global.logical_maximum = item_udata(item);
 358                return 0;
 359
 360        case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
 361                parser->global.physical_minimum = item_sdata(item);
 362                return 0;
 363
 364        case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
 365                if (parser->global.physical_minimum < 0)
 366                        parser->global.physical_maximum = item_sdata(item);
 367                else
 368                        parser->global.physical_maximum = item_udata(item);
 369                return 0;
 370
 371        case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
 372                /* Many devices provide unit exponent as a two's complement
 373                 * nibble due to the common misunderstanding of HID
 374                 * specification 1.11, 6.2.2.7 Global Items. Attempt to handle
 375                 * both this and the standard encoding. */
 376                raw_value = item_sdata(item);
 377                if (!(raw_value & 0xfffffff0))
 378                        parser->global.unit_exponent = hid_snto32(raw_value, 4);
 379                else
 380                        parser->global.unit_exponent = raw_value;
 381                return 0;
 382
 383        case HID_GLOBAL_ITEM_TAG_UNIT:
 384                parser->global.unit = item_udata(item);
 385                return 0;
 386
 387        case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
 388                parser->global.report_size = item_udata(item);
 389                if (parser->global.report_size > 128) {
 390                        hid_err(parser->device, "invalid report_size %d\n",
 391                                        parser->global.report_size);
 392                        return -1;
 393                }
 394                return 0;
 395
 396        case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
 397                parser->global.report_count = item_udata(item);
 398                if (parser->global.report_count > HID_MAX_USAGES) {
 399                        hid_err(parser->device, "invalid report_count %d\n",
 400                                        parser->global.report_count);
 401                        return -1;
 402                }
 403                return 0;
 404
 405        case HID_GLOBAL_ITEM_TAG_REPORT_ID:
 406                parser->global.report_id = item_udata(item);
 407                if (parser->global.report_id == 0 ||
 408                    parser->global.report_id >= HID_MAX_IDS) {
 409                        hid_err(parser->device, "report_id %u is invalid\n",
 410                                parser->global.report_id);
 411                        return -1;
 412                }
 413                return 0;
 414
 415        default:
 416                hid_err(parser->device, "unknown global tag 0x%x\n", item->tag);
 417                return -1;
 418        }
 419}
 420
 421/*
 422 * Process a local item.
 423 */
 424
 425static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
 426{
 427        __u32 data;
 428        unsigned n;
 429        __u32 count;
 430
 431        data = item_udata(item);
 432
 433        switch (item->tag) {
 434        case HID_LOCAL_ITEM_TAG_DELIMITER:
 435
 436                if (data) {
 437                        /*
 438                         * We treat items before the first delimiter
 439                         * as global to all usage sets (branch 0).
 440                         * In the moment we process only these global
 441                         * items and the first delimiter set.
 442                         */
 443                        if (parser->local.delimiter_depth != 0) {
 444                                hid_err(parser->device, "nested delimiters\n");
 445                                return -1;
 446                        }
 447                        parser->local.delimiter_depth++;
 448                        parser->local.delimiter_branch++;
 449                } else {
 450                        if (parser->local.delimiter_depth < 1) {
 451                                hid_err(parser->device, "bogus close delimiter\n");
 452                                return -1;
 453                        }
 454                        parser->local.delimiter_depth--;
 455                }
 456                return 0;
 457
 458        case HID_LOCAL_ITEM_TAG_USAGE:
 459
 460                if (parser->local.delimiter_branch > 1) {
 461                        dbg_hid("alternative usage ignored\n");
 462                        return 0;
 463                }
 464
 465                if (item->size <= 2)
 466                        data = (parser->global.usage_page << 16) + data;
 467
 468                return hid_add_usage(parser, data);
 469
 470        case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 471
 472                if (parser->local.delimiter_branch > 1) {
 473                        dbg_hid("alternative usage ignored\n");
 474                        return 0;
 475                }
 476
 477                if (item->size <= 2)
 478                        data = (parser->global.usage_page << 16) + data;
 479
 480                parser->local.usage_minimum = data;
 481                return 0;
 482
 483        case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 484
 485                if (parser->local.delimiter_branch > 1) {
 486                        dbg_hid("alternative usage ignored\n");
 487                        return 0;
 488                }
 489
 490                if (item->size <= 2)
 491                        data = (parser->global.usage_page << 16) + data;
 492
 493                count = data - parser->local.usage_minimum;
 494                if (count + parser->local.usage_index >= HID_MAX_USAGES) {
 495                        /*
 496                         * We do not warn if the name is not set, we are
 497                         * actually pre-scanning the device.
 498                         */
 499                        if (dev_name(&parser->device->dev))
 500                                hid_warn(parser->device,
 501                                         "ignoring exceeding usage max\n");
 502                        data = HID_MAX_USAGES - parser->local.usage_index +
 503                                parser->local.usage_minimum - 1;
 504                        if (data <= 0) {
 505                                hid_err(parser->device,
 506                                        "no more usage index available\n");
 507                                return -1;
 508                        }
 509                }
 510
 511                for (n = parser->local.usage_minimum; n <= data; n++)
 512                        if (hid_add_usage(parser, n)) {
 513                                dbg_hid("hid_add_usage failed\n");
 514                                return -1;
 515                        }
 516                return 0;
 517
 518        default:
 519
 520                dbg_hid("unknown local item tag 0x%x\n", item->tag);
 521                return 0;
 522        }
 523        return 0;
 524}
 525
 526/*
 527 * Process a main item.
 528 */
 529
 530static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
 531{
 532        __u32 data;
 533        int ret;
 534
 535        data = item_udata(item);
 536
 537        switch (item->tag) {
 538        case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
 539                ret = open_collection(parser, data & 0xff);
 540                break;
 541        case HID_MAIN_ITEM_TAG_END_COLLECTION:
 542                ret = close_collection(parser);
 543                break;
 544        case HID_MAIN_ITEM_TAG_INPUT:
 545                ret = hid_add_field(parser, HID_INPUT_REPORT, data);
 546                break;
 547        case HID_MAIN_ITEM_TAG_OUTPUT:
 548                ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
 549                break;
 550        case HID_MAIN_ITEM_TAG_FEATURE:
 551                ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
 552                break;
 553        default:
 554                hid_err(parser->device, "unknown main item tag 0x%x\n", item->tag);
 555                ret = 0;
 556        }
 557
 558        memset(&parser->local, 0, sizeof(parser->local));       /* Reset the local parser environment */
 559
 560        return ret;
 561}
 562
 563/*
 564 * Process a reserved item.
 565 */
 566
 567static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)
 568{
 569        dbg_hid("reserved item type, tag 0x%x\n", item->tag);
 570        return 0;
 571}
 572
 573/*
 574 * Free a report and all registered fields. The field->usage and
 575 * field->value table's are allocated behind the field, so we need
 576 * only to free(field) itself.
 577 */
 578
 579static void hid_free_report(struct hid_report *report)
 580{
 581        unsigned n;
 582
 583        for (n = 0; n < report->maxfield; n++)
 584                kfree(report->field[n]);
 585        kfree(report);
 586}
 587
 588/*
 589 * Close report. This function returns the device
 590 * state to the point prior to hid_open_report().
 591 */
 592static void hid_close_report(struct hid_device *device)
 593{
 594        unsigned i, j;
 595
 596        for (i = 0; i < HID_REPORT_TYPES; i++) {
 597                struct hid_report_enum *report_enum = device->report_enum + i;
 598
 599                for (j = 0; j < HID_MAX_IDS; j++) {
 600                        struct hid_report *report = report_enum->report_id_hash[j];
 601                        if (report)
 602                                hid_free_report(report);
 603                }
 604                memset(report_enum, 0, sizeof(*report_enum));
 605                INIT_LIST_HEAD(&report_enum->report_list);
 606        }
 607
 608        kfree(device->rdesc);
 609        device->rdesc = NULL;
 610        device->rsize = 0;
 611
 612        kfree(device->collection);
 613        device->collection = NULL;
 614        device->collection_size = 0;
 615        device->maxcollection = 0;
 616        device->maxapplication = 0;
 617
 618        device->status &= ~HID_STAT_PARSED;
 619}
 620
 621/*
 622 * Free a device structure, all reports, and all fields.
 623 */
 624
 625static void hid_device_release(struct device *dev)
 626{
 627        struct hid_device *hid = to_hid_device(dev);
 628
 629        hid_close_report(hid);
 630        kfree(hid->dev_rdesc);
 631        kfree(hid);
 632}
 633
 634/*
 635 * Fetch a report description item from the data stream. We support long
 636 * items, though they are not used yet.
 637 */
 638
 639static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
 640{
 641        u8 b;
 642
 643        if ((end - start) <= 0)
 644                return NULL;
 645
 646        b = *start++;
 647
 648        item->type = (b >> 2) & 3;
 649        item->tag  = (b >> 4) & 15;
 650
 651        if (item->tag == HID_ITEM_TAG_LONG) {
 652
 653                item->format = HID_ITEM_FORMAT_LONG;
 654
 655                if ((end - start) < 2)
 656                        return NULL;
 657
 658                item->size = *start++;
 659                item->tag  = *start++;
 660
 661                if ((end - start) < item->size)
 662                        return NULL;
 663
 664                item->data.longdata = start;
 665                start += item->size;
 666                return start;
 667        }
 668
 669        item->format = HID_ITEM_FORMAT_SHORT;
 670        item->size = b & 3;
 671
 672        switch (item->size) {
 673        case 0:
 674                return start;
 675
 676        case 1:
 677                if ((end - start) < 1)
 678                        return NULL;
 679                item->data.u8 = *start++;
 680                return start;
 681
 682        case 2:
 683                if ((end - start) < 2)
 684                        return NULL;
 685                item->data.u16 = get_unaligned_le16(start);
 686                start = (__u8 *)((__le16 *)start + 1);
 687                return start;
 688
 689        case 3:
 690                item->size++;
 691                if ((end - start) < 4)
 692                        return NULL;
 693                item->data.u32 = get_unaligned_le32(start);
 694                start = (__u8 *)((__le32 *)start + 1);
 695                return start;
 696        }
 697
 698        return NULL;
 699}
 700
 701static void hid_scan_input_usage(struct hid_parser *parser, u32 usage)
 702{
 703        struct hid_device *hid = parser->device;
 704
 705        if (usage == HID_DG_CONTACTID)
 706                hid->group = HID_GROUP_MULTITOUCH;
 707}
 708
 709static void hid_scan_feature_usage(struct hid_parser *parser, u32 usage)
 710{
 711        if (usage == 0xff0000c5 && parser->global.report_count == 256 &&
 712            parser->global.report_size == 8)
 713                parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8;
 714}
 715
 716static void hid_scan_collection(struct hid_parser *parser, unsigned type)
 717{
 718        struct hid_device *hid = parser->device;
 719        int i;
 720
 721        if (((parser->global.usage_page << 16) == HID_UP_SENSOR) &&
 722            type == HID_COLLECTION_PHYSICAL)
 723                hid->group = HID_GROUP_SENSOR_HUB;
 724
 725        if (hid->vendor == USB_VENDOR_ID_MICROSOFT &&
 726            hid->product == USB_DEVICE_ID_MS_POWER_COVER &&
 727            hid->group == HID_GROUP_MULTITOUCH)
 728                hid->group = HID_GROUP_GENERIC;
 729
 730        if ((parser->global.usage_page << 16) == HID_UP_GENDESK)
 731                for (i = 0; i < parser->local.usage_index; i++)
 732                        if (parser->local.usage[i] == HID_GD_POINTER)
 733                                parser->scan_flags |= HID_SCAN_FLAG_GD_POINTER;
 734
 735        if ((parser->global.usage_page << 16) >= HID_UP_MSVENDOR)
 736                parser->scan_flags |= HID_SCAN_FLAG_VENDOR_SPECIFIC;
 737}
 738
 739static int hid_scan_main(struct hid_parser *parser, struct hid_item *item)
 740{
 741        __u32 data;
 742        int i;
 743
 744        data = item_udata(item);
 745
 746        switch (item->tag) {
 747        case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
 748                hid_scan_collection(parser, data & 0xff);
 749                break;
 750        case HID_MAIN_ITEM_TAG_END_COLLECTION:
 751                break;
 752        case HID_MAIN_ITEM_TAG_INPUT:
 753                /* ignore constant inputs, they will be ignored by hid-input */
 754                if (data & HID_MAIN_ITEM_CONSTANT)
 755                        break;
 756                for (i = 0; i < parser->local.usage_index; i++)
 757                        hid_scan_input_usage(parser, parser->local.usage[i]);
 758                break;
 759        case HID_MAIN_ITEM_TAG_OUTPUT:
 760                break;
 761        case HID_MAIN_ITEM_TAG_FEATURE:
 762                for (i = 0; i < parser->local.usage_index; i++)
 763                        hid_scan_feature_usage(parser, parser->local.usage[i]);
 764                break;
 765        }
 766
 767        /* Reset the local parser environment */
 768        memset(&parser->local, 0, sizeof(parser->local));
 769
 770        return 0;
 771}
 772
 773/*
 774 * Scan a report descriptor before the device is added to the bus.
 775 * Sets device groups and other properties that determine what driver
 776 * to load.
 777 */
 778static int hid_scan_report(struct hid_device *hid)
 779{
 780        struct hid_parser *parser;
 781        struct hid_item item;
 782        __u8 *start = hid->dev_rdesc;
 783        __u8 *end = start + hid->dev_rsize;
 784        static int (*dispatch_type[])(struct hid_parser *parser,
 785                                      struct hid_item *item) = {
 786                hid_scan_main,
 787                hid_parser_global,
 788                hid_parser_local,
 789                hid_parser_reserved
 790        };
 791
 792        parser = vzalloc(sizeof(struct hid_parser));
 793        if (!parser)
 794                return -ENOMEM;
 795
 796        parser->device = hid;
 797        hid->group = HID_GROUP_GENERIC;
 798
 799        /*
 800         * The parsing is simpler than the one in hid_open_report() as we should
 801         * be robust against hid errors. Those errors will be raised by
 802         * hid_open_report() anyway.
 803         */
 804        while ((start = fetch_item(start, end, &item)) != NULL)
 805                dispatch_type[item.type](parser, &item);
 806
 807        /*
 808         * Handle special flags set during scanning.
 809         */
 810        if ((parser->scan_flags & HID_SCAN_FLAG_MT_WIN_8) &&
 811            (hid->group == HID_GROUP_MULTITOUCH))
 812                hid->group = HID_GROUP_MULTITOUCH_WIN_8;
 813
 814        /*
 815         * Vendor specific handlings
 816         */
 817        switch (hid->vendor) {
 818        case USB_VENDOR_ID_WACOM:
 819                hid->group = HID_GROUP_WACOM;
 820                break;
 821        case USB_VENDOR_ID_SYNAPTICS:
 822                if (hid->group == HID_GROUP_GENERIC)
 823                        if ((parser->scan_flags & HID_SCAN_FLAG_VENDOR_SPECIFIC)
 824                            && (parser->scan_flags & HID_SCAN_FLAG_GD_POINTER))
 825                                /*
 826                                 * hid-rmi should take care of them,
 827                                 * not hid-generic
 828                                 */
 829                                hid->group = HID_GROUP_RMI;
 830                break;
 831        }
 832
 833        /* fall back to generic driver in case specific driver doesn't exist */
 834        switch (hid->group) {
 835        case HID_GROUP_MULTITOUCH_WIN_8:
 836                /* fall-through */
 837        case HID_GROUP_MULTITOUCH:
 838                if (!IS_ENABLED(CONFIG_HID_MULTITOUCH))
 839                        hid->group = HID_GROUP_GENERIC;
 840                break;
 841        case HID_GROUP_SENSOR_HUB:
 842                if (!IS_ENABLED(CONFIG_HID_SENSOR_HUB))
 843                        hid->group = HID_GROUP_GENERIC;
 844                break;
 845        case HID_GROUP_RMI:
 846                if (!IS_ENABLED(CONFIG_HID_RMI))
 847                        hid->group = HID_GROUP_GENERIC;
 848                break;
 849        case HID_GROUP_WACOM:
 850                if (!IS_ENABLED(CONFIG_HID_WACOM))
 851                        hid->group = HID_GROUP_GENERIC;
 852                break;
 853        case HID_GROUP_LOGITECH_DJ_DEVICE:
 854                if (!IS_ENABLED(CONFIG_HID_LOGITECH_DJ))
 855                        hid->group = HID_GROUP_GENERIC;
 856                break;
 857        }
 858        vfree(parser);
 859        return 0;
 860}
 861
 862/**
 863 * hid_parse_report - parse device report
 864 *
 865 * @device: hid device
 866 * @start: report start
 867 * @size: report size
 868 *
 869 * Allocate the device report as read by the bus driver. This function should
 870 * only be called from parse() in ll drivers.
 871 */
 872int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size)
 873{
 874        hid->dev_rdesc = kmemdup(start, size, GFP_KERNEL);
 875        if (!hid->dev_rdesc)
 876                return -ENOMEM;
 877        hid->dev_rsize = size;
 878        return 0;
 879}
 880EXPORT_SYMBOL_GPL(hid_parse_report);
 881
 882static const char * const hid_report_names[] = {
 883        "HID_INPUT_REPORT",
 884        "HID_OUTPUT_REPORT",
 885        "HID_FEATURE_REPORT",
 886};
 887/**
 888 * hid_validate_values - validate existing device report's value indexes
 889 *
 890 * @device: hid device
 891 * @type: which report type to examine
 892 * @id: which report ID to examine (0 for first)
 893 * @field_index: which report field to examine
 894 * @report_counts: expected number of values
 895 *
 896 * Validate the number of values in a given field of a given report, after
 897 * parsing.
 898 */
 899struct hid_report *hid_validate_values(struct hid_device *hid,
 900                                       unsigned int type, unsigned int id,
 901                                       unsigned int field_index,
 902                                       unsigned int report_counts)
 903{
 904        struct hid_report *report;
 905
 906        if (type > HID_FEATURE_REPORT) {
 907                hid_err(hid, "invalid HID report type %u\n", type);
 908                return NULL;
 909        }
 910
 911        if (id >= HID_MAX_IDS) {
 912                hid_err(hid, "invalid HID report id %u\n", id);
 913                return NULL;
 914        }
 915
 916        /*
 917         * Explicitly not using hid_get_report() here since it depends on
 918         * ->numbered being checked, which may not always be the case when
 919         * drivers go to access report values.
 920         */
 921        if (id == 0) {
 922                /*
 923                 * Validating on id 0 means we should examine the first
 924                 * report in the list.
 925                 */
 926                report = list_entry(
 927                                hid->report_enum[type].report_list.next,
 928                                struct hid_report, list);
 929        } else {
 930                report = hid->report_enum[type].report_id_hash[id];
 931        }
 932        if (!report) {
 933                hid_err(hid, "missing %s %u\n", hid_report_names[type], id);
 934                return NULL;
 935        }
 936        if (report->maxfield <= field_index) {
 937                hid_err(hid, "not enough fields in %s %u\n",
 938                        hid_report_names[type], id);
 939                return NULL;
 940        }
 941        if (report->field[field_index]->report_count < report_counts) {
 942                hid_err(hid, "not enough values in %s %u field %u\n",
 943                        hid_report_names[type], id, field_index);
 944                return NULL;
 945        }
 946        return report;
 947}
 948EXPORT_SYMBOL_GPL(hid_validate_values);
 949
 950/**
 951 * hid_open_report - open a driver-specific device report
 952 *
 953 * @device: hid device
 954 *
 955 * Parse a report description into a hid_device structure. Reports are
 956 * enumerated, fields are attached to these reports.
 957 * 0 returned on success, otherwise nonzero error value.
 958 *
 959 * This function (or the equivalent hid_parse() macro) should only be
 960 * called from probe() in drivers, before starting the device.
 961 */
 962int hid_open_report(struct hid_device *device)
 963{
 964        struct hid_parser *parser;
 965        struct hid_item item;
 966        unsigned int size;
 967        __u8 *start;
 968        __u8 *buf;
 969        __u8 *end;
 970        int ret;
 971        static int (*dispatch_type[])(struct hid_parser *parser,
 972                                      struct hid_item *item) = {
 973                hid_parser_main,
 974                hid_parser_global,
 975                hid_parser_local,
 976                hid_parser_reserved
 977        };
 978
 979        if (WARN_ON(device->status & HID_STAT_PARSED))
 980                return -EBUSY;
 981
 982        start = device->dev_rdesc;
 983        if (WARN_ON(!start))
 984                return -ENODEV;
 985        size = device->dev_rsize;
 986
 987        buf = kmemdup(start, size, GFP_KERNEL);
 988        if (buf == NULL)
 989                return -ENOMEM;
 990
 991        if (device->driver->report_fixup)
 992                start = device->driver->report_fixup(device, buf, &size);
 993        else
 994                start = buf;
 995
 996        start = kmemdup(start, size, GFP_KERNEL);
 997        kfree(buf);
 998        if (start == NULL)
 999                return -ENOMEM;
1000

1001        device->rdesc = start;
1002        device->rsize = size;
1003
1004        parser = vzalloc(sizeof(struct hid_parser));
1005        if (!parser) {
1006                ret = -ENOMEM;
1007                goto err;
1008        }
1009
1010        parser->device = device;
1011
1012        end = start + size;
1013
1014        device->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,
1015                                     sizeof(struct hid_collection), GFP_KERNEL);
1016        if (!device->collection) {
1017                ret = -ENOMEM;
1018                goto err;
1019        }
1020        device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
1021
1022        ret = -EINVAL;
1023        while ((start = fetch_item(start, end, &item)) != NULL) {
1024
1025                if (item.format != HID_ITEM_FORMAT_SHORT) {
1026                        hid_err(device, "unexpected long global item\n");
1027                        goto err;
1028                }
1029
1030                if (dispatch_type[item.type](parser, &item)) {
1031                        hid_err(device, "item %u %u %u %u parsing failed\n",
1032                                item.format, (unsigned)item.size,
1033                                (unsigned)item.type, (unsigned)item.tag);
1034                        goto err;
1035                }
1036
1037                if (start == end) {
1038                        if (parser->collection_stack_ptr) {
1039                                hid_err(device, "unbalanced collection at end of report description\n");
1040                                goto err;
1041                        }
1042                        if (parser->local.delimiter_depth) {
1043                                hid_err(device, "unbalanced delimiter at end of report description\n");
1044                                goto err;
1045                        }
1046                        vfree(parser);
1047                        device->status |= HID_STAT_PARSED;
1048                        return 0;
1049                }
1050        }
1051
1052        hid_err(device, "item fetching failed at offset %d\n", (int)(end - start));
1053err:
1054        vfree(parser);
1055        hid_close_report(device);
1056        return ret;
1057}
1058EXPORT_SYMBOL_GPL(hid_open_report);
1059
1060/*
1061 * Convert a signed n-bit integer to signed 32-bit integer. Common
1062 * cases are done through the compiler, the screwed things has to be
1063 * done by hand.
1064 */
1065
1066static s32 snto32(__u32 value, unsigned n)
1067{
1068        switch (n) {
1069        case 8:  return ((__s8)value);
1070        case 16: return ((__s16)value);
1071        case 32: return ((__s32)value);
1072        }
1073        return value & (1 << (n - 1)) ? value | (~0U << n) : value;
1074}
1075
1076s32 hid_snto32(__u32 value, unsigned n)
1077{
1078        return snto32(value, n);
1079}
1080EXPORT_SYMBOL_GPL(hid_snto32);
1081
1082/*
1083 * Convert a signed 32-bit integer to a signed n-bit integer.
1084 */
1085
1086static u32 s32ton(__s32 value, unsigned n)
1087{
1088        s32 a = value >> (n - 1);
1089        if (a && a != -1)
1090                return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1;
1091        return value & ((1 << n) - 1);
1092}
1093
1094/*
1095 * Extract/implement a data field from/to a little endian report (bit array).
1096 *
1097 * Code sort-of follows HID spec:
1098 *     http://www.usb.org/developers/hidpage/HID1_11.pdf
1099 *
1100 * While the USB HID spec allows unlimited length bit fields in "report
1101 * descriptors", most devices never use more than 16 bits.
1102 * One model of UPS is claimed to report "LINEV" as a 32-bit field.
1103 * Search linux-kernel and linux-usb-devel archives for "hid-core extract".
1104 */
1105
1106static u32 __extract(u8 *report, unsigned offset, int n)
1107{
1108        unsigned int idx = offset / 8;
1109        unsigned int bit_nr = 0;
1110        unsigned int bit_shift = offset % 8;
1111        int bits_to_copy = 8 - bit_shift;
1112        u32 value = 0;
1113        u32 mask = n < 32 ? (1U << n) - 1 : ~0U;
1114
1115        while (n > 0) {
1116                value |= ((u32)report[idx] >> bit_shift) << bit_nr;
1117                n -= bits_to_copy;
1118                bit_nr += bits_to_copy;
1119                bits_to_copy = 8;
1120                bit_shift = 0;
1121                idx++;
1122        }
1123
1124        return value & mask;
1125}
1126
1127u32 hid_field_extract(const struct hid_device *hid, u8 *report,
1128                        unsigned offset, unsigned n)
1129{
1130        if (n > 32) {
1131                hid_warn(hid, "hid_field_extract() called with n (%d) > 32! (%s)\n",
1132                         n, current->comm);
1133                n = 32;
1134        }
1135
1136        return __extract(report, offset, n);
1137}
1138EXPORT_SYMBOL_GPL(hid_field_extract);
1139
1140/*
1141 * "implement" : set bits in a little endian bit stream.
1142 * Same concepts as "extract" (see comments above).
1143 * The data mangled in the bit stream remains in little endian
1144 * order the whole time. It make more sense to talk about
1145 * endianness of register values by considering a register
1146 * a "cached" copy of the little endian bit stream.
1147 */
1148
1149static void __implement(u8 *report, unsigned offset, int n, u32 value)
1150{
1151        unsigned int idx = offset / 8;
1152        unsigned int bit_shift = offset % 8;
1153        int bits_to_set = 8 - bit_shift;
1154
1155        while (n - bits_to_set >= 0) {
1156                report[idx] &= ~(0xff << bit_shift);
1157                report[idx] |= value << bit_shift;
1158                value >>= bits_to_set;
1159                n -= bits_to_set;
1160                bits_to_set = 8;
1161                bit_shift = 0;
1162                idx++;
1163        }
1164
1165        /* last nibble */
1166        if (n) {
1167                u8 bit_mask = ((1U << n) - 1);
1168                report[idx] &= ~(bit_mask << bit_shift);
1169                report[idx] |= value << bit_shift;
1170        }
1171}
1172
1173static void implement(const struct hid_device *hid, u8 *report,
1174                      unsigned offset, unsigned n, u32 value)
1175{
1176        if (unlikely(n > 32)) {
1177                hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n",
1178                         __func__, n, current->comm);
1179                n = 32;
1180        } else if (n < 32) {
1181                u32 m = (1U << n) - 1;
1182
1183                if (unlikely(value > m)) {
1184                        hid_warn(hid,
1185                                 "%s() called with too large value %d (n: %d)! (%s)\n",
1186                                 __func__, value, n, current->comm);
1187                        WARN_ON(1);
1188                        value &= m;
1189                }
1190        }
1191
1192        __implement(report, offset, n, value);
1193}
1194
1195/*
1196 * Search an array for a value.
1197 */
1198
1199static int search(__s32 *array, __s32 value, unsigned n)
1200{
1201        while (n--) {
1202                if (*array++ == value)
1203                        return 0;
1204        }
1205        return -1;
1206}
1207
1208/**
1209 * hid_match_report - check if driver's raw_event should be called
1210 *
1211 * @hid: hid device
1212 * @report_type: type to match against
1213 *
1214 * compare hid->driver->report_table->report_type to report->type
1215 */
1216static int hid_match_report(struct hid_device *hid, struct hid_report *report)
1217{
1218        const struct hid_report_id *id = hid->driver->report_table;
1219
1220        if (!id) /* NULL means all */
1221                return 1;
1222
1223        for (; id->report_type != HID_TERMINATOR; id++)
1224                if (id->report_type == HID_ANY_ID ||
1225                                id->report_type == report->type)
1226                        return 1;
1227        return 0;
1228}
1229
1230/**
1231 * hid_match_usage - check if driver's event should be called
1232 *
1233 * @hid: hid device
1234 * @usage: usage to match against
1235 *
1236 * compare hid->driver->usage_table->usage_{type,code} to
1237 * usage->usage_{type,code}
1238 */
1239static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage)
1240{
1241        const struct hid_usage_id *id = hid->driver->usage_table;
1242
1243        if (!id) /* NULL means all */
1244                return 1;
1245
1246        for (; id->usage_type != HID_ANY_ID - 1; id++)
1247                if ((id->usage_hid == HID_ANY_ID ||
1248                                id->usage_hid == usage->hid) &&
1249                                (id->usage_type == HID_ANY_ID ||
1250                                id->usage_type == usage->type) &&
1251                                (id->usage_code == HID_ANY_ID ||
1252                                 id->usage_code == usage->code))
1253                        return 1;
1254        return 0;
1255}
1256
1257static void hid_process_event(struct hid_device *hid, struct hid_field *field,
1258                struct hid_usage *usage, __s32 value, int interrupt)
1259{
1260        struct hid_driver *hdrv = hid->driver;
1261        int ret;
1262
1263        if (!list_empty(&hid->debug_list))
1264                hid_dump_input(hid, usage, value);
1265
1266        if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
1267                ret = hdrv->event(hid, field, usage, value);
1268                if (ret != 0) {
1269                        if (ret < 0)
1270                                hid_err(hid, "%s's event failed with %d\n",
1271                                                hdrv->name, ret);
1272                        return;
1273                }
1274        }
1275
1276        if (hid->claimed & HID_CLAIMED_INPUT)
1277                hidinput_hid_event(hid, field, usage, value);
1278        if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)
1279                hid->hiddev_hid_event(hid, field, usage, value);
1280}
1281
1282/*
1283 * Analyse a received field, and fetch the data from it. The field
1284 * content is stored for next report processing (we do differential
1285 * reporting to the layer).
1286 */
1287
1288static void hid_input_field(struct hid_device *hid, struct hid_field *field,
1289                            __u8 *data, int interrupt)
1290{
1291        unsigned n;
1292        unsigned count = field->report_count;
1293        unsigned offset = field->report_offset;
1294        unsigned size = field->report_size;
1295        __s32 min = field->logical_minimum;
1296        __s32 max = field->logical_maximum;
1297        __s32 *value;
1298
1299        value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC);
1300        if (!value)
1301                return;
1302
1303        for (n = 0; n < count; n++) {
1304
1305                value[n] = min < 0 ?
1306                        snto32(hid_field_extract(hid, data, offset + n * size,
1307                               size), size) :
1308                        hid_field_extract(hid, data, offset + n * size, size);
1309
1310                /* Ignore report if ErrorRollOver */
1311                if (!(field->flags & HID_MAIN_ITEM_VARIABLE) &&
1312                    value[n] >= min && value[n] <= max &&
1313                    value[n] - min < field->maxusage &&
1314                    field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
1315                        goto exit;
1316        }
1317
1318        for (n = 0; n < count; n++) {
1319
1320                if (HID_MAIN_ITEM_VARIABLE & field->flags) {
1321                        hid_process_event(hid, field, &field->usage[n], value[n], interrupt);
1322                        continue;
1323                }
1324
1325                if (field->value[n] >= min && field->value[n] <= max
1326                        && field->value[n] - min < field->maxusage
1327                        && field->usage[field->value[n] - min].hid
1328                        && search(value, field->value[n], count))
1329                                hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt);
1330
1331                if (value[n] >= min && value[n] <= max
1332                        && value[n] - min < field->maxusage
1333                        && field->usage[value[n] - min].hid
1334                        && search(field->value, value[n], count))
1335                                hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt);
1336        }
1337
1338        memcpy(field->value, value, count * sizeof(__s32));
1339exit:
1340        kfree(value);
1341}
1342
1343/*
1344 * Output the field into the report.
1345 */
1346
1347static void hid_output_field(const struct hid_device *hid,
1348                             struct hid_field *field, __u8 *data)
1349{
1350        unsigned count = field->report_count;
1351        unsigned offset = field->report_offset;
1352        unsigned size = field->report_size;
1353        unsigned n;
1354
1355        for (n = 0; n < count; n++) {
1356                if (field->logical_minimum < 0) /* signed values */
1357                        implement(hid, data, offset + n * size, size,
1358                                  s32ton(field->value[n], size));
1359                else                            /* unsigned values */
1360                        implement(hid, data, offset + n * size, size,
1361                                  field->value[n]);
1362        }
1363}
1364
1365/*
1366 * Create a report. 'data' has to be allocated using
1367 * hid_alloc_report_buf() so that it has proper size.
1368 */
1369
1370void hid_output_report(struct hid_report *report, __u8 *data)
1371{
1372        unsigned n;
1373
1374        if (report->id > 0)
1375                *data++ = report->id;
1376
1377        memset(data, 0, ((report->size - 1) >> 3) + 1);
1378        for (n = 0; n < report->maxfield; n++)
1379                hid_output_field(report->device, report->field[n], data);
1380}
1381EXPORT_SYMBOL_GPL(hid_output_report);
1382
1383/*
1384 * Allocator for buffer that is going to be passed to hid_output_report()
1385 */
1386u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags)
1387{
1388        /*
1389         * 7 extra bytes are necessary to achieve proper functionality
1390         * of implement() working on 8 byte chunks
1391         */
1392
1393        int len = hid_report_len(report) + 7;
1394
1395        return kmalloc(len, flags);
1396}
1397EXPORT_SYMBOL_GPL(hid_alloc_report_buf);
1398
1399/*
1400 * Set a field value. The report this field belongs to has to be
1401 * created and transferred to the device, to set this value in the
1402 * device.
1403 */
1404
1405int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
1406{
1407        unsigned size;
1408
1409        if (!field)
1410                return -1;
1411
1412        size = field->report_size;
1413
1414        hid_dump_input(field->report->device, field->usage + offset, value);
1415
1416        if (offset >= field->report_count) {
1417                hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n",
1418                                offset, field->report_count);
1419                return -1;
1420        }
1421        if (field->logical_minimum < 0) {
1422                if (value != snto32(s32ton(value, size), size)) {
1423                        hid_err(field->report->device, "value %d is out of range\n", value);
1424                        return -1;
1425                }
1426        }
1427        field->value[offset] = value;
1428        return 0;
1429}
1430EXPORT_SYMBOL_GPL(hid_set_field);
1431
1432static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,
1433                const u8 *data)
1434{
1435        struct hid_report *report;
1436        unsigned int n = 0;     /* Normally report number is 0 */
1437
1438        /* Device uses numbered reports, data[0] is report number */
1439        if (report_enum->numbered)
1440                n = *data;
1441
1442        report = report_enum->report_id_hash[n];
1443        if (report == NULL)
1444                dbg_hid("undefined report_id %u received\n", n);
1445
1446        return report;
1447}
1448
1449/*
1450 * Implement a generic .request() callback, using .raw_request()
1451 * DO NOT USE in hid drivers directly, but through hid_hw_request instead.
1452 */
1453void __hid_request(struct hid_device *hid, struct hid_report *report,
1454                int reqtype)
1455{
1456        char *buf;
1457        int ret;
1458        int len;
1459
1460        buf = hid_alloc_report_buf(report, GFP_KERNEL);
1461        if (!buf)
1462                return;
1463
1464        len = hid_report_len(report);
1465
1466        if (reqtype == HID_REQ_SET_REPORT)
1467                hid_output_report(report, buf);
1468
1469        ret = hid->ll_driver->raw_request(hid, report->id, buf, len,
1470                                          report->type, reqtype);
1471        if (ret < 0) {
1472                dbg_hid("unable to complete request: %d\n", ret);
1473                goto out;
1474        }
1475
1476        if (reqtype == HID_REQ_GET_REPORT)
1477                hid_input_report(hid, report->type, buf, ret, 0);
1478
1479out:
1480        kfree(buf);
1481}
1482EXPORT_SYMBOL_GPL(__hid_request);
1483
1484int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
1485                int interrupt)
1486{
1487        struct hid_report_enum *report_enum = hid->report_enum + type;
1488        struct hid_report *report;
1489        struct hid_driver *hdrv;
1490        unsigned int a;
1491        int rsize, csize = size;
1492        u8 *cdata = data;
1493        int ret = 0;
1494
1495        report = hid_get_report(report_enum, data);
1496        if (!report)
1497                goto out;
1498
1499        if (report_enum->numbered) {
1500                cdata++;
1501                csize--;
1502        }
1503
1504        rsize = ((report->size - 1) >> 3) + 1;
1505
1506        if (rsize > HID_MAX_BUFFER_SIZE)
1507                rsize = HID_MAX_BUFFER_SIZE;
1508
1509        if (csize < rsize) {
1510                dbg_hid("report %d is too short, (%d < %d)\n", report->id,
1511                                csize, rsize);
1512                memset(cdata + csize, 0, rsize - csize);
1513        }
1514
1515        if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
1516                hid->hiddev_report_event(hid, report);
1517        if (hid->claimed & HID_CLAIMED_HIDRAW) {
1518                ret = hidraw_report_event(hid, data, size);
1519                if (ret)
1520                        goto out;
1521        }
1522
1523        if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) {
1524                for (a = 0; a < report->maxfield; a++)
1525                        hid_input_field(hid, report->field[a], cdata, interrupt);
1526                hdrv = hid->driver;
1527                if (hdrv && hdrv->report)
1528                        hdrv->report(hid, report);
1529        }
1530
1531        if (hid->claimed & HID_CLAIMED_INPUT)
1532                hidinput_report_event(hid, report);
1533out:
1534        return ret;
1535}
1536EXPORT_SYMBOL_GPL(hid_report_raw_event);
1537
1538/**
1539 * hid_input_report - report data from lower layer (usb, bt...)
1540 *
1541 * @hid: hid device
1542 * @type: HID report type (HID_*_REPORT)
1543 * @data: report contents
1544 * @size: size of data parameter
1545 * @interrupt: distinguish between interrupt and control transfers
1546 *
1547 * This is data entry for lower layers.
1548 */
1549int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)
1550{
1551        struct hid_report_enum *report_enum;
1552        struct hid_driver *hdrv;
1553        struct hid_report *report;
1554        int ret = 0;
1555
1556        if (!hid)
1557                return -ENODEV;
1558
1559        if (down_trylock(&hid->driver_input_lock))
1560                return -EBUSY;
1561
1562        if (!hid->driver) {
1563                ret = -ENODEV;
1564                goto unlock;
1565        }
1566        report_enum = hid->report_enum + type;
1567        hdrv = hid->driver;
1568
1569        if (!size) {
1570                dbg_hid("empty report\n");
1571                ret = -1;
1572                goto unlock;
1573        }
1574
1575        /* Avoid unnecessary overhead if debugfs is disabled */
1576        if (!list_empty(&hid->debug_list))
1577                hid_dump_report(hid, type, data, size);
1578
1579        report = hid_get_report(report_enum, data);
1580
1581        if (!report) {
1582                ret = -1;
1583                goto unlock;
1584        }
1585
1586        if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
1587                ret = hdrv->raw_event(hid, report, data, size);
1588                if (ret < 0)
1589                        goto unlock;
1590        }
1591
1592        ret = hid_report_raw_event(hid, type, data, size, interrupt);
1593
1594unlock:
1595        up(&hid->driver_input_lock);
1596        return ret;
1597}
1598EXPORT_SYMBOL_GPL(hid_input_report);
1599
1600static bool hid_match_one_id(struct hid_device *hdev,
1601                const struct hid_device_id *id)
1602{
1603        return (id->bus == HID_BUS_ANY || id->bus == hdev->bus) &&
1604                (id->group == HID_GROUP_ANY || id->group == hdev->group) &&
1605                (id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
1606                (id->product == HID_ANY_ID || id->product == hdev->product);
1607}
1608
1609const struct hid_device_id *hid_match_id(struct hid_device *hdev,
1610                const struct hid_device_id *id)
1611{
1612        for (; id->bus; id++)
1613                if (hid_match_one_id(hdev, id))
1614                        return id;
1615
1616        return NULL;
1617}
1618
1619static const struct hid_device_id hid_hiddev_list[] = {
1620        { HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS) },
1621        { HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1) },
1622        { }
1623};
1624
1625static bool hid_hiddev(struct hid_device *hdev)
1626{
1627        return !!hid_match_id(hdev, hid_hiddev_list);
1628}
1629
1630
1631static ssize_t
1632read_report_descriptor(struct file *filp, struct kobject *kobj,
1633                struct bin_attribute *attr,
1634                char *buf, loff_t off, size_t count)
1635{
1636        struct device *dev = kobj_to_dev(kobj);
1637        struct hid_device *hdev = to_hid_device(dev);
1638
1639        if (off >= hdev->rsize)
1640                return 0;
1641
1642        if (off + count > hdev->rsize)
1643                count = hdev->rsize - off;
1644
1645        memcpy(buf, hdev->rdesc + off, count);
1646
1647        return count;
1648}
1649
1650static ssize_t
1651show_country(struct device *dev, struct device_attribute *attr,
1652                char *buf)
1653{
1654        struct hid_device *hdev = to_hid_device(dev);
1655
1656        return sprintf(buf, "%02x\n", hdev->country & 0xff);
1657}
1658
1659static struct bin_attribute dev_bin_attr_report_desc = {
1660        .attr = { .name = "report_descriptor", .mode = 0444 },
1661        .read = read_report_descriptor,
1662        .size = HID_MAX_DESCRIPTOR_SIZE,
1663};
1664
1665static struct device_attribute dev_attr_country = {
1666        .attr = { .name = "country", .mode = 0444 },
1667        .show = show_country,
1668};
1669
1670int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
1671{
1672        static const char *types[] = { "Device", "Pointer", "Mouse", "Device",
1673                "Joystick", "Gamepad", "Keyboard", "Keypad",
1674                "Multi-Axis Controller"
1675        };
1676        const char *type, *bus;
1677        char buf[64] = "";
1678        unsigned int i;
1679        int len;
1680        int ret;
1681
1682        if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE)
1683                connect_mask |= (HID_CONNECT_HIDDEV_FORCE | HID_CONNECT_HIDDEV);
1684        if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE)
1685                connect_mask |= HID_CONNECT_HIDINPUT_FORCE;
1686        if (hdev->bus != BUS_USB)
1687                connect_mask &= ~HID_CONNECT_HIDDEV;
1688        if (hid_hiddev(hdev))
1689                connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1690
1691        if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,
1692                                connect_mask & HID_CONNECT_HIDINPUT_FORCE))
1693                hdev->claimed |= HID_CLAIMED_INPUT;
1694
1695        if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&
1696                        !hdev->hiddev_connect(hdev,
1697                                connect_mask & HID_CONNECT_HIDDEV_FORCE))
1698                hdev->claimed |= HID_CLAIMED_HIDDEV;
1699        if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev))
1700                hdev->claimed |= HID_CLAIMED_HIDRAW;
1701
1702        if (connect_mask & HID_CONNECT_DRIVER)
1703                hdev->claimed |= HID_CLAIMED_DRIVER;
1704
1705        /* Drivers with the ->raw_event callback set are not required to connect
1706         * to any other listener. */
1707        if (!hdev->claimed && !hdev->driver->raw_event) {
1708                hid_err(hdev, "device has no listeners, quitting\n");
1709                return -ENODEV;
1710        }
1711
1712        if ((hdev->claimed & HID_CLAIMED_INPUT) &&
1713                        (connect_mask & HID_CONNECT_FF) && hdev->ff_init)
1714                hdev->ff_init(hdev);
1715
1716        len = 0;
1717        if (hdev->claimed & HID_CLAIMED_INPUT)
1718                len += sprintf(buf + len, "input");
1719        if (hdev->claimed & HID_CLAIMED_HIDDEV)
1720                len += sprintf(buf + len, "%shiddev%d", len ? "," : "",
1721                                ((struct hiddev *)hdev->hiddev)->minor);
1722        if (hdev->claimed & HID_CLAIMED_HIDRAW)
1723                len += sprintf(buf + len, "%shidraw%d", len ? "," : "",
1724                                ((struct hidraw *)hdev->hidraw)->minor);
1725
1726        type = "Device";
1727        for (i = 0; i < hdev->maxcollection; i++) {
1728                struct hid_collection *col = &hdev->collection[i];
1729                if (col->type == HID_COLLECTION_APPLICATION &&
1730                   (col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
1731                   (col->usage & 0xffff) < ARRAY_SIZE(types)) {
1732                        type = types[col->usage & 0xffff];
1733                        break;
1734                }
1735        }
1736
1737        switch (hdev->bus) {
1738        case BUS_USB:
1739                bus = "USB";
1740                break;
1741        case BUS_BLUETOOTH:
1742                bus = "BLUETOOTH";
1743                break;
1744        case BUS_I2C:
1745                bus = "I2C";
1746                break;
1747        default:
1748                bus = "<UNKNOWN>";
1749        }
1750
1751        ret = device_create_file(&hdev->dev, &dev_attr_country);
1752        if (ret)
1753                hid_warn(hdev,
1754                         "can't create sysfs country code attribute err: %d\n", ret);
1755
1756        hid_info(hdev, "%s: %s HID v%x.%02x %s [%s] on %s\n",
1757                 buf, bus, hdev->version >> 8, hdev->version & 0xff,
1758                 type, hdev->name, hdev->phys);
1759
1760        return 0;
1761}
1762EXPORT_SYMBOL_GPL(hid_connect);
1763
1764void hid_disconnect(struct hid_device *hdev)
1765{
1766        device_remove_file(&hdev->dev, &dev_attr_country);
1767        if (hdev->claimed & HID_CLAIMED_INPUT)
1768                hidinput_disconnect(hdev);
1769        if (hdev->claimed & HID_CLAIMED_HIDDEV)
1770                hdev->hiddev_disconnect(hdev);
1771        if (hdev->claimed & HID_CLAIMED_HIDRAW)
1772                hidraw_disconnect(hdev);
1773        hdev->claimed = 0;
1774}
1775EXPORT_SYMBOL_GPL(hid_disconnect);
1776
1777/**
1778 * hid_hw_start - start underlying HW
1779 * @hdev: hid device
1780 * @connect_mask: which outputs to connect, see HID_CONNECT_*
1781 *
1782 * Call this in probe function *after* hid_parse. This will setup HW
1783 * buffers and start the device (if not defeirred to device open).
1784 * hid_hw_stop must be called if this was successful.
1785 */
1786int hid_hw_start(struct hid_device *hdev, unsigned int connect_mask)
1787{
1788        int error;
1789
1790        error = hdev->ll_driver->start(hdev);
1791        if (error)
1792                return error;
1793
1794        if (connect_mask) {
1795                error = hid_connect(hdev, connect_mask);
1796                if (error) {
1797                        hdev->ll_driver->stop(hdev);
1798                        return error;
1799                }
1800        }
1801
1802        return 0;
1803}
1804EXPORT_SYMBOL_GPL(hid_hw_start);
1805
1806/**
1807 * hid_hw_stop - stop underlying HW
1808 * @hdev: hid device
1809 *
1810 * This is usually called from remove function or from probe when something
1811 * failed and hid_hw_start was called already.
1812 */
1813void hid_hw_stop(struct hid_device *hdev)
1814{
1815        hid_disconnect(hdev);
1816        hdev->ll_driver->stop(hdev);
1817}
1818EXPORT_SYMBOL_GPL(hid_hw_stop);
1819
1820/**
1821 * hid_hw_open - signal underlying HW to start delivering events
1822 * @hdev: hid device
1823 *
1824 * Tell underlying HW to start delivering events from the device.
1825 * This function should be called sometime after successful call
1826 * to hid_hiw_start().
1827 */
1828int hid_hw_open(struct hid_device *hdev)
1829{
1830        int ret;
1831
1832        ret = mutex_lock_killable(&hdev->ll_open_lock);
1833        if (ret)
1834                return ret;
1835
1836        if (!hdev->ll_open_count++) {
1837                ret = hdev->ll_driver->open(hdev);
1838                if (ret)
1839                        hdev->ll_open_count--;
1840        }
1841
1842        mutex_unlock(&hdev->ll_open_lock);
1843        return ret;
1844}
1845EXPORT_SYMBOL_GPL(hid_hw_open);
1846
1847/**
1848 * hid_hw_close - signal underlaying HW to stop delivering events
1849 *
1850 * @hdev: hid device
1851 *
1852 * This function indicates that we are not interested in the events
1853 * from this device anymore. Delivery of events may or may not stop,
1854 * depending on the number of users still outstanding.
1855 */
1856void hid_hw_close(struct hid_device *hdev)
1857{
1858        mutex_lock(&hdev->ll_open_lock);
1859        if (!--hdev->ll_open_count)
1860                hdev->ll_driver->close(hdev);
1861        mutex_unlock(&hdev->ll_open_lock);
1862}
1863EXPORT_SYMBOL_GPL(hid_hw_close);
1864
1865/*
1866 * A list of devices for which there is a specialized driver on HID bus.
1867 *
1868 * Please note that for multitouch devices (driven by hid-multitouch driver),
1869 * there is a proper autodetection and autoloading in place (based on presence
1870 * of HID_DG_CONTACTID), so those devices don't need to be added to this list,
1871 * as we are doing the right thing in hid_scan_usage().
1872 *
1873 * Autodetection for (USB) HID sensor hubs exists too. If a collection of type
1874 * physical is found inside a usage page of type sensor, hid-sensor-hub will be
1875 * used as a driver. See hid_scan_report().
1876 */
1877static const struct hid_device_id hid_have_special_driver[] = {
1878#if IS_ENABLED(CONFIG_HID_A4TECH)
1879        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },
1880        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },
1881        { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_RP_649) },
1882#endif
1883#if IS_ENABLED(CONFIG_HID_ACCUTOUCH)
1884        { HID_USB_DEVICE(USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_ACCUTOUCH_2216) },
1885#endif
1886#if IS_ENABLED(CONFIG_HID_ACRUX)
1887        { HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0x0802) },
1888        { HID_USB_DEVICE(USB_VENDOR_ID_ACRUX, 0xf705) },
1889#endif
1890#if IS_ENABLED(CONFIG_HID_ALPS)
1891        { HID_DEVICE(HID_BUS_ANY, HID_GROUP_ANY, USB_VENDOR_ID_ALPS_JP, HID_DEVICE_ID_ALPS_U1_DUAL) },
1892#endif
1893#if IS_ENABLED(CONFIG_HID_APPLE)
1894        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },
1895        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },
1896        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },
1897        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },
1898        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },
1899        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },
1900        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },
1901        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },
1902        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },
1903        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },
1904        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },
1905        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },
1906        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ANSI) },
1907        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ISO) },
1908        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_JIS) },
1909        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI) },
1910        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO) },
1911        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS) },
1912        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },
1913        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },
1914        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },
1915        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI) },
1916        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO) },
1917        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS) },
1918        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },
1919        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },
1920        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },
1921        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },
1922        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },
1923        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },
1924        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) },
1925        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },
1926        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },
1927        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI) },
1928        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO) },
1929        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS) },
1930        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI) },
1931        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO) },
1932        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) },
1933        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },
1934        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },
1935        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },
1936        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI) },
1937        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO) },
1938        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS) },
1939        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI) },
1940        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO) },
1941        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS) },
1942        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },
1943        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },
1944        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },
1945        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
1946        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
1947        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
1948        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
1949        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
1950        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
1951        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI) },
1952        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO) },
1953        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS) },
1954        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI) },
1955        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ISO) },
1956        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_JIS) },
1957        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ANSI) },
1958        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ISO) },
1959        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_JIS) },
1960        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },
1961        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },
1962        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },
1963        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI) },
1964        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO) },
1965        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_JIS) },
1966        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_ANSI) },
1967        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
1968        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
1969#endif
1970#if IS_ENABLED(CONFIG_HID_APPLEIR)
1971        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL) },
1972        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL2) },
1973        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL3) },
1974        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
1975        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL5) },
1976#endif
1977#if IS_ENABLED(CONFIG_HID_ASUS)
1978        { HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_I2C_KEYBOARD) },
1979        { HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_I2C_TOUCHPAD) },
1980        { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD1) },
1981        { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD2) },
1982        { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_T100_KEYBOARD) },
1983        { HID_USB_DEVICE(USB_VENDOR_ID_JESS, USB_DEVICE_ID_ASUS_MD_5112) },
1984        { HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_ASUS_MD_5110) },
1985        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_T100CHI_KEYBOARD) },
1986#endif
1987#if IS_ENABLED(CONFIG_HID_AUREAL)
1988        { HID_USB_DEVICE(USB_VENDOR_ID_AUREAL, USB_DEVICE_ID_AUREAL_W01RN) },
1989#endif
1990#if IS_ENABLED(CONFIG_HID_BELKIN)
1991        { HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },
1992        { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
1993#endif
1994#if IS_ENABLED(CONFIG_HID_BETOP_FF)
1995        { HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185BFM, 0x2208) },
1996        { HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185PC, 0x5506) },
1997        { HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185V2PC, 0x1850) },
1998        { HID_USB_DEVICE(USB_VENDOR_ID_BETOP_2185V2BFM, 0x5500) },
1999#endif
2000#if IS_ENABLED(CONFIG_HID_CHERRY)

2001        { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
2002        { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR) },
2003#endif
2004#if IS_ENABLED(CONFIG_HID_CHICONY)
2005        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
2006        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS2) },
2007        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_ASUS_AK1D) },
2008        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_ACER_SWITCH12) },
2009#endif
2010#if IS_ENABLED(CONFIG_HID_CMEDIA)
2011        { HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM6533) },
2012#endif
2013#if IS_ENABLED(CONFIG_HID_CORSAIR)
2014        { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_K90) },
2015        { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_SCIMITAR_PRO_RGB) },
2016#endif
2017#if IS_ENABLED(CONFIG_HID_CP2112)
2018        { HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_CP2112) },
2019#endif
2020#if IS_ENABLED(CONFIG_HID_CYPRESS)
2021        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_1) },
2022        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) },
2023        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_3) },
2024        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_4) },
2025        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },
2026#endif
2027#if IS_ENABLED(CONFIG_HID_DRAGONRISE)
2028        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },
2029        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) },
2030#endif
2031#if IS_ENABLED(CONFIG_HID_ELECOM)
2032        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_BM084) },
2033        { HID_USB_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_DEFT_WIRED) },
2034        { HID_USB_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_DEFT_WIRELESS) },
2035        { HID_USB_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_HUGE_WIRED) },
2036        { HID_USB_DEVICE(USB_VENDOR_ID_ELECOM, USB_DEVICE_ID_ELECOM_HUGE_WIRELESS) },
2037#endif
2038#if IS_ENABLED(CONFIG_HID_ELO)
2039        { HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0009) },
2040        { HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0030) },
2041#endif
2042#if IS_ENABLED(CONFIG_HID_EMS_FF)
2043        { HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },
2044#endif
2045#if IS_ENABLED(CONFIG_HID_EZKEY)
2046        { HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
2047#endif
2048#if IS_ENABLED(CONFIG_HID_GEMBIRD)
2049        { HID_USB_DEVICE(USB_VENDOR_ID_GEMBIRD, USB_DEVICE_ID_GEMBIRD_JPD_DUALFORCE2) },
2050#endif
2051#if IS_ENABLED(CONFIG_HID_GFRM)
2052        { HID_BLUETOOTH_DEVICE(0x58, 0x2000) },
2053        { HID_BLUETOOTH_DEVICE(0x471, 0x2210) },
2054#endif
2055#if IS_ENABLED(CONFIG_HID_GREENASIA)
2056        { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) },
2057#endif
2058#if IS_ENABLED(CONFIG_HID_GT683R)
2059        { HID_USB_DEVICE(USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL) },
2060#endif
2061#if IS_ENABLED(CONFIG_HID_GYRATION)
2062        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
2063        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
2064        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
2065#endif
2066#if IS_ENABLED(CONFIG_HID_HOLTEK)
2067        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK, USB_DEVICE_ID_HOLTEK_ON_LINE_GRIP) },
2068        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_KEYBOARD) },
2069        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A04A) },
2070        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067) },
2071        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A070) },
2072        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A072) },
2073        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A081) },
2074        { HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT, USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A0C2) },
2075#endif
2076#if IS_ENABLED(CONFIG_HID_ICADE)
2077        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ION, USB_DEVICE_ID_ICADE) },
2078#endif
2079#if IS_ENABLED(CONFIG_HID_ITE)
2080        { HID_USB_DEVICE(USB_VENDOR_ID_ITE, USB_DEVICE_ID_ITE8595) },
2081#endif
2082#if IS_ENABLED(CONFIG_HID_KENSINGTON)
2083        { HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
2084#endif
2085#if IS_ENABLED(CONFIG_HID_KEYTOUCH)
2086        { HID_USB_DEVICE(USB_VENDOR_ID_KEYTOUCH, USB_DEVICE_ID_KEYTOUCH_IEC) },
2087#endif
2088#if IS_ENABLED(CONFIG_HID_KYE)
2089        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GILA_GAMING_MOUSE) },
2090        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_MANTICORE) },
2091        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_GENIUS_GX_IMPERATOR) },
2092        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
2093        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_I405X) },
2094        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X) },
2095        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_MOUSEPEN_I608X_V2) },
2096        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_EASYPEN_M610X) },
2097        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_PENSKETCH_M912) },
2098#endif
2099#if IS_ENABLED(CONFIG_HID_LCPOWER)
2100        { HID_USB_DEVICE(USB_VENDOR_ID_LCPOWER, USB_DEVICE_ID_LCPOWER_LC1000 ) },
2101#endif
2102#if IS_ENABLED(CONFIG_HID_LED)
2103        { HID_USB_DEVICE(USB_VENDOR_ID_DELCOM, USB_DEVICE_ID_DELCOM_VISUAL_IND) },
2104        { HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, USB_DEVICE_ID_DREAM_CHEEKY_WN) },
2105        { HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, USB_DEVICE_ID_DREAM_CHEEKY_FA) },
2106        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_LUXAFOR) },
2107        { HID_USB_DEVICE(USB_VENDOR_ID_RISO_KAGAKU, USB_DEVICE_ID_RI_KA_WEBMAIL) },
2108        { HID_USB_DEVICE(USB_VENDOR_ID_THINGM, USB_DEVICE_ID_BLINK1) },
2109#endif
2110#if IS_ENABLED(CONFIG_HID_LENOVO)
2111        { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) },
2112        { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) },
2113        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) },
2114        { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) },
2115#endif
2116#if IS_ENABLED(CONFIG_HID_LOGITECH)
2117        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) },
2118        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) },
2119        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) },
2120        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER) },
2121        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP) },
2122        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE) },
2123        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI) },
2124        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD) },
2125        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500) },
2126        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D) },
2127        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DUAL_ACTION) },
2128        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL) },
2129        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD) },
2130        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD) },
2131        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2) },
2132        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G29_WHEEL) },
2133        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D) },
2134        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ) },
2135        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO) },
2136        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940) },
2137        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL) },
2138        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2) },
2139        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_VIBRATION_WHEEL) },
2140        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL) },
2141        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL) },
2142        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) },
2143        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL) },
2144        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL) },
2145        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },
2146        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) },
2147        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR) },
2148#endif
2149#if IS_ENABLED(CONFIG_HID_LOGITECH_HIDPP)
2150        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_T651) },
2151        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL) },
2152#endif
2153#if IS_ENABLED(CONFIG_HID_LOGITECH_DJ)
2154        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER) },
2155        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2) },
2156#endif
2157#if IS_ENABLED(CONFIG_HID_MAGICMOUSE)
2158        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE) },
2159        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICTRACKPAD) },
2160#endif
2161#if IS_ENABLED(CONFIG_HID_MAYFLASH)
2162        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3) },
2163        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_DOLPHINBAR) },
2164        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE1) },
2165        { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE2) },
2166#endif
2167#if IS_ENABLED(CONFIG_HID_MICROSOFT)
2168        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500) },
2169        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_KEYBOARD) },
2170        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV) },
2171        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K) },
2172        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K_JP) },
2173        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE7K) },
2174        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K) },
2175        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB) },
2176        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K) },
2177        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },
2178        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_OFFICE_KB) },
2179        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_7K) },
2180        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_600) },
2181        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3KV1) },
2182        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER) },
2183        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
2184#endif
2185#if IS_ENABLED(CONFIG_HID_MONTEREY)
2186        { HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
2187#endif
2188#if IS_ENABLED(CONFIG_HID_MULTITOUCH)
2189        { HID_USB_DEVICE(USB_VENDOR_ID_LG, USB_DEVICE_ID_LG_MELFAS_MT) },
2190#endif
2191#if IS_ENABLED(CONFIG_HID_WIIMOTE)
2192        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE) },
2193        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
2194#endif
2195#if IS_ENABLED(CONFIG_HID_NTI)
2196        { HID_USB_DEVICE(USB_VENDOR_ID_NTI, USB_DEVICE_ID_USB_SUN) },
2197#endif
2198#if IS_ENABLED(CONFIG_HID_NTRIG)
2199        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) },
2200        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_1) },
2201        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_2) },
2202        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_3) },
2203        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_4) },
2204        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_5) },
2205        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_6) },
2206        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_7) },
2207        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_8) },
2208        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_9) },
2209        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_10) },
2210        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_11) },
2211        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_12) },
2212        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_13) },
2213        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_14) },
2214        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_15) },
2215        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_16) },
2216        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_17) },
2217        { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN_18) },
2218#endif
2219#if IS_ENABLED(CONFIG_HID_ORTEK)
2220        { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_PKB1700) },
2221        { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },
2222        { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_IHOME_IMAC_A210S) },
2223        { HID_USB_DEVICE(USB_VENDOR_ID_SKYCABLE, USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER) },
2224#endif
2225#if IS_ENABLED(CONFIG_HID_PANTHERLORD)
2226        { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
2227        { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) },
2228        { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },
2229        { HID_USB_DEVICE(USB_VENDOR_ID_JESS2, USB_DEVICE_ID_JESS2_COLOR_RUMBLE_PAD) },
2230#endif
2231#if IS_ENABLED(CONFIG_HID_PENMOUNT)
2232        { HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT, USB_DEVICE_ID_PENMOUNT_6000) },
2233#endif
2234#if IS_ENABLED(CONFIG_HID_PETALYNX)
2235        { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
2236#endif
2237#if IS_ENABLED(CONFIG_HID_PICOLCD)
2238        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD) },
2239        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICOLCD_BOOTLOADER) },
2240#endif
2241#if IS_ENABLED(CONFIG_HID_PLANTRONICS)
2242        { HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS, HID_ANY_ID) },
2243#endif
2244#if IS_ENABLED(CONFIG_HID_PRIMAX)
2245        { HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_KEYBOARD) },
2246#endif
2247#if IS_ENABLED(CONFIG_HID_PRODIKEYS)
2248        { HID_USB_DEVICE(USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_PRODIKEYS_PCMIDI) },
2249#endif
2250#if IS_ENABLED(CONFIG_HID_RETRODE)
2251        { HID_USB_DEVICE(USB_VENDOR_ID_FUTURE_TECHNOLOGY, USB_DEVICE_ID_RETRODE2) },
2252#endif
2253#if IS_ENABLED(CONFIG_HID_RMI)
2254        { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) },
2255        { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14) },
2256#endif
2257#if IS_ENABLED(CONFIG_HID_ROCCAT)
2258        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) },
2259        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKU) },
2260        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ISKUFX) },
2261        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },
2262        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPLUS) },
2263        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE) },
2264        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPURE_OPTICAL) },
2265        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEXTD) },
2266        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KOVAPLUS) },
2267        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_LUA) },
2268        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRED) },
2269        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS) },
2270        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK) },
2271        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK_GLOW) },
2272        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK_PRO) },
2273        { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_SAVU) },
2274#endif
2275#if IS_ENABLED(CONFIG_HID_SAITEK)
2276        { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000) },
2277        { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7_OLD) },
2278        { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7) },
2279        { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT9) },
2280        { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_MMO7) },
2281        { HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_RAT5) },
2282        { HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_RAT9) },
2283#endif
2284#if IS_ENABLED(CONFIG_HID_SAMSUNG)
2285        { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
2286        { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE) },
2287#endif
2288#if IS_ENABLED(CONFIG_HID_SMARTJOYPLUS)
2289        { HID_USB_DEVICE(USB_VENDOR_ID_PLAYDOTCOM, USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII) },
2290        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SMARTJOY_PLUS) },
2291        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_SUPER_JOY_BOX_3) },
2292        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD) },
2293        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_3_PRO) },
2294        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_DUAL_BOX_PRO) },
2295        { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SUPER_JOY_BOX_5_PRO) },
2296#endif
2297#if IS_ENABLED(CONFIG_HID_SONY)
2298        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_HARMONY_PS3) },
2299        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SMK, USB_DEVICE_ID_SMK_PS3_BDREMOTE) },
2300        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_BUZZ_CONTROLLER) },
2301        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_WIRELESS_BUZZ_CONTROLLER) },
2302        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER) },
2303        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_MOTION_CONTROLLER) },
2304        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER) },
2305        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER) },
2306        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_BDREMOTE) },
2307        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
2308        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
2309        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER) },
2310        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER) },
2311        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2) },
2312        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_2) },
2313        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE) },
2314        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },
2315        { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGP_MOUSE) },
2316        { HID_USB_DEVICE(USB_VENDOR_ID_SINO_LITE, USB_DEVICE_ID_SINO_LITE_CONTROLLER) },
2317#endif
2318#if IS_ENABLED(CONFIG_HID_SPEEDLINK)
2319        { HID_USB_DEVICE(USB_VENDOR_ID_X_TENSIONS, USB_DEVICE_ID_SPEEDLINK_VAD_CEZANNE) },
2320#endif
2321#if IS_ENABLED(CONFIG_HID_STEELSERIES)
2322        { HID_USB_DEVICE(USB_VENDOR_ID_STEELSERIES, USB_DEVICE_ID_STEELSERIES_SRWS1) },
2323#endif
2324#if IS_ENABLED(CONFIG_HID_SUNPLUS)
2325        { HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
2326#endif
2327#if IS_ENABLED(CONFIG_HID_THRUSTMASTER)
2328        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
2329        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
2330        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb323) },
2331        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb324) },
2332        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651) },
2333        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb653) },
2334        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },
2335        { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb65a) },
2336#endif
2337#if IS_ENABLED(CONFIG_HID_TIVO)
2338        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_BT) },
2339        { HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE) },
2340        { HID_USB_DEVICE(USB_VENDOR_ID_TIVO, USB_DEVICE_ID_TIVO_SLIDE_PRO) },
2341#endif
2342#if IS_ENABLED(CONFIG_HID_TOPSEED)
2343        { HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE) },
2344        { HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE_2) },
2345        { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS) },
2346        { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) },
2347        { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) },
2348#endif
2349#if IS_ENABLED(CONFIG_HID_TWINHAN)
2350        { HID_USB_DEVICE(USB_VENDOR_ID_TWINHAN, USB_DEVICE_ID_TWINHAN_IR_REMOTE) },
2351#endif
2352#if IS_ENABLED(CONFIG_HID_UCLOGIC)
2353        { HID_USB_DEVICE(USB_VENDOR_ID_HUION, USB_DEVICE_ID_HUION_TABLET) },
2354        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_HUION_TABLET) },
2355        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209) },
2356        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U) },
2357        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U) },
2358        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP8060U) },
2359        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP1062) },
2360        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_WIRELESS_TABLET_TWHL850) },
2361        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_TWHA60) },
2362        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_YIYNOVA_TABLET) },
2363        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UGEE_TABLET_81) },
2364        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UGEE_TABLET_45) },
2365        { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_DRAWIMAGE_G3) },
2366        { HID_USB_DEVICE(USB_VENDOR_ID_UGEE, USB_DEVICE_ID_UGEE_TABLET_EX07S) },
2367        { HID_USB_DEVICE(USB_VENDOR_ID_UGTIZER, USB_DEVICE_ID_UGTIZER_TABLET_GP0610) },
2368#endif
2369#if IS_ENABLED(CONFIG_HID_UDRAW_PS3)
2370        { HID_USB_DEVICE(USB_VENDOR_ID_THQ, USB_DEVICE_ID_THQ_PS3_UDRAW) },
2371#endif
2372#if IS_ENABLED(CONFIG_HID_WALTOP)
2373        { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_5_8_INCH) },
2374        { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SLIM_TABLET_12_1_INCH) },
2375        { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_Q_PAD) },
2376        { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_PID_0038) },
2377        { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_10_6_INCH) },
2378        { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_MEDIA_TABLET_14_1_INCH) },
2379        { HID_USB_DEVICE(USB_VENDOR_ID_WALTOP, USB_DEVICE_ID_WALTOP_SIRIUS_BATTERY_FREE_TABLET) },
2380#endif
2381#if IS_ENABLED(CONFIG_HID_XINMO)
2382        { HID_USB_DEVICE(USB_VENDOR_ID_XIN_MO, USB_DEVICE_ID_XIN_MO_DUAL_ARCADE) },
2383        { HID_USB_DEVICE(USB_VENDOR_ID_XIN_MO, USB_DEVICE_ID_THT_2P_ARCADE) },
2384#endif
2385#if IS_ENABLED(CONFIG_HID_ZEROPLUS)
2386        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
2387        { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
2388#endif
2389#if IS_ENABLED(CONFIG_HID_ZYDACRON)
2390        { HID_USB_DEVICE(USB_VENDOR_ID_ZYDACRON, USB_DEVICE_ID_ZYDACRON_REMOTE_CONTROL) },
2391#endif
2392        { }
2393};
2394
2395struct hid_dynid {
2396        struct list_head list;
2397        struct hid_device_id id;
2398};
2399
2400/**
2401 * store_new_id - add a new HID device ID to this driver and re-probe devices
2402 * @driver: target device driver
2403 * @buf: buffer for scanning device ID data
2404 * @count: input size
2405 *
2406 * Adds a new dynamic hid device ID to this driver,
2407 * and causes the driver to probe for all devices again.
2408 */
2409static ssize_t new_id_store(struct device_driver *drv, const char *buf,
2410                size_t count)
2411{
2412        struct hid_driver *hdrv = to_hid_driver(drv);
2413        struct hid_dynid *dynid;
2414        __u32 bus, vendor, product;
2415        unsigned long driver_data = 0;
2416        int ret;
2417
2418        ret = sscanf(buf, "%x %x %x %lx",
2419                        &bus, &vendor, &product, &driver_data);
2420        if (ret < 3)
2421                return -EINVAL;
2422
2423        dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
2424        if (!dynid)
2425                return -ENOMEM;
2426
2427        dynid->id.bus = bus;
2428        dynid->id.group = HID_GROUP_ANY;
2429        dynid->id.vendor = vendor;
2430        dynid->id.product = product;
2431        dynid->id.driver_data = driver_data;
2432
2433        spin_lock(&hdrv->dyn_lock);
2434        list_add_tail(&dynid->list, &hdrv->dyn_list);
2435        spin_unlock(&hdrv->dyn_lock);
2436
2437        ret = driver_attach(&hdrv->driver);
2438
2439        return ret ? : count;
2440}
2441static DRIVER_ATTR_WO(new_id);
2442
2443static struct attribute *hid_drv_attrs[] = {
2444        &driver_attr_new_id.attr,
2445        NULL,
2446};
2447ATTRIBUTE_GROUPS(hid_drv);
2448
2449static void hid_free_dynids(struct hid_driver *hdrv)
2450{
2451        struct hid_dynid *dynid, *n;
2452
2453        spin_lock(&hdrv->dyn_lock);
2454        list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) {
2455                list_del(&dynid->list);
2456                kfree(dynid);
2457        }
2458        spin_unlock(&hdrv->dyn_lock);
2459}
2460
2461static const struct hid_device_id *hid_match_device(struct hid_device *hdev,
2462                struct hid_driver *hdrv)
2463{
2464        struct hid_dynid *dynid;
2465
2466        spin_lock(&hdrv->dyn_lock);
2467        list_for_each_entry(dynid, &hdrv->dyn_list, list) {
2468                if (hid_match_one_id(hdev, &dynid->id)) {
2469                        spin_unlock(&hdrv->dyn_lock);
2470                        return &dynid->id;
2471                }
2472        }
2473        spin_unlock(&hdrv->dyn_lock);
2474
2475        return hid_match_id(hdev, hdrv->id_table);
2476}
2477
2478static int hid_bus_match(struct device *dev, struct device_driver *drv)
2479{
2480        struct hid_driver *hdrv = to_hid_driver(drv);
2481        struct hid_device *hdev = to_hid_device(dev);
2482
2483        return hid_match_device(hdev, hdrv) != NULL;
2484}
2485
2486static int hid_device_probe(struct device *dev)
2487{
2488        struct hid_driver *hdrv = to_hid_driver(dev->driver);
2489        struct hid_device *hdev = to_hid_device(dev);
2490        const struct hid_device_id *id;
2491        int ret = 0;
2492
2493        if (down_interruptible(&hdev->driver_input_lock)) {
2494                ret = -EINTR;
2495                goto end;
2496        }
2497        hdev->io_started = false;
2498
2499        if (!hdev->driver) {
2500                id = hid_match_device(hdev, hdrv);
2501                if (id == NULL) {
2502                        ret = -ENODEV;
2503                        goto unlock;
2504                }
2505
2506                hdev->driver = hdrv;
2507                if (hdrv->probe) {
2508                        ret = hdrv->probe(hdev, id);
2509                } else { /* default probe */
2510                        ret = hid_open_report(hdev);
2511                        if (!ret)
2512                                ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
2513                }
2514                if (ret) {
2515                        hid_close_report(hdev);
2516                        hdev->driver = NULL;
2517                }
2518        }
2519unlock:
2520        if (!hdev->io_started)
2521                up(&hdev->driver_input_lock);
2522end:
2523        return ret;
2524}
2525
2526static int hid_device_remove(struct device *dev)
2527{
2528        struct hid_device *hdev = to_hid_device(dev);
2529        struct hid_driver *hdrv;
2530        int ret = 0;
2531
2532        if (down_interruptible(&hdev->driver_input_lock)) {
2533                ret = -EINTR;
2534                goto end;
2535        }
2536        hdev->io_started = false;
2537
2538        hdrv = hdev->driver;
2539        if (hdrv) {
2540                if (hdrv->remove)
2541                        hdrv->remove(hdev);
2542                else /* default remove */
2543                        hid_hw_stop(hdev);
2544                hid_close_report(hdev);
2545                hdev->driver = NULL;
2546        }
2547
2548        if (!hdev->io_started)
2549                up(&hdev->driver_input_lock);
2550end:
2551        return ret;
2552}
2553
2554static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
2555                             char *buf)
2556{
2557        struct hid_device *hdev = container_of(dev, struct hid_device, dev);
2558
2559        return scnprintf(buf, PAGE_SIZE, "hid:b%04Xg%04Xv%08Xp%08X\n",
2560                         hdev->bus, hdev->group, hdev->vendor, hdev->product);
2561}
2562static DEVICE_ATTR_RO(modalias);
2563
2564static struct attribute *hid_dev_attrs[] = {
2565        &dev_attr_modalias.attr,
2566        NULL,
2567};
2568static struct bin_attribute *hid_dev_bin_attrs[] = {
2569        &dev_bin_attr_report_desc,
2570        NULL
2571};
2572static const struct attribute_group hid_dev_group = {
2573        .attrs = hid_dev_attrs,
2574        .bin_attrs = hid_dev_bin_attrs,
2575};
2576__ATTRIBUTE_GROUPS(hid_dev);
2577
2578static int hid_uevent(struct device *dev, struct kobj_uevent_env *env)
2579{
2580        struct hid_device *hdev = to_hid_device(dev);
2581
2582        if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X",
2583                        hdev->bus, hdev->vendor, hdev->product))
2584                return -ENOMEM;
2585
2586        if (add_uevent_var(env, "HID_NAME=%s", hdev->name))
2587                return -ENOMEM;
2588
2589        if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys))
2590                return -ENOMEM;
2591
2592        if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq))
2593                return -ENOMEM;
2594
2595        if (add_uevent_var(env, "MODALIAS=hid:b%04Xg%04Xv%08Xp%08X",
2596                           hdev->bus, hdev->group, hdev->vendor, hdev->product))
2597                return -ENOMEM;
2598
2599        return 0;
2600}
2601
2602static struct bus_type hid_bus_type = {
2603        .name           = "hid",
2604        .dev_groups     = hid_dev_groups,
2605        .drv_groups     = hid_drv_groups,
2606        .match          = hid_bus_match,
2607        .probe          = hid_device_probe,
2608        .remove         = hid_device_remove,
2609        .uevent         = hid_uevent,
2610};
2611
2612/* a list of devices that shouldn't be handled by HID core at all */
2613static const struct hid_device_id hid_ignore_list[] = {
2614        { HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_FLAIR) },
2615        { HID_USB_DEVICE(USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_302) },
2616        { HID_USB_DEVICE(USB_VENDOR_ID_ADS_TECH, USB_DEVICE_ID_ADS_TECH_RADIO_SI470X) },
2617        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_01) },
2618        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_10) },
2619        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_20) },
2620        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_21) },
2621        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_22) },
2622        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_23) },
2623        { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_24) },
2624        { HID_USB_DEVICE(USB_VENDOR_ID_AIRCABLE, USB_DEVICE_ID_AIRCABLE1) },
2625        { HID_USB_DEVICE(USB_VENDOR_ID_ALCOR, USB_DEVICE_ID_ALCOR_USBRS232) },
2626        { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM)},
2627        { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM2)},
2628        { HID_USB_DEVICE(USB_VENDOR_ID_AVERMEDIA, USB_DEVICE_ID_AVER_FM_MR800) },
2629        { HID_USB_DEVICE(USB_VENDOR_ID_AXENTIA, USB_DEVICE_ID_AXENTIA_FM_RADIO) },
2630        { HID_USB_DEVICE(USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD) },
2631        { HID_USB_DEVICE(USB_VENDOR_ID_CIDC, 0x0103) },
2632        { HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI470X) },
2633        { HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL, USB_DEVICE_ID_CYGNAL_RADIO_SI4713) },
2634        { HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM109) },
2635        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM) },
2636        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_ULTRAMOUSE) },
2637        { HID_USB_DEVICE(USB_VENDOR_ID_DEALEXTREAME, USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701) },
2638        { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE) },
2639        { HID_USB_DEVICE(USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20) },
2640        { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, 0x0400) },
2641        { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, 0x0401) },
2642        { HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },
2643        { HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC5UH) },
2644        { HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC4UM) },
2645        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0001) },
2646        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0002) },
2647        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0004) },
2648        { HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_SUPER_Q2) },
2649        { HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_GOGOPEN) },
2650        { HID_USB_DEVICE(USB_VENDOR_ID_GOTOP, USB_DEVICE_ID_PENPOWER) },
2651        { HID_USB_DEVICE(USB_VENDOR_ID_GRETAGMACBETH, USB_DEVICE_ID_GRETAGMACBETH_HUEY) },
2652        { HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE) },
2653        { HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB) },
2654        { HID_USB_DEVICE(USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_RADIOSHARK) },
2655        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_90) },
2656        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_100) },
2657        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_101) },
2658        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_103) },
2659        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_104) },
2660        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_105) },
2661        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_106) },
2662        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_107) },
2663        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_108) },
2664        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_200) },
2665        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_201) },
2666        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_202) },
2667        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_203) },
2668        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_204) },
2669        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_205) },
2670        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_206) },
2671        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_207) },
2672        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_300) },
2673        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_301) },
2674        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_302) },
2675        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_303) },
2676        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_304) },
2677        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_305) },
2678        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_306) },
2679        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_307) },
2680        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_308) },
2681        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_309) },
2682        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_400) },
2683        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_401) },
2684        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_402) },
2685        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_403) },
2686        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_404) },
2687        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_405) },
2688        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_500) },
2689        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_501) },
2690        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502) },
2691        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503) },
2692        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504) },
2693        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000) },
2694        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001) },
2695        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002) },
2696        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1003) },
2697        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004) },
2698        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005) },
2699        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006) },
2700        { HID_USB_DEVICE(USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1007) },
2701        { HID_USB_DEVICE(USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA) },
2702        { HID_USB_DEVICE(USB_VENDOR_ID_JABRA, USB_DEVICE_ID_JABRA_SPEAK_410) },
2703        { HID_USB_DEVICE(USB_VENDOR_ID_JABRA, USB_DEVICE_ID_JABRA_SPEAK_510) },
2704        { HID_USB_DEVICE(USB_VENDOR_ID_JABRA, USB_DEVICE_ID_JABRA_GN9350E) },
2705        { HID_USB_DEVICE(USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO) },
2706        { HID_USB_DEVICE(USB_VENDOR_ID_KWORLD, USB_DEVICE_ID_KWORLD_RADIO_FM700) },
2707        { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_GPEN_560) },
2708        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_KYE, 0x0058) },
2709        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY) },
2710        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY2) },
2711        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY) },
2712        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY2) },
2713        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY) },
2714        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY2) },
2715        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYVOLTAGE) },
2716        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYCURRENT) },
2717        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTIME) },
2718        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYTEMPERATURE) },
2719        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MICROCASSYPH) },
2720        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM) },
2721        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP) },
2722        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP) },
2723        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIC) },
2724        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIB) },
2725        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY) },
2726        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2) },
2727        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM) },
2728        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOTOR) },
2729        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB) },
2730        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT) },
2731        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER) },
2732        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL) },
2733        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST) },
2734        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER) },
2735        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOSTANALYSER2) },
2736        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_ABSESP) },
2737        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_AUTODATABUS) },
2738        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },
2739        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },
2740        { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },
2741        { HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_BEATPAD) },
2742        { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS) },
2743        { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS) },
2744        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1) },
2745        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT2) },
2746        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICK16F1454) },
2747        { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICK16F1454_V2) },
2748        { HID_USB_DEVICE(USB_VENDOR_ID_NATIONAL_SEMICONDUCTOR, USB_DEVICE_ID_N_S_HARMONY) },
2749        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100) },
2750        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 20) },
2751        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 30) },
2752        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 100) },
2753        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 108) },
2754        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 118) },
2755        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 200) },
2756        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 300) },
2757        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 400) },
2758        { HID_USB_DEVICE(USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 500) },
2759        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0001) },
2760        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0002) },
2761        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0003) },
2762        { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0004) },
2763        { HID_USB_DEVICE(USB_VENDOR_ID_PETZL, USB_DEVICE_ID_PETZL_HEADLAMP) },
2764        { HID_USB_DEVICE(USB_VENDOR_ID_PHILIPS, USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE) },
2765        { HID_USB_DEVICE(USB_VENDOR_ID_POWERCOM, USB_DEVICE_ID_POWERCOM_UPS) },
2766#if IS_ENABLED(CONFIG_MOUSE_SYNAPTICS_USB)
2767        { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_TP) },
2768        { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_INT_TP) },
2769        { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_CPAD) },
2770        { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_STICK) },
2771        { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_WP) },
2772        { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_COMP_TP) },
2773        { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_WTP) },
2774        { HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_DPAD) },
2775#endif
2776        { HID_USB_DEVICE(USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K) },
2777        { }
2778};
2779
2780/**
2781 * hid_mouse_ignore_list - mouse devices which should not be handled by the hid layer
2782 *
2783 * There are composite devices for which we want to ignore only a certain
2784 * interface. This is a list of devices for which only the mouse interface will
2785 * be ignored. This allows a dedicated driver to take care of the interface.
2786 */
2787static const struct hid_device_id hid_mouse_ignore_list[] = {
2788        /* appletouch driver */
2789        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },
2790        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },
2791        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },
2792        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO) },
2793        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS) },
2794        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI) },
2795        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO) },
2796        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS) },
2797        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI) },
2798        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO) },
2799        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS) },
2800        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI) },
2801        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO) },
2802        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS) },
2803        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI) },
2804        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO) },
2805        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS) },
2806        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI) },
2807        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO) },
2808        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS) },
2809        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI) },
2810        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO) },
2811        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS) },
2812        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI) },
2813        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO) },
2814        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS) },
2815        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI) },
2816        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO) },
2817        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS) },
2818        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },
2819        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },
2820        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },
2821        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI) },
2822        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO) },
2823        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS) },
2824        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI) },
2825        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO) },
2826        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS) },
2827        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
2828        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
2829        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
2830        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
2831        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
2832        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
2833        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI) },
2834        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO) },
2835        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS) },
2836        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI) },
2837        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ISO) },
2838        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_JIS) },
2839        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ANSI) },
2840        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ISO) },
2841        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_JIS) },
2842        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
2843        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
2844        { }
2845};
2846
2847bool hid_ignore(struct hid_device *hdev)
2848{
2849        if (hdev->quirks & HID_QUIRK_NO_IGNORE)
2850                return false;
2851        if (hdev->quirks & HID_QUIRK_IGNORE)
2852                return true;
2853
2854        switch (hdev->vendor) {
2855        case USB_VENDOR_ID_CODEMERCS:
2856                /* ignore all Code Mercenaries IOWarrior devices */
2857                if (hdev->product >= USB_DEVICE_ID_CODEMERCS_IOW_FIRST &&
2858                                hdev->product <= USB_DEVICE_ID_CODEMERCS_IOW_LAST)
2859                        return true;
2860                break;
2861        case USB_VENDOR_ID_LOGITECH:
2862                if (hdev->product >= USB_DEVICE_ID_LOGITECH_HARMONY_FIRST &&
2863                                hdev->product <= USB_DEVICE_ID_LOGITECH_HARMONY_LAST)
2864                        return true;
2865                /*
2866                 * The Keene FM transmitter USB device has the same USB ID as
2867                 * the Logitech AudioHub Speaker, but it should ignore the hid.
2868                 * Check if the name is that of the Keene device.
2869                 * For reference: the name of the AudioHub is
2870                 * "HOLTEK  AudioHub Speaker".
2871                 */
2872                if (hdev->product == USB_DEVICE_ID_LOGITECH_AUDIOHUB &&
2873                        !strcmp(hdev->name, "HOLTEK  B-LINK USB Audio  "))
2874                                return true;
2875                break;
2876        case USB_VENDOR_ID_SOUNDGRAPH:
2877                if (hdev->product >= USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST &&
2878                    hdev->product <= USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST)
2879                        return true;
2880                break;
2881        case USB_VENDOR_ID_HANWANG:
2882                if (hdev->product >= USB_DEVICE_ID_HANWANG_TABLET_FIRST &&
2883                    hdev->product <= USB_DEVICE_ID_HANWANG_TABLET_LAST)
2884                        return true;
2885                break;
2886        case USB_VENDOR_ID_JESS:
2887                if (hdev->product == USB_DEVICE_ID_JESS_YUREX &&
2888                                hdev->type == HID_TYPE_USBNONE)
2889                        return true;
2890                break;
2891        case USB_VENDOR_ID_VELLEMAN:
2892                /* These are not HID devices.  They are handled by comedi. */
2893                if ((hdev->product >= USB_DEVICE_ID_VELLEMAN_K8055_FIRST &&
2894                     hdev->product <= USB_DEVICE_ID_VELLEMAN_K8055_LAST) ||
2895                    (hdev->product >= USB_DEVICE_ID_VELLEMAN_K8061_FIRST &&
2896                     hdev->product <= USB_DEVICE_ID_VELLEMAN_K8061_LAST))
2897                        return true;
2898                break;
2899        case USB_VENDOR_ID_ATMEL_V_USB:
2900                /* Masterkit MA901 usb radio based on Atmel tiny85 chip and
2901                 * it has the same USB ID as many Atmel V-USB devices. This
2902                 * usb radio is handled by radio-ma901.c driver so we want
2903                 * ignore the hid. Check the name, bus, product and ignore
2904                 * if we have MA901 usb radio.
2905                 */
2906                if (hdev->product == USB_DEVICE_ID_ATMEL_V_USB &&
2907                        hdev->bus == BUS_USB &&
2908                        strncmp(hdev->name, "www.masterkit.ru MA901", 22) == 0)
2909                        return true;
2910                break;
2911        }
2912
2913        if (hdev->type == HID_TYPE_USBMOUSE &&
2914                        hid_match_id(hdev, hid_mouse_ignore_list))
2915                return true;
2916
2917        return !!hid_match_id(hdev, hid_ignore_list);
2918}
2919EXPORT_SYMBOL_GPL(hid_ignore);
2920
2921int hid_add_device(struct hid_device *hdev)
2922{
2923        static atomic_t id = ATOMIC_INIT(0);
2924        int ret;
2925
2926        if (WARN_ON(hdev->status & HID_STAT_ADDED))
2927                return -EBUSY;
2928
2929        /* we need to kill them here, otherwise they will stay allocated to
2930         * wait for coming driver */
2931        if (hid_ignore(hdev))
2932                return -ENODEV;
2933
2934        /*
2935         * Check for the mandatory transport channel.
2936         */
2937         if (!hdev->ll_driver->raw_request) {
2938                hid_err(hdev, "transport driver missing .raw_request()\n");
2939                return -EINVAL;
2940         }
2941
2942        /*
2943         * Read the device report descriptor once and use as template
2944         * for the driver-specific modifications.
2945         */
2946        ret = hdev->ll_driver->parse(hdev);
2947        if (ret)
2948                return ret;
2949        if (!hdev->dev_rdesc)
2950                return -ENODEV;
2951
2952        /*
2953         * Scan generic devices for group information
2954         */
2955        if (hid_ignore_special_drivers) {
2956                hdev->group = HID_GROUP_GENERIC;
2957        } else if (!hdev->group &&
2958                   !hid_match_id(hdev, hid_have_special_driver)) {
2959                ret = hid_scan_report(hdev);
2960                if (ret)
2961                        hid_warn(hdev, "bad device descriptor (%d)\n", ret);
2962        }
2963
2964        /* XXX hack, any other cleaner solution after the driver core
2965         * is converted to allow more than 20 bytes as the device name? */
2966        dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,
2967                     hdev->vendor, hdev->product, atomic_inc_return(&id));
2968
2969        hid_debug_register(hdev, dev_name(&hdev->dev));
2970        ret = device_add(&hdev->dev);
2971        if (!ret)
2972                hdev->status |= HID_STAT_ADDED;
2973        else
2974                hid_debug_unregister(hdev);
2975
2976        return ret;
2977}
2978EXPORT_SYMBOL_GPL(hid_add_device);
2979
2980/**
2981 * hid_allocate_device - allocate new hid device descriptor
2982 *
2983 * Allocate and initialize hid device, so that hid_destroy_device might be
2984 * used to free it.
2985 *
2986 * New hid_device pointer is returned on success, otherwise ERR_PTR encoded
2987 * error value.
2988 */
2989struct hid_device *hid_allocate_device(void)
2990{
2991        struct hid_device *hdev;
2992        int ret = -ENOMEM;
2993
2994        hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
2995        if (hdev == NULL)
2996                return ERR_PTR(ret);
2997
2998        device_initialize(&hdev->dev);
2999        hdev->dev.release = hid_device_release;
3000        hdev->dev.bus = &hid_bus_type;

3001        device_enable_async_suspend(&hdev->dev);
3002
3003        hid_close_report(hdev);
3004
3005        init_waitqueue_head(&hdev->debug_wait);
3006        INIT_LIST_HEAD(&hdev->debug_list);
3007        spin_lock_init(&hdev->debug_list_lock);
3008        sema_init(&hdev->driver_input_lock, 1);
3009        mutex_init(&hdev->ll_open_lock);
3010
3011        return hdev;
3012}
3013EXPORT_SYMBOL_GPL(hid_allocate_device);
3014
3015static void hid_remove_device(struct hid_device *hdev)
3016{
3017        if (hdev->status & HID_STAT_ADDED) {
3018                device_del(&hdev->dev);
3019                hid_debug_unregister(hdev);
3020                hdev->status &= ~HID_STAT_ADDED;
3021        }
3022        kfree(hdev->dev_rdesc);
3023        hdev->dev_rdesc = NULL;
3024        hdev->dev_rsize = 0;
3025}
3026
3027/**
3028 * hid_destroy_device - free previously allocated device
3029 *
3030 * @hdev: hid device
3031 *
3032 * If you allocate hid_device through hid_allocate_device, you should ever
3033 * free by this function.
3034 */
3035void hid_destroy_device(struct hid_device *hdev)
3036{
3037        hid_remove_device(hdev);
3038        put_device(&hdev->dev);
3039}
3040EXPORT_SYMBOL_GPL(hid_destroy_device);
3041
3042int __hid_register_driver(struct hid_driver *hdrv, struct module *owner,
3043                const char *mod_name)
3044{
3045        hdrv->driver.name = hdrv->name;
3046        hdrv->driver.bus = &hid_bus_type;
3047        hdrv->driver.owner = owner;
3048        hdrv->driver.mod_name = mod_name;
3049
3050        INIT_LIST_HEAD(&hdrv->dyn_list);
3051        spin_lock_init(&hdrv->dyn_lock);
3052
3053        return driver_register(&hdrv->driver);
3054}
3055EXPORT_SYMBOL_GPL(__hid_register_driver);
3056
3057void hid_unregister_driver(struct hid_driver *hdrv)
3058{
3059        driver_unregister(&hdrv->driver);
3060        hid_free_dynids(hdrv);
3061}
3062EXPORT_SYMBOL_GPL(hid_unregister_driver);
3063
3064int hid_check_keys_pressed(struct hid_device *hid)
3065{
3066        struct hid_input *hidinput;
3067        int i;
3068
3069        if (!(hid->claimed & HID_CLAIMED_INPUT))
3070                return 0;
3071
3072        list_for_each_entry(hidinput, &hid->inputs, list) {
3073                for (i = 0; i < BITS_TO_LONGS(KEY_MAX); i++)
3074                        if (hidinput->input->key[i])
3075                                return 1;
3076        }
3077
3078        return 0;
3079}
3080
3081EXPORT_SYMBOL_GPL(hid_check_keys_pressed);
3082
3083static int __init hid_init(void)
3084{
3085        int ret;
3086
3087        if (hid_debug)
3088                pr_warn("hid_debug is now used solely for parser and driver debugging.\n"
3089                        "debugfs is now used for inspecting the device (report descriptor, reports)\n");
3090
3091        ret = bus_register(&hid_bus_type);
3092        if (ret) {
3093                pr_err("can't register hid bus\n");
3094                goto err;
3095        }
3096
3097        ret = hidraw_init();
3098        if (ret)
3099                goto err_bus;
3100
3101        hid_debug_init();
3102
3103        return 0;
3104err_bus:
3105        bus_unregister(&hid_bus_type);
3106err:
3107        return ret;
3108}
3109
3110static void __exit hid_exit(void)
3111{
3112        hid_debug_exit();
3113        hidraw_exit();
3114        bus_unregister(&hid_bus_type);
3115}
3116
3117module_init(hid_init);
3118module_exit(hid_exit);
3119
3120MODULE_AUTHOR("Andreas Gal");
3121MODULE_AUTHOR("Vojtech Pavlik");
3122MODULE_AUTHOR("Jiri Kosina");
3123MODULE_LICENSE("GPL");
3124
3125