LCOV - code coverage report
Current view: top level - drivers/hid - hid-core.c (source / functions) Hit Total Coverage
Test: Real Lines: 581 973 59.7 %
Date: 2020-10-17 15:46:16 Functions: 2 73 2.7 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14