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