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-2007 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 #include <linux/module.h>
  18 #include <linux/slab.h>
  19 #include <linux/init.h>
  20 #include <linux/kernel.h>
  21 #include <linux/list.h>
  22 #include <linux/mm.h>
  23 #include <linux/spinlock.h>
  24 #include <asm/unaligned.h>
  25 #include <asm/byteorder.h>
  26 #include <linux/input.h>
  27 #include <linux/wait.h>
  28 #include <linux/vmalloc.h>
  29
  30 #include <linux/hid.h>
  31 #include <linux/hiddev.h>
  32 #include <linux/hid-debug.h>
  33 #include <linux/hidraw.h>
  34
  35 /*
  36  * Version Information
  37  */
  38
  39 #define DRIVER_VERSION "v2.6"
  40 #define DRIVER_AUTHOR "Andreas Gal, Vojtech Pavlik, Jiri Kosina"
  41 #define DRIVER_DESC "HID core driver"
  42 #define DRIVER_LICENSE "GPL"
  43
  44 #ifdef CONFIG_HID_DEBUG
  45 int hid_debug = 0;
  46 module_param_named(debug, hid_debug, bool, 0600);
  47 MODULE_PARM_DESC(debug, "Turn HID debugging mode on and off");
  48 EXPORT_SYMBOL_GPL(hid_debug);
  49 #endif
  50
  51 /*
  52  * Register a new report for a device.
  53  */
  54
  55 static struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id)
  56 {
  57         struct hid_report_enum *report_enum = device->report_enum + type;
  58         struct hid_report *report;
  59
  60         if (report_enum->report_id_hash[id])
  61                 return report_enum->report_id_hash[id];
  62
  63         if (!(report = kzalloc(sizeof(struct hid_report), GFP_KERNEL)))
  64                 return NULL;
  65
  66         if (id != 0)
  67                 report_enum->numbered = 1;
  68
  69         report->id = id;
  70         report->type = type;
  71         report->size = 0;
  72         report->device = device;
  73         report_enum->report_id_hash[id] = report;
  74
  75         list_add_tail(&report->list, &report_enum->report_list);
  76
  77         return report;
  78 }
  79
  80 /*
  81  * Register a new field for this report.
  82  */
  83
  84 static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages, unsigned values)
  85 {
  86         struct hid_field *field;
  87
  88         if (report->maxfield == HID_MAX_FIELDS) {
  89                 dbg_hid("too many fields in report\n");
  90                 return NULL;
  91         }
  92
  93         if (!(field = kzalloc(sizeof(struct hid_field) + usages * sizeof(struct hid_usage)
  94                 + values * sizeof(unsigned), GFP_KERNEL))) return NULL;
  95
  96         field->index = report->maxfield++;
  97         report->field[field->index] = field;
  98         field->usage = (struct hid_usage *)(field + 1);
  99         field->value = (unsigned *)(field->usage + usages);
 100         field->report = report;
 101
 102         return field;
 103 }
 104
 105 /*
 106  * Open a collection. The type/usage is pushed on the stack.
 107  */
 108
 109 static int open_collection(struct hid_parser *parser, unsigned type)
 110 {
 111         struct hid_collection *collection;
 112         unsigned usage;
 113
 114         usage = parser->local.usage[0];
 115
 116         if (parser->collection_stack_ptr == HID_COLLECTION_STACK_SIZE) {
 117                 dbg_hid("collection stack overflow\n");
 118                 return -1;
 119         }
 120
 121         if (parser->device->maxcollection == parser->device->collection_size) {
 122                 collection = kmalloc(sizeof(struct hid_collection) *
 123                                 parser->device->collection_size * 2, GFP_KERNEL);
 124                 if (collection == NULL) {
 125                         dbg_hid("failed to reallocate collection array\n");
 126                         return -1;
 127                 }
 128                 memcpy(collection, parser->device->collection,
 129                         sizeof(struct hid_collection) *
 130                         parser->device->collection_size);
 131                 memset(collection + parser->device->collection_size, 0,
 132                         sizeof(struct hid_collection) *
 133                         parser->device->collection_size);
 134                 kfree(parser->device->collection);
 135                 parser->device->collection = collection;
 136                 parser->device->collection_size *= 2;
 137         }
 138
 139         parser->collection_stack[parser->collection_stack_ptr++] =
 140                 parser->device->maxcollection;
 141
 142         collection = parser->device->collection +
 143                 parser->device->maxcollection++;
 144         collection->type = type;
 145         collection->usage = usage;
 146         collection->level = parser->collection_stack_ptr - 1;
 147
 148         if (type == HID_COLLECTION_APPLICATION)
 149                 parser->device->maxapplication++;
 150
 151         return 0;
 152 }
 153
 154 /*
 155  * Close a collection.
 156  */
 157
 158 static int close_collection(struct hid_parser *parser)
 159 {
 160         if (!parser->collection_stack_ptr) {
 161                 dbg_hid("collection stack underflow\n");
 162                 return -1;
 163         }
 164         parser->collection_stack_ptr--;
 165         return 0;
 166 }
 167
 168 /*
 169  * Climb up the stack, search for the specified collection type
 170  * and return the usage.
 171  */
 172
 173 static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
 174 {
 175         int n;
 176         for (n = parser->collection_stack_ptr - 1; n >= 0; n--)
 177                 if (parser->device->collection[parser->collection_stack[n]].type == type)
 178                         return parser->device->collection[parser->collection_stack[n]].usage;
 179         return 0; /* we know nothing about this usage type */
 180 }
 181
 182 /*
 183  * Add a usage to the temporary parser table.
 184  */
 185
 186 static int hid_add_usage(struct hid_parser *parser, unsigned usage)
 187 {
 188         if (parser->local.usage_index >= HID_MAX_USAGES) {
 189                 dbg_hid("usage index exceeded\n");
 190                 return -1;
 191         }
 192         parser->local.usage[parser->local.usage_index] = usage;
 193         parser->local.collection_index[parser->local.usage_index] =
 194                 parser->collection_stack_ptr ?
 195                 parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
 196         parser->local.usage_index++;
 197         return 0;
 198 }
 199
 200 /*
 201  * Register a new field for this report.
 202  */
 203
 204 static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)
 205 {
 206         struct hid_report *report;
 207         struct hid_field *field;
 208         int usages;
 209         unsigned offset;
 210         int i;
 211
 212         if (!(report = hid_register_report(parser->device, report_type, parser->global.report_id))) {
 213                 dbg_hid("hid_register_report failed\n");
 214                 return -1;
 215         }
 216
 217         if (parser->global.logical_maximum < parser->global.logical_minimum) {
 218                 dbg_hid("logical range invalid %d %d\n", parser->global.logical_minimum, parser->global.logical_maximum);
 219                 return -1;
 220         }
 221
 222         offset = report->size;
 223         report->size += parser->global.report_size * parser->global.report_count;
 224
 225         if (!parser->local.usage_index) /* Ignore padding fields */
 226                 return 0;
 227
 228         usages = max_t(int, parser->local.usage_index, parser->global.report_count);
 229
 230         if ((field = hid_register_field(report, usages, parser->global.report_count)) == NULL)
 231                 return 0;
 232
 233         field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);
 234         field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);
 235         field->application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);
 236
 237         for (i = 0; i < usages; i++) {
 238                 int j = i;
 239                 /* Duplicate the last usage we parsed if we have excess values */
 240                 if (i >= parser->local.usage_index)
 241                         j = parser->local.usage_index - 1;
 242                 field->usage[i].hid = parser->local.usage[j];
 243                 field->usage[i].collection_index =
 244                         parser->local.collection_index[j];
 245         }
 246
 247         field->maxusage = usages;
 248         field->flags = flags;
 249         field->report_offset = offset;
 250         field->report_type = report_type;
 251         field->report_size = parser->global.report_size;
 252         field->report_count = parser->global.report_count;
 253         field->logical_minimum = parser->global.logical_minimum;
 254         field->logical_maximum = parser->global.logical_maximum;
 255         field->physical_minimum = parser->global.physical_minimum;
 256         field->physical_maximum = parser->global.physical_maximum;
 257         field->unit_exponent = parser->global.unit_exponent;
 258         field->unit = parser->global.unit;
 259
 260         return 0;
 261 }
 262
 263 /*
 264  * Read data value from item.
 265  */
 266
 267 static u32 item_udata(struct hid_item *item)
 268 {
 269         switch (item->size) {
 270                 case 1: return item->data.u8;
 271                 case 2: return item->data.u16;
 272                 case 4: return item->data.u32;
 273         }
 274         return 0;
 275 }
 276
 277 static s32 item_sdata(struct hid_item *item)
 278 {
 279         switch (item->size) {
 280                 case 1: return item->data.s8;
 281                 case 2: return item->data.s16;
 282                 case 4: return item->data.s32;
 283         }
 284         return 0;
 285 }
 286
 287 /*
 288  * Process a global item.
 289  */
 290
 291 static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
 292 {
 293         switch (item->tag) {
 294
 295                 case HID_GLOBAL_ITEM_TAG_PUSH:
 296
 297                         if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
 298                                 dbg_hid("global enviroment stack overflow\n");
 299                                 return -1;
 300                         }
 301
 302                         memcpy(parser->global_stack + parser->global_stack_ptr++,
 303                                 &parser->global, sizeof(struct hid_global));
 304                         return 0;
 305
 306                 case HID_GLOBAL_ITEM_TAG_POP:
 307
 308                         if (!parser->global_stack_ptr) {
 309                                 dbg_hid("global enviroment stack underflow\n");
 310                                 return -1;
 311                         }
 312
 313                         memcpy(&parser->global, parser->global_stack + --parser->global_stack_ptr,
 314                                 sizeof(struct hid_global));
 315                         return 0;
 316
 317                 case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
 318                         parser->global.usage_page = item_udata(item);
 319                         return 0;
 320
 321                 case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
 322                         parser->global.logical_minimum = item_sdata(item);
 323                         return 0;
 324
 325                 case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
 326                         if (parser->global.logical_minimum < 0)
 327                                 parser->global.logical_maximum = item_sdata(item);
 328                         else
 329                                 parser->global.logical_maximum = item_udata(item);
 330                         return 0;
 331
 332                 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
 333                         parser->global.physical_minimum = item_sdata(item);
 334                         return 0;
 335
 336                 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
 337                         if (parser->global.physical_minimum < 0)
 338                                 parser->global.physical_maximum = item_sdata(item);
 339                         else
 340                                 parser->global.physical_maximum = item_udata(item);
 341                         return 0;
 342
 343                 case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
 344                         parser->global.unit_exponent = item_sdata(item);
 345                         return 0;
 346
 347                 case HID_GLOBAL_ITEM_TAG_UNIT:
 348                         parser->global.unit = item_udata(item);
 349                         return 0;
 350
 351                 case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
 352                         if ((parser->global.report_size = item_udata(item)) > 32) {
 353                                 dbg_hid("invalid report_size %d\n", parser->global.report_size);
 354                                 return -1;
 355                         }
 356                         return 0;
 357
 358                 case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
 359                         if ((parser->global.report_count = item_udata(item)) > HID_MAX_USAGES) {
 360                                 dbg_hid("invalid report_count %d\n", parser->global.report_count);
 361                                 return -1;
 362                         }
 363                         return 0;
 364
 365                 case HID_GLOBAL_ITEM_TAG_REPORT_ID:
 366                         if ((parser->global.report_id = item_udata(item)) == 0) {
 367                                 dbg_hid("report_id 0 is invalid\n");
 368                                 return -1;
 369                         }
 370                         return 0;
 371
 372                 default:
 373                         dbg_hid("unknown global tag 0x%x\n", item->tag);
 374                         return -1;
 375         }
 376 }
 377
 378 /*
 379  * Process a local item.
 380  */
 381
 382 static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
 383 {
 384         __u32 data;
 385         unsigned n;
 386
 387         if (item->size == 0) {
 388                 dbg_hid("item data expected for local item\n");
 389                 return -1;
 390         }
 391
 392         data = item_udata(item);
 393
 394         switch (item->tag) {
 395
 396                 case HID_LOCAL_ITEM_TAG_DELIMITER:
 397
 398                         if (data) {
 399                                 /*
 400                                  * We treat items before the first delimiter
 401                                  * as global to all usage sets (branch 0).
 402                                  * In the moment we process only these global
 403                                  * items and the first delimiter set.
 404                                  */
 405                                 if (parser->local.delimiter_depth != 0) {
 406                                         dbg_hid("nested delimiters\n");
 407                                         return -1;
 408                                 }
 409                                 parser->local.delimiter_depth++;
 410                                 parser->local.delimiter_branch++;
 411                         } else {
 412                                 if (parser->local.delimiter_depth < 1) {
 413                                         dbg_hid("bogus close delimiter\n");
 414                                         return -1;
 415                                 }
 416                                 parser->local.delimiter_depth--;
 417                         }
 418                         return 1;
 419
 420                 case HID_LOCAL_ITEM_TAG_USAGE:
 421
 422                         if (parser->local.delimiter_branch > 1) {
 423                                 dbg_hid("alternative usage ignored\n");
 424                                 return 0;
 425                         }
 426
 427                         if (item->size <= 2)
 428                                 data = (parser->global.usage_page << 16) + data;
 429
 430                         return hid_add_usage(parser, data);
 431
 432                 case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 433
 434                         if (parser->local.delimiter_branch > 1) {
 435                                 dbg_hid("alternative usage ignored\n");
 436                                 return 0;
 437                         }
 438
 439                         if (item->size <= 2)
 440                                 data = (parser->global.usage_page << 16) + data;
 441
 442                         parser->local.usage_minimum = data;
 443                         return 0;
 444
 445                 case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 446
 447                         if (parser->local.delimiter_branch > 1) {
 448                                 dbg_hid("alternative usage ignored\n");
 449                                 return 0;
 450                         }
 451
 452                         if (item->size <= 2)
 453                                 data = (parser->global.usage_page << 16) + data;
 454
 455                         for (n = parser->local.usage_minimum; n <= data; n++)
 456                                 if (hid_add_usage(parser, n)) {
 457                                         dbg_hid("hid_add_usage failed\n");
 458                                         return -1;
 459                                 }
 460                         return 0;
 461
 462                 default:
 463
 464                         dbg_hid("unknown local item tag 0x%x\n", item->tag);
 465                         return 0;
 466         }
 467         return 0;
 468 }
 469
 470 /*
 471  * Process a main item.
 472  */
 473
 474 static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
 475 {
 476         __u32 data;
 477         int ret;
 478
 479         data = item_udata(item);
 480
 481         switch (item->tag) {
 482                 case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
 483                         ret = open_collection(parser, data & 0xff);
 484                         break;
 485                 case HID_MAIN_ITEM_TAG_END_COLLECTION:
 486                         ret = close_collection(parser);
 487                         break;
 488                 case HID_MAIN_ITEM_TAG_INPUT:
 489                         ret = hid_add_field(parser, HID_INPUT_REPORT, data);
 490                         break;
 491                 case HID_MAIN_ITEM_TAG_OUTPUT:
 492                         ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
 493                         break;
 494                 case HID_MAIN_ITEM_TAG_FEATURE:
 495                         ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
 496                         break;
 497                 default:
 498                         dbg_hid("unknown main item tag 0x%x\n", item->tag);
 499                         ret = 0;
 500         }
 501
 502         memset(&parser->local, 0, sizeof(parser->local));       /* Reset the local parser environment */
 503
 504         return ret;
 505 }
 506
 507 /*
 508  * Process a reserved item.
 509  */
 510
 511 static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)
 512 {
 513         dbg_hid("reserved item type, tag 0x%x\n", item->tag);
 514         return 0;
 515 }
 516
 517 /*
 518  * Free a report and all registered fields. The field->usage and
 519  * field->value table's are allocated behind the field, so we need
 520  * only to free(field) itself.
 521  */
 522
 523 static void hid_free_report(struct hid_report *report)
 524 {
 525         unsigned n;
 526
 527         for (n = 0; n < report->maxfield; n++)
 528                 kfree(report->field[n]);
 529         kfree(report);
 530 }
 531
 532 /*
 533  * Free a device structure, all reports, and all fields.
 534  */
 535
 536 void hid_free_device(struct hid_device *device)
 537 {
 538         unsigned i,j;
 539
 540         for (i = 0; i < HID_REPORT_TYPES; i++) {
 541                 struct hid_report_enum *report_enum = device->report_enum + i;
 542
 543                 for (j = 0; j < 256; j++) {
 544                         struct hid_report *report = report_enum->report_id_hash[j];
 545                         if (report)
 546                                 hid_free_report(report);
 547                 }
 548         }
 549
 550         kfree(device->rdesc);
 551         kfree(device->collection);
 552         kfree(device);
 553 }
 554 EXPORT_SYMBOL_GPL(hid_free_device);
 555
 556 /*
 557  * Fetch a report description item from the data stream. We support long
 558  * items, though they are not used yet.
 559  */
 560
 561 static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
 562 {
 563         u8 b;
 564
 565         if ((end - start) <= 0)
 566                 return NULL;
 567
 568         b = *start++;
 569
 570         item->type = (b >> 2) & 3;
 571         item->tag  = (b >> 4) & 15;
 572
 573         if (item->tag == HID_ITEM_TAG_LONG) {
 574
 575                 item->format = HID_ITEM_FORMAT_LONG;
 576
 577                 if ((end - start) < 2)
 578                         return NULL;
 579
 580                 item->size = *start++;
 581                 item->tag  = *start++;
 582
 583                 if ((end - start) < item->size)
 584                         return NULL;
 585
 586                 item->data.longdata = start;
 587                 start += item->size;
 588                 return start;
 589         }
 590
 591         item->format = HID_ITEM_FORMAT_SHORT;
 592         item->size = b & 3;
 593
 594         switch (item->size) {
 595
 596                 case 0:
 597                         return start;
 598
 599                 case 1:
 600                         if ((end - start) < 1)
 601                                 return NULL;
 602                         item->data.u8 = *start++;
 603                         return start;
 604
 605                 case 2:
 606                         if ((end - start) < 2)
 607                                 return NULL;
 608                         item->data.u16 = le16_to_cpu(get_unaligned((__le16*)start));
 609                         start = (__u8 *)((__le16 *)start + 1);
 610                         return start;
 611
 612                 case 3:
 613                         item->size++;
 614                         if ((end - start) < 4)
 615                                 return NULL;
 616                         item->data.u32 = le32_to_cpu(get_unaligned((__le32*)start));
 617                         start = (__u8 *)((__le32 *)start + 1);
 618                         return start;
 619         }
 620
 621         return NULL;
 622 }
 623
 624 /*
 625  * Parse a report description into a hid_device structure. Reports are
 626  * enumerated, fields are attached to these reports.
 627  */
 628
 629 struct hid_device *hid_parse_report(__u8 *start, unsigned size)
 630 {
 631         struct hid_device *device;
 632         struct hid_parser *parser;
 633         struct hid_item item;
 634         __u8 *end;
 635         unsigned i;
 636         static int (*dispatch_type[])(struct hid_parser *parser,
 637                                       struct hid_item *item) = {
 638                 hid_parser_main,
 639                 hid_parser_global,
 640                 hid_parser_local,
 641                 hid_parser_reserved
 642         };
 643
 644         if (!(device = kzalloc(sizeof(struct hid_device), GFP_KERNEL)))
 645                 return NULL;
 646
 647         if (!(device->collection = kzalloc(sizeof(struct hid_collection) *
 648                                    HID_DEFAULT_NUM_COLLECTIONS, GFP_KERNEL))) {
 649                 kfree(device);
 650                 return NULL;
 651         }
 652         device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
 653
 654         for (i = 0; i < HID_REPORT_TYPES; i++)
 655                 INIT_LIST_HEAD(&device->report_enum[i].report_list);
 656
 657         if (!(device->rdesc = kmalloc(size, GFP_KERNEL))) {
 658                 kfree(device->collection);
 659                 kfree(device);
 660                 return NULL;
 661         }
 662         memcpy(device->rdesc, start, size);
 663         device->rsize = size;
 664
 665         if (!(parser = vmalloc(sizeof(struct hid_parser)))) {
 666                 kfree(device->rdesc);
 667                 kfree(device->collection);
 668                 kfree(device);
 669                 return NULL;
 670         }
 671         memset(parser, 0, sizeof(struct hid_parser));
 672         parser->device = device;
 673
 674         end = start + size;
 675         while ((start = fetch_item(start, end, &item)) != NULL) {
 676
 677                 if (item.format != HID_ITEM_FORMAT_SHORT) {
 678                         dbg_hid("unexpected long global item\n");
 679                         hid_free_device(device);
 680                         vfree(parser);
 681                         return NULL;
 682                 }
 683
 684                 if (dispatch_type[item.type](parser, &item)) {
 685                         dbg_hid("item %u %u %u %u parsing failed\n",
 686                                 item.format, (unsigned)item.size, (unsigned)item.type, (unsigned)item.tag);
 687                         hid_free_device(device);
 688                         vfree(parser);
 689                         return NULL;
 690                 }
 691
 692                 if (start == end) {
 693                         if (parser->collection_stack_ptr) {
 694                                 dbg_hid("unbalanced collection at end of report description\n");
 695                                 hid_free_device(device);
 696                                 vfree(parser);
 697                                 return NULL;
 698                         }
 699                         if (parser->local.delimiter_depth) {
 700                                 dbg_hid("unbalanced delimiter at end of report description\n");
 701                                 hid_free_device(device);
 702                                 vfree(parser);
 703                                 return NULL;
 704                         }
 705                         vfree(parser);
 706                         return device;
 707                 }
 708         }
 709
 710         dbg_hid("item fetching failed at offset %d\n", (int)(end - start));
 711         hid_free_device(device);
 712         vfree(parser);
 713         return NULL;
 714 }
 715 EXPORT_SYMBOL_GPL(hid_parse_report);
 716
 717 /*
 718  * Convert a signed n-bit integer to signed 32-bit integer. Common
 719  * cases are done through the compiler, the screwed things has to be
 720  * done by hand.
 721  */
 722
 723 static s32 snto32(__u32 value, unsigned n)
 724 {
 725         switch (n) {
 726                 case 8:  return ((__s8)value);
 727                 case 16: return ((__s16)value);
 728                 case 32: return ((__s32)value);
 729         }
 730         return value & (1 << (n - 1)) ? value | (-1 << n) : value;
 731 }
 732
 733 /*
 734  * Convert a signed 32-bit integer to a signed n-bit integer.
 735  */
 736
 737 static u32 s32ton(__s32 value, unsigned n)
 738 {
 739         s32 a = value >> (n - 1);
 740         if (a && a != -1)
 741                 return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1;
 742         return value & ((1 << n) - 1);
 743 }
 744
 745 /*
 746  * Extract/implement a data field from/to a little endian report (bit array).
 747  *
 748  * Code sort-of follows HID spec:
 749  *     http://www.usb.org/developers/devclass_docs/HID1_11.pdf
 750  *
 751  * While the USB HID spec allows unlimited length bit fields in "report
 752  * descriptors", most devices never use more than 16 bits.
 753  * One model of UPS is claimed to report "LINEV" as a 32-bit field.
 754  * Search linux-kernel and linux-usb-devel archives for "hid-core extract".
 755  */
 756
 757 static __inline__ __u32 extract(__u8 *report, unsigned offset, unsigned n)
 758 {
 759         u64 x;
 760
 761         WARN_ON(n > 32);
 762
 763         report += offset >> 3;  /* adjust byte index */
 764         offset &= 7;            /* now only need bit offset into one byte */
 765         x = le64_to_cpu(get_unaligned((__le64 *) report));
 766         x = (x >> offset) & ((1ULL << n) - 1);  /* extract bit field */
 767         return (u32) x;
 768 }
 769
 770 /*
 771  * "implement" : set bits in a little endian bit stream.
 772  * Same concepts as "extract" (see comments above).
 773  * The data mangled in the bit stream remains in little endian
 774  * order the whole time. It make more sense to talk about
 775  * endianness of register values by considering a register
 776  * a "cached" copy of the little endiad bit stream.
 777  */
 778 static __inline__ void implement(__u8 *report, unsigned offset, unsigned n, __u32 value)
 779 {
 780         __le64 x;
 781         u64 m = (1ULL << n) - 1;
 782
 783         WARN_ON(n > 32);
 784
 785         WARN_ON(value > m);
 786         value &= m;
 787
 788         report += offset >> 3;
 789         offset &= 7;
 790
 791         x = get_unaligned((__le64 *)report);
 792         x &= cpu_to_le64(~(m << offset));
 793         x |= cpu_to_le64(((u64) value) << offset);
 794         put_unaligned(x, (__le64 *) report);
 795 }
 796
 797 /*
 798  * Search an array for a value.
 799  */
 800
 801 static __inline__ int search(__s32 *array, __s32 value, unsigned n)
 802 {
 803         while (n--) {
 804                 if (*array++ == value)
 805                         return 0;
 806         }
 807         return -1;
 808 }
 809
 810 static void hid_process_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value, int interrupt)
 811 {
 812         hid_dump_input(usage, value);
 813         if (hid->claimed & HID_CLAIMED_INPUT)
 814                 hidinput_hid_event(hid, field, usage, value);
 815         if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt && hid->hiddev_hid_event)
 816                 hid->hiddev_hid_event(hid, field, usage, value);
 817 }
 818
 819 /*
 820  * Analyse a received field, and fetch the data from it. The field
 821  * content is stored for next report processing (we do differential
 822  * reporting to the layer).
 823  */
 824
 825 void hid_input_field(struct hid_device *hid, struct hid_field *field, __u8 *data, int interrupt)
 826 {
 827         unsigned n;
 828         unsigned count = field->report_count;
 829         unsigned offset = field->report_offset;
 830         unsigned size = field->report_size;
 831         __s32 min = field->logical_minimum;
 832         __s32 max = field->logical_maximum;
 833         __s32 *value;
 834
 835         if (!(value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC)))
 836                 return;
 837
 838         for (n = 0; n < count; n++) {
 839
 840                         value[n] = min < 0 ? snto32(extract(data, offset + n * size, size), size) :
 841                                                     extract(data, offset + n * size, size);
 842
 843                         if (!(field->flags & HID_MAIN_ITEM_VARIABLE) /* Ignore report if ErrorRollOver */
 844                             && value[n] >= min && value[n] <= max
 845                             && field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
 846                                 goto exit;
 847         }
 848
 849         for (n = 0; n < count; n++) {
 850
 851                 if (HID_MAIN_ITEM_VARIABLE & field->flags) {
 852                         hid_process_event(hid, field, &field->usage[n], value[n], interrupt);
 853                         continue;
 854                 }
 855
 856                 if (field->value[n] >= min && field->value[n] <= max
 857                         && field->usage[field->value[n] - min].hid
 858                         && search(value, field->value[n], count))
 859                                 hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt);
 860
 861                 if (value[n] >= min && value[n] <= max
 862                         && field->usage[value[n] - min].hid
 863                         && search(field->value, value[n], count))
 864                                 hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt);
 865         }
 866
 867         memcpy(field->value, value, count * sizeof(__s32));
 868 exit:
 869         kfree(value);
 870 }
 871 EXPORT_SYMBOL_GPL(hid_input_field);
 872
 873 /*
 874  * Output the field into the report.
 875  */
 876
 877 static void hid_output_field(struct hid_field *field, __u8 *data)
 878 {
 879         unsigned count = field->report_count;
 880         unsigned offset = field->report_offset;
 881         unsigned size = field->report_size;
 882         unsigned bitsused = offset + count * size;
 883         unsigned n;
 884
 885         /* make sure the unused bits in the last byte are zeros */
 886         if (count > 0 && size > 0 && (bitsused % 8) != 0)
 887                 data[(bitsused-1)/8] &= (1 << (bitsused % 8)) - 1;
 888
 889         for (n = 0; n < count; n++) {
 890                 if (field->logical_minimum < 0) /* signed values */
 891                         implement(data, offset + n * size, size, s32ton(field->value[n], size));
 892                 else                            /* unsigned values */
 893                         implement(data, offset + n * size, size, field->value[n]);
 894         }
 895 }
 896
 897 /*
 898  * Create a report.
 899  */
 900
 901 void hid_output_report(struct hid_report *report, __u8 *data)
 902 {
 903         unsigned n;
 904
 905         if (report->id > 0)
 906                 *data++ = report->id;
 907
 908         for (n = 0; n < report->maxfield; n++)
 909                 hid_output_field(report->field[n], data);
 910 }
 911 EXPORT_SYMBOL_GPL(hid_output_report);
 912
 913 /*
 914  * Set a field value. The report this field belongs to has to be
 915  * created and transferred to the device, to set this value in the
 916  * device.
 917  */
 918
 919 int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
 920 {
 921         unsigned size = field->report_size;
 922
 923         hid_dump_input(field->usage + offset, value);
 924
 925         if (offset >= field->report_count) {
 926                 dbg_hid("offset (%d) exceeds report_count (%d)\n", offset, field->report_count);
 927                 hid_dump_field(field, 8);
 928                 return -1;
 929         }
 930         if (field->logical_minimum < 0) {
 931                 if (value != snto32(s32ton(value, size), size)) {
 932                         dbg_hid("value %d is out of range\n", value);
 933                         return -1;
 934                 }
 935         }
 936         field->value[offset] = value;
 937         return 0;
 938 }
 939 EXPORT_SYMBOL_GPL(hid_set_field);
 940
 941 int hid_input_report(struct hid_device *hid, int type, u8 *data, int size, int interrupt)
 942 {
 943         struct hid_report_enum *report_enum = hid->report_enum + type;
 944         struct hid_report *report;
 945         int n, rsize, i;
 946
 947         if (!hid)
 948                 return -ENODEV;
 949
 950         if (!size) {
 951                 dbg_hid("empty report\n");
 952                 return -1;
 953         }
 954
 955         dbg_hid("report (size %u) (%snumbered)\n", size, report_enum->numbered ? "" : "un");
 956
 957         n = 0;                          /* Normally report number is 0 */
 958         if (report_enum->numbered) {    /* Device uses numbered reports, data[0] is report number */
 959                 n = *data++;
 960                 size--;
 961         }
 962
 963         /* dump the report descriptor */
 964         dbg_hid("report %d (size %u) = ", n, size);
 965         for (i = 0; i < size; i++)
 966                 dbg_hid_line(" %02x", data[i]);
 967         dbg_hid_line("\n");
 968
 969         if (!(report = report_enum->report_id_hash[n])) {
 970                 dbg_hid("undefined report_id %d received\n", n);
 971                 return -1;
 972         }
 973
 974         rsize = ((report->size - 1) >> 3) + 1;
 975
 976         if (size < rsize) {
 977                 dbg_hid("report %d is too short, (%d < %d)\n", report->id, size, rsize);
 978                 memset(data + size, 0, rsize - size);
 979         }
 980
 981         if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
 982                 hid->hiddev_report_event(hid, report);
 983         if (hid->claimed & HID_CLAIMED_HIDRAW)
 984                 hidraw_report_event(hid, data, size);
 985
 986         for (n = 0; n < report->maxfield; n++)
 987                 hid_input_field(hid, report->field[n], data, interrupt);
 988
 989         if (hid->claimed & HID_CLAIMED_INPUT)
 990                 hidinput_report_event(hid, report);
 991
 992         return 0;
 993 }
 994 EXPORT_SYMBOL_GPL(hid_input_report);
 995
 996 static int __init hid_init(void)
 997 {
 998         return hidraw_init();
 999 }
1000
1001 static void __exit hid_exit(void)
1002 {
1003         hidraw_exit();
1004 }
1005
1006 module_init(hid_init);
1007 module_exit(hid_exit);
1008
1009 MODULE_LICENSE(DRIVER_LICENSE);
1010