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
  47 int hid_debug = 0;
  48 module_param_named(debug, hid_debug, int, 0600);
  49 MODULE_PARM_DESC(debug, "toggle HID debugging messages");
  50 EXPORT_SYMBOL_GPL(hid_debug);
  51
  52 static int hid_ignore_special_drivers = 0;
  53 module_param_named(ignore_special_drivers, hid_ignore_special_drivers, int, 0600);
  54 MODULE_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
  60 struct hid_report *hid_register_report(struct hid_device *device,
  61                                        unsigned int type, unsigned int id,
  62                                        unsigned int application)
  63 {
  64         struct hid_report_enum *report_enum = device->report_enum + type;
  65         struct hid_report *report;
  66
  67         if (id >= HID_MAX_IDS)
  68                 return NULL;
  69         if (report_enum->report_id_hash[id])
  70                 return report_enum->report_id_hash[id];
  71
  72         report = kzalloc(sizeof(struct hid_report), GFP_KERNEL);
  73         if (!report)
  74                 return NULL;
  75
  76         if (id != 0)
  77                 report_enum->numbered = 1;
  78
  79         report->id = id;
  80         report->type = type;
  81         report->size = 0;
  82         report->device = device;
  83         report->application = application;
  84         report_enum->report_id_hash[id] = report;
  85
  86         list_add_tail(&report->list, &report_enum->report_list);
  87
  88         return report;
  89 }
  90 EXPORT_SYMBOL_GPL(hid_register_report);
  91
  92 /*
  93  * Register a new field for this report.
  94  */
  95
  96 static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages)
  97 {
  98         struct hid_field *field;
  99
 100         if (report->maxfield == HID_MAX_FIELDS) {
 101                 hid_err(report->device, "too many fields in report\n");
 102                 return NULL;
 103         }
 104
 105         field = kzalloc((sizeof(struct hid_field) +
 106                          usages * sizeof(struct hid_usage) +
 107                          usages * sizeof(unsigned)), GFP_KERNEL);
 108         if (!field)
 109                 return NULL;
 110
 111         field->index = report->maxfield++;
 112         report->field[field->index] = field;
 113         field->usage = (struct hid_usage *)(field + 1);
 114         field->value = (s32 *)(field->usage + usages);
 115         field->report = report;
 116
 117         return field;
 118 }
 119
 120 /*
 121  * Open a collection. The type/usage is pushed on the stack.
 122  */
 123
 124 static int open_collection(struct hid_parser *parser, unsigned type)
 125 {
 126         struct hid_collection *collection;
 127         unsigned usage;
 128
 129         usage = parser->local.usage[0];
 130
 131         if (parser->collection_stack_ptr == parser->collection_stack_size) {
 132                 unsigned int *collection_stack;
 133                 unsigned int new_size = parser->collection_stack_size +
 134                                         HID_COLLECTION_STACK_SIZE;
 135
 136                 collection_stack = krealloc(parser->collection_stack,
 137                                             new_size * sizeof(unsigned int),
 138                                             GFP_KERNEL);
 139                 if (!collection_stack)
 140                         return -ENOMEM;
 141
 142                 parser->collection_stack = collection_stack;
 143                 parser->collection_stack_size = new_size;
 144         }
 145
 146         if (parser->device->maxcollection == parser->device->collection_size) {
 147                 collection = kmalloc(
 148                                 array3_size(sizeof(struct hid_collection),
 149                                             parser->device->collection_size,
 150                                             2),
 151                                 GFP_KERNEL);
 152                 if (collection == NULL) {
 153                         hid_err(parser->device, "failed to reallocate collection array\n");
 154                         return -ENOMEM;
 155                 }
 156                 memcpy(collection, parser->device->collection,
 157                         sizeof(struct hid_collection) *
 158                         parser->device->collection_size);
 159                 memset(collection + parser->device->collection_size, 0,
 160                         sizeof(struct hid_collection) *
 161                         parser->device->collection_size);
 162                 kfree(parser->device->collection);
 163                 parser->device->collection = collection;
 164                 parser->device->collection_size *= 2;
 165         }
 166
 167         parser->collection_stack[parser->collection_stack_ptr++] =
 168                 parser->device->maxcollection;
 169
 170         collection = parser->device->collection +
 171                 parser->device->maxcollection++;
 172         collection->type = type;
 173         collection->usage = usage;
 174         collection->level = parser->collection_stack_ptr - 1;
 175
 176         if (type == HID_COLLECTION_APPLICATION)
 177                 parser->device->maxapplication++;
 178
 179         return 0;
 180 }
 181
 182 /*
 183  * Close a collection.
 184  */
 185
 186 static int close_collection(struct hid_parser *parser)
 187 {
 188         if (!parser->collection_stack_ptr) {
 189                 hid_err(parser->device, "collection stack underflow\n");
 190                 return -EINVAL;
 191         }
 192         parser->collection_stack_ptr--;
 193         return 0;
 194 }
 195
 196 /*
 197  * Climb up the stack, search for the specified collection type
 198  * and return the usage.
 199  */
 200
 201 static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
 202 {
 203         struct hid_collection *collection = parser->device->collection;
 204         int n;
 205
 206         for (n = parser->collection_stack_ptr - 1; n >= 0; n--) {
 207                 unsigned index = parser->collection_stack[n];
 208                 if (collection[index].type == type)
 209                         return collection[index].usage;
 210         }
 211         return 0; /* we know nothing about this usage type */
 212 }
 213
 214 /*
 215  * Concatenate usage which defines 16 bits or less with the
 216  * currently defined usage page to form a 32 bit usage
 217  */
 218
 219 static void complete_usage(struct hid_parser *parser, unsigned int index)
 220 {
 221         parser->local.usage[index] &= 0xFFFF;
 222         parser->local.usage[index] |=
 223                 (parser->global.usage_page & 0xFFFF) << 16;
 224 }
 225
 226 /*
 227  * Add a usage to the temporary parser table.
 228  */
 229
 230 static int hid_add_usage(struct hid_parser *parser, unsigned usage, u8 size)
 231 {
 232         if (parser->local.usage_index >= HID_MAX_USAGES) {
 233                 hid_err(parser->device, "usage index exceeded\n");
 234                 return -1;
 235         }
 236         parser->local.usage[parser->local.usage_index] = usage;
 237
 238         /*
 239          * If Usage item only includes usage id, concatenate it with
 240          * currently defined usage page
 241          */
 242         if (size <= 2)
 243                 complete_usage(parser, parser->local.usage_index);
 244
 245         parser->local.usage_size[parser->local.usage_index] = size;
 246         parser->local.collection_index[parser->local.usage_index] =
 247                 parser->collection_stack_ptr ?
 248                 parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
 249         parser->local.usage_index++;
 250         return 0;
 251 }
 252
 253 /*
 254  * Register a new field for this report.
 255  */
 256
 257 static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)
 258 {
 259         struct hid_report *report;
 260         struct hid_field *field;
 261         unsigned int max_buffer_size = HID_MAX_BUFFER_SIZE;
 262         unsigned int usages;
 263         unsigned int offset;
 264         unsigned int i;
 265         unsigned int application;
 266
 267         application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);
 268
 269         report = hid_register_report(parser->device, report_type,
 270                                      parser->global.report_id, application);
 271         if (!report) {
 272                 hid_err(parser->device, "hid_register_report failed\n");
 273                 return -1;
 274         }
 275
 276         /* Handle both signed and unsigned cases properly */
 277         if ((parser->global.logical_minimum < 0 &&
 278                 parser->global.logical_maximum <
 279                 parser->global.logical_minimum) ||
 280                 (parser->global.logical_minimum >= 0 &&
 281                 (__u32)parser->global.logical_maximum <
 282                 (__u32)parser->global.logical_minimum)) {
 283                 dbg_hid("logical range invalid 0x%x 0x%x\n",
 284                         parser->global.logical_minimum,
 285                         parser->global.logical_maximum);
 286                 return -1;
 287         }
 288
 289         offset = report->size;
 290         report->size += parser->global.report_size * parser->global.report_count;
 291
 292         if (parser->device->ll_driver->max_buffer_size)
 293                 max_buffer_size = parser->device->ll_driver->max_buffer_size;
 294
 295         /* Total size check: Allow for possible report index byte */
 296         if (report->size > (max_buffer_size - 1) << 3) {
 297                 hid_err(parser->device, "report is too long\n");
 298                 return -1;
 299         }
 300
 301         if (!parser->local.usage_index) /* Ignore padding fields */
 302                 return 0;
 303
 304         usages = max_t(unsigned, parser->local.usage_index,
 305                                  parser->global.report_count);
 306
 307         field = hid_register_field(report, usages);
 308         if (!field)
 309                 return 0;
 310
 311         field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);
 312         field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);
 313         field->application = application;
 314
 315         for (i = 0; i < usages; i++) {
 316                 unsigned j = i;
 317                 /* Duplicate the last usage we parsed if we have excess values */
 318                 if (i >= parser->local.usage_index)
 319                         j = parser->local.usage_index - 1;
 320                 field->usage[i].hid = parser->local.usage[j];
 321                 field->usage[i].collection_index =
 322                         parser->local.collection_index[j];
 323                 field->usage[i].usage_index = i;
 324         }
 325
 326         field->maxusage = usages;
 327         field->flags = flags;
 328         field->report_offset = offset;
 329         field->report_type = report_type;
 330         field->report_size = parser->global.report_size;
 331         field->report_count = parser->global.report_count;
 332         field->logical_minimum = parser->global.logical_minimum;
 333         field->logical_maximum = parser->global.logical_maximum;
 334         field->physical_minimum = parser->global.physical_minimum;
 335         field->physical_maximum = parser->global.physical_maximum;
 336         field->unit_exponent = parser->global.unit_exponent;
 337         field->unit = parser->global.unit;
 338
 339         return 0;
 340 }
 341
 342 /*
 343  * Read data value from item.
 344  */
 345
 346 static u32 item_udata(struct hid_item *item)
 347 {
 348         switch (item->size) {
 349         case 1: return item->data.u8;
 350         case 2: return item->data.u16;
 351         case 4: return item->data.u32;
 352         }
 353         return 0;
 354 }
 355
 356 static s32 item_sdata(struct hid_item *item)
 357 {
 358         switch (item->size) {
 359         case 1: return item->data.s8;
 360         case 2: return item->data.s16;
 361         case 4: return item->data.s32;
 362         }
 363         return 0;
 364 }
 365
 366 /*
 367  * Process a global item.
 368  */
 369
 370 static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
 371 {
 372         __s32 raw_value;
 373         switch (item->tag) {
 374         case HID_GLOBAL_ITEM_TAG_PUSH:
 375
 376                 if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
 377                         hid_err(parser->device, "global environment stack overflow\n");
 378                         return -1;
 379                 }
 380
 381                 memcpy(parser->global_stack + parser->global_stack_ptr++,
 382                         &parser->global, sizeof(struct hid_global));
 383                 return 0;
 384
 385         case HID_GLOBAL_ITEM_TAG_POP:
 386
 387                 if (!parser->global_stack_ptr) {
 388                         hid_err(parser->device, "global environment stack underflow\n");
 389                         return -1;
 390                 }
 391
 392                 memcpy(&parser->global, parser->global_stack +
 393                         --parser->global_stack_ptr, sizeof(struct hid_global));
 394                 return 0;
 395
 396         case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
 397                 parser->global.usage_page = item_udata(item);
 398                 return 0;
 399
 400         case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
 401                 parser->global.logical_minimum = item_sdata(item);
 402                 return 0;
 403
 404         case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
 405                 if (parser->global.logical_minimum < 0)
 406                         parser->global.logical_maximum = item_sdata(item);
 407                 else
 408                         parser->global.logical_maximum = item_udata(item);
 409                 return 0;
 410
 411         case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
 412                 parser->global.physical_minimum = item_sdata(item);
 413                 return 0;
 414
 415         case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
 416                 if (parser->global.physical_minimum < 0)
 417                         parser->global.physical_maximum = item_sdata(item);
 418                 else
 419                         parser->global.physical_maximum = item_udata(item);
 420                 return 0;
 421
 422         case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
 423                 /* Many devices provide unit exponent as a two's complement
 424                  * nibble due to the common misunderstanding of HID
 425                  * specification 1.11, 6.2.2.7 Global Items. Attempt to handle
 426                  * both this and the standard encoding. */
 427                 raw_value = item_sdata(item);
 428                 if (!(raw_value & 0xfffffff0))
 429                         parser->global.unit_exponent = hid_snto32(raw_value, 4);
 430                 else
 431                         parser->global.unit_exponent = raw_value;
 432                 return 0;
 433
 434         case HID_GLOBAL_ITEM_TAG_UNIT:
 435                 parser->global.unit = item_udata(item);
 436                 return 0;
 437
 438         case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
 439                 parser->global.report_size = item_udata(item);
 440                 if (parser->global.report_size > 128) {
 441                         hid_err(parser->device, "invalid report_size %d\n",
 442                                         parser->global.report_size);
 443                         return -1;
 444                 }
 445                 return 0;
 446
 447         case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
 448                 parser->global.report_count = item_udata(item);
 449                 if (parser->global.report_count > HID_MAX_USAGES) {
 450                         hid_err(parser->device, "invalid report_count %d\n",
 451                                         parser->global.report_count);
 452                         return -1;
 453                 }
 454                 return 0;
 455
 456         case HID_GLOBAL_ITEM_TAG_REPORT_ID:
 457                 parser->global.report_id = item_udata(item);
 458                 if (parser->global.report_id == 0 ||
 459                     parser->global.report_id >= HID_MAX_IDS) {
 460                         hid_err(parser->device, "report_id %u is invalid\n",
 461                                 parser->global.report_id);
 462                         return -1;
 463                 }
 464                 return 0;
 465
 466         default:
 467                 hid_err(parser->device, "unknown global tag 0x%x\n", item->tag);
 468                 return -1;
 469         }
 470 }
 471
 472 /*
 473  * Process a local item.
 474  */
 475
 476 static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
 477 {
 478         __u32 data;
 479         unsigned n;
 480         __u32 count;
 481
 482         data = item_udata(item);
 483
 484         switch (item->tag) {
 485         case HID_LOCAL_ITEM_TAG_DELIMITER:
 486
 487                 if (data) {
 488                         /*
 489                          * We treat items before the first delimiter
 490                          * as global to all usage sets (branch 0).
 491                          * In the moment we process only these global
 492                          * items and the first delimiter set.
 493                          */
 494                         if (parser->local.delimiter_depth != 0) {
 495                                 hid_err(parser->device, "nested delimiters\n");
 496                                 return -1;
 497                         }
 498                         parser->local.delimiter_depth++;
 499                         parser->local.delimiter_branch++;
 500                 } else {
 501                         if (parser->local.delimiter_depth < 1) {
 502                                 hid_err(parser->device, "bogus close delimiter\n");
 503                                 return -1;
 504                         }
 505                         parser->local.delimiter_depth--;
 506                 }
 507                 return 0;
 508
 509         case HID_LOCAL_ITEM_TAG_USAGE:
 510
 511                 if (parser->local.delimiter_branch > 1) {
 512                         dbg_hid("alternative usage ignored\n");
 513                         return 0;
 514                 }
 515
 516                 return hid_add_usage(parser, data, item->size);
 517
 518         case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 519
 520                 if (parser->local.delimiter_branch > 1) {
 521                         dbg_hid("alternative usage ignored\n");
 522                         return 0;
 523                 }
 524
 525                 parser->local.usage_minimum = data;
 526                 return 0;
 527
 528         case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 529
 530                 if (parser->local.delimiter_branch > 1) {
 531                         dbg_hid("alternative usage ignored\n");
 532                         return 0;
 533                 }
 534
 535                 count = data - parser->local.usage_minimum;
 536                 if (count + parser->local.usage_index >= HID_MAX_USAGES) {
 537                         /*
 538                          * We do not warn if the name is not set, we are
 539                          * actually pre-scanning the device.
 540                          */
 541                         if (dev_name(&parser->device->dev))
 542                                 hid_warn(parser->device,
 543                                          "ignoring exceeding usage max\n");
 544                         data = HID_MAX_USAGES - parser->local.usage_index +
 545                                 parser->local.usage_minimum - 1;
 546                         if (data <= 0) {
 547                                 hid_err(parser->device,
 548                                         "no more usage index available\n");
 549                                 return -1;
 550                         }
 551                 }
 552
 553                 for (n = parser->local.usage_minimum; n <= data; n++)
 554                         if (hid_add_usage(parser, n, item->size)) {
 555                                 dbg_hid("hid_add_usage failed\n");
 556                                 return -1;
 557                         }
 558                 return 0;
 559
 560         default:
 561
 562                 dbg_hid("unknown local item tag 0x%x\n", item->tag);
 563                 return 0;
 564         }
 565         return 0;
 566 }
 567
 568 /*
 569  * Concatenate Usage Pages into Usages where relevant:
 570  * As per specification, 6.2.2.8: "When the parser encounters a main item it
 571  * concatenates the last declared Usage Page with a Usage to form a complete
 572  * usage value."
 573  */
 574
 575 static void hid_concatenate_last_usage_page(struct hid_parser *parser)
 576 {
 577         int i;
 578         unsigned int usage_page;
 579         unsigned int current_page;
 580
 581         if (!parser->local.usage_index)
 582                 return;
 583
 584         usage_page = parser->global.usage_page;
 585
 586         /*
 587          * Concatenate usage page again only if last declared Usage Page
 588          * has not been already used in previous usages concatenation
 589          */
 590         for (i = parser->local.usage_index - 1; i >= 0; i--) {
 591                 if (parser->local.usage_size[i] > 2)
 592                         /* Ignore extended usages */
 593                         continue;
 594
 595                 current_page = parser->local.usage[i] >> 16;
 596                 if (current_page == usage_page)
 597                         break;
 598
 599                 complete_usage(parser, i);
 600         }
 601 }
 602
 603 /*
 604  * Process a main item.
 605  */
 606
 607 static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
 608 {
 609         __u32 data;
 610         int ret;
 611
 612         hid_concatenate_last_usage_page(parser);
 613
 614         data = item_udata(item);
 615
 616         switch (item->tag) {
 617         case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
 618                 ret = open_collection(parser, data & 0xff);
 619                 break;
 620         case HID_MAIN_ITEM_TAG_END_COLLECTION:
 621                 ret = close_collection(parser);
 622                 break;
 623         case HID_MAIN_ITEM_TAG_INPUT:
 624                 ret = hid_add_field(parser, HID_INPUT_REPORT, data);
 625                 break;
 626         case HID_MAIN_ITEM_TAG_OUTPUT:
 627                 ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
 628                 break;
 629         case HID_MAIN_ITEM_TAG_FEATURE:
 630                 ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
 631                 break;
 632         default:
 633                 hid_warn(parser->device, "unknown main item tag 0x%x\n", item->tag);
 634                 ret = 0;
 635         }
 636
 637         memset(&parser->local, 0, sizeof(parser->local));       /* Reset the local parser environment */
 638
 639         return ret;
 640 }
 641
 642 /*
 643  * Process a reserved item.
 644  */
 645
 646 static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)
 647 {
 648         dbg_hid("reserved item type, tag 0x%x\n", item->tag);
 649         return 0;
 650 }
 651
 652 /*
 653  * Free a report and all registered fields. The field->usage and
 654  * field->value table's are allocated behind the field, so we need
 655  * only to free(field) itself.
 656  */
 657
 658 static void hid_free_report(struct hid_report *report)
 659 {
 660         unsigned n;
 661
 662         for (n = 0; n < report->maxfield; n++)
 663                 kfree(report->field[n]);
 664         kfree(report);
 665 }
 666
 667 /*
 668  * Close report. This function returns the device
 669  * state to the point prior to hid_open_report().
 670  */
 671 static void hid_close_report(struct hid_device *device)
 672 {
 673         unsigned i, j;
 674
 675         for (i = 0; i < HID_REPORT_TYPES; i++) {
 676                 struct hid_report_enum *report_enum = device->report_enum + i;
 677
 678                 for (j = 0; j < HID_MAX_IDS; j++) {
 679                         struct hid_report *report = report_enum->report_id_hash[j];
 680                         if (report)
 681                                 hid_free_report(report);
 682                 }
 683                 memset(report_enum, 0, sizeof(*report_enum));
 684                 INIT_LIST_HEAD(&report_enum->report_list);
 685         }
 686
 687         kfree(device->rdesc);
 688         device->rdesc = NULL;
 689         device->rsize = 0;
 690
 691         kfree(device->collection);
 692         device->collection = NULL;
 693         device->collection_size = 0;
 694         device->maxcollection = 0;
 695         device->maxapplication = 0;
 696
 697         device->status &= ~HID_STAT_PARSED;
 698 }
 699
 700 /*
 701  * Free a device structure, all reports, and all fields.
 702  */
 703
 704 void hiddev_free(struct kref *ref)
 705 {
 706         struct hid_device *hid = container_of(ref, struct hid_device, ref);
 707
 708         hid_close_report(hid);
 709         kfree(hid->dev_rdesc);
 710         kfree(hid);
 711 }
 712
 713 static void hid_device_release(struct device *dev)
 714 {
 715         struct hid_device *hid = to_hid_device(dev);
 716
 717         kref_put(&hid->ref, hiddev_free);
 718 }
 719
 720 /*
 721  * Fetch a report description item from the data stream. We support long
 722  * items, though they are not used yet.
 723  */
 724
 725 static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
 726 {
 727         u8 b;
 728
 729         if ((end - start) <= 0)
 730                 return NULL;
 731
 732         b = *start++;
 733
 734         item->type = (b >> 2) & 3;
 735         item->tag  = (b >> 4) & 15;
 736
 737         if (item->tag == HID_ITEM_TAG_LONG) {
 738
 739                 item->format = HID_ITEM_FORMAT_LONG;
 740
 741                 if ((end - start) < 2)
 742                         return NULL;
 743
 744                 item->size = *start++;
 745                 item->tag  = *start++;
 746
 747                 if ((end - start) < item->size)
 748                         return NULL;
 749
 750                 item->data.longdata = start;
 751                 start += item->size;
 752                 return start;
 753         }
 754
 755         item->format = HID_ITEM_FORMAT_SHORT;
 756         item->size = b & 3;
 757
 758         switch (item->size) {
 759         case 0:
 760                 return start;
 761
 762         case 1:
 763                 if ((end - start) < 1)
 764                         return NULL;
 765                 item->data.u8 = *start++;
 766                 return start;
 767
 768         case 2:
 769                 if ((end - start) < 2)
 770                         return NULL;
 771                 item->data.u16 = get_unaligned_le16(start);
 772                 start = (__u8 *)((__le16 *)start + 1);
 773                 return start;
 774
 775         case 3:
 776                 item->size++;
 777                 if ((end - start) < 4)
 778                         return NULL;
 779                 item->data.u32 = get_unaligned_le32(start);
 780                 start = (__u8 *)((__le32 *)start + 1);
 781                 return start;
 782         }
 783
 784         return NULL;
 785 }
 786
 787 static void hid_scan_input_usage(struct hid_parser *parser, u32 usage)
 788 {
 789         struct hid_device *hid = parser->device;
 790
 791         if (usage == HID_DG_CONTACTID)
 792                 hid->group = HID_GROUP_MULTITOUCH;
 793 }
 794
 795 static void hid_scan_feature_usage(struct hid_parser *parser, u32 usage)
 796 {
 797         if (usage == 0xff0000c5 && parser->global.report_count == 256 &&
 798             parser->global.report_size == 8)
 799                 parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8;
 800
 801         if (usage == 0xff0000c6 && parser->global.report_count == 1 &&
 802             parser->global.report_size == 8)
 803                 parser->scan_flags |= HID_SCAN_FLAG_MT_WIN_8;
 804 }
 805
 806 static void hid_scan_collection(struct hid_parser *parser, unsigned type)
 807 {
 808         struct hid_device *hid = parser->device;
 809         int i;
 810
 811         if (((parser->global.usage_page << 16) == HID_UP_SENSOR) &&
 812             type == HID_COLLECTION_PHYSICAL)
 813                 hid->group = HID_GROUP_SENSOR_HUB;
 814
 815         if (hid->vendor == USB_VENDOR_ID_MICROSOFT &&
 816             hid->product == USB_DEVICE_ID_MS_POWER_COVER &&
 817             hid->group == HID_GROUP_MULTITOUCH)
 818                 hid->group = HID_GROUP_GENERIC;
 819
 820         if ((parser->global.usage_page << 16) == HID_UP_GENDESK)
 821                 for (i = 0; i < parser->local.usage_index; i++)
 822                         if (parser->local.usage[i] == HID_GD_POINTER)
 823                                 parser->scan_flags |= HID_SCAN_FLAG_GD_POINTER;
 824
 825         if ((parser->global.usage_page << 16) >= HID_UP_MSVENDOR)
 826                 parser->scan_flags |= HID_SCAN_FLAG_VENDOR_SPECIFIC;
 827 }
 828
 829 static int hid_scan_main(struct hid_parser *parser, struct hid_item *item)
 830 {
 831         __u32 data;
 832         int i;
 833
 834         hid_concatenate_last_usage_page(parser);
 835
 836         data = item_udata(item);
 837
 838         switch (item->tag) {
 839         case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
 840                 hid_scan_collection(parser, data & 0xff);
 841                 break;
 842         case HID_MAIN_ITEM_TAG_END_COLLECTION:
 843                 break;
 844         case HID_MAIN_ITEM_TAG_INPUT:
 845                 /* ignore constant inputs, they will be ignored by hid-input */
 846                 if (data & HID_MAIN_ITEM_CONSTANT)
 847                         break;
 848                 for (i = 0; i < parser->local.usage_index; i++)
 849                         hid_scan_input_usage(parser, parser->local.usage[i]);
 850                 break;
 851         case HID_MAIN_ITEM_TAG_OUTPUT:
 852                 break;
 853         case HID_MAIN_ITEM_TAG_FEATURE:
 854                 for (i = 0; i < parser->local.usage_index; i++)
 855                         hid_scan_feature_usage(parser, parser->local.usage[i]);
 856                 break;
 857         }
 858
 859         /* Reset the local parser environment */
 860         memset(&parser->local, 0, sizeof(parser->local));
 861
 862         return 0;
 863 }
 864
 865 /*
 866  * Scan a report descriptor before the device is added to the bus.
 867  * Sets device groups and other properties that determine what driver
 868  * to load.
 869  */
 870 static int hid_scan_report(struct hid_device *hid)
 871 {
 872         struct hid_parser *parser;
 873         struct hid_item item;
 874         __u8 *start = hid->dev_rdesc;
 875         __u8 *end = start + hid->dev_rsize;
 876         static int (*dispatch_type[])(struct hid_parser *parser,
 877                                       struct hid_item *item) = {
 878                 hid_scan_main,
 879                 hid_parser_global,
 880                 hid_parser_local,
 881                 hid_parser_reserved
 882         };
 883
 884         parser = vzalloc(sizeof(struct hid_parser));
 885         if (!parser)
 886                 return -ENOMEM;
 887
 888         parser->device = hid;
 889         hid->group = HID_GROUP_GENERIC;
 890
 891         /*
 892          * The parsing is simpler than the one in hid_open_report() as we should
 893          * be robust against hid errors. Those errors will be raised by
 894          * hid_open_report() anyway.
 895          */
 896         while ((start = fetch_item(start, end, &item)) != NULL)
 897                 dispatch_type[item.type](parser, &item);
 898
 899         /*
 900          * Handle special flags set during scanning.
 901          */
 902         if ((parser->scan_flags & HID_SCAN_FLAG_MT_WIN_8) &&
 903             (hid->group == HID_GROUP_MULTITOUCH))
 904                 hid->group = HID_GROUP_MULTITOUCH_WIN_8;
 905
 906         /*
 907          * Vendor specific handlings
 908          */
 909         switch (hid->vendor) {
 910         case USB_VENDOR_ID_WACOM:
 911                 hid->group = HID_GROUP_WACOM;
 912                 break;
 913         case USB_VENDOR_ID_SYNAPTICS:
 914                 if (hid->group == HID_GROUP_GENERIC)
 915                         if ((parser->scan_flags & HID_SCAN_FLAG_VENDOR_SPECIFIC)
 916                             && (parser->scan_flags & HID_SCAN_FLAG_GD_POINTER))
 917                                 /*
 918                                  * hid-rmi should take care of them,
 919                                  * not hid-generic
 920                                  */
 921                                 hid->group = HID_GROUP_RMI;
 922                 break;
 923         }
 924
 925         kfree(parser->collection_stack);
 926         vfree(parser);
 927         return 0;
 928 }
 929
 930 /**
 931  * hid_parse_report - parse device report
 932  *
 933  * @device: hid device
 934  * @start: report start
 935  * @size: report size
 936  *
 937  * Allocate the device report as read by the bus driver. This function should
 938  * only be called from parse() in ll drivers.
 939  */
 940 int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size)
 941 {
 942         hid->dev_rdesc = kmemdup(start, size, GFP_KERNEL);
 943         if (!hid->dev_rdesc)
 944                 return -ENOMEM;
 945         hid->dev_rsize = size;
 946         return 0;
 947 }
 948 EXPORT_SYMBOL_GPL(hid_parse_report);
 949
 950 static const char * const hid_report_names[] = {
 951         "HID_INPUT_REPORT",
 952         "HID_OUTPUT_REPORT",
 953         "HID_FEATURE_REPORT",
 954 };
 955 /**
 956  * hid_validate_values - validate existing device report's value indexes
 957  *
 958  * @device: hid device
 959  * @type: which report type to examine
 960  * @id: which report ID to examine (0 for first)
 961  * @field_index: which report field to examine
 962  * @report_counts: expected number of values
 963  *
 964  * Validate the number of values in a given field of a given report, after
 965  * parsing.
 966  */
 967 struct hid_report *hid_validate_values(struct hid_device *hid,
 968                                        unsigned int type, unsigned int id,
 969                                        unsigned int field_index,
 970                                        unsigned int report_counts)
 971 {
 972         struct hid_report *report;
 973
 974         if (type > HID_FEATURE_REPORT) {
 975                 hid_err(hid, "invalid HID report type %u\n", type);
 976                 return NULL;
 977         }
 978
 979         if (id >= HID_MAX_IDS) {
 980                 hid_err(hid, "invalid HID report id %u\n", id);
 981                 return NULL;
 982         }
 983
 984         /*
 985          * Explicitly not using hid_get_report() here since it depends on
 986          * ->numbered being checked, which may not always be the case when
 987          * drivers go to access report values.
 988          */
 989         if (id == 0) {
 990                 /*
 991                  * Validating on id 0 means we should examine the first
 992                  * report in the list.
 993                  */
 994                 report = list_first_entry_or_null(
 995                                 &hid->report_enum[type].report_list,
 996                                 struct hid_report, list);
 997         } else {
 998                 report = hid->report_enum[type].report_id_hash[id];
 999         }
1000         if (!report) {
1001                 hid_err(hid, "missing %s %u\n", hid_report_names[type], id);
1002                 return NULL;
1003         }
1004         if (report->maxfield <= field_index) {
1005                 hid_err(hid, "not enough fields in %s %u\n",
1006                         hid_report_names[type], id);
1007                 return NULL;
1008         }
1009         if (report->field[field_index]->report_count < report_counts) {
1010                 hid_err(hid, "not enough values in %s %u field %u\n",
1011                         hid_report_names[type], id, field_index);
1012                 return NULL;
1013         }
1014         return report;
1015 }
1016 EXPORT_SYMBOL_GPL(hid_validate_values);
1017
1018 /**
1019  * hid_open_report - open a driver-specific device report
1020  *
1021  * @device: hid device
1022  *
1023  * Parse a report description into a hid_device structure. Reports are
1024  * enumerated, fields are attached to these reports.
1025  * 0 returned on success, otherwise nonzero error value.
1026  *
1027  * This function (or the equivalent hid_parse() macro) should only be
1028  * called from probe() in drivers, before starting the device.
1029  */
1030 int hid_open_report(struct hid_device *device)
1031 {
1032         struct hid_parser *parser;
1033         struct hid_item item;
1034         unsigned int size;
1035         __u8 *start;
1036         __u8 *buf;
1037         __u8 *end;
1038         __u8 *next;
1039         int ret;
1040         static int (*dispatch_type[])(struct hid_parser *parser,
1041                                       struct hid_item *item) = {
1042                 hid_parser_main,
1043                 hid_parser_global,
1044                 hid_parser_local,
1045                 hid_parser_reserved
1046         };
1047
1048         if (WARN_ON(device->status & HID_STAT_PARSED))
1049                 return -EBUSY;
1050
1051         start = device->dev_rdesc;
1052         if (WARN_ON(!start))
1053                 return -ENODEV;
1054         size = device->dev_rsize;
1055
1056         buf = kmemdup(start, size, GFP_KERNEL);
1057         if (buf == NULL)
1058                 return -ENOMEM;
1059
1060         if (device->driver->report_fixup)
1061                 start = device->driver->report_fixup(device, buf, &size);
1062         else
1063                 start = buf;
1064
1065         start = kmemdup(start, size, GFP_KERNEL);
1066         kfree(buf);
1067         if (start == NULL)
1068                 return -ENOMEM;
1069
1070         device->rdesc = start;
1071         device->rsize = size;
1072
1073         parser = vzalloc(sizeof(struct hid_parser));
1074         if (!parser) {
1075                 ret = -ENOMEM;
1076                 goto alloc_err;
1077         }
1078
1079         parser->device = device;
1080
1081         end = start + size;
1082
1083         device->collection = kcalloc(HID_DEFAULT_NUM_COLLECTIONS,
1084                                      sizeof(struct hid_collection), GFP_KERNEL);
1085         if (!device->collection) {
1086                 ret = -ENOMEM;
1087                 goto err;
1088         }
1089         device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
1090
1091         ret = -EINVAL;
1092         while ((next = fetch_item(start, end, &item)) != NULL) {
1093                 start = next;
1094
1095                 if (item.format != HID_ITEM_FORMAT_SHORT) {
1096                         hid_err(device, "unexpected long global item\n");
1097                         goto err;
1098                 }
1099
1100                 if (dispatch_type[item.type](parser, &item)) {
1101                         hid_err(device, "item %u %u %u %u parsing failed\n",
1102                                 item.format, (unsigned)item.size,
1103                                 (unsigned)item.type, (unsigned)item.tag);
1104                         goto err;
1105                 }
1106
1107                 if (start == end) {
1108                         if (parser->collection_stack_ptr) {
1109                                 hid_err(device, "unbalanced collection at end of report description\n");
1110                                 goto err;
1111                         }
1112                         if (parser->local.delimiter_depth) {
1113                                 hid_err(device, "unbalanced delimiter at end of report description\n");
1114                                 goto err;
1115                         }
1116                         kfree(parser->collection_stack);
1117                         vfree(parser);
1118                         device->status |= HID_STAT_PARSED;
1119                         return 0;
1120                 }
1121         }
1122
1123         hid_err(device, "item fetching failed at offset %u/%u\n",
1124                 size - (unsigned int)(end - start), size);
1125 err:
1126         kfree(parser->collection_stack);
1127 alloc_err:
1128         vfree(parser);
1129         hid_close_report(device);
1130         return ret;
1131 }
1132 EXPORT_SYMBOL_GPL(hid_open_report);
1133
1134 /*
1135  * Convert a signed n-bit integer to signed 32-bit integer. Common
1136  * cases are done through the compiler, the screwed things has to be
1137  * done by hand.
1138  */
1139
1140 static s32 snto32(__u32 value, unsigned n)
1141 {
1142         if (!value || !n)
1143                 return 0;
1144
1145         if (n > 32)
1146                 n = 32;
1147
1148         switch (n) {
1149         case 8:  return ((__s8)value);
1150         case 16: return ((__s16)value);
1151         case 32: return ((__s32)value);
1152         }
1153         return value & (1 << (n - 1)) ? value | (~0U << n) : value;
1154 }
1155
1156 s32 hid_snto32(__u32 value, unsigned n)
1157 {
1158         return snto32(value, n);
1159 }
1160 EXPORT_SYMBOL_GPL(hid_snto32);
1161
1162 /*
1163  * Convert a signed 32-bit integer to a signed n-bit integer.
1164  */
1165
1166 static u32 s32ton(__s32 value, unsigned n)
1167 {
1168         s32 a = value >> (n - 1);
1169         if (a && a != -1)
1170                 return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1;
1171         return value & ((1 << n) - 1);
1172 }
1173
1174 /*
1175  * Extract/implement a data field from/to a little endian report (bit array).
1176  *
1177  * Code sort-of follows HID spec:
1178  *     http://www.usb.org/developers/hidpage/HID1_11.pdf
1179  *
1180  * While the USB HID spec allows unlimited length bit fields in "report
1181  * descriptors", most devices never use more than 16 bits.
1182  * One model of UPS is claimed to report "LINEV" as a 32-bit field.
1183  * Search linux-kernel and linux-usb-devel archives for "hid-core extract".
1184  */
1185
1186 static u32 __extract(u8 *report, unsigned offset, int n)
1187 {
1188         unsigned int idx = offset / 8;
1189         unsigned int bit_nr = 0;
1190         unsigned int bit_shift = offset % 8;
1191         int bits_to_copy = 8 - bit_shift;
1192         u32 value = 0;
1193         u32 mask = n < 32 ? (1U << n) - 1 : ~0U;
1194
1195         while (n > 0) {
1196                 value |= ((u32)report[idx] >> bit_shift) << bit_nr;
1197                 n -= bits_to_copy;
1198                 bit_nr += bits_to_copy;
1199                 bits_to_copy = 8;
1200                 bit_shift = 0;
1201                 idx++;
1202         }
1203
1204         return value & mask;
1205 }
1206
1207 u32 hid_field_extract(const struct hid_device *hid, u8 *report,
1208                         unsigned offset, unsigned n)
1209 {
1210         if (n > 32) {
1211                 hid_warn(hid, "hid_field_extract() called with n (%d) > 32! (%s)\n",
1212                          n, current->comm);
1213                 n = 32;
1214         }
1215
1216         return __extract(report, offset, n);
1217 }
1218 EXPORT_SYMBOL_GPL(hid_field_extract);
1219
1220 /*
1221  * "implement" : set bits in a little endian bit stream.
1222  * Same concepts as "extract" (see comments above).
1223  * The data mangled in the bit stream remains in little endian
1224  * order the whole time. It make more sense to talk about
1225  * endianness of register values by considering a register
1226  * a "cached" copy of the little endian bit stream.
1227  */
1228
1229 static void __implement(u8 *report, unsigned offset, int n, u32 value)
1230 {
1231         unsigned int idx = offset / 8;
1232         unsigned int bit_shift = offset % 8;
1233         int bits_to_set = 8 - bit_shift;
1234
1235         while (n - bits_to_set >= 0) {
1236                 report[idx] &= ~(0xff << bit_shift);
1237                 report[idx] |= value << bit_shift;
1238                 value >>= bits_to_set;
1239                 n -= bits_to_set;
1240                 bits_to_set = 8;
1241                 bit_shift = 0;
1242                 idx++;
1243         }
1244
1245         /* last nibble */
1246         if (n) {
1247                 u8 bit_mask = ((1U << n) - 1);
1248                 report[idx] &= ~(bit_mask << bit_shift);
1249                 report[idx] |= value << bit_shift;
1250         }
1251 }
1252
1253 static void implement(const struct hid_device *hid, u8 *report,
1254                       unsigned offset, unsigned n, u32 value)
1255 {
1256         if (unlikely(n > 32)) {
1257                 hid_warn(hid, "%s() called with n (%d) > 32! (%s)\n",
1258                          __func__, n, current->comm);
1259                 n = 32;
1260         } else if (n < 32) {
1261                 u32 m = (1U << n) - 1;
1262
1263                 if (unlikely(value > m)) {
1264                         hid_warn(hid,
1265                                  "%s() called with too large value %d (n: %d)! (%s)\n",
1266                                  __func__, value, n, current->comm);
1267                         WARN_ON(1);
1268                         value &= m;
1269                 }
1270         }
1271
1272         __implement(report, offset, n, value);
1273 }
1274
1275 /*
1276  * Search an array for a value.
1277  */
1278
1279 static int search(__s32 *array, __s32 value, unsigned n)
1280 {
1281         while (n--) {
1282                 if (*array++ == value)
1283                         return 0;
1284         }
1285         return -1;
1286 }
1287
1288 /**
1289  * hid_match_report - check if driver's raw_event should be called
1290  *
1291  * @hid: hid device
1292  * @report_type: type to match against
1293  *
1294  * compare hid->driver->report_table->report_type to report->type
1295  */
1296 static int hid_match_report(struct hid_device *hid, struct hid_report *report)
1297 {
1298         const struct hid_report_id *id = hid->driver->report_table;
1299
1300         if (!id) /* NULL means all */
1301                 return 1;
1302
1303         for (; id->report_type != HID_TERMINATOR; id++)
1304                 if (id->report_type == HID_ANY_ID ||
1305                                 id->report_type == report->type)
1306                         return 1;
1307         return 0;
1308 }
1309
1310 /**
1311  * hid_match_usage - check if driver's event should be called
1312  *
1313  * @hid: hid device
1314  * @usage: usage to match against
1315  *
1316  * compare hid->driver->usage_table->usage_{type,code} to
1317  * usage->usage_{type,code}
1318  */
1319 static int hid_match_usage(struct hid_device *hid, struct hid_usage *usage)
1320 {
1321         const struct hid_usage_id *id = hid->driver->usage_table;
1322
1323         if (!id) /* NULL means all */
1324                 return 1;
1325
1326         for (; id->usage_type != HID_ANY_ID - 1; id++)
1327                 if ((id->usage_hid == HID_ANY_ID ||
1328                                 id->usage_hid == usage->hid) &&
1329                                 (id->usage_type == HID_ANY_ID ||
1330                                 id->usage_type == usage->type) &&
1331                                 (id->usage_code == HID_ANY_ID ||
1332                                  id->usage_code == usage->code))
1333                         return 1;
1334         return 0;
1335 }
1336
1337 static void hid_process_event(struct hid_device *hid, struct hid_field *field,
1338                 struct hid_usage *usage, __s32 value, int interrupt)
1339 {
1340         struct hid_driver *hdrv = hid->driver;
1341         int ret;
1342
1343         if (!list_empty(&hid->debug_list))
1344                 hid_dump_input(hid, usage, value);
1345
1346         if (hdrv && hdrv->event && hid_match_usage(hid, usage)) {
1347                 ret = hdrv->event(hid, field, usage, value);
1348                 if (ret != 0) {
1349                         if (ret < 0)
1350                                 hid_err(hid, "%s's event failed with %d\n",
1351                                                 hdrv->name, ret);
1352                         return;
1353                 }
1354         }
1355
1356         if (hid->claimed & HID_CLAIMED_INPUT)
1357                 hidinput_hid_event(hid, field, usage, value);
1358         if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)
1359                 hid->hiddev_hid_event(hid, field, usage, value);
1360 }
1361
1362 /*
1363  * Analyse a received field, and fetch the data from it. The field
1364  * content is stored for next report processing (we do differential
1365  * reporting to the layer).
1366  */
1367
1368 static void hid_input_field(struct hid_device *hid, struct hid_field *field,
1369                             __u8 *data, int interrupt)
1370 {
1371         unsigned n;
1372         unsigned count = field->report_count;
1373         unsigned offset = field->report_offset;
1374         unsigned size = field->report_size;
1375         __s32 min = field->logical_minimum;
1376         __s32 max = field->logical_maximum;
1377         __s32 *value;
1378
1379         value = kmalloc_array(count, sizeof(__s32), GFP_ATOMIC);
1380         if (!value)
1381                 return;
1382
1383         for (n = 0; n < count; n++) {
1384
1385                 value[n] = min < 0 ?
1386                         snto32(hid_field_extract(hid, data, offset + n * size,
1387                                size), size) :
1388                         hid_field_extract(hid, data, offset + n * size, size);
1389
1390                 /* Ignore report if ErrorRollOver */
1391                 if (!(field->flags & HID_MAIN_ITEM_VARIABLE) &&
1392                     value[n] >= min && value[n] <= max &&
1393                     value[n] - min < field->maxusage &&
1394                     field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
1395                         goto exit;
1396         }
1397
1398         for (n = 0; n < count; n++) {
1399
1400                 if (HID_MAIN_ITEM_VARIABLE & field->flags) {
1401                         hid_process_event(hid, field, &field->usage[n], value[n], interrupt);
1402                         continue;
1403                 }
1404
1405                 if (field->value[n] >= min && field->value[n] <= max
1406                         && field->value[n] - min < field->maxusage
1407                         && field->usage[field->value[n] - min].hid
1408                         && search(value, field->value[n], count))
1409                                 hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt);
1410
1411                 if (value[n] >= min && value[n] <= max
1412                         && value[n] - min < field->maxusage
1413                         && field->usage[value[n] - min].hid
1414                         && search(field->value, value[n], count))
1415                                 hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt);
1416         }
1417
1418         memcpy(field->value, value, count * sizeof(__s32));
1419 exit:
1420         kfree(value);
1421 }
1422
1423 /*
1424  * Output the field into the report.
1425  */
1426
1427 static void hid_output_field(const struct hid_device *hid,
1428                              struct hid_field *field, __u8 *data)
1429 {
1430         unsigned count = field->report_count;
1431         unsigned offset = field->report_offset;
1432         unsigned size = field->report_size;
1433         unsigned n;
1434
1435         for (n = 0; n < count; n++) {
1436                 if (field->logical_minimum < 0) /* signed values */
1437                         implement(hid, data, offset + n * size, size,
1438                                   s32ton(field->value[n], size));
1439                 else                            /* unsigned values */
1440                         implement(hid, data, offset + n * size, size,
1441                                   field->value[n]);
1442         }
1443 }
1444
1445 /*
1446  * Compute the size of a report.
1447  */
1448 static size_t hid_compute_report_size(struct hid_report *report)
1449 {
1450         if (report->size)
1451                 return ((report->size - 1) >> 3) + 1;
1452
1453         return 0;
1454 }
1455
1456 /*
1457  * Create a report. 'data' has to be allocated using
1458  * hid_alloc_report_buf() so that it has proper size.
1459  */
1460
1461 void hid_output_report(struct hid_report *report, __u8 *data)
1462 {
1463         unsigned n;
1464
1465         if (report->id > 0)
1466                 *data++ = report->id;
1467
1468         memset(data, 0, hid_compute_report_size(report));
1469         for (n = 0; n < report->maxfield; n++)
1470                 hid_output_field(report->device, report->field[n], data);
1471 }
1472 EXPORT_SYMBOL_GPL(hid_output_report);
1473
1474 /*
1475  * Allocator for buffer that is going to be passed to hid_output_report()
1476  */
1477 u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags)
1478 {
1479         /*
1480          * 7 extra bytes are necessary to achieve proper functionality
1481          * of implement() working on 8 byte chunks
1482          */
1483
1484         u32 len = hid_report_len(report) + 7;
1485
1486         return kmalloc(len, flags);
1487 }
1488 EXPORT_SYMBOL_GPL(hid_alloc_report_buf);
1489
1490 /*
1491  * Set a field value. The report this field belongs to has to be
1492  * created and transferred to the device, to set this value in the
1493  * device.
1494  */
1495
1496 int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
1497 {
1498         unsigned size;
1499
1500         if (!field)
1501                 return -1;
1502
1503         size = field->report_size;
1504
1505         hid_dump_input(field->report->device, field->usage + offset, value);
1506
1507         if (offset >= field->report_count) {
1508                 hid_err(field->report->device, "offset (%d) exceeds report_count (%d)\n",
1509                                 offset, field->report_count);
1510                 return -1;
1511         }
1512         if (field->logical_minimum < 0) {
1513                 if (value != snto32(s32ton(value, size), size)) {
1514                         hid_err(field->report->device, "value %d is out of range\n", value);
1515                         return -1;
1516                 }
1517         }
1518         field->value[offset] = value;
1519         return 0;
1520 }
1521 EXPORT_SYMBOL_GPL(hid_set_field);
1522
1523 static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,
1524                 const u8 *data)
1525 {
1526         struct hid_report *report;
1527         unsigned int n = 0;     /* Normally report number is 0 */
1528
1529         /* Device uses numbered reports, data[0] is report number */
1530         if (report_enum->numbered)
1531                 n = *data;
1532
1533         report = report_enum->report_id_hash[n];
1534         if (report == NULL)
1535                 dbg_hid("undefined report_id %u received\n", n);
1536
1537         return report;
1538 }
1539
1540 /*
1541  * Implement a generic .request() callback, using .raw_request()
1542  * DO NOT USE in hid drivers directly, but through hid_hw_request instead.
1543  */
1544 void __hid_request(struct hid_device *hid, struct hid_report *report,
1545                 int reqtype)
1546 {
1547         char *buf;
1548         int ret;
1549         u32 len;
1550
1551         buf = hid_alloc_report_buf(report, GFP_KERNEL);
1552         if (!buf)
1553                 return;
1554
1555         len = hid_report_len(report);
1556
1557         if (reqtype == HID_REQ_SET_REPORT)
1558                 hid_output_report(report, buf);
1559
1560         ret = hid->ll_driver->raw_request(hid, report->id, buf, len,
1561                                           report->type, reqtype);
1562         if (ret < 0) {
1563                 dbg_hid("unable to complete request: %d\n", ret);
1564                 goto out;
1565         }
1566
1567         if (reqtype == HID_REQ_GET_REPORT)
1568                 hid_input_report(hid, report->type, buf, ret, 0);
1569
1570 out:
1571         kfree(buf);
1572 }
1573 EXPORT_SYMBOL_GPL(__hid_request);
1574
1575 int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size,
1576                 int interrupt)
1577 {
1578         struct hid_report_enum *report_enum = hid->report_enum + type;
1579         struct hid_report *report;
1580         struct hid_driver *hdrv;
1581         int max_buffer_size = HID_MAX_BUFFER_SIZE;
1582         unsigned int a;
1583         u32 rsize, csize = size;
1584         u8 *cdata = data;
1585         int ret = 0;
1586
1587         report = hid_get_report(report_enum, data);
1588         if (!report)
1589                 goto out;
1590
1591         if (report_enum->numbered) {
1592                 cdata++;
1593                 csize--;
1594         }
1595
1596         rsize = hid_compute_report_size(report);
1597
1598         if (hid->ll_driver->max_buffer_size)
1599                 max_buffer_size = hid->ll_driver->max_buffer_size;
1600
1601         if (report_enum->numbered && rsize >= max_buffer_size)
1602                 rsize = max_buffer_size - 1;
1603         else if (rsize > max_buffer_size)
1604                 rsize = max_buffer_size;
1605
1606         if (csize < rsize) {
1607                 dbg_hid("report %d is too short, (%d < %d)\n", report->id,
1608                                 csize, rsize);
1609                 memset(cdata + csize, 0, rsize - csize);
1610         }
1611
1612         if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
1613                 hid->hiddev_report_event(hid, report);
1614         if (hid->claimed & HID_CLAIMED_HIDRAW) {
1615                 ret = hidraw_report_event(hid, data, size);
1616                 if (ret)
1617                         goto out;
1618         }
1619
1620         if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) {
1621                 for (a = 0; a < report->maxfield; a++)
1622                         hid_input_field(hid, report->field[a], cdata, interrupt);
1623                 hdrv = hid->driver;
1624                 if (hdrv && hdrv->report)
1625                         hdrv->report(hid, report);
1626         }
1627
1628         if (hid->claimed & HID_CLAIMED_INPUT)
1629                 hidinput_report_event(hid, report);
1630 out:
1631         return ret;
1632 }
1633 EXPORT_SYMBOL_GPL(hid_report_raw_event);
1634
1635 /**
1636  * hid_input_report - report data from lower layer (usb, bt...)
1637  *
1638  * @hid: hid device
1639  * @type: HID report type (HID_*_REPORT)
1640  * @data: report contents
1641  * @size: size of data parameter
1642  * @interrupt: distinguish between interrupt and control transfers
1643  *
1644  * This is data entry for lower layers.
1645  */
1646 int hid_input_report(struct hid_device *hid, int type, u8 *data, u32 size, int interrupt)
1647 {
1648         struct hid_report_enum *report_enum;
1649         struct hid_driver *hdrv;
1650         struct hid_report *report;
1651         int ret = 0;
1652
1653         if (!hid)
1654                 return -ENODEV;
1655
1656         if (down_trylock(&hid->driver_input_lock))
1657                 return -EBUSY;
1658
1659         if (!hid->driver) {
1660                 ret = -ENODEV;
1661                 goto unlock;
1662         }
1663         report_enum = hid->report_enum + type;
1664         hdrv = hid->driver;
1665
1666         if (!size) {
1667                 dbg_hid("empty report\n");
1668                 ret = -1;
1669                 goto unlock;
1670         }
1671
1672         /* Avoid unnecessary overhead if debugfs is disabled */
1673         if (!list_empty(&hid->debug_list))
1674                 hid_dump_report(hid, type, data, size);
1675
1676         report = hid_get_report(report_enum, data);
1677
1678         if (!report) {
1679                 ret = -1;
1680                 goto unlock;
1681         }
1682
1683         if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
1684                 ret = hdrv->raw_event(hid, report, data, size);
1685                 if (ret < 0)
1686                         goto unlock;
1687         }
1688
1689         ret = hid_report_raw_event(hid, type, data, size, interrupt);
1690
1691 unlock:
1692         up(&hid->driver_input_lock);
1693         return ret;
1694 }
1695 EXPORT_SYMBOL_GPL(hid_input_report);
1696
1697 bool hid_match_one_id(const struct hid_device *hdev,
1698                       const struct hid_device_id *id)
1699 {
1700         return (id->bus == HID_BUS_ANY || id->bus == hdev->bus) &&
1701                 (id->group == HID_GROUP_ANY || id->group == hdev->group) &&
1702                 (id->vendor == HID_ANY_ID || id->vendor == hdev->vendor) &&
1703                 (id->product == HID_ANY_ID || id->product == hdev->product);
1704 }
1705
1706 const struct hid_device_id *hid_match_id(const struct hid_device *hdev,
1707                 const struct hid_device_id *id)
1708 {
1709         for (; id->bus; id++)
1710                 if (hid_match_one_id(hdev, id))
1711                         return id;
1712
1713         return NULL;
1714 }
1715
1716 static const struct hid_device_id hid_hiddev_list[] = {
1717         { HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS) },
1718         { HID_USB_DEVICE(USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1) },
1719         { }
1720 };
1721
1722 static bool hid_hiddev(struct hid_device *hdev)
1723 {
1724         return !!hid_match_id(hdev, hid_hiddev_list);
1725 }
1726
1727
1728 static ssize_t
1729 read_report_descriptor(struct file *filp, struct kobject *kobj,
1730                 struct bin_attribute *attr,
1731                 char *buf, loff_t off, size_t count)
1732 {
1733         struct device *dev = kobj_to_dev(kobj);
1734         struct hid_device *hdev = to_hid_device(dev);
1735
1736         if (off >= hdev->rsize)
1737                 return 0;
1738
1739         if (off + count > hdev->rsize)
1740                 count = hdev->rsize - off;
1741
1742         memcpy(buf, hdev->rdesc + off, count);
1743
1744         return count;
1745 }
1746
1747 static ssize_t
1748 show_country(struct device *dev, struct device_attribute *attr,
1749                 char *buf)
1750 {
1751         struct hid_device *hdev = to_hid_device(dev);
1752
1753         return sprintf(buf, "%02x\n", hdev->country & 0xff);
1754 }
1755
1756 static struct bin_attribute dev_bin_attr_report_desc = {
1757         .attr = { .name = "report_descriptor", .mode = 0444 },
1758         .read = read_report_descriptor,
1759         .size = HID_MAX_DESCRIPTOR_SIZE,
1760 };
1761
1762 static const struct device_attribute dev_attr_country = {
1763         .attr = { .name = "country", .mode = 0444 },
1764         .show = show_country,
1765 };
1766
1767 int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
1768 {
1769         static const char *types[] = { "Device", "Pointer", "Mouse", "Device",
1770                 "Joystick", "Gamepad", "Keyboard", "Keypad",
1771                 "Multi-Axis Controller"
1772         };
1773         const char *type, *bus;
1774         char buf[64] = "";
1775         unsigned int i;
1776         int len;
1777         int ret;
1778
1779         if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE)
1780                 connect_mask |= (HID_CONNECT_HIDDEV_FORCE | HID_CONNECT_HIDDEV);
1781         if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE)
1782                 connect_mask |= HID_CONNECT_HIDINPUT_FORCE;
1783         if (hdev->bus != BUS_USB)
1784                 connect_mask &= ~HID_CONNECT_HIDDEV;
1785         if (hid_hiddev(hdev))
1786                 connect_mask |= HID_CONNECT_HIDDEV_FORCE;
1787
1788         if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev,
1789                                 connect_mask & HID_CONNECT_HIDINPUT_FORCE))
1790                 hdev->claimed |= HID_CLAIMED_INPUT;
1791
1792         if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect &&
1793                         !hdev->hiddev_connect(hdev,
1794                                 connect_mask & HID_CONNECT_HIDDEV_FORCE))
1795                 hdev->claimed |= HID_CLAIMED_HIDDEV;
1796         if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev))
1797                 hdev->claimed |= HID_CLAIMED_HIDRAW;
1798
1799         if (connect_mask & HID_CONNECT_DRIVER)
1800                 hdev->claimed |= HID_CLAIMED_DRIVER;
1801
1802         /* Drivers with the ->raw_event callback set are not required to connect
1803          * to any other listener. */
1804         if (!hdev->claimed && !hdev->driver->raw_event) {
1805                 hid_err(hdev, "device has no listeners, quitting\n");
1806                 return -ENODEV;
1807         }
1808
1809         if ((hdev->claimed & HID_CLAIMED_INPUT) &&
1810                         (connect_mask & HID_CONNECT_FF) && hdev->ff_init)
1811                 hdev->ff_init(hdev);
1812
1813         len = 0;
1814         if (hdev->claimed & HID_CLAIMED_INPUT)
1815                 len += sprintf(buf + len, "input");
1816         if (hdev->claimed & HID_CLAIMED_HIDDEV)
1817                 len += sprintf(buf + len, "%shiddev%d", len ? "," : "",
1818                                 ((struct hiddev *)hdev->hiddev)->minor);
1819         if (hdev->claimed & HID_CLAIMED_HIDRAW)
1820                 len += sprintf(buf + len, "%shidraw%d", len ? "," : "",
1821                                 ((struct hidraw *)hdev->hidraw)->minor);
1822
1823         type = "Device";
1824         for (i = 0; i < hdev->maxcollection; i++) {
1825                 struct hid_collection *col = &hdev->collection[i];
1826                 if (col->type == HID_COLLECTION_APPLICATION &&
1827                    (col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
1828                    (col->usage & 0xffff) < ARRAY_SIZE(types)) {
1829                         type = types[col->usage & 0xffff];
1830                         break;
1831                 }
1832         }
1833
1834         switch (hdev->bus) {
1835         case BUS_USB:
1836                 bus = "USB";
1837                 break;
1838         case BUS_BLUETOOTH:
1839                 bus = "BLUETOOTH";
1840                 break;
1841         case BUS_I2C:
1842                 bus = "I2C";
1843                 break;
1844         case BUS_VIRTUAL:
1845                 bus = "VIRTUAL";
1846                 break;
1847         default:
1848                 bus = "<UNKNOWN>";
1849         }
1850
1851         ret = device_create_file(&hdev->dev, &dev_attr_country);
1852         if (ret)
1853                 hid_warn(hdev,
1854                          "can't create sysfs country code attribute err: %d\n", ret);
1855
1856         hid_info(hdev, "%s: %s HID v%x.%02x %s [%s] on %s\n",
1857                  buf, bus, hdev->version >> 8, hdev->version & 0xff,
1858                  type, hdev->name, hdev->phys);
1859
1860         return 0;
1861 }
1862 EXPORT_SYMBOL_GPL(hid_connect);
1863
1864 void hid_disconnect(struct hid_device *hdev)
1865 {
1866         device_remove_file(&hdev->dev, &dev_attr_country);
1867         if (hdev->claimed & HID_CLAIMED_INPUT)
1868                 hidinput_disconnect(hdev);
1869         if (hdev->claimed & HID_CLAIMED_HIDDEV)
1870                 hdev->hiddev_disconnect(hdev);
1871         if (hdev->claimed & HID_CLAIMED_HIDRAW)
1872                 hidraw_disconnect(hdev);
1873         hdev->claimed = 0;
1874 }
1875 EXPORT_SYMBOL_GPL(hid_disconnect);
1876
1877 /**
1878  * hid_hw_start - start underlying HW
1879  * @hdev: hid device
1880  * @connect_mask: which outputs to connect, see HID_CONNECT_*
1881  *
1882  * Call this in probe function *after* hid_parse. This will setup HW
1883  * buffers and start the device (if not defeirred to device open).
1884  * hid_hw_stop must be called if this was successful.
1885  */
1886 int hid_hw_start(struct hid_device *hdev, unsigned int connect_mask)
1887 {
1888         int error;
1889
1890         error = hdev->ll_driver->start(hdev);
1891         if (error)
1892                 return error;
1893
1894         if (connect_mask) {
1895                 error = hid_connect(hdev, connect_mask);
1896                 if (error) {
1897                         hdev->ll_driver->stop(hdev);
1898                         return error;
1899                 }
1900         }
1901
1902         return 0;
1903 }
1904 EXPORT_SYMBOL_GPL(hid_hw_start);
1905
1906 /**
1907  * hid_hw_stop - stop underlying HW
1908  * @hdev: hid device
1909  *
1910  * This is usually called from remove function or from probe when something
1911  * failed and hid_hw_start was called already.
1912  */
1913 void hid_hw_stop(struct hid_device *hdev)
1914 {
1915         hid_disconnect(hdev);
1916         hdev->ll_driver->stop(hdev);
1917 }
1918 EXPORT_SYMBOL_GPL(hid_hw_stop);
1919
1920 /**
1921  * hid_hw_open - signal underlying HW to start delivering events
1922  * @hdev: hid device
1923  *
1924  * Tell underlying HW to start delivering events from the device.
1925  * This function should be called sometime after successful call
1926  * to hid_hw_start().
1927  */
1928 int hid_hw_open(struct hid_device *hdev)
1929 {
1930         int ret;
1931
1932         ret = mutex_lock_killable(&hdev->ll_open_lock);
1933         if (ret)
1934                 return ret;
1935
1936         if (!hdev->ll_open_count++) {
1937                 ret = hdev->ll_driver->open(hdev);
1938                 if (ret)
1939                         hdev->ll_open_count--;
1940         }
1941
1942         mutex_unlock(&hdev->ll_open_lock);
1943         return ret;
1944 }
1945 EXPORT_SYMBOL_GPL(hid_hw_open);
1946
1947 /**
1948  * hid_hw_close - signal underlaying HW to stop delivering events
1949  *
1950  * @hdev: hid device
1951  *
1952  * This function indicates that we are not interested in the events
1953  * from this device anymore. Delivery of events may or may not stop,
1954  * depending on the number of users still outstanding.
1955  */
1956 void hid_hw_close(struct hid_device *hdev)
1957 {
1958         mutex_lock(&hdev->ll_open_lock);
1959         if (!--hdev->ll_open_count)
1960                 hdev->ll_driver->close(hdev);
1961         mutex_unlock(&hdev->ll_open_lock);
1962 }
1963 EXPORT_SYMBOL_GPL(hid_hw_close);
1964
1965 struct hid_dynid {
1966         struct list_head list;
1967         struct hid_device_id id;
1968 };
1969
1970 /**
1971  * store_new_id - add a new HID device ID to this driver and re-probe devices
1972  * @driver: target device driver
1973  * @buf: buffer for scanning device ID data
1974  * @count: input size
1975  *
1976  * Adds a new dynamic hid device ID to this driver,
1977  * and causes the driver to probe for all devices again.
1978  */
1979 static ssize_t new_id_store(struct device_driver *drv, const char *buf,
1980                 size_t count)
1981 {
1982         struct hid_driver *hdrv = to_hid_driver(drv);
1983         struct hid_dynid *dynid;
1984         __u32 bus, vendor, product;
1985         unsigned long driver_data = 0;
1986         int ret;
1987
1988         ret = sscanf(buf, "%x %x %x %lx",
1989                         &bus, &vendor, &product, &driver_data);
1990         if (ret < 3)
1991                 return -EINVAL;
1992
1993         dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
1994         if (!dynid)
1995                 return -ENOMEM;
1996
1997         dynid->id.bus = bus;
1998         dynid->id.group = HID_GROUP_ANY;
1999         dynid->id.vendor = vendor;
2000         dynid->id.product = product;
2001         dynid->id.driver_data = driver_data;
2002
2003         spin_lock(&hdrv->dyn_lock);
2004         list_add_tail(&dynid->list, &hdrv->dyn_list);
2005         spin_unlock(&hdrv->dyn_lock);
2006
2007         ret = driver_attach(&hdrv->driver);
2008
2009         return ret ? : count;
2010 }
2011 static DRIVER_ATTR_WO(new_id);
2012
2013 static struct attribute *hid_drv_attrs[] = {
2014         &driver_attr_new_id.attr,
2015         NULL,
2016 };
2017 ATTRIBUTE_GROUPS(hid_drv);
2018
2019 static void hid_free_dynids(struct hid_driver *hdrv)
2020 {
2021         struct hid_dynid *dynid, *n;
2022
2023         spin_lock(&hdrv->dyn_lock);
2024         list_for_each_entry_safe(dynid, n, &hdrv->dyn_list, list) {
2025                 list_del(&dynid->list);
2026                 kfree(dynid);
2027         }
2028         spin_unlock(&hdrv->dyn_lock);
2029 }
2030
2031 const struct hid_device_id *hid_match_device(struct hid_device *hdev,
2032                                              struct hid_driver *hdrv)
2033 {
2034         struct hid_dynid *dynid;
2035
2036         spin_lock(&hdrv->dyn_lock);
2037         list_for_each_entry(dynid, &hdrv->dyn_list, list) {
2038                 if (hid_match_one_id(hdev, &dynid->id)) {
2039                         spin_unlock(&hdrv->dyn_lock);
2040                         return &dynid->id;
2041                 }
2042         }
2043         spin_unlock(&hdrv->dyn_lock);
2044
2045         return hid_match_id(hdev, hdrv->id_table);
2046 }
2047 EXPORT_SYMBOL_GPL(hid_match_device);
2048
2049 static int hid_bus_match(struct device *dev, struct device_driver *drv)
2050 {
2051         struct hid_driver *hdrv = to_hid_driver(drv);
2052         struct hid_device *hdev = to_hid_device(dev);
2053
2054         return hid_match_device(hdev, hdrv) != NULL;
2055 }
2056
2057 /**
2058  * hid_compare_device_paths - check if both devices share the same path
2059  * @hdev_a: hid device
2060  * @hdev_b: hid device
2061  * @separator: char to use as separator
2062  *
2063  * Check if two devices share the same path up to the last occurrence of
2064  * the separator char. Both paths must exist (i.e., zero-length paths
2065  * don't match).
2066  */
2067 bool hid_compare_device_paths(struct hid_device *hdev_a,
2068                               struct hid_device *hdev_b, char separator)
2069 {
2070         int n1 = strrchr(hdev_a->phys, separator) - hdev_a->phys;
2071         int n2 = strrchr(hdev_b->phys, separator) - hdev_b->phys;
2072
2073         if (n1 != n2 || n1 <= 0 || n2 <= 0)
2074                 return false;
2075
2076         return !strncmp(hdev_a->phys, hdev_b->phys, n1);
2077 }
2078 EXPORT_SYMBOL_GPL(hid_compare_device_paths);
2079
2080 static int hid_device_probe(struct device *dev)
2081 {
2082         struct hid_driver *hdrv = to_hid_driver(dev->driver);
2083         struct hid_device *hdev = to_hid_device(dev);
2084         const struct hid_device_id *id;
2085         int ret = 0;
2086
2087         if (down_interruptible(&hdev->driver_input_lock)) {
2088                 ret = -EINTR;
2089                 goto end;
2090         }
2091         hdev->io_started = false;
2092
2093         clear_bit(ffs(HID_STAT_REPROBED), &hdev->status);
2094
2095         if (!hdev->driver) {
2096                 id = hid_match_device(hdev, hdrv);
2097                 if (id == NULL) {
2098                         ret = -ENODEV;
2099                         goto unlock;
2100                 }
2101
2102                 if (hdrv->match) {
2103                         if (!hdrv->match(hdev, hid_ignore_special_drivers)) {
2104                                 ret = -ENODEV;
2105                                 goto unlock;
2106                         }
2107                 } else {
2108                         /*
2109                          * hid-generic implements .match(), so if
2110                          * hid_ignore_special_drivers is set, we can safely
2111                          * return.
2112                          */
2113                         if (hid_ignore_special_drivers) {
2114                                 ret = -ENODEV;
2115                                 goto unlock;
2116                         }
2117                 }
2118
2119                 /* reset the quirks that has been previously set */
2120                 hdev->quirks = hid_lookup_quirk(hdev);
2121                 hdev->driver = hdrv;
2122                 if (hdrv->probe) {
2123                         ret = hdrv->probe(hdev, id);
2124                 } else { /* default probe */
2125                         ret = hid_open_report(hdev);
2126                         if (!ret)
2127                                 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
2128                 }
2129                 if (ret) {
2130                         hid_close_report(hdev);
2131                         hdev->driver = NULL;
2132                 }
2133         }
2134 unlock:
2135         if (!hdev->io_started)
2136                 up(&hdev->driver_input_lock);
2137 end:
2138         return ret;
2139 }
2140
2141 static int hid_device_remove(struct device *dev)
2142 {
2143         struct hid_device *hdev = to_hid_device(dev);
2144         struct hid_driver *hdrv;
2145
2146         down(&hdev->driver_input_lock);
2147         hdev->io_started = false;
2148
2149         hdrv = hdev->driver;
2150         if (hdrv) {
2151                 if (hdrv->remove)
2152                         hdrv->remove(hdev);
2153                 else /* default remove */
2154                         hid_hw_stop(hdev);
2155                 hid_close_report(hdev);
2156                 hdev->driver = NULL;
2157         }
2158
2159         if (!hdev->io_started)
2160                 up(&hdev->driver_input_lock);
2161
2162         return 0;
2163 }
2164
2165 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
2166                              char *buf)
2167 {
2168         struct hid_device *hdev = container_of(dev, struct hid_device, dev);
2169
2170         return scnprintf(buf, PAGE_SIZE, "hid:b%04Xg%04Xv%08Xp%08X\n",
2171                          hdev->bus, hdev->group, hdev->vendor, hdev->product);
2172 }
2173 static DEVICE_ATTR_RO(modalias);
2174
2175 static struct attribute *hid_dev_attrs[] = {
2176         &dev_attr_modalias.attr,
2177         NULL,
2178 };
2179 static struct bin_attribute *hid_dev_bin_attrs[] = {
2180         &dev_bin_attr_report_desc,
2181         NULL
2182 };
2183 static const struct attribute_group hid_dev_group = {
2184         .attrs = hid_dev_attrs,
2185         .bin_attrs = hid_dev_bin_attrs,
2186 };
2187 __ATTRIBUTE_GROUPS(hid_dev);
2188
2189 static int hid_uevent(struct device *dev, struct kobj_uevent_env *env)
2190 {
2191         struct hid_device *hdev = to_hid_device(dev);
2192
2193         if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X",
2194                         hdev->bus, hdev->vendor, hdev->product))
2195                 return -ENOMEM;
2196
2197         if (add_uevent_var(env, "HID_NAME=%s", hdev->name))
2198                 return -ENOMEM;
2199
2200         if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys))
2201                 return -ENOMEM;
2202
2203         if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq))
2204                 return -ENOMEM;
2205
2206         if (add_uevent_var(env, "MODALIAS=hid:b%04Xg%04Xv%08Xp%08X",
2207                            hdev->bus, hdev->group, hdev->vendor, hdev->product))
2208                 return -ENOMEM;
2209
2210         return 0;
2211 }
2212
2213 struct bus_type hid_bus_type = {
2214         .name           = "hid",
2215         .dev_groups     = hid_dev_groups,
2216         .drv_groups     = hid_drv_groups,
2217         .match          = hid_bus_match,
2218         .probe          = hid_device_probe,
2219         .remove         = hid_device_remove,
2220         .uevent         = hid_uevent,
2221 };
2222 EXPORT_SYMBOL(hid_bus_type);
2223
2224 int hid_add_device(struct hid_device *hdev)
2225 {
2226         static atomic_t id = ATOMIC_INIT(0);
2227         int ret;
2228
2229         if (WARN_ON(hdev->status & HID_STAT_ADDED))
2230                 return -EBUSY;
2231
2232         hdev->quirks = hid_lookup_quirk(hdev);
2233
2234         /* we need to kill them here, otherwise they will stay allocated to
2235          * wait for coming driver */
2236         if (hid_ignore(hdev))
2237                 return -ENODEV;
2238
2239         /*
2240          * Check for the mandatory transport channel.
2241          */
2242          if (!hdev->ll_driver->raw_request) {
2243                 hid_err(hdev, "transport driver missing .raw_request()\n");
2244                 return -EINVAL;
2245          }
2246
2247         /*
2248          * Read the device report descriptor once and use as template
2249          * for the driver-specific modifications.
2250          */
2251         ret = hdev->ll_driver->parse(hdev);
2252         if (ret)
2253                 return ret;
2254         if (!hdev->dev_rdesc)
2255                 return -ENODEV;
2256
2257         /*
2258          * Scan generic devices for group information
2259          */
2260         if (hid_ignore_special_drivers) {
2261                 hdev->group = HID_GROUP_GENERIC;
2262         } else if (!hdev->group &&
2263                    !(hdev->quirks & HID_QUIRK_HAVE_SPECIAL_DRIVER)) {
2264                 ret = hid_scan_report(hdev);
2265                 if (ret)
2266                         hid_warn(hdev, "bad device descriptor (%d)\n", ret);
2267         }
2268
2269         hdev->id = atomic_inc_return(&id);
2270
2271         /* XXX hack, any other cleaner solution after the driver core
2272          * is converted to allow more than 20 bytes as the device name? */
2273         dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,
2274                      hdev->vendor, hdev->product, hdev->id);
2275
2276         hid_debug_register(hdev, dev_name(&hdev->dev));
2277         ret = device_add(&hdev->dev);
2278         if (!ret)
2279                 hdev->status |= HID_STAT_ADDED;
2280         else
2281                 hid_debug_unregister(hdev);
2282
2283         return ret;
2284 }
2285 EXPORT_SYMBOL_GPL(hid_add_device);
2286
2287 /**
2288  * hid_allocate_device - allocate new hid device descriptor
2289  *
2290  * Allocate and initialize hid device, so that hid_destroy_device might be
2291  * used to free it.
2292  *
2293  * New hid_device pointer is returned on success, otherwise ERR_PTR encoded
2294  * error value.
2295  */
2296 struct hid_device *hid_allocate_device(void)
2297 {
2298         struct hid_device *hdev;
2299         int ret = -ENOMEM;
2300
2301         hdev = kzalloc(sizeof(*hdev), GFP_KERNEL);
2302         if (hdev == NULL)
2303                 return ERR_PTR(ret);
2304
2305         device_initialize(&hdev->dev);
2306         hdev->dev.release = hid_device_release;
2307         hdev->dev.bus = &hid_bus_type;
2308         device_enable_async_suspend(&hdev->dev);
2309
2310         hid_close_report(hdev);
2311
2312         init_waitqueue_head(&hdev->debug_wait);
2313         INIT_LIST_HEAD(&hdev->debug_list);
2314         spin_lock_init(&hdev->debug_list_lock);
2315         sema_init(&hdev->driver_input_lock, 1);
2316         mutex_init(&hdev->ll_open_lock);
2317         kref_init(&hdev->ref);
2318
2319         return hdev;
2320 }
2321 EXPORT_SYMBOL_GPL(hid_allocate_device);
2322
2323 static void hid_remove_device(struct hid_device *hdev)
2324 {
2325         if (hdev->status & HID_STAT_ADDED) {
2326                 device_del(&hdev->dev);
2327                 hid_debug_unregister(hdev);
2328                 hdev->status &= ~HID_STAT_ADDED;
2329         }
2330         kfree(hdev->dev_rdesc);
2331         hdev->dev_rdesc = NULL;
2332         hdev->dev_rsize = 0;
2333 }
2334
2335 /**
2336  * hid_destroy_device - free previously allocated device
2337  *
2338  * @hdev: hid device
2339  *
2340  * If you allocate hid_device through hid_allocate_device, you should ever
2341  * free by this function.
2342  */
2343 void hid_destroy_device(struct hid_device *hdev)
2344 {
2345         hid_remove_device(hdev);
2346         put_device(&hdev->dev);
2347 }
2348 EXPORT_SYMBOL_GPL(hid_destroy_device);
2349
2350
2351 static int __hid_bus_reprobe_drivers(struct device *dev, void *data)
2352 {
2353         struct hid_driver *hdrv = data;
2354         struct hid_device *hdev = to_hid_device(dev);
2355
2356         if (hdev->driver == hdrv &&
2357             !hdrv->match(hdev, hid_ignore_special_drivers) &&
2358             !test_and_set_bit(ffs(HID_STAT_REPROBED), &hdev->status))
2359                 return device_reprobe(dev);
2360
2361         return 0;
2362 }
2363
2364 static int __hid_bus_driver_added(struct device_driver *drv, void *data)
2365 {
2366         struct hid_driver *hdrv = to_hid_driver(drv);
2367
2368         if (hdrv->match) {
2369                 bus_for_each_dev(&hid_bus_type, NULL, hdrv,
2370                                  __hid_bus_reprobe_drivers);
2371         }
2372
2373         return 0;
2374 }
2375
2376 static int __bus_removed_driver(struct device_driver *drv, void *data)
2377 {
2378         return bus_rescan_devices(&hid_bus_type);
2379 }
2380
2381 int __hid_register_driver(struct hid_driver *hdrv, struct module *owner,
2382                 const char *mod_name)
2383 {
2384         int ret;
2385
2386         hdrv->driver.name = hdrv->name;
2387         hdrv->driver.bus = &hid_bus_type;
2388         hdrv->driver.owner = owner;
2389         hdrv->driver.mod_name = mod_name;
2390
2391         INIT_LIST_HEAD(&hdrv->dyn_list);
2392         spin_lock_init(&hdrv->dyn_lock);
2393
2394         ret = driver_register(&hdrv->driver);
2395
2396         if (ret == 0)
2397                 bus_for_each_drv(&hid_bus_type, NULL, NULL,
2398                                  __hid_bus_driver_added);
2399
2400         return ret;
2401 }
2402 EXPORT_SYMBOL_GPL(__hid_register_driver);
2403
2404 void hid_unregister_driver(struct hid_driver *hdrv)
2405 {
2406         driver_unregister(&hdrv->driver);
2407         hid_free_dynids(hdrv);
2408
2409         bus_for_each_drv(&hid_bus_type, NULL, hdrv, __bus_removed_driver);
2410 }
2411 EXPORT_SYMBOL_GPL(hid_unregister_driver);
2412
2413 int hid_check_keys_pressed(struct hid_device *hid)
2414 {
2415         struct hid_input *hidinput;
2416         int i;
2417
2418         if (!(hid->claimed & HID_CLAIMED_INPUT))
2419                 return 0;
2420
2421         list_for_each_entry(hidinput, &hid->inputs, list) {
2422                 for (i = 0; i < BITS_TO_LONGS(KEY_MAX); i++)
2423                         if (hidinput->input->key[i])
2424                                 return 1;
2425         }
2426
2427         return 0;
2428 }
2429
2430 EXPORT_SYMBOL_GPL(hid_check_keys_pressed);
2431
2432 static int __init hid_init(void)
2433 {
2434         int ret;
2435
2436         if (hid_debug)
2437                 pr_warn("hid_debug is now used solely for parser and driver debugging.\n"
2438                         "debugfs is now used for inspecting the device (report descriptor, reports)\n");
2439
2440         ret = bus_register(&hid_bus_type);
2441         if (ret) {
2442                 pr_err("can't register hid bus\n");
2443                 goto err;
2444         }
2445
2446         ret = hidraw_init();
2447         if (ret)
2448                 goto err_bus;
2449
2450         hid_debug_init();
2451
2452         return 0;
2453 err_bus:
2454         bus_unregister(&hid_bus_type);
2455 err:
2456         return ret;
2457 }
2458
2459 static void __exit hid_exit(void)
2460 {
2461         hid_debug_exit();
2462         hidraw_exit();
2463         bus_unregister(&hid_bus_type);
2464         hid_quirks_exit(HID_BUS_ANY);
2465 }
2466
2467 module_init(hid_init);
2468 module_exit(hid_exit);
2469
2470 MODULE_AUTHOR("Andreas Gal");
2471 MODULE_AUTHOR("Vojtech Pavlik");
2472 MODULE_AUTHOR("Jiri Kosina");
2473 MODULE_LICENSE("GPL");