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