LCOV - code coverage report
Current view: top level - drivers/hid - hid-input.c (source / functions) Hit Total Coverage
Test: Real Lines: 376 842 44.7 %
Date: 2020-10-17 15:46:16 Functions: 3 33 9.1 %
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                 :            :  *  Copyright (c) 2000-2001 Vojtech Pavlik
       4                 :            :  *  Copyright (c) 2006-2010 Jiri Kosina
       5                 :            :  *
       6                 :            :  *  HID to Linux Input mapping
       7                 :            :  */
       8                 :            : 
       9                 :            : /*
      10                 :            :  *
      11                 :            :  * Should you need to contact me, the author, you can do so either by
      12                 :            :  * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
      13                 :            :  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
      14                 :            :  */
      15                 :            : 
      16                 :            : #include <linux/module.h>
      17                 :            : #include <linux/slab.h>
      18                 :            : #include <linux/kernel.h>
      19                 :            : 
      20                 :            : #include <linux/hid.h>
      21                 :            : #include <linux/hid-debug.h>
      22                 :            : 
      23                 :            : #include "hid-ids.h"
      24                 :            : 
      25                 :            : #define unk     KEY_UNKNOWN
      26                 :            : 
      27                 :            : static const unsigned char hid_keyboard[256] = {
      28                 :            :           0,  0,  0,  0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
      29                 :            :          50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44,  2,  3,
      30                 :            :           4,  5,  6,  7,  8,  9, 10, 11, 28,  1, 14, 15, 57, 12, 13, 26,
      31                 :            :          27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
      32                 :            :          65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
      33                 :            :         105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
      34                 :            :          72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
      35                 :            :         191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
      36                 :            :         115,114,unk,unk,unk,121,unk, 89, 93,124, 92, 94, 95,unk,unk,unk,
      37                 :            :         122,123, 90, 91, 85,unk,unk,unk,unk,unk,unk,unk,111,unk,unk,unk,
      38                 :            :         unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
      39                 :            :         unk,unk,unk,unk,unk,unk,179,180,unk,unk,unk,unk,unk,unk,unk,unk,
      40                 :            :         unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
      41                 :            :         unk,unk,unk,unk,unk,unk,unk,unk,111,unk,unk,unk,unk,unk,unk,unk,
      42                 :            :          29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
      43                 :            :         150,158,159,128,136,177,178,176,142,152,173,140,unk,unk,unk,unk
      44                 :            : };
      45                 :            : 
      46                 :            : static const struct {
      47                 :            :         __s32 x;
      48                 :            :         __s32 y;
      49                 :            : }  hid_hat_to_axis[] = {{ 0, 0}, { 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
      50                 :            : 
      51                 :            : #define map_abs(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_ABS, (c))
      52                 :            : #define map_rel(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_REL, (c))
      53                 :            : #define map_key(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_KEY, (c))
      54                 :            : #define map_led(c)      hid_map_usage(hidinput, usage, &bit, &max, EV_LED, (c))
      55                 :            : 
      56                 :            : #define map_abs_clear(c)        hid_map_usage_clear(hidinput, usage, &bit, \
      57                 :            :                 &max, EV_ABS, (c))
      58                 :            : #define map_key_clear(c)        hid_map_usage_clear(hidinput, usage, &bit, \
      59                 :            :                 &max, EV_KEY, (c))
      60                 :            : 
      61                 :          0 : static bool match_scancode(struct hid_usage *usage,
      62                 :            :                            unsigned int cur_idx, unsigned int scancode)
      63                 :            : {
      64                 :          0 :         return (usage->hid & (HID_USAGE_PAGE | HID_USAGE)) == scancode;
      65                 :            : }
      66                 :            : 
      67                 :          0 : static bool match_keycode(struct hid_usage *usage,
      68                 :            :                           unsigned int cur_idx, unsigned int keycode)
      69                 :            : {
      70                 :            :         /*
      71                 :            :          * We should exclude unmapped usages when doing lookup by keycode.
      72                 :            :          */
      73                 :          0 :         return (usage->type == EV_KEY && usage->code == keycode);
      74                 :            : }
      75                 :            : 
      76                 :          0 : static bool match_index(struct hid_usage *usage,
      77                 :            :                         unsigned int cur_idx, unsigned int idx)
      78                 :            : {
      79                 :          0 :         return cur_idx == idx;
      80                 :            : }
      81                 :            : 
      82                 :            : typedef bool (*hid_usage_cmp_t)(struct hid_usage *usage,
      83                 :            :                                 unsigned int cur_idx, unsigned int val);
      84                 :            : 
      85                 :          0 : static struct hid_usage *hidinput_find_key(struct hid_device *hid,
      86                 :            :                                            hid_usage_cmp_t match,
      87                 :            :                                            unsigned int value,
      88                 :            :                                            unsigned int *usage_idx)
      89                 :            : {
      90                 :            :         unsigned int i, j, k, cur_idx = 0;
      91                 :            :         struct hid_report *report;
      92                 :            :         struct hid_usage *usage;
      93                 :            : 
      94                 :          0 :         for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
      95                 :          0 :                 list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
      96                 :          0 :                         for (i = 0; i < report->maxfield; i++) {
      97                 :          0 :                                 for (j = 0; j < report->field[i]->maxusage; j++) {
      98                 :          0 :                                         usage = report->field[i]->usage + j;
      99                 :          0 :                                         if (usage->type == EV_KEY || usage->type == 0) {
     100                 :          0 :                                                 if (match(usage, cur_idx, value)) {
     101                 :          0 :                                                         if (usage_idx)
     102                 :          0 :                                                                 *usage_idx = cur_idx;
     103                 :          0 :                                                         return usage;
     104                 :            :                                                 }
     105                 :          0 :                                                 cur_idx++;
     106                 :            :                                         }
     107                 :            :                                 }
     108                 :            :                         }
     109                 :            :                 }
     110                 :            :         }
     111                 :            :         return NULL;
     112                 :            : }
     113                 :            : 
     114                 :          0 : static struct hid_usage *hidinput_locate_usage(struct hid_device *hid,
     115                 :            :                                         const struct input_keymap_entry *ke,
     116                 :            :                                         unsigned int *index)
     117                 :            : {
     118                 :            :         struct hid_usage *usage;
     119                 :            :         unsigned int scancode;
     120                 :            : 
     121                 :          0 :         if (ke->flags & INPUT_KEYMAP_BY_INDEX)
     122                 :          0 :                 usage = hidinput_find_key(hid, match_index, ke->index, index);
     123                 :          0 :         else if (input_scancode_to_scalar(ke, &scancode) == 0)
     124                 :          0 :                 usage = hidinput_find_key(hid, match_scancode, scancode, index);
     125                 :            :         else
     126                 :            :                 usage = NULL;
     127                 :            : 
     128                 :          0 :         return usage;
     129                 :            : }
     130                 :            : 
     131                 :          0 : static int hidinput_getkeycode(struct input_dev *dev,
     132                 :            :                                struct input_keymap_entry *ke)
     133                 :            : {
     134                 :            :         struct hid_device *hid = input_get_drvdata(dev);
     135                 :            :         struct hid_usage *usage;
     136                 :            :         unsigned int scancode, index;
     137                 :            : 
     138                 :          0 :         usage = hidinput_locate_usage(hid, ke, &index);
     139                 :          0 :         if (usage) {
     140                 :          0 :                 ke->keycode = usage->type == EV_KEY ?
     141                 :          0 :                                 usage->code : KEY_RESERVED;
     142                 :          0 :                 ke->index = index;
     143                 :          0 :                 scancode = usage->hid & (HID_USAGE_PAGE | HID_USAGE);
     144                 :          0 :                 ke->len = sizeof(scancode);
     145                 :          0 :                 memcpy(ke->scancode, &scancode, sizeof(scancode));
     146                 :          0 :                 return 0;
     147                 :            :         }
     148                 :            : 
     149                 :            :         return -EINVAL;
     150                 :            : }
     151                 :            : 
     152                 :          0 : static int hidinput_setkeycode(struct input_dev *dev,
     153                 :            :                                const struct input_keymap_entry *ke,
     154                 :            :                                unsigned int *old_keycode)
     155                 :            : {
     156                 :            :         struct hid_device *hid = input_get_drvdata(dev);
     157                 :            :         struct hid_usage *usage;
     158                 :            : 
     159                 :          0 :         usage = hidinput_locate_usage(hid, ke, NULL);
     160                 :          0 :         if (usage) {
     161                 :          0 :                 *old_keycode = usage->type == EV_KEY ?
     162                 :          0 :                                 usage->code : KEY_RESERVED;
     163                 :          0 :                 usage->code = ke->keycode;
     164                 :            : 
     165                 :          0 :                 clear_bit(*old_keycode, dev->keybit);
     166                 :          0 :                 set_bit(usage->code, dev->keybit);
     167                 :          0 :                 dbg_hid("Assigned keycode %d to HID usage code %x\n",
     168                 :            :                         usage->code, usage->hid);
     169                 :            : 
     170                 :            :                 /*
     171                 :            :                  * Set the keybit for the old keycode if the old keycode is used
     172                 :            :                  * by another key
     173                 :            :                  */
     174                 :          0 :                 if (hidinput_find_key(hid, match_keycode, *old_keycode, NULL))
     175                 :          0 :                         set_bit(*old_keycode, dev->keybit);
     176                 :            : 
     177                 :            :                 return 0;
     178                 :            :         }
     179                 :            : 
     180                 :            :         return -EINVAL;
     181                 :            : }
     182                 :            : 
     183                 :            : 
     184                 :            : /**
     185                 :            :  * hidinput_calc_abs_res - calculate an absolute axis resolution
     186                 :            :  * @field: the HID report field to calculate resolution for
     187                 :            :  * @code: axis code
     188                 :            :  *
     189                 :            :  * The formula is:
     190                 :            :  *                         (logical_maximum - logical_minimum)
     191                 :            :  * resolution = ----------------------------------------------------------
     192                 :            :  *              (physical_maximum - physical_minimum) * 10 ^ unit_exponent
     193                 :            :  *
     194                 :            :  * as seen in the HID specification v1.11 6.2.2.7 Global Items.
     195                 :            :  *
     196                 :            :  * Only exponent 1 length units are processed. Centimeters and inches are
     197                 :            :  * converted to millimeters. Degrees are converted to radians.
     198                 :            :  */
     199                 :          2 : __s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code)
     200                 :            : {
     201                 :          2 :         __s32 unit_exponent = field->unit_exponent;
     202                 :          2 :         __s32 logical_extents = field->logical_maximum -
     203                 :          2 :                                         field->logical_minimum;
     204                 :          2 :         __s32 physical_extents = field->physical_maximum -
     205                 :          2 :                                         field->physical_minimum;
     206                 :            :         __s32 prev;
     207                 :            : 
     208                 :            :         /* Check if the extents are sane */
     209                 :          2 :         if (logical_extents <= 0 || physical_extents <= 0)
     210                 :            :                 return 0;
     211                 :            : 
     212                 :            :         /*
     213                 :            :          * Verify and convert units.
     214                 :            :          * See HID specification v1.11 6.2.2.7 Global Items for unit decoding
     215                 :            :          */
     216                 :          0 :         switch (code) {
     217                 :            :         case ABS_X:
     218                 :            :         case ABS_Y:
     219                 :            :         case ABS_Z:
     220                 :            :         case ABS_MT_POSITION_X:
     221                 :            :         case ABS_MT_POSITION_Y:
     222                 :            :         case ABS_MT_TOOL_X:
     223                 :            :         case ABS_MT_TOOL_Y:
     224                 :            :         case ABS_MT_TOUCH_MAJOR:
     225                 :            :         case ABS_MT_TOUCH_MINOR:
     226                 :          0 :                 if (field->unit == 0x11) {           /* If centimeters */
     227                 :            :                         /* Convert to millimeters */
     228                 :          0 :                         unit_exponent += 1;
     229                 :          0 :                 } else if (field->unit == 0x13) {    /* If inches */
     230                 :            :                         /* Convert to millimeters */
     231                 :            :                         prev = physical_extents;
     232                 :          0 :                         physical_extents *= 254;
     233                 :          0 :                         if (physical_extents < prev)
     234                 :            :                                 return 0;
     235                 :          0 :                         unit_exponent -= 1;
     236                 :            :                 } else {
     237                 :            :                         return 0;
     238                 :            :                 }
     239                 :            :                 break;
     240                 :            : 
     241                 :            :         case ABS_RX:
     242                 :            :         case ABS_RY:
     243                 :            :         case ABS_RZ:
     244                 :            :         case ABS_WHEEL:
     245                 :            :         case ABS_TILT_X:
     246                 :            :         case ABS_TILT_Y:
     247                 :          0 :                 if (field->unit == 0x14) {           /* If degrees */
     248                 :            :                         /* Convert to radians */
     249                 :            :                         prev = logical_extents;
     250                 :          0 :                         logical_extents *= 573;
     251                 :          0 :                         if (logical_extents < prev)
     252                 :            :                                 return 0;
     253                 :          0 :                         unit_exponent += 1;
     254                 :          0 :                 } else if (field->unit != 0x12) {    /* If not radians */
     255                 :            :                         return 0;
     256                 :            :                 }
     257                 :            :                 break;
     258                 :            : 
     259                 :            :         default:
     260                 :            :                 return 0;
     261                 :            :         }
     262                 :            : 
     263                 :            :         /* Apply negative unit exponent */
     264                 :          0 :         for (; unit_exponent < 0; unit_exponent++) {
     265                 :            :                 prev = logical_extents;
     266                 :          0 :                 logical_extents *= 10;
     267                 :          0 :                 if (logical_extents < prev)
     268                 :            :                         return 0;
     269                 :            :         }
     270                 :            :         /* Apply positive unit exponent */
     271                 :          0 :         for (; unit_exponent > 0; unit_exponent--) {
     272                 :            :                 prev = physical_extents;
     273                 :          0 :                 physical_extents *= 10;
     274                 :          0 :                 if (physical_extents < prev)
     275                 :            :                         return 0;
     276                 :            :         }
     277                 :            : 
     278                 :            :         /* Calculate resolution */
     279                 :          0 :         return DIV_ROUND_CLOSEST(logical_extents, physical_extents);
     280                 :            : }
     281                 :            : EXPORT_SYMBOL_GPL(hidinput_calc_abs_res);
     282                 :            : 
     283                 :            : #ifdef CONFIG_HID_BATTERY_STRENGTH
     284                 :            : static enum power_supply_property hidinput_battery_props[] = {
     285                 :            :         POWER_SUPPLY_PROP_PRESENT,
     286                 :            :         POWER_SUPPLY_PROP_ONLINE,
     287                 :            :         POWER_SUPPLY_PROP_CAPACITY,
     288                 :            :         POWER_SUPPLY_PROP_MODEL_NAME,
     289                 :            :         POWER_SUPPLY_PROP_STATUS,
     290                 :            :         POWER_SUPPLY_PROP_SCOPE,
     291                 :            : };
     292                 :            : 
     293                 :            : #define HID_BATTERY_QUIRK_PERCENT       (1 << 0) /* always reports percent */
     294                 :            : #define HID_BATTERY_QUIRK_FEATURE       (1 << 1) /* ask for feature report */
     295                 :            : #define HID_BATTERY_QUIRK_IGNORE        (1 << 2) /* completely ignore the battery */
     296                 :            : 
     297                 :            : static const struct hid_device_id hid_battery_quirks[] = {
     298                 :            :         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
     299                 :            :                 USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
     300                 :            :           HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
     301                 :            :         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
     302                 :            :                 USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI),
     303                 :            :           HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
     304                 :            :         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
     305                 :            :                 USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI),
     306                 :            :           HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
     307                 :            :         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
     308                 :            :                                USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO),
     309                 :            :           HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
     310                 :            :         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
     311                 :            :                 USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
     312                 :            :           HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
     313                 :            :         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM,
     314                 :            :                 USB_DEVICE_ID_ELECOM_BM084),
     315                 :            :           HID_BATTERY_QUIRK_IGNORE },
     316                 :            :         { HID_USB_DEVICE(USB_VENDOR_ID_SYMBOL,
     317                 :            :                 USB_DEVICE_ID_SYMBOL_SCANNER_3),
     318                 :            :           HID_BATTERY_QUIRK_IGNORE },
     319                 :            :         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ASUSTEK,
     320                 :            :                 USB_DEVICE_ID_ASUSTEK_T100CHI_KEYBOARD),
     321                 :            :           HID_BATTERY_QUIRK_IGNORE },
     322                 :            :         {}
     323                 :            : };
     324                 :            : 
     325                 :            : static unsigned find_battery_quirk(struct hid_device *hdev)
     326                 :            : {
     327                 :            :         unsigned quirks = 0;
     328                 :            :         const struct hid_device_id *match;
     329                 :            : 
     330                 :          0 :         match = hid_match_id(hdev, hid_battery_quirks);
     331                 :          0 :         if (match != NULL)
     332                 :          0 :                 quirks = match->driver_data;
     333                 :            : 
     334                 :            :         return quirks;
     335                 :            : }
     336                 :            : 
     337                 :            : static int hidinput_scale_battery_capacity(struct hid_device *dev,
     338                 :            :                                            int value)
     339                 :            : {
     340                 :          0 :         if (dev->battery_min < dev->battery_max &&
     341                 :          0 :             value >= dev->battery_min && value <= dev->battery_max)
     342                 :          0 :                 value = ((value - dev->battery_min) * 100) /
     343                 :          0 :                         (dev->battery_max - dev->battery_min);
     344                 :            : 
     345                 :            :         return value;
     346                 :            : }
     347                 :            : 
     348                 :          0 : static int hidinput_query_battery_capacity(struct hid_device *dev)
     349                 :            : {
     350                 :            :         u8 *buf;
     351                 :            :         int ret;
     352                 :            : 
     353                 :            :         buf = kmalloc(4, GFP_KERNEL);
     354                 :          0 :         if (!buf)
     355                 :            :                 return -ENOMEM;
     356                 :            : 
     357                 :          0 :         ret = hid_hw_raw_request(dev, dev->battery_report_id, buf, 4,
     358                 :          0 :                                  dev->battery_report_type, HID_REQ_GET_REPORT);
     359                 :          0 :         if (ret < 2) {
     360                 :          0 :                 kfree(buf);
     361                 :          0 :                 return -ENODATA;
     362                 :            :         }
     363                 :            : 
     364                 :          0 :         ret = hidinput_scale_battery_capacity(dev, buf[1]);
     365                 :          0 :         kfree(buf);
     366                 :          0 :         return ret;
     367                 :            : }
     368                 :            : 
     369                 :          0 : static int hidinput_get_battery_property(struct power_supply *psy,
     370                 :            :                                          enum power_supply_property prop,
     371                 :            :                                          union power_supply_propval *val)
     372                 :            : {
     373                 :          0 :         struct hid_device *dev = power_supply_get_drvdata(psy);
     374                 :            :         int value;
     375                 :            :         int ret = 0;
     376                 :            : 
     377                 :          0 :         switch (prop) {
     378                 :            :         case POWER_SUPPLY_PROP_PRESENT:
     379                 :            :         case POWER_SUPPLY_PROP_ONLINE:
     380                 :          0 :                 val->intval = 1;
     381                 :          0 :                 break;
     382                 :            : 
     383                 :            :         case POWER_SUPPLY_PROP_CAPACITY:
     384                 :          0 :                 if (dev->battery_status != HID_BATTERY_REPORTED &&
     385                 :          0 :                     !dev->battery_avoid_query) {
     386                 :          0 :                         value = hidinput_query_battery_capacity(dev);
     387                 :          0 :                         if (value < 0)
     388                 :            :                                 return value;
     389                 :            :                 } else  {
     390                 :          0 :                         value = dev->battery_capacity;
     391                 :            :                 }
     392                 :            : 
     393                 :          0 :                 val->intval = value;
     394                 :          0 :                 break;
     395                 :            : 
     396                 :            :         case POWER_SUPPLY_PROP_MODEL_NAME:
     397                 :          0 :                 val->strval = dev->name;
     398                 :          0 :                 break;
     399                 :            : 
     400                 :            :         case POWER_SUPPLY_PROP_STATUS:
     401                 :          0 :                 if (dev->battery_status != HID_BATTERY_REPORTED &&
     402                 :          0 :                     !dev->battery_avoid_query) {
     403                 :          0 :                         value = hidinput_query_battery_capacity(dev);
     404                 :          0 :                         if (value < 0)
     405                 :            :                                 return value;
     406                 :            : 
     407                 :          0 :                         dev->battery_capacity = value;
     408                 :          0 :                         dev->battery_status = HID_BATTERY_QUERIED;
     409                 :            :                 }
     410                 :            : 
     411                 :          0 :                 if (dev->battery_status == HID_BATTERY_UNKNOWN)
     412                 :          0 :                         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
     413                 :          0 :                 else if (dev->battery_capacity == 100)
     414                 :          0 :                         val->intval = POWER_SUPPLY_STATUS_FULL;
     415                 :            :                 else
     416                 :          0 :                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
     417                 :            :                 break;
     418                 :            : 
     419                 :            :         case POWER_SUPPLY_PROP_SCOPE:
     420                 :          0 :                 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
     421                 :          0 :                 break;
     422                 :            : 
     423                 :            :         default:
     424                 :            :                 ret = -EINVAL;
     425                 :            :                 break;
     426                 :            :         }
     427                 :            : 
     428                 :          0 :         return ret;
     429                 :            : }
     430                 :            : 
     431                 :          0 : static int hidinput_setup_battery(struct hid_device *dev, unsigned report_type, struct hid_field *field)
     432                 :            : {
     433                 :            :         struct power_supply_desc *psy_desc;
     434                 :          0 :         struct power_supply_config psy_cfg = { .drv_data = dev, };
     435                 :            :         unsigned quirks;
     436                 :            :         s32 min, max;
     437                 :            :         int error;
     438                 :            : 
     439                 :          0 :         if (dev->battery)
     440                 :            :                 return 0;       /* already initialized? */
     441                 :            : 
     442                 :            :         quirks = find_battery_quirk(dev);
     443                 :            : 
     444                 :            :         hid_dbg(dev, "device %x:%x:%x %d quirks %d\n",
     445                 :            :                 dev->bus, dev->vendor, dev->product, dev->version, quirks);
     446                 :            : 
     447                 :          0 :         if (quirks & HID_BATTERY_QUIRK_IGNORE)
     448                 :            :                 return 0;
     449                 :            : 
     450                 :          0 :         psy_desc = kzalloc(sizeof(*psy_desc), GFP_KERNEL);
     451                 :          0 :         if (!psy_desc)
     452                 :            :                 return -ENOMEM;
     453                 :            : 
     454                 :          0 :         psy_desc->name = kasprintf(GFP_KERNEL, "hid-%s-battery",
     455                 :          0 :                                    strlen(dev->uniq) ?
     456                 :            :                                         dev->uniq : dev_name(&dev->dev));
     457                 :          0 :         if (!psy_desc->name) {
     458                 :            :                 error = -ENOMEM;
     459                 :            :                 goto err_free_mem;
     460                 :            :         }
     461                 :            : 
     462                 :          0 :         psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;
     463                 :          0 :         psy_desc->properties = hidinput_battery_props;
     464                 :          0 :         psy_desc->num_properties = ARRAY_SIZE(hidinput_battery_props);
     465                 :          0 :         psy_desc->use_for_apm = 0;
     466                 :          0 :         psy_desc->get_property = hidinput_get_battery_property;
     467                 :            : 
     468                 :          0 :         min = field->logical_minimum;
     469                 :          0 :         max = field->logical_maximum;
     470                 :            : 
     471                 :          0 :         if (quirks & HID_BATTERY_QUIRK_PERCENT) {
     472                 :            :                 min = 0;
     473                 :            :                 max = 100;
     474                 :            :         }
     475                 :            : 
     476                 :          0 :         if (quirks & HID_BATTERY_QUIRK_FEATURE)
     477                 :            :                 report_type = HID_FEATURE_REPORT;
     478                 :            : 
     479                 :          0 :         dev->battery_min = min;
     480                 :          0 :         dev->battery_max = max;
     481                 :          0 :         dev->battery_report_type = report_type;
     482                 :          0 :         dev->battery_report_id = field->report->id;
     483                 :            : 
     484                 :            :         /*
     485                 :            :          * Stylus is normally not connected to the device and thus we
     486                 :            :          * can't query the device and get meaningful battery strength.
     487                 :            :          * We have to wait for the device to report it on its own.
     488                 :            :          */
     489                 :          0 :         dev->battery_avoid_query = report_type == HID_INPUT_REPORT &&
     490                 :          0 :                                    field->physical == HID_DG_STYLUS;
     491                 :            : 
     492                 :          0 :         dev->battery = power_supply_register(&dev->dev, psy_desc, &psy_cfg);
     493                 :          0 :         if (IS_ERR(dev->battery)) {
     494                 :            :                 error = PTR_ERR(dev->battery);
     495                 :          0 :                 hid_warn(dev, "can't register power supply: %d\n", error);
     496                 :            :                 goto err_free_name;
     497                 :            :         }
     498                 :            : 
     499                 :          0 :         power_supply_powers(dev->battery, &dev->dev);
     500                 :          0 :         return 0;
     501                 :            : 
     502                 :            : err_free_name:
     503                 :          0 :         kfree(psy_desc->name);
     504                 :            : err_free_mem:
     505                 :          0 :         kfree(psy_desc);
     506                 :          0 :         dev->battery = NULL;
     507                 :          0 :         return error;
     508                 :            : }
     509                 :            : 
     510                 :          0 : static void hidinput_cleanup_battery(struct hid_device *dev)
     511                 :            : {
     512                 :            :         const struct power_supply_desc *psy_desc;
     513                 :            : 
     514                 :          0 :         if (!dev->battery)
     515                 :          0 :                 return;
     516                 :            : 
     517                 :          0 :         psy_desc = dev->battery->desc;
     518                 :          0 :         power_supply_unregister(dev->battery);
     519                 :          0 :         kfree(psy_desc->name);
     520                 :          0 :         kfree(psy_desc);
     521                 :          0 :         dev->battery = NULL;
     522                 :            : }
     523                 :            : 
     524                 :          0 : static void hidinput_update_battery(struct hid_device *dev, int value)
     525                 :            : {
     526                 :            :         int capacity;
     527                 :            : 
     528                 :          0 :         if (!dev->battery)
     529                 :            :                 return;
     530                 :            : 
     531                 :          0 :         if (value == 0 || value < dev->battery_min || value > dev->battery_max)
     532                 :            :                 return;
     533                 :            : 
     534                 :            :         capacity = hidinput_scale_battery_capacity(dev, value);
     535                 :            : 
     536                 :          0 :         if (dev->battery_status != HID_BATTERY_REPORTED ||
     537                 :          0 :             capacity != dev->battery_capacity) {
     538                 :          0 :                 dev->battery_capacity = capacity;
     539                 :          0 :                 dev->battery_status = HID_BATTERY_REPORTED;
     540                 :          0 :                 power_supply_changed(dev->battery);
     541                 :            :         }
     542                 :            : }
     543                 :            : #else  /* !CONFIG_HID_BATTERY_STRENGTH */
     544                 :            : static int hidinput_setup_battery(struct hid_device *dev, unsigned report_type,
     545                 :            :                                   struct hid_field *field)
     546                 :            : {
     547                 :            :         return 0;
     548                 :            : }
     549                 :            : 
     550                 :            : static void hidinput_cleanup_battery(struct hid_device *dev)
     551                 :            : {
     552                 :            : }
     553                 :            : 
     554                 :            : static void hidinput_update_battery(struct hid_device *dev, int value)
     555                 :            : {
     556                 :            : }
     557                 :            : #endif  /* CONFIG_HID_BATTERY_STRENGTH */
     558                 :            : 
     559                 :          3 : static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_field *field,
     560                 :            :                                      struct hid_usage *usage)
     561                 :            : {
     562                 :          3 :         struct input_dev *input = hidinput->input;
     563                 :            :         struct hid_device *device = input_get_drvdata(input);
     564                 :          3 :         int max = 0, code;
     565                 :          3 :         unsigned long *bit = NULL;
     566                 :            : 
     567                 :          3 :         field->hidinput = hidinput;
     568                 :            : 
     569                 :          3 :         if (field->flags & HID_MAIN_ITEM_CONSTANT)
     570                 :            :                 goto ignore;
     571                 :            : 
     572                 :            :         /* Ignore if report count is out of bounds. */
     573                 :          3 :         if (field->report_count < 1)
     574                 :            :                 goto ignore;
     575                 :            : 
     576                 :            :         /* only LED usages are supported in output fields */
     577                 :          3 :         if (field->report_type == HID_OUTPUT_REPORT &&
     578                 :          3 :                         (usage->hid & HID_USAGE_PAGE) != HID_UP_LED) {
     579                 :            :                 goto ignore;
     580                 :            :         }
     581                 :            : 
     582                 :          3 :         if (device->driver->input_mapping) {
     583                 :          0 :                 int ret = device->driver->input_mapping(device, hidinput, field,
     584                 :            :                                 usage, &bit, &max);
     585                 :          0 :                 if (ret > 0)
     586                 :            :                         goto mapped;
     587                 :          0 :                 if (ret < 0)
     588                 :            :                         goto ignore;
     589                 :            :         }
     590                 :            : 
     591                 :          3 :         switch (usage->hid & HID_USAGE_PAGE) {
     592                 :            :         case HID_UP_UNDEFINED:
     593                 :            :                 goto ignore;
     594                 :            : 
     595                 :            :         case HID_UP_KEYBOARD:
     596                 :          3 :                 set_bit(EV_REP, input->evbit);
     597                 :            : 
     598                 :          3 :                 if ((usage->hid & HID_USAGE) < 256) {
     599                 :          3 :                         if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;
     600                 :          3 :                         map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);
     601                 :            :                 } else
     602                 :            :                         map_key(KEY_UNKNOWN);
     603                 :            : 
     604                 :            :                 break;
     605                 :            : 
     606                 :            :         case HID_UP_BUTTON:
     607                 :          3 :                 code = ((usage->hid - 1) & HID_USAGE);
     608                 :            : 
     609                 :          3 :                 switch (field->application) {
     610                 :            :                 case HID_GD_MOUSE:
     611                 :          3 :                 case HID_GD_POINTER:  code += BTN_MOUSE; break;
     612                 :            :                 case HID_GD_JOYSTICK:
     613                 :          0 :                                 if (code <= 0xf)
     614                 :          0 :                                         code += BTN_JOYSTICK;
     615                 :            :                                 else
     616                 :          0 :                                         code += BTN_TRIGGER_HAPPY - 0x10;
     617                 :            :                                 break;
     618                 :            :                 case HID_GD_GAMEPAD:
     619                 :          0 :                                 if (code <= 0xf)
     620                 :          0 :                                         code += BTN_GAMEPAD;
     621                 :            :                                 else
     622                 :          0 :                                         code += BTN_TRIGGER_HAPPY - 0x10;
     623                 :            :                                 break;
     624                 :            :                 default:
     625                 :          0 :                         switch (field->physical) {
     626                 :            :                         case HID_GD_MOUSE:
     627                 :          0 :                         case HID_GD_POINTER:  code += BTN_MOUSE; break;
     628                 :          0 :                         case HID_GD_JOYSTICK: code += BTN_JOYSTICK; break;
     629                 :          0 :                         case HID_GD_GAMEPAD:  code += BTN_GAMEPAD; break;
     630                 :          0 :                         default:              code += BTN_MISC;
     631                 :            :                         }
     632                 :            :                 }
     633                 :            : 
     634                 :          3 :                 map_key(code);
     635                 :            :                 break;
     636                 :            : 
     637                 :            :         case HID_UP_SIMULATION:
     638                 :          0 :                 switch (usage->hid & 0xffff) {
     639                 :            :                 case 0xba: map_abs(ABS_RUDDER);   break;
     640                 :            :                 case 0xbb: map_abs(ABS_THROTTLE); break;
     641                 :            :                 case 0xc4: map_abs(ABS_GAS);      break;
     642                 :            :                 case 0xc5: map_abs(ABS_BRAKE);    break;
     643                 :            :                 case 0xc8: map_abs(ABS_WHEEL);    break;
     644                 :            :                 default:   goto ignore;
     645                 :            :                 }
     646                 :            :                 break;
     647                 :            : 
     648                 :            :         case HID_UP_GENDESK:
     649                 :          3 :                 if ((usage->hid & 0xf0) == 0x80) {       /* SystemControl */
     650                 :          0 :                         switch (usage->hid & 0xf) {
     651                 :          0 :                         case 0x1: map_key_clear(KEY_POWER);  break;
     652                 :          0 :                         case 0x2: map_key_clear(KEY_SLEEP);  break;
     653                 :          0 :                         case 0x3: map_key_clear(KEY_WAKEUP); break;
     654                 :          0 :                         case 0x4: map_key_clear(KEY_CONTEXT_MENU); break;
     655                 :          0 :                         case 0x5: map_key_clear(KEY_MENU); break;
     656                 :          0 :                         case 0x6: map_key_clear(KEY_PROG1); break;
     657                 :          0 :                         case 0x7: map_key_clear(KEY_HELP); break;
     658                 :          0 :                         case 0x8: map_key_clear(KEY_EXIT); break;
     659                 :          0 :                         case 0x9: map_key_clear(KEY_SELECT); break;
     660                 :          0 :                         case 0xa: map_key_clear(KEY_RIGHT); break;
     661                 :          0 :                         case 0xb: map_key_clear(KEY_LEFT); break;
     662                 :          0 :                         case 0xc: map_key_clear(KEY_UP); break;
     663                 :          0 :                         case 0xd: map_key_clear(KEY_DOWN); break;
     664                 :          0 :                         case 0xe: map_key_clear(KEY_POWER2); break;
     665                 :          0 :                         case 0xf: map_key_clear(KEY_RESTART); break;
     666                 :            :                         default: goto unknown;
     667                 :            :                         }
     668                 :            :                         break;
     669                 :            :                 }
     670                 :            : 
     671                 :          3 :                 if ((usage->hid & 0xf0) == 0xb0) {       /* SC - Display */
     672                 :          0 :                         switch (usage->hid & 0xf) {
     673                 :          0 :                         case 0x05: map_key_clear(KEY_SWITCHVIDEOMODE); break;
     674                 :            :                         default: goto ignore;
     675                 :            :                         }
     676                 :          0 :                         break;
     677                 :            :                 }
     678                 :            : 
     679                 :            :                 /*
     680                 :            :                  * Some lazy vendors declare 255 usages for System Control,
     681                 :            :                  * leading to the creation of ABS_X|Y axis and too many others.
     682                 :            :                  * It wouldn't be a problem if joydev doesn't consider the
     683                 :            :                  * device as a joystick then.
     684                 :            :                  */
     685                 :          3 :                 if (field->application == HID_GD_SYSTEM_CONTROL)
     686                 :            :                         goto ignore;
     687                 :            : 
     688                 :          3 :                 if ((usage->hid & 0xf0) == 0x90) {       /* D-pad */
     689                 :          0 :                         switch (usage->hid) {
     690                 :          0 :                         case HID_GD_UP:    usage->hat_dir = 1; break;
     691                 :          0 :                         case HID_GD_DOWN:  usage->hat_dir = 5; break;
     692                 :          0 :                         case HID_GD_RIGHT: usage->hat_dir = 3; break;
     693                 :          0 :                         case HID_GD_LEFT:  usage->hat_dir = 7; break;
     694                 :            :                         default: goto unknown;
     695                 :            :                         }
     696                 :          0 :                         if (field->dpad) {
     697                 :            :                                 map_abs(field->dpad);
     698                 :            :                                 goto ignore;
     699                 :            :                         }
     700                 :            :                         map_abs(ABS_HAT0X);
     701                 :            :                         break;
     702                 :            :                 }
     703                 :            : 
     704                 :          3 :                 switch (usage->hid) {
     705                 :            :                 /* These usage IDs map directly to the usage codes. */
     706                 :            :                 case HID_GD_X: case HID_GD_Y: case HID_GD_Z:
     707                 :            :                 case HID_GD_RX: case HID_GD_RY: case HID_GD_RZ:
     708                 :          3 :                         if (field->flags & HID_MAIN_ITEM_RELATIVE)
     709                 :          3 :                                 map_rel(usage->hid & 0xf);
     710                 :            :                         else
     711                 :          0 :                                 map_abs_clear(usage->hid & 0xf);
     712                 :            :                         break;
     713                 :            : 
     714                 :            :                 case HID_GD_WHEEL:
     715                 :          3 :                         if (field->flags & HID_MAIN_ITEM_RELATIVE) {
     716                 :          3 :                                 set_bit(REL_WHEEL, input->relbit);
     717                 :            :                                 map_rel(REL_WHEEL_HI_RES);
     718                 :            :                         } else {
     719                 :          0 :                                 map_abs(usage->hid & 0xf);
     720                 :            :                         }
     721                 :            :                         break;
     722                 :            :                 case HID_GD_SLIDER: case HID_GD_DIAL:
     723                 :          0 :                         if (field->flags & HID_MAIN_ITEM_RELATIVE)
     724                 :          0 :                                 map_rel(usage->hid & 0xf);
     725                 :            :                         else
     726                 :          0 :                                 map_abs(usage->hid & 0xf);
     727                 :            :                         break;
     728                 :            : 
     729                 :            :                 case HID_GD_HATSWITCH:
     730                 :          0 :                         usage->hat_min = field->logical_minimum;
     731                 :          0 :                         usage->hat_max = field->logical_maximum;
     732                 :            :                         map_abs(ABS_HAT0X);
     733                 :            :                         break;
     734                 :            : 
     735                 :          0 :                 case HID_GD_START:      map_key_clear(BTN_START);       break;
     736                 :          0 :                 case HID_GD_SELECT:     map_key_clear(BTN_SELECT);      break;
     737                 :            : 
     738                 :            :                 case HID_GD_RFKILL_BTN:
     739                 :            :                         /* MS wireless radio ctl extension, also check CA */
     740                 :          0 :                         if (field->application == HID_GD_WIRELESS_RADIO_CTLS) {
     741                 :          0 :                                 map_key_clear(KEY_RFKILL);
     742                 :            :                                 /* We need to simulate the btn release */
     743                 :          0 :                                 field->flags |= HID_MAIN_ITEM_RELATIVE;
     744                 :          0 :                                 break;
     745                 :            :                         }
     746                 :            : 
     747                 :            :                 default: goto unknown;
     748                 :            :                 }
     749                 :            : 
     750                 :            :                 break;
     751                 :            : 
     752                 :            :         case HID_UP_LED:
     753                 :          3 :                 switch (usage->hid & 0xffff) {                 /* HID-Value:                   */
     754                 :            :                 case 0x01:  map_led (LED_NUML);     break;    /*   "Num Lock"                 */
     755                 :            :                 case 0x02:  map_led (LED_CAPSL);    break;    /*   "Caps Lock"                */
     756                 :            :                 case 0x03:  map_led (LED_SCROLLL);  break;    /*   "Scroll Lock"              */
     757                 :            :                 case 0x04:  map_led (LED_COMPOSE);  break;    /*   "Compose"                  */
     758                 :            :                 case 0x05:  map_led (LED_KANA);     break;    /*   "Kana"                     */
     759                 :            :                 case 0x27:  map_led (LED_SLEEP);    break;    /*   "Stand-By"                 */
     760                 :            :                 case 0x4c:  map_led (LED_SUSPEND);  break;    /*   "System Suspend"           */
     761                 :            :                 case 0x09:  map_led (LED_MUTE);     break;    /*   "Mute"                     */
     762                 :            :                 case 0x4b:  map_led (LED_MISC);     break;    /*   "Generic Indicator"        */
     763                 :            :                 case 0x19:  map_led (LED_MAIL);     break;    /*   "Message Waiting"          */
     764                 :            :                 case 0x4d:  map_led (LED_CHARGING); break;    /*   "External Power Connected" */
     765                 :            : 
     766                 :            :                 default: goto ignore;
     767                 :            :                 }
     768                 :            :                 break;
     769                 :            : 
     770                 :            :         case HID_UP_DIGITIZER:
     771                 :          0 :                 if ((field->application & 0xff) == 0x01) /* Digitizer */
     772                 :            :                         __set_bit(INPUT_PROP_POINTER, input->propbit);
     773                 :          0 :                 else if ((field->application & 0xff) == 0x02) /* Pen */
     774                 :            :                         __set_bit(INPUT_PROP_DIRECT, input->propbit);
     775                 :            : 
     776                 :          0 :                 switch (usage->hid & 0xff) {
     777                 :            :                 case 0x00: /* Undefined */
     778                 :            :                         goto ignore;
     779                 :            : 
     780                 :            :                 case 0x30: /* TipPressure */
     781                 :          0 :                         if (!test_bit(BTN_TOUCH, input->keybit)) {
     782                 :          0 :                                 device->quirks |= HID_QUIRK_NOTOUCH;
     783                 :          0 :                                 set_bit(EV_KEY, input->evbit);
     784                 :          0 :                                 set_bit(BTN_TOUCH, input->keybit);
     785                 :            :                         }
     786                 :          0 :                         map_abs_clear(ABS_PRESSURE);
     787                 :          0 :                         break;
     788                 :            : 
     789                 :            :                 case 0x32: /* InRange */
     790                 :          0 :                         switch (field->physical & 0xff) {
     791                 :            :                         case 0x21: map_key(BTN_TOOL_MOUSE); break;
     792                 :            :                         case 0x22: map_key(BTN_TOOL_FINGER); break;
     793                 :            :                         default: map_key(BTN_TOOL_PEN); break;
     794                 :            :                         }
     795                 :            :                         break;
     796                 :            : 
     797                 :            :                 case 0x3b: /* Battery Strength */
     798                 :          0 :                         hidinput_setup_battery(device, HID_INPUT_REPORT, field);
     799                 :          0 :                         usage->type = EV_PWR;
     800                 :          0 :                         goto ignore;
     801                 :            : 
     802                 :            :                 case 0x3c: /* Invert */
     803                 :          0 :                         map_key_clear(BTN_TOOL_RUBBER);
     804                 :          0 :                         break;
     805                 :            : 
     806                 :            :                 case 0x3d: /* X Tilt */
     807                 :          0 :                         map_abs_clear(ABS_TILT_X);
     808                 :          0 :                         break;
     809                 :            : 
     810                 :            :                 case 0x3e: /* Y Tilt */
     811                 :          0 :                         map_abs_clear(ABS_TILT_Y);
     812                 :          0 :                         break;
     813                 :            : 
     814                 :            :                 case 0x33: /* Touch */
     815                 :            :                 case 0x42: /* TipSwitch */
     816                 :            :                 case 0x43: /* TipSwitch2 */
     817                 :          0 :                         device->quirks &= ~HID_QUIRK_NOTOUCH;
     818                 :          0 :                         map_key_clear(BTN_TOUCH);
     819                 :          0 :                         break;
     820                 :            : 
     821                 :            :                 case 0x44: /* BarrelSwitch */
     822                 :          0 :                         map_key_clear(BTN_STYLUS);
     823                 :          0 :                         break;
     824                 :            : 
     825                 :            :                 case 0x45: /* ERASER */
     826                 :            :                         /*
     827                 :            :                          * This event is reported when eraser tip touches the surface.
     828                 :            :                          * Actual eraser (BTN_TOOL_RUBBER) is set by Invert usage when
     829                 :            :                          * tool gets in proximity.
     830                 :            :                          */
     831                 :          0 :                         map_key_clear(BTN_TOUCH);
     832                 :          0 :                         break;
     833                 :            : 
     834                 :            :                 case 0x46: /* TabletPick */
     835                 :            :                 case 0x5a: /* SecondaryBarrelSwitch */
     836                 :          0 :                         map_key_clear(BTN_STYLUS2);
     837                 :          0 :                         break;
     838                 :            : 
     839                 :            :                 case 0x5b: /* TransducerSerialNumber */
     840                 :          0 :                         usage->type = EV_MSC;
     841                 :          0 :                         usage->code = MSC_SERIAL;
     842                 :          0 :                         bit = input->mscbit;
     843                 :          0 :                         max = MSC_MAX;
     844                 :          0 :                         break;
     845                 :            : 
     846                 :            :                 default:  goto unknown;
     847                 :            :                 }
     848                 :            :                 break;
     849                 :            : 
     850                 :            :         case HID_UP_TELEPHONY:
     851                 :          0 :                 switch (usage->hid & HID_USAGE) {
     852                 :          0 :                 case 0x2f: map_key_clear(KEY_MICMUTE);          break;
     853                 :          0 :                 case 0xb0: map_key_clear(KEY_NUMERIC_0);        break;
     854                 :          0 :                 case 0xb1: map_key_clear(KEY_NUMERIC_1);        break;
     855                 :          0 :                 case 0xb2: map_key_clear(KEY_NUMERIC_2);        break;
     856                 :          0 :                 case 0xb3: map_key_clear(KEY_NUMERIC_3);        break;
     857                 :          0 :                 case 0xb4: map_key_clear(KEY_NUMERIC_4);        break;
     858                 :          0 :                 case 0xb5: map_key_clear(KEY_NUMERIC_5);        break;
     859                 :          0 :                 case 0xb6: map_key_clear(KEY_NUMERIC_6);        break;
     860                 :          0 :                 case 0xb7: map_key_clear(KEY_NUMERIC_7);        break;
     861                 :          0 :                 case 0xb8: map_key_clear(KEY_NUMERIC_8);        break;
     862                 :          0 :                 case 0xb9: map_key_clear(KEY_NUMERIC_9);        break;
     863                 :          0 :                 case 0xba: map_key_clear(KEY_NUMERIC_STAR);     break;
     864                 :          0 :                 case 0xbb: map_key_clear(KEY_NUMERIC_POUND);    break;
     865                 :          0 :                 case 0xbc: map_key_clear(KEY_NUMERIC_A);        break;
     866                 :          0 :                 case 0xbd: map_key_clear(KEY_NUMERIC_B);        break;
     867                 :          0 :                 case 0xbe: map_key_clear(KEY_NUMERIC_C);        break;
     868                 :          0 :                 case 0xbf: map_key_clear(KEY_NUMERIC_D);        break;
     869                 :            :                 default: goto ignore;
     870                 :            :                 }
     871                 :            :                 break;
     872                 :            : 
     873                 :            :         case HID_UP_CONSUMER:   /* USB HUT v1.12, pages 75-84 */
     874                 :          2 :                 switch (usage->hid & HID_USAGE) {
     875                 :            :                 case 0x000: goto ignore;
     876                 :          2 :                 case 0x030: map_key_clear(KEY_POWER);           break;
     877                 :          2 :                 case 0x031: map_key_clear(KEY_RESTART);         break;
     878                 :          2 :                 case 0x032: map_key_clear(KEY_SLEEP);           break;
     879                 :          2 :                 case 0x034: map_key_clear(KEY_SLEEP);           break;
     880                 :          2 :                 case 0x035: map_key_clear(KEY_KBDILLUMTOGGLE);  break;
     881                 :          2 :                 case 0x036: map_key_clear(BTN_MISC);            break;
     882                 :            : 
     883                 :          2 :                 case 0x040: map_key_clear(KEY_MENU);            break; /* Menu */
     884                 :          2 :                 case 0x041: map_key_clear(KEY_SELECT);          break; /* Menu Pick */
     885                 :          2 :                 case 0x042: map_key_clear(KEY_UP);              break; /* Menu Up */
     886                 :          2 :                 case 0x043: map_key_clear(KEY_DOWN);            break; /* Menu Down */
     887                 :          2 :                 case 0x044: map_key_clear(KEY_LEFT);            break; /* Menu Left */
     888                 :          2 :                 case 0x045: map_key_clear(KEY_RIGHT);           break; /* Menu Right */
     889                 :          2 :                 case 0x046: map_key_clear(KEY_ESC);             break; /* Menu Escape */
     890                 :          2 :                 case 0x047: map_key_clear(KEY_KPPLUS);          break; /* Menu Value Increase */
     891                 :          2 :                 case 0x048: map_key_clear(KEY_KPMINUS);         break; /* Menu Value Decrease */
     892                 :            : 
     893                 :          2 :                 case 0x060: map_key_clear(KEY_INFO);            break; /* Data On Screen */
     894                 :          2 :                 case 0x061: map_key_clear(KEY_SUBTITLE);        break; /* Closed Caption */
     895                 :          2 :                 case 0x063: map_key_clear(KEY_VCR);             break; /* VCR/TV */
     896                 :          2 :                 case 0x065: map_key_clear(KEY_CAMERA);          break; /* Snapshot */
     897                 :          2 :                 case 0x069: map_key_clear(KEY_RED);             break;
     898                 :          2 :                 case 0x06a: map_key_clear(KEY_GREEN);           break;
     899                 :          2 :                 case 0x06b: map_key_clear(KEY_BLUE);            break;
     900                 :          2 :                 case 0x06c: map_key_clear(KEY_YELLOW);          break;
     901                 :          2 :                 case 0x06d: map_key_clear(KEY_ASPECT_RATIO);    break;
     902                 :            : 
     903                 :          2 :                 case 0x06f: map_key_clear(KEY_BRIGHTNESSUP);            break;
     904                 :          2 :                 case 0x070: map_key_clear(KEY_BRIGHTNESSDOWN);          break;
     905                 :          2 :                 case 0x072: map_key_clear(KEY_BRIGHTNESS_TOGGLE);       break;
     906                 :          2 :                 case 0x073: map_key_clear(KEY_BRIGHTNESS_MIN);          break;
     907                 :          2 :                 case 0x074: map_key_clear(KEY_BRIGHTNESS_MAX);          break;
     908                 :          2 :                 case 0x075: map_key_clear(KEY_BRIGHTNESS_AUTO);         break;
     909                 :            : 
     910                 :          2 :                 case 0x079: map_key_clear(KEY_KBDILLUMUP);      break;
     911                 :          2 :                 case 0x07a: map_key_clear(KEY_KBDILLUMDOWN);    break;
     912                 :          2 :                 case 0x07c: map_key_clear(KEY_KBDILLUMTOGGLE);  break;
     913                 :            : 
     914                 :          2 :                 case 0x082: map_key_clear(KEY_VIDEO_NEXT);      break;
     915                 :          2 :                 case 0x083: map_key_clear(KEY_LAST);            break;
     916                 :          2 :                 case 0x084: map_key_clear(KEY_ENTER);           break;
     917                 :          2 :                 case 0x088: map_key_clear(KEY_PC);              break;
     918                 :          2 :                 case 0x089: map_key_clear(KEY_TV);              break;
     919                 :          2 :                 case 0x08a: map_key_clear(KEY_WWW);             break;
     920                 :          2 :                 case 0x08b: map_key_clear(KEY_DVD);             break;
     921                 :          2 :                 case 0x08c: map_key_clear(KEY_PHONE);           break;
     922                 :          2 :                 case 0x08d: map_key_clear(KEY_PROGRAM);         break;
     923                 :          2 :                 case 0x08e: map_key_clear(KEY_VIDEOPHONE);      break;
     924                 :          2 :                 case 0x08f: map_key_clear(KEY_GAMES);           break;
     925                 :          2 :                 case 0x090: map_key_clear(KEY_MEMO);            break;
     926                 :          2 :                 case 0x091: map_key_clear(KEY_CD);              break;
     927                 :          2 :                 case 0x092: map_key_clear(KEY_VCR);             break;
     928                 :          2 :                 case 0x093: map_key_clear(KEY_TUNER);           break;
     929                 :          2 :                 case 0x094: map_key_clear(KEY_EXIT);            break;
     930                 :          2 :                 case 0x095: map_key_clear(KEY_HELP);            break;
     931                 :          2 :                 case 0x096: map_key_clear(KEY_TAPE);            break;
     932                 :          2 :                 case 0x097: map_key_clear(KEY_TV2);             break;
     933                 :          2 :                 case 0x098: map_key_clear(KEY_SAT);             break;
     934                 :          2 :                 case 0x09a: map_key_clear(KEY_PVR);             break;
     935                 :            : 
     936                 :          2 :                 case 0x09c: map_key_clear(KEY_CHANNELUP);       break;
     937                 :          2 :                 case 0x09d: map_key_clear(KEY_CHANNELDOWN);     break;
     938                 :          2 :                 case 0x0a0: map_key_clear(KEY_VCR2);            break;
     939                 :            : 
     940                 :          2 :                 case 0x0b0: map_key_clear(KEY_PLAY);            break;
     941                 :          2 :                 case 0x0b1: map_key_clear(KEY_PAUSE);           break;
     942                 :          2 :                 case 0x0b2: map_key_clear(KEY_RECORD);          break;
     943                 :          2 :                 case 0x0b3: map_key_clear(KEY_FASTFORWARD);     break;
     944                 :          2 :                 case 0x0b4: map_key_clear(KEY_REWIND);          break;
     945                 :          2 :                 case 0x0b5: map_key_clear(KEY_NEXTSONG);        break;
     946                 :          2 :                 case 0x0b6: map_key_clear(KEY_PREVIOUSSONG);    break;
     947                 :          2 :                 case 0x0b7: map_key_clear(KEY_STOPCD);          break;
     948                 :          2 :                 case 0x0b8: map_key_clear(KEY_EJECTCD);         break;
     949                 :          2 :                 case 0x0bc: map_key_clear(KEY_MEDIA_REPEAT);    break;
     950                 :          2 :                 case 0x0b9: map_key_clear(KEY_SHUFFLE);         break;
     951                 :          2 :                 case 0x0bf: map_key_clear(KEY_SLOW);            break;
     952                 :            : 
     953                 :          2 :                 case 0x0cd: map_key_clear(KEY_PLAYPAUSE);       break;
     954                 :          2 :                 case 0x0cf: map_key_clear(KEY_VOICECOMMAND);    break;
     955                 :          2 :                 case 0x0e0: map_abs_clear(ABS_VOLUME);          break;
     956                 :          2 :                 case 0x0e2: map_key_clear(KEY_MUTE);            break;
     957                 :          2 :                 case 0x0e5: map_key_clear(KEY_BASSBOOST);       break;
     958                 :          2 :                 case 0x0e9: map_key_clear(KEY_VOLUMEUP);        break;
     959                 :          2 :                 case 0x0ea: map_key_clear(KEY_VOLUMEDOWN);      break;
     960                 :          2 :                 case 0x0f5: map_key_clear(KEY_SLOW);            break;
     961                 :            : 
     962                 :          2 :                 case 0x181: map_key_clear(KEY_BUTTONCONFIG);    break;
     963                 :          2 :                 case 0x182: map_key_clear(KEY_BOOKMARKS);       break;
     964                 :          2 :                 case 0x183: map_key_clear(KEY_CONFIG);          break;
     965                 :          2 :                 case 0x184: map_key_clear(KEY_WORDPROCESSOR);   break;
     966                 :          2 :                 case 0x185: map_key_clear(KEY_EDITOR);          break;
     967                 :          2 :                 case 0x186: map_key_clear(KEY_SPREADSHEET);     break;
     968                 :          2 :                 case 0x187: map_key_clear(KEY_GRAPHICSEDITOR);  break;
     969                 :          2 :                 case 0x188: map_key_clear(KEY_PRESENTATION);    break;
     970                 :          2 :                 case 0x189: map_key_clear(KEY_DATABASE);        break;
     971                 :          2 :                 case 0x18a: map_key_clear(KEY_MAIL);            break;
     972                 :          2 :                 case 0x18b: map_key_clear(KEY_NEWS);            break;
     973                 :          2 :                 case 0x18c: map_key_clear(KEY_VOICEMAIL);       break;
     974                 :          2 :                 case 0x18d: map_key_clear(KEY_ADDRESSBOOK);     break;
     975                 :          2 :                 case 0x18e: map_key_clear(KEY_CALENDAR);        break;
     976                 :          2 :                 case 0x18f: map_key_clear(KEY_TASKMANAGER);     break;
     977                 :          2 :                 case 0x190: map_key_clear(KEY_JOURNAL);         break;
     978                 :          2 :                 case 0x191: map_key_clear(KEY_FINANCE);         break;
     979                 :          2 :                 case 0x192: map_key_clear(KEY_CALC);            break;
     980                 :          2 :                 case 0x193: map_key_clear(KEY_PLAYER);          break;
     981                 :          2 :                 case 0x194: map_key_clear(KEY_FILE);            break;
     982                 :          2 :                 case 0x196: map_key_clear(KEY_WWW);             break;
     983                 :          2 :                 case 0x199: map_key_clear(KEY_CHAT);            break;
     984                 :          2 :                 case 0x19c: map_key_clear(KEY_LOGOFF);          break;
     985                 :          2 :                 case 0x19e: map_key_clear(KEY_COFFEE);          break;
     986                 :          2 :                 case 0x19f: map_key_clear(KEY_CONTROLPANEL);            break;
     987                 :          2 :                 case 0x1a2: map_key_clear(KEY_APPSELECT);               break;
     988                 :          2 :                 case 0x1a3: map_key_clear(KEY_NEXT);            break;
     989                 :          2 :                 case 0x1a4: map_key_clear(KEY_PREVIOUS);        break;
     990                 :          2 :                 case 0x1a6: map_key_clear(KEY_HELP);            break;
     991                 :          2 :                 case 0x1a7: map_key_clear(KEY_DOCUMENTS);       break;
     992                 :          2 :                 case 0x1ab: map_key_clear(KEY_SPELLCHECK);      break;
     993                 :          2 :                 case 0x1ae: map_key_clear(KEY_KEYBOARD);        break;
     994                 :          2 :                 case 0x1b1: map_key_clear(KEY_SCREENSAVER);             break;
     995                 :          2 :                 case 0x1b4: map_key_clear(KEY_FILE);            break;
     996                 :          2 :                 case 0x1b6: map_key_clear(KEY_IMAGES);          break;
     997                 :          2 :                 case 0x1b7: map_key_clear(KEY_AUDIO);           break;
     998                 :          2 :                 case 0x1b8: map_key_clear(KEY_VIDEO);           break;
     999                 :          2 :                 case 0x1bc: map_key_clear(KEY_MESSENGER);       break;
    1000                 :          2 :                 case 0x1bd: map_key_clear(KEY_INFO);            break;
    1001                 :          2 :                 case 0x1cb: map_key_clear(KEY_ASSISTANT);       break;
    1002                 :          2 :                 case 0x201: map_key_clear(KEY_NEW);             break;
    1003                 :          2 :                 case 0x202: map_key_clear(KEY_OPEN);            break;
    1004                 :          2 :                 case 0x203: map_key_clear(KEY_CLOSE);           break;
    1005                 :          2 :                 case 0x204: map_key_clear(KEY_EXIT);            break;
    1006                 :          2 :                 case 0x207: map_key_clear(KEY_SAVE);            break;
    1007                 :          2 :                 case 0x208: map_key_clear(KEY_PRINT);           break;
    1008                 :          2 :                 case 0x209: map_key_clear(KEY_PROPS);           break;
    1009                 :          2 :                 case 0x21a: map_key_clear(KEY_UNDO);            break;
    1010                 :          2 :                 case 0x21b: map_key_clear(KEY_COPY);            break;
    1011                 :          2 :                 case 0x21c: map_key_clear(KEY_CUT);             break;
    1012                 :          2 :                 case 0x21d: map_key_clear(KEY_PASTE);           break;
    1013                 :          2 :                 case 0x21f: map_key_clear(KEY_FIND);            break;
    1014                 :          2 :                 case 0x221: map_key_clear(KEY_SEARCH);          break;
    1015                 :          2 :                 case 0x222: map_key_clear(KEY_GOTO);            break;
    1016                 :          2 :                 case 0x223: map_key_clear(KEY_HOMEPAGE);        break;
    1017                 :          2 :                 case 0x224: map_key_clear(KEY_BACK);            break;
    1018                 :          2 :                 case 0x225: map_key_clear(KEY_FORWARD);         break;
    1019                 :          2 :                 case 0x226: map_key_clear(KEY_STOP);            break;
    1020                 :          2 :                 case 0x227: map_key_clear(KEY_REFRESH);         break;
    1021                 :          2 :                 case 0x22a: map_key_clear(KEY_BOOKMARKS);       break;
    1022                 :          2 :                 case 0x22d: map_key_clear(KEY_ZOOMIN);          break;
    1023                 :          2 :                 case 0x22e: map_key_clear(KEY_ZOOMOUT);         break;
    1024                 :          2 :                 case 0x22f: map_key_clear(KEY_ZOOMRESET);       break;
    1025                 :          2 :                 case 0x232: map_key_clear(KEY_FULL_SCREEN);     break;
    1026                 :          2 :                 case 0x233: map_key_clear(KEY_SCROLLUP);        break;
    1027                 :          2 :                 case 0x234: map_key_clear(KEY_SCROLLDOWN);      break;
    1028                 :            :                 case 0x238: /* AC Pan */
    1029                 :          2 :                         set_bit(REL_HWHEEL, input->relbit);
    1030                 :            :                         map_rel(REL_HWHEEL_HI_RES);
    1031                 :            :                         break;
    1032                 :          2 :                 case 0x23d: map_key_clear(KEY_EDIT);            break;
    1033                 :          2 :                 case 0x25f: map_key_clear(KEY_CANCEL);          break;
    1034                 :          2 :                 case 0x269: map_key_clear(KEY_INSERT);          break;
    1035                 :          2 :                 case 0x26a: map_key_clear(KEY_DELETE);          break;
    1036                 :          2 :                 case 0x279: map_key_clear(KEY_REDO);            break;
    1037                 :            : 
    1038                 :          2 :                 case 0x289: map_key_clear(KEY_REPLY);           break;
    1039                 :          2 :                 case 0x28b: map_key_clear(KEY_FORWARDMAIL);     break;
    1040                 :          2 :                 case 0x28c: map_key_clear(KEY_SEND);            break;
    1041                 :            : 
    1042                 :          2 :                 case 0x29d: map_key_clear(KEY_KBD_LAYOUT_NEXT); break;
    1043                 :            : 
    1044                 :          2 :                 case 0x2c7: map_key_clear(KEY_KBDINPUTASSIST_PREV);             break;
    1045                 :          2 :                 case 0x2c8: map_key_clear(KEY_KBDINPUTASSIST_NEXT);             break;
    1046                 :          2 :                 case 0x2c9: map_key_clear(KEY_KBDINPUTASSIST_PREVGROUP);                break;
    1047                 :          2 :                 case 0x2ca: map_key_clear(KEY_KBDINPUTASSIST_NEXTGROUP);                break;
    1048                 :          2 :                 case 0x2cb: map_key_clear(KEY_KBDINPUTASSIST_ACCEPT);   break;
    1049                 :          2 :                 case 0x2cc: map_key_clear(KEY_KBDINPUTASSIST_CANCEL);   break;
    1050                 :            : 
    1051                 :          2 :                 case 0x29f: map_key_clear(KEY_SCALE);           break;
    1052                 :            : 
    1053                 :          2 :                 default: map_key_clear(KEY_UNKNOWN);
    1054                 :            :                 }
    1055                 :            :                 break;
    1056                 :            : 
    1057                 :            :         case HID_UP_GENDEVCTRLS:
    1058                 :          0 :                 switch (usage->hid) {
    1059                 :            :                 case HID_DC_BATTERYSTRENGTH:
    1060                 :          0 :                         hidinput_setup_battery(device, HID_INPUT_REPORT, field);
    1061                 :          0 :                         usage->type = EV_PWR;
    1062                 :          0 :                         goto ignore;
    1063                 :            :                 }
    1064                 :            :                 goto unknown;
    1065                 :            : 
    1066                 :            :         case HID_UP_HPVENDOR:   /* Reported on a Dutch layout HP5308 */
    1067                 :          0 :                 set_bit(EV_REP, input->evbit);
    1068                 :          0 :                 switch (usage->hid & HID_USAGE) {
    1069                 :          0 :                 case 0x021: map_key_clear(KEY_PRINT);           break;
    1070                 :          0 :                 case 0x070: map_key_clear(KEY_HP);              break;
    1071                 :          0 :                 case 0x071: map_key_clear(KEY_CAMERA);          break;
    1072                 :          0 :                 case 0x072: map_key_clear(KEY_SOUND);           break;
    1073                 :          0 :                 case 0x073: map_key_clear(KEY_QUESTION);        break;
    1074                 :          0 :                 case 0x080: map_key_clear(KEY_EMAIL);           break;
    1075                 :          0 :                 case 0x081: map_key_clear(KEY_CHAT);            break;
    1076                 :          0 :                 case 0x082: map_key_clear(KEY_SEARCH);          break;
    1077                 :          0 :                 case 0x083: map_key_clear(KEY_CONNECT);         break;
    1078                 :          0 :                 case 0x084: map_key_clear(KEY_FINANCE);         break;
    1079                 :          0 :                 case 0x085: map_key_clear(KEY_SPORT);           break;
    1080                 :          0 :                 case 0x086: map_key_clear(KEY_SHOP);            break;
    1081                 :            :                 default:    goto ignore;
    1082                 :            :                 }
    1083                 :            :                 break;
    1084                 :            : 
    1085                 :            :         case HID_UP_HPVENDOR2:
    1086                 :          0 :                 set_bit(EV_REP, input->evbit);
    1087                 :          0 :                 switch (usage->hid & HID_USAGE) {
    1088                 :          0 :                 case 0x001: map_key_clear(KEY_MICMUTE);         break;
    1089                 :          0 :                 case 0x003: map_key_clear(KEY_BRIGHTNESSDOWN);  break;
    1090                 :          0 :                 case 0x004: map_key_clear(KEY_BRIGHTNESSUP);    break;
    1091                 :            :                 default:    goto ignore;
    1092                 :            :                 }
    1093                 :            :                 break;
    1094                 :            : 
    1095                 :            :         case HID_UP_MSVENDOR:
    1096                 :            :                 goto ignore;
    1097                 :            : 
    1098                 :            :         case HID_UP_CUSTOM: /* Reported on Logitech and Apple USB keyboards */
    1099                 :          0 :                 set_bit(EV_REP, input->evbit);
    1100                 :          0 :                 goto ignore;
    1101                 :            : 
    1102                 :            :         case HID_UP_LOGIVENDOR:
    1103                 :            :                 /* intentional fallback */
    1104                 :            :         case HID_UP_LOGIVENDOR2:
    1105                 :            :                 /* intentional fallback */
    1106                 :            :         case HID_UP_LOGIVENDOR3:
    1107                 :            :                 goto ignore;
    1108                 :            : 
    1109                 :            :         case HID_UP_PID:
    1110                 :          0 :                 switch (usage->hid & HID_USAGE) {
    1111                 :          0 :                 case 0xa4: map_key_clear(BTN_DEAD);     break;
    1112                 :            :                 default: goto ignore;
    1113                 :            :                 }
    1114                 :          0 :                 break;
    1115                 :            : 
    1116                 :            :         default:
    1117                 :            :         unknown:
    1118                 :          0 :                 if (field->report_size == 1) {
    1119                 :          0 :                         if (field->report->type == HID_OUTPUT_REPORT) {
    1120                 :            :                                 map_led(LED_MISC);
    1121                 :            :                                 break;
    1122                 :            :                         }
    1123                 :            :                         map_key(BTN_MISC);
    1124                 :            :                         break;
    1125                 :            :                 }
    1126                 :          0 :                 if (field->flags & HID_MAIN_ITEM_RELATIVE) {
    1127                 :            :                         map_rel(REL_MISC);
    1128                 :            :                         break;
    1129                 :            :                 }
    1130                 :            :                 map_abs(ABS_MISC);
    1131                 :            :                 break;
    1132                 :            :         }
    1133                 :            : 
    1134                 :            : mapped:
    1135                 :          3 :         if (device->driver->input_mapped &&
    1136                 :          0 :             device->driver->input_mapped(device, hidinput, field, usage,
    1137                 :            :                                          &bit, &max) < 0) {
    1138                 :            :                 /*
    1139                 :            :                  * The driver indicated that no further generic handling
    1140                 :            :                  * of the usage is desired.
    1141                 :            :                  */
    1142                 :          3 :                 return;
    1143                 :            :         }
    1144                 :            : 
    1145                 :          3 :         set_bit(usage->type, input->evbit);
    1146                 :            : 
    1147                 :            :         /*
    1148                 :            :          * This part is *really* controversial:
    1149                 :            :          * - HID aims at being generic so we should do our best to export
    1150                 :            :          *   all incoming events
    1151                 :            :          * - HID describes what events are, so there is no reason for ABS_X
    1152                 :            :          *   to be mapped to ABS_Y
    1153                 :            :          * - HID is using *_MISC+N as a default value, but nothing prevents
    1154                 :            :          *   *_MISC+N to overwrite a legitimate even, which confuses userspace
    1155                 :            :          *   (for instance ABS_MISC + 7 is ABS_MT_SLOT, which has a different
    1156                 :            :          *   processing)
    1157                 :            :          *
    1158                 :            :          * If devices still want to use this (at their own risk), they will
    1159                 :            :          * have to use the quirk HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE, but
    1160                 :            :          * the default should be a reliable mapping.
    1161                 :            :          */
    1162                 :          3 :         while (usage->code <= max && test_and_set_bit(usage->code, bit)) {
    1163                 :          2 :                 if (device->quirks & HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE) {
    1164                 :          0 :                         usage->code = find_next_zero_bit(bit,
    1165                 :            :                                                          max + 1,
    1166                 :            :                                                          usage->code);
    1167                 :            :                 } else {
    1168                 :          2 :                         device->status |= HID_STAT_DUP_DETECTED;
    1169                 :          2 :                         goto ignore;
    1170                 :            :                 }
    1171                 :            :         }
    1172                 :            : 
    1173                 :          3 :         if (usage->code > max)
    1174                 :            :                 goto ignore;
    1175                 :            : 
    1176                 :          3 :         if (usage->type == EV_ABS) {
    1177                 :            : 
    1178                 :          2 :                 int a = field->logical_minimum;
    1179                 :          2 :                 int b = field->logical_maximum;
    1180                 :            : 
    1181                 :          2 :                 if ((device->quirks & HID_QUIRK_BADPAD) && (usage->code == ABS_X || usage->code == ABS_Y)) {
    1182                 :          0 :                         a = field->logical_minimum = 0;
    1183                 :          0 :                         b = field->logical_maximum = 255;
    1184                 :            :                 }
    1185                 :            : 
    1186                 :          2 :                 if (field->application == HID_GD_GAMEPAD || field->application == HID_GD_JOYSTICK)
    1187                 :          0 :                         input_set_abs_params(input, usage->code, a, b, (b - a) >> 8, (b - a) >> 4);
    1188                 :          2 :                 else    input_set_abs_params(input, usage->code, a, b, 0, 0);
    1189                 :            : 
    1190                 :          2 :                 input_abs_set_res(input, usage->code,
    1191                 :            :                                   hidinput_calc_abs_res(field, usage->code));
    1192                 :            : 
    1193                 :            :                 /* use a larger default input buffer for MT devices */
    1194                 :          2 :                 if (usage->code == ABS_MT_POSITION_X && input->hint_events_per_packet == 0)
    1195                 :            :                         input_set_events_per_packet(input, 60);
    1196                 :            :         }
    1197                 :            : 
    1198                 :          3 :         if (usage->type == EV_ABS &&
    1199                 :          2 :             (usage->hat_min < usage->hat_max || usage->hat_dir)) {
    1200                 :            :                 int i;
    1201                 :          0 :                 for (i = usage->code; i < usage->code + 2 && i <= max; i++) {
    1202                 :          0 :                         input_set_abs_params(input, i, -1, 1, 0, 0);
    1203                 :          0 :                         set_bit(i, input->absbit);
    1204                 :            :                 }
    1205                 :          0 :                 if (usage->hat_dir && !field->dpad)
    1206                 :          0 :                         field->dpad = usage->code;
    1207                 :            :         }
    1208                 :            : 
    1209                 :            :         /* for those devices which produce Consumer volume usage as relative,
    1210                 :            :          * we emulate pressing volumeup/volumedown appropriate number of times
    1211                 :            :          * in hidinput_hid_event()
    1212                 :            :          */
    1213                 :          3 :         if ((usage->type == EV_ABS) && (field->flags & HID_MAIN_ITEM_RELATIVE) &&
    1214                 :          0 :                         (usage->code == ABS_VOLUME)) {
    1215                 :          0 :                 set_bit(KEY_VOLUMEUP, input->keybit);
    1216                 :          0 :                 set_bit(KEY_VOLUMEDOWN, input->keybit);
    1217                 :            :         }
    1218                 :            : 
    1219                 :          3 :         if (usage->type == EV_KEY) {
    1220                 :          3 :                 set_bit(EV_MSC, input->evbit);
    1221                 :          3 :                 set_bit(MSC_SCAN, input->mscbit);
    1222                 :            :         }
    1223                 :            : 
    1224                 :            :         return;
    1225                 :            : 
    1226                 :            : ignore:
    1227                 :          3 :         usage->type = 0;
    1228                 :          3 :         usage->code = 0;
    1229                 :            : }
    1230                 :            : 
    1231                 :          1 : static void hidinput_handle_scroll(struct hid_usage *usage,
    1232                 :            :                                    struct input_dev *input,
    1233                 :            :                                    __s32 value)
    1234                 :            : {
    1235                 :            :         int code;
    1236                 :            :         int hi_res, lo_res;
    1237                 :            : 
    1238                 :          1 :         if (value == 0)
    1239                 :          1 :                 return;
    1240                 :            : 
    1241                 :          0 :         if (usage->code == REL_WHEEL_HI_RES)
    1242                 :            :                 code = REL_WHEEL;
    1243                 :            :         else
    1244                 :            :                 code = REL_HWHEEL;
    1245                 :            : 
    1246                 :            :         /*
    1247                 :            :          * Windows reports one wheel click as value 120. Where a high-res
    1248                 :            :          * scroll wheel is present, a fraction of 120 is reported instead.
    1249                 :            :          * Our REL_WHEEL_HI_RES axis does the same because all HW must
    1250                 :            :          * adhere to the 120 expectation.
    1251                 :            :          */
    1252                 :          0 :         hi_res = value * 120/usage->resolution_multiplier;
    1253                 :            : 
    1254                 :          0 :         usage->wheel_accumulated += hi_res;
    1255                 :          0 :         lo_res = usage->wheel_accumulated/120;
    1256                 :          0 :         if (lo_res)
    1257                 :          0 :                 usage->wheel_accumulated -= lo_res * 120;
    1258                 :            : 
    1259                 :          0 :         input_event(input, EV_REL, code, lo_res);
    1260                 :          0 :         input_event(input, EV_REL, usage->code, hi_res);
    1261                 :            : }
    1262                 :            : 
    1263                 :          3 : void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value)
    1264                 :            : {
    1265                 :            :         struct input_dev *input;
    1266                 :            :         unsigned *quirks = &hid->quirks;
    1267                 :            : 
    1268                 :          3 :         if (!usage->type)
    1269                 :            :                 return;
    1270                 :            : 
    1271                 :          3 :         if (usage->type == EV_PWR) {
    1272                 :          0 :                 hidinput_update_battery(hid, value);
    1273                 :          0 :                 return;
    1274                 :            :         }
    1275                 :            : 
    1276                 :          3 :         if (!field->hidinput)
    1277                 :            :                 return;
    1278                 :            : 
    1279                 :          3 :         input = field->hidinput->input;
    1280                 :            : 
    1281                 :          3 :         if (usage->hat_min < usage->hat_max || usage->hat_dir) {
    1282                 :          0 :                 int hat_dir = usage->hat_dir;
    1283                 :          0 :                 if (!hat_dir)
    1284                 :          0 :                         hat_dir = (value - usage->hat_min) * 8 / (usage->hat_max - usage->hat_min + 1) + 1;
    1285                 :          0 :                 if (hat_dir < 0 || hat_dir > 8) hat_dir = 0;
    1286                 :          0 :                 input_event(input, usage->type, usage->code    , hid_hat_to_axis[hat_dir].x);
    1287                 :          0 :                 input_event(input, usage->type, usage->code + 1, hid_hat_to_axis[hat_dir].y);
    1288                 :          0 :                 return;
    1289                 :            :         }
    1290                 :            : 
    1291                 :          3 :         if (usage->hid == (HID_UP_DIGITIZER | 0x003c)) { /* Invert */
    1292                 :          0 :                 *quirks = value ? (*quirks | HID_QUIRK_INVERT) : (*quirks & ~HID_QUIRK_INVERT);
    1293                 :          0 :                 return;
    1294                 :            :         }
    1295                 :            : 
    1296                 :          3 :         if (usage->hid == (HID_UP_DIGITIZER | 0x0032)) { /* InRange */
    1297                 :          0 :                 if (value) {
    1298                 :          0 :                         input_event(input, usage->type, (*quirks & HID_QUIRK_INVERT) ? BTN_TOOL_RUBBER : usage->code, 1);
    1299                 :          0 :                         return;
    1300                 :            :                 }
    1301                 :          0 :                 input_event(input, usage->type, usage->code, 0);
    1302                 :          0 :                 input_event(input, usage->type, BTN_TOOL_RUBBER, 0);
    1303                 :          0 :                 return;
    1304                 :            :         }
    1305                 :            : 
    1306                 :          3 :         if (usage->hid == (HID_UP_DIGITIZER | 0x0030) && (*quirks & HID_QUIRK_NOTOUCH)) { /* Pressure */
    1307                 :          0 :                 int a = field->logical_minimum;
    1308                 :          0 :                 int b = field->logical_maximum;
    1309                 :          0 :                 input_event(input, EV_KEY, BTN_TOUCH, value > a + ((b - a) >> 3));
    1310                 :            :         }
    1311                 :            : 
    1312                 :          3 :         if (usage->hid == (HID_UP_PID | 0x83UL)) { /* Simultaneous Effects Max */
    1313                 :          0 :                 dbg_hid("Maximum Effects - %d\n",value);
    1314                 :            :                 return;
    1315                 :            :         }
    1316                 :            : 
    1317                 :          3 :         if (usage->hid == (HID_UP_PID | 0x7fUL)) {
    1318                 :          0 :                 dbg_hid("PID Pool Report\n");
    1319                 :            :                 return;
    1320                 :            :         }
    1321                 :            : 
    1322                 :          3 :         if ((usage->type == EV_KEY) && (usage->code == 0)) /* Key 0 is "unassigned", not KEY_UNKNOWN */
    1323                 :            :                 return;
    1324                 :            : 
    1325                 :          3 :         if ((usage->type == EV_REL) && (usage->code == REL_WHEEL_HI_RES ||
    1326                 :            :                                         usage->code == REL_HWHEEL_HI_RES)) {
    1327                 :          1 :                 hidinput_handle_scroll(usage, input, value);
    1328                 :          1 :                 return;
    1329                 :            :         }
    1330                 :            : 
    1331                 :          3 :         if ((usage->type == EV_ABS) && (field->flags & HID_MAIN_ITEM_RELATIVE) &&
    1332                 :          0 :                         (usage->code == ABS_VOLUME)) {
    1333                 :          0 :                 int count = abs(value);
    1334                 :          0 :                 int direction = value > 0 ? KEY_VOLUMEUP : KEY_VOLUMEDOWN;
    1335                 :            :                 int i;
    1336                 :            : 
    1337                 :          0 :                 for (i = 0; i < count; i++) {
    1338                 :          0 :                         input_event(input, EV_KEY, direction, 1);
    1339                 :            :                         input_sync(input);
    1340                 :          0 :                         input_event(input, EV_KEY, direction, 0);
    1341                 :            :                         input_sync(input);
    1342                 :            :                 }
    1343                 :            :                 return;
    1344                 :            :         }
    1345                 :            : 
    1346                 :            :         /*
    1347                 :            :          * Ignore out-of-range values as per HID specification,
    1348                 :            :          * section 5.10 and 6.2.25, when NULL state bit is present.
    1349                 :            :          * When it's not, clamp the value to match Microsoft's input
    1350                 :            :          * driver as mentioned in "Required HID usages for digitizers":
    1351                 :            :          * https://msdn.microsoft.com/en-us/library/windows/hardware/dn672278(v=vs.85).asp
    1352                 :            :          *
    1353                 :            :          * The logical_minimum < logical_maximum check is done so that we
    1354                 :            :          * don't unintentionally discard values sent by devices which
    1355                 :            :          * don't specify logical min and max.
    1356                 :            :          */
    1357                 :          3 :         if ((field->flags & HID_MAIN_ITEM_VARIABLE) &&
    1358                 :          3 :             (field->logical_minimum < field->logical_maximum)) {
    1359                 :          3 :                 if (field->flags & HID_MAIN_ITEM_NULL_STATE &&
    1360                 :          0 :                     (value < field->logical_minimum ||
    1361                 :            :                      value > field->logical_maximum)) {
    1362                 :          0 :                         dbg_hid("Ignoring out-of-range value %x\n", value);
    1363                 :            :                         return;
    1364                 :            :                 }
    1365                 :          3 :                 value = clamp(value,
    1366                 :            :                               field->logical_minimum,
    1367                 :            :                               field->logical_maximum);
    1368                 :            :         }
    1369                 :            : 
    1370                 :            :         /*
    1371                 :            :          * Ignore reports for absolute data if the data didn't change. This is
    1372                 :            :          * not only an optimization but also fixes 'dead' key reports. Some
    1373                 :            :          * RollOver implementations for localized keys (like BACKSLASH/PIPE; HID
    1374                 :            :          * 0x31 and 0x32) report multiple keys, even though a localized keyboard
    1375                 :            :          * can only have one of them physically available. The 'dead' keys
    1376                 :            :          * report constant 0. As all map to the same keycode, they'd confuse
    1377                 :            :          * the input layer. If we filter the 'dead' keys on the HID level, we
    1378                 :            :          * skip the keycode translation and only forward real events.
    1379                 :            :          */
    1380                 :          3 :         if (!(field->flags & (HID_MAIN_ITEM_RELATIVE |
    1381                 :          3 :                               HID_MAIN_ITEM_BUFFERED_BYTE)) &&
    1382                 :          3 :                               (field->flags & HID_MAIN_ITEM_VARIABLE) &&
    1383                 :          3 :             usage->usage_index < field->maxusage &&
    1384                 :          3 :             value == field->value[usage->usage_index])
    1385                 :            :                 return;
    1386                 :            : 
    1387                 :            :         /* report the usage code as scancode if the key status has changed */
    1388                 :          3 :         if (usage->type == EV_KEY &&
    1389                 :          3 :             (!test_bit(usage->code, input->key)) == value)
    1390                 :          3 :                 input_event(input, EV_MSC, MSC_SCAN, usage->hid);
    1391                 :            : 
    1392                 :          3 :         input_event(input, usage->type, usage->code, value);
    1393                 :            : 
    1394                 :          3 :         if ((field->flags & HID_MAIN_ITEM_RELATIVE) &&
    1395                 :          1 :             usage->type == EV_KEY && value) {
    1396                 :            :                 input_sync(input);
    1397                 :          0 :                 input_event(input, usage->type, usage->code, 0);
    1398                 :            :         }
    1399                 :            : }
    1400                 :            : 
    1401                 :          3 : void hidinput_report_event(struct hid_device *hid, struct hid_report *report)
    1402                 :            : {
    1403                 :            :         struct hid_input *hidinput;
    1404                 :            : 
    1405                 :          3 :         if (hid->quirks & HID_QUIRK_NO_INPUT_SYNC)
    1406                 :          3 :                 return;
    1407                 :            : 
    1408                 :          3 :         list_for_each_entry(hidinput, &hid->inputs, list)
    1409                 :          3 :                 input_sync(hidinput->input);
    1410                 :            : }
    1411                 :            : EXPORT_SYMBOL_GPL(hidinput_report_event);
    1412                 :            : 
    1413                 :          0 : int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field)
    1414                 :            : {
    1415                 :            :         struct hid_report *report;
    1416                 :            :         int i, j;
    1417                 :            : 
    1418                 :          0 :         list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {
    1419                 :          0 :                 for (i = 0; i < report->maxfield; i++) {
    1420                 :          0 :                         *field = report->field[i];
    1421                 :          0 :                         for (j = 0; j < (*field)->maxusage; j++)
    1422                 :          0 :                                 if ((*field)->usage[j].type == type && (*field)->usage[j].code == code)
    1423                 :          0 :                                         return j;
    1424                 :            :                 }
    1425                 :            :         }
    1426                 :            :         return -1;
    1427                 :            : }
    1428                 :            : EXPORT_SYMBOL_GPL(hidinput_find_field);
    1429                 :            : 
    1430                 :          0 : struct hid_field *hidinput_get_led_field(struct hid_device *hid)
    1431                 :            : {
    1432                 :            :         struct hid_report *report;
    1433                 :            :         struct hid_field *field;
    1434                 :            :         int i, j;
    1435                 :            : 
    1436                 :          0 :         list_for_each_entry(report,
    1437                 :            :                             &hid->report_enum[HID_OUTPUT_REPORT].report_list,
    1438                 :            :                             list) {
    1439                 :          0 :                 for (i = 0; i < report->maxfield; i++) {
    1440                 :          0 :                         field = report->field[i];
    1441                 :          0 :                         for (j = 0; j < field->maxusage; j++)
    1442                 :          0 :                                 if (field->usage[j].type == EV_LED)
    1443                 :          0 :                                         return field;
    1444                 :            :                 }
    1445                 :            :         }
    1446                 :            :         return NULL;
    1447                 :            : }
    1448                 :            : EXPORT_SYMBOL_GPL(hidinput_get_led_field);
    1449                 :            : 
    1450                 :          0 : unsigned int hidinput_count_leds(struct hid_device *hid)
    1451                 :            : {
    1452                 :            :         struct hid_report *report;
    1453                 :            :         struct hid_field *field;
    1454                 :            :         int i, j;
    1455                 :            :         unsigned int count = 0;
    1456                 :            : 
    1457                 :          0 :         list_for_each_entry(report,
    1458                 :            :                             &hid->report_enum[HID_OUTPUT_REPORT].report_list,
    1459                 :            :                             list) {
    1460                 :          0 :                 for (i = 0; i < report->maxfield; i++) {
    1461                 :          0 :                         field = report->field[i];
    1462                 :          0 :                         for (j = 0; j < field->maxusage; j++)
    1463                 :          0 :                                 if (field->usage[j].type == EV_LED &&
    1464                 :          0 :                                     field->value[j])
    1465                 :          0 :                                         count += 1;
    1466                 :            :                 }
    1467                 :            :         }
    1468                 :          0 :         return count;
    1469                 :            : }
    1470                 :            : EXPORT_SYMBOL_GPL(hidinput_count_leds);
    1471                 :            : 
    1472                 :          0 : static void hidinput_led_worker(struct work_struct *work)
    1473                 :            : {
    1474                 :          0 :         struct hid_device *hid = container_of(work, struct hid_device,
    1475                 :            :                                               led_work);
    1476                 :            :         struct hid_field *field;
    1477                 :            :         struct hid_report *report;
    1478                 :            :         int ret;
    1479                 :            :         u32 len;
    1480                 :            :         __u8 *buf;
    1481                 :            : 
    1482                 :          0 :         field = hidinput_get_led_field(hid);
    1483                 :          0 :         if (!field)
    1484                 :            :                 return;
    1485                 :            : 
    1486                 :            :         /*
    1487                 :            :          * field->report is accessed unlocked regarding HID core. So there might
    1488                 :            :          * be another incoming SET-LED request from user-space, which changes
    1489                 :            :          * the LED state while we assemble our outgoing buffer. However, this
    1490                 :            :          * doesn't matter as hid_output_report() correctly converts it into a
    1491                 :            :          * boolean value no matter what information is currently set on the LED
    1492                 :            :          * field (even garbage). So the remote device will always get a valid
    1493                 :            :          * request.
    1494                 :            :          * And in case we send a wrong value, a next led worker is spawned
    1495                 :            :          * for every SET-LED request so the following worker will send the
    1496                 :            :          * correct value, guaranteed!
    1497                 :            :          */
    1498                 :            : 
    1499                 :          0 :         report = field->report;
    1500                 :            : 
    1501                 :            :         /* use custom SET_REPORT request if possible (asynchronous) */
    1502                 :          0 :         if (hid->ll_driver->request)
    1503                 :          0 :                 return hid->ll_driver->request(hid, report, HID_REQ_SET_REPORT);
    1504                 :            : 
    1505                 :            :         /* fall back to generic raw-output-report */
    1506                 :            :         len = hid_report_len(report);
    1507                 :          0 :         buf = hid_alloc_report_buf(report, GFP_KERNEL);
    1508                 :          0 :         if (!buf)
    1509                 :            :                 return;
    1510                 :            : 
    1511                 :          0 :         hid_output_report(report, buf);
    1512                 :            :         /* synchronous output report */
    1513                 :            :         ret = hid_hw_output_report(hid, buf, len);
    1514                 :          0 :         if (ret == -ENOSYS)
    1515                 :          0 :                 hid_hw_raw_request(hid, report->id, buf, len, HID_OUTPUT_REPORT,
    1516                 :            :                                 HID_REQ_SET_REPORT);
    1517                 :          0 :         kfree(buf);
    1518                 :            : }
    1519                 :            : 
    1520                 :          3 : static int hidinput_input_event(struct input_dev *dev, unsigned int type,
    1521                 :            :                                 unsigned int code, int value)
    1522                 :            : {
    1523                 :            :         struct hid_device *hid = input_get_drvdata(dev);
    1524                 :            :         struct hid_field *field;
    1525                 :            :         int offset;
    1526                 :            : 
    1527                 :          3 :         if (type == EV_FF)
    1528                 :          0 :                 return input_ff_event(dev, type, code, value);
    1529                 :            : 
    1530                 :          3 :         if (type != EV_LED)
    1531                 :            :                 return -1;
    1532                 :            : 
    1533                 :          0 :         if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
    1534                 :          0 :                 hid_warn(dev, "event field not found\n");
    1535                 :          0 :                 return -1;
    1536                 :            :         }
    1537                 :            : 
    1538                 :          0 :         hid_set_field(field, offset, value);
    1539                 :            : 
    1540                 :          0 :         schedule_work(&hid->led_work);
    1541                 :          0 :         return 0;
    1542                 :            : }
    1543                 :            : 
    1544                 :          3 : static int hidinput_open(struct input_dev *dev)
    1545                 :            : {
    1546                 :            :         struct hid_device *hid = input_get_drvdata(dev);
    1547                 :            : 
    1548                 :          3 :         return hid_hw_open(hid);
    1549                 :            : }
    1550                 :            : 
    1551                 :          3 : static void hidinput_close(struct input_dev *dev)
    1552                 :            : {
    1553                 :            :         struct hid_device *hid = input_get_drvdata(dev);
    1554                 :            : 
    1555                 :          3 :         hid_hw_close(hid);
    1556                 :          3 : }
    1557                 :            : 
    1558                 :          2 : static bool __hidinput_change_resolution_multipliers(struct hid_device *hid,
    1559                 :            :                 struct hid_report *report, bool use_logical_max)
    1560                 :            : {
    1561                 :            :         struct hid_usage *usage;
    1562                 :            :         bool update_needed = false;
    1563                 :            :         int i, j;
    1564                 :            : 
    1565                 :          2 :         if (report->maxfield == 0)
    1566                 :            :                 return false;
    1567                 :            : 
    1568                 :            :         /*
    1569                 :            :          * If we have more than one feature within this report we
    1570                 :            :          * need to fill in the bits from the others before we can
    1571                 :            :          * overwrite the ones for the Resolution Multiplier.
    1572                 :            :          */
    1573                 :          2 :         if (report->maxfield > 1) {
    1574                 :          0 :                 hid_hw_request(hid, report, HID_REQ_GET_REPORT);
    1575                 :            :                 hid_hw_wait(hid);
    1576                 :            :         }
    1577                 :            : 
    1578                 :          2 :         for (i = 0; i < report->maxfield; i++) {
    1579                 :            :                 __s32 value = use_logical_max ?
    1580                 :          2 :                               report->field[i]->logical_maximum :
    1581                 :          0 :                               report->field[i]->logical_minimum;
    1582                 :            : 
    1583                 :            :                 /* There is no good reason for a Resolution
    1584                 :            :                  * Multiplier to have a count other than 1.
    1585                 :            :                  * Ignore that case.
    1586                 :            :                  */
    1587                 :          2 :                 if (report->field[i]->report_count != 1)
    1588                 :          2 :                         continue;
    1589                 :            : 
    1590                 :          0 :                 for (j = 0; j < report->field[i]->maxusage; j++) {
    1591                 :          0 :                         usage = &report->field[i]->usage[j];
    1592                 :            : 
    1593                 :          0 :                         if (usage->hid != HID_GD_RESOLUTION_MULTIPLIER)
    1594                 :          0 :                                 continue;
    1595                 :            : 
    1596                 :          0 :                         report->field[i]->value[j] = value;
    1597                 :            :                         update_needed = true;
    1598                 :            :                 }
    1599                 :            :         }
    1600                 :            : 
    1601                 :          2 :         return update_needed;
    1602                 :            : }
    1603                 :            : 
    1604                 :          3 : static void hidinput_change_resolution_multipliers(struct hid_device *hid)
    1605                 :            : {
    1606                 :            :         struct hid_report_enum *rep_enum;
    1607                 :            :         struct hid_report *rep;
    1608                 :            :         int ret;
    1609                 :            : 
    1610                 :            :         rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
    1611                 :          3 :         list_for_each_entry(rep, &rep_enum->report_list, list) {
    1612                 :          2 :                 bool update_needed = __hidinput_change_resolution_multipliers(hid,
    1613                 :            :                                                                      rep, true);
    1614                 :            : 
    1615                 :          2 :                 if (update_needed) {
    1616                 :          0 :                         ret = __hid_request(hid, rep, HID_REQ_SET_REPORT);
    1617                 :          0 :                         if (ret) {
    1618                 :          0 :                                 __hidinput_change_resolution_multipliers(hid,
    1619                 :            :                                                                     rep, false);
    1620                 :          3 :                                 return;
    1621                 :            :                         }
    1622                 :            :                 }
    1623                 :            :         }
    1624                 :            : 
    1625                 :            :         /* refresh our structs */
    1626                 :          3 :         hid_setup_resolution_multiplier(hid);
    1627                 :            : }
    1628                 :            : 
    1629                 :          3 : static void report_features(struct hid_device *hid)
    1630                 :            : {
    1631                 :          3 :         struct hid_driver *drv = hid->driver;
    1632                 :            :         struct hid_report_enum *rep_enum;
    1633                 :            :         struct hid_report *rep;
    1634                 :            :         struct hid_usage *usage;
    1635                 :            :         int i, j;
    1636                 :            : 
    1637                 :            :         rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
    1638                 :          3 :         list_for_each_entry(rep, &rep_enum->report_list, list)
    1639                 :          2 :                 for (i = 0; i < rep->maxfield; i++) {
    1640                 :            :                         /* Ignore if report count is out of bounds. */
    1641                 :          2 :                         if (rep->field[i]->report_count < 1)
    1642                 :          0 :                                 continue;
    1643                 :            : 
    1644                 :          2 :                         for (j = 0; j < rep->field[i]->maxusage; j++) {
    1645                 :          2 :                                 usage = &rep->field[i]->usage[j];
    1646                 :            : 
    1647                 :            :                                 /* Verify if Battery Strength feature is available */
    1648                 :          2 :                                 if (usage->hid == HID_DC_BATTERYSTRENGTH)
    1649                 :          0 :                                         hidinput_setup_battery(hid, HID_FEATURE_REPORT,
    1650                 :            :                                                                rep->field[i]);
    1651                 :            : 
    1652                 :          2 :                                 if (drv->feature_mapping)
    1653                 :          0 :                                         drv->feature_mapping(hid, rep->field[i], usage);
    1654                 :            :                         }
    1655                 :            :                 }
    1656                 :          3 : }
    1657                 :            : 
    1658                 :          3 : static struct hid_input *hidinput_allocate(struct hid_device *hid,
    1659                 :            :                                            unsigned int application)
    1660                 :            : {
    1661                 :          3 :         struct hid_input *hidinput = kzalloc(sizeof(*hidinput), GFP_KERNEL);
    1662                 :          3 :         struct input_dev *input_dev = input_allocate_device();
    1663                 :            :         const char *suffix = NULL;
    1664                 :            :         size_t suffix_len, name_len;
    1665                 :            : 
    1666                 :          3 :         if (!hidinput || !input_dev)
    1667                 :            :                 goto fail;
    1668                 :            : 
    1669                 :          3 :         if ((hid->quirks & HID_QUIRK_INPUT_PER_APP) &&
    1670                 :          3 :             hid->maxapplication > 1) {
    1671                 :          0 :                 switch (application) {
    1672                 :            :                 case HID_GD_KEYBOARD:
    1673                 :            :                         suffix = "Keyboard";
    1674                 :          0 :                         break;
    1675                 :            :                 case HID_GD_KEYPAD:
    1676                 :            :                         suffix = "Keypad";
    1677                 :          0 :                         break;
    1678                 :            :                 case HID_GD_MOUSE:
    1679                 :            :                         suffix = "Mouse";
    1680                 :          0 :                         break;
    1681                 :            :                 case HID_DG_STYLUS:
    1682                 :            :                         suffix = "Pen";
    1683                 :          0 :                         break;
    1684                 :            :                 case HID_DG_TOUCHSCREEN:
    1685                 :            :                         suffix = "Touchscreen";
    1686                 :          0 :                         break;
    1687                 :            :                 case HID_DG_TOUCHPAD:
    1688                 :            :                         suffix = "Touchpad";
    1689                 :          0 :                         break;
    1690                 :            :                 case HID_GD_SYSTEM_CONTROL:
    1691                 :            :                         suffix = "System Control";
    1692                 :          0 :                         break;
    1693                 :            :                 case HID_CP_CONSUMER_CONTROL:
    1694                 :            :                         suffix = "Consumer Control";
    1695                 :          0 :                         break;
    1696                 :            :                 case HID_GD_WIRELESS_RADIO_CTLS:
    1697                 :            :                         suffix = "Wireless Radio Control";
    1698                 :          0 :                         break;
    1699                 :            :                 case HID_GD_SYSTEM_MULTIAXIS:
    1700                 :            :                         suffix = "System Multi Axis";
    1701                 :          0 :                         break;
    1702                 :            :                 default:
    1703                 :            :                         break;
    1704                 :            :                 }
    1705                 :            :         }
    1706                 :            : 
    1707                 :          3 :         if (suffix) {
    1708                 :          0 :                 name_len = strlen(hid->name);
    1709                 :          0 :                 suffix_len = strlen(suffix);
    1710                 :          0 :                 if ((name_len < suffix_len) ||
    1711                 :          0 :                     strcmp(hid->name + name_len - suffix_len, suffix)) {
    1712                 :          0 :                         hidinput->name = kasprintf(GFP_KERNEL, "%s %s",
    1713                 :            :                                                    hid->name, suffix);
    1714                 :          0 :                         if (!hidinput->name)
    1715                 :            :                                 goto fail;
    1716                 :            :                 }
    1717                 :            :         }
    1718                 :            : 
    1719                 :            :         input_set_drvdata(input_dev, hid);
    1720                 :          3 :         input_dev->event = hidinput_input_event;
    1721                 :          3 :         input_dev->open = hidinput_open;
    1722                 :          3 :         input_dev->close = hidinput_close;
    1723                 :          3 :         input_dev->setkeycode = hidinput_setkeycode;
    1724                 :          3 :         input_dev->getkeycode = hidinput_getkeycode;
    1725                 :            : 
    1726                 :          3 :         input_dev->name = hidinput->name ? hidinput->name : hid->name;
    1727                 :          3 :         input_dev->phys = hid->phys;
    1728                 :          3 :         input_dev->uniq = hid->uniq;
    1729                 :          3 :         input_dev->id.bustype = hid->bus;
    1730                 :          3 :         input_dev->id.vendor  = hid->vendor;
    1731                 :          3 :         input_dev->id.product = hid->product;
    1732                 :          3 :         input_dev->id.version = hid->version;
    1733                 :          3 :         input_dev->dev.parent = &hid->dev;
    1734                 :            : 
    1735                 :          3 :         hidinput->input = input_dev;
    1736                 :          3 :         hidinput->application = application;
    1737                 :          3 :         list_add_tail(&hidinput->list, &hid->inputs);
    1738                 :            : 
    1739                 :          3 :         INIT_LIST_HEAD(&hidinput->reports);
    1740                 :            : 
    1741                 :          3 :         return hidinput;
    1742                 :            : 
    1743                 :            : fail:
    1744                 :          0 :         kfree(hidinput);
    1745                 :          0 :         input_free_device(input_dev);
    1746                 :          0 :         hid_err(hid, "Out of memory during hid input probe\n");
    1747                 :          0 :         return NULL;
    1748                 :            : }
    1749                 :            : 
    1750                 :          3 : static bool hidinput_has_been_populated(struct hid_input *hidinput)
    1751                 :            : {
    1752                 :            :         int i;
    1753                 :            :         unsigned long r = 0;
    1754                 :            : 
    1755                 :          3 :         for (i = 0; i < BITS_TO_LONGS(EV_CNT); i++)
    1756                 :          3 :                 r |= hidinput->input->evbit[i];
    1757                 :            : 
    1758                 :          3 :         for (i = 0; i < BITS_TO_LONGS(KEY_CNT); i++)
    1759                 :          3 :                 r |= hidinput->input->keybit[i];
    1760                 :            : 
    1761                 :          3 :         for (i = 0; i < BITS_TO_LONGS(REL_CNT); i++)
    1762                 :          3 :                 r |= hidinput->input->relbit[i];
    1763                 :            : 
    1764                 :          3 :         for (i = 0; i < BITS_TO_LONGS(ABS_CNT); i++)
    1765                 :          3 :                 r |= hidinput->input->absbit[i];
    1766                 :            : 
    1767                 :          3 :         for (i = 0; i < BITS_TO_LONGS(MSC_CNT); i++)
    1768                 :          3 :                 r |= hidinput->input->mscbit[i];
    1769                 :            : 
    1770                 :          3 :         for (i = 0; i < BITS_TO_LONGS(LED_CNT); i++)
    1771                 :          3 :                 r |= hidinput->input->ledbit[i];
    1772                 :            : 
    1773                 :          3 :         for (i = 0; i < BITS_TO_LONGS(SND_CNT); i++)
    1774                 :          3 :                 r |= hidinput->input->sndbit[i];
    1775                 :            : 
    1776                 :          3 :         for (i = 0; i < BITS_TO_LONGS(FF_CNT); i++)
    1777                 :          3 :                 r |= hidinput->input->ffbit[i];
    1778                 :            : 
    1779                 :          3 :         for (i = 0; i < BITS_TO_LONGS(SW_CNT); i++)
    1780                 :          3 :                 r |= hidinput->input->swbit[i];
    1781                 :            : 
    1782                 :          3 :         return !!r;
    1783                 :            : }
    1784                 :            : 
    1785                 :          0 : static void hidinput_cleanup_hidinput(struct hid_device *hid,
    1786                 :            :                 struct hid_input *hidinput)
    1787                 :            : {
    1788                 :            :         struct hid_report *report;
    1789                 :            :         int i, k;
    1790                 :            : 
    1791                 :            :         list_del(&hidinput->list);
    1792                 :          0 :         input_free_device(hidinput->input);
    1793                 :          0 :         kfree(hidinput->name);
    1794                 :            : 
    1795                 :          0 :         for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
    1796                 :          0 :                 if (k == HID_OUTPUT_REPORT &&
    1797                 :          0 :                         hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
    1798                 :          0 :                         continue;
    1799                 :            : 
    1800                 :          0 :                 list_for_each_entry(report, &hid->report_enum[k].report_list,
    1801                 :            :                                     list) {
    1802                 :            : 
    1803                 :          0 :                         for (i = 0; i < report->maxfield; i++)
    1804                 :          0 :                                 if (report->field[i]->hidinput == hidinput)
    1805                 :          0 :                                         report->field[i]->hidinput = NULL;
    1806                 :            :                 }
    1807                 :            :         }
    1808                 :            : 
    1809                 :          0 :         kfree(hidinput);
    1810                 :          0 : }
    1811                 :            : 
    1812                 :            : static struct hid_input *hidinput_match(struct hid_report *report)
    1813                 :            : {
    1814                 :          0 :         struct hid_device *hid = report->device;
    1815                 :            :         struct hid_input *hidinput;
    1816                 :            : 
    1817                 :          0 :         list_for_each_entry(hidinput, &hid->inputs, list) {
    1818                 :          0 :                 if (hidinput->report &&
    1819                 :          0 :                     hidinput->report->id == report->id)
    1820                 :          0 :                         return hidinput;
    1821                 :            :         }
    1822                 :            : 
    1823                 :            :         return NULL;
    1824                 :            : }
    1825                 :            : 
    1826                 :            : static struct hid_input *hidinput_match_application(struct hid_report *report)
    1827                 :            : {
    1828                 :          0 :         struct hid_device *hid = report->device;
    1829                 :            :         struct hid_input *hidinput;
    1830                 :            : 
    1831                 :          0 :         list_for_each_entry(hidinput, &hid->inputs, list) {
    1832                 :          0 :                 if (hidinput->application == report->application)
    1833                 :          0 :                         return hidinput;
    1834                 :            :         }
    1835                 :            : 
    1836                 :            :         return NULL;
    1837                 :            : }
    1838                 :            : 
    1839                 :          3 : static inline void hidinput_configure_usages(struct hid_input *hidinput,
    1840                 :            :                                              struct hid_report *report)
    1841                 :            : {
    1842                 :            :         int i, j;
    1843                 :            : 
    1844                 :          3 :         for (i = 0; i < report->maxfield; i++)
    1845                 :          3 :                 for (j = 0; j < report->field[i]->maxusage; j++)
    1846                 :          3 :                         hidinput_configure_usage(hidinput, report->field[i],
    1847                 :          3 :                                                  report->field[i]->usage + j);
    1848                 :          3 : }
    1849                 :            : 
    1850                 :            : /*
    1851                 :            :  * Register the input device; print a message.
    1852                 :            :  * Configure the input layer interface
    1853                 :            :  * Read all reports and initialize the absolute field values.
    1854                 :            :  */
    1855                 :            : 
    1856                 :          3 : int hidinput_connect(struct hid_device *hid, unsigned int force)
    1857                 :            : {
    1858                 :          3 :         struct hid_driver *drv = hid->driver;
    1859                 :            :         struct hid_report *report;
    1860                 :            :         struct hid_input *next, *hidinput = NULL;
    1861                 :            :         unsigned int application;
    1862                 :            :         int i, k;
    1863                 :            : 
    1864                 :          3 :         INIT_LIST_HEAD(&hid->inputs);
    1865                 :          3 :         INIT_WORK(&hid->led_work, hidinput_led_worker);
    1866                 :            : 
    1867                 :          3 :         hid->status &= ~HID_STAT_DUP_DETECTED;
    1868                 :            : 
    1869                 :          3 :         if (!force) {
    1870                 :          0 :                 for (i = 0; i < hid->maxcollection; i++) {
    1871                 :          3 :                         struct hid_collection *col = &hid->collection[i];
    1872                 :          3 :                         if (col->type == HID_COLLECTION_APPLICATION ||
    1873                 :            :                                         col->type == HID_COLLECTION_PHYSICAL)
    1874                 :          3 :                                 if (IS_INPUT_APPLICATION(col->usage))
    1875                 :            :                                         break;
    1876                 :            :                 }
    1877                 :            : 
    1878                 :          3 :                 if (i == hid->maxcollection)
    1879                 :            :                         return -1;
    1880                 :            :         }
    1881                 :            : 
    1882                 :          3 :         report_features(hid);
    1883                 :            : 
    1884                 :          3 :         for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
    1885                 :          3 :                 if (k == HID_OUTPUT_REPORT &&
    1886                 :          3 :                         hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
    1887                 :          0 :                         continue;
    1888                 :            : 
    1889                 :          3 :                 list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
    1890                 :            : 
    1891                 :          3 :                         if (!report->maxfield)
    1892                 :          0 :                                 continue;
    1893                 :            : 
    1894                 :          3 :                         application = report->application;
    1895                 :            : 
    1896                 :            :                         /*
    1897                 :            :                          * Find the previous hidinput report attached
    1898                 :            :                          * to this report id.
    1899                 :            :                          */
    1900                 :          3 :                         if (hid->quirks & HID_QUIRK_MULTI_INPUT)
    1901                 :            :                                 hidinput = hidinput_match(report);
    1902                 :          3 :                         else if (hid->maxapplication > 1 &&
    1903                 :          0 :                                  (hid->quirks & HID_QUIRK_INPUT_PER_APP))
    1904                 :            :                                 hidinput = hidinput_match_application(report);
    1905                 :            : 
    1906                 :          3 :                         if (!hidinput) {
    1907                 :          3 :                                 hidinput = hidinput_allocate(hid, application);
    1908                 :          3 :                                 if (!hidinput)
    1909                 :            :                                         goto out_unwind;
    1910                 :            :                         }
    1911                 :            : 
    1912                 :          3 :                         hidinput_configure_usages(hidinput, report);
    1913                 :            : 
    1914                 :          3 :                         if (hid->quirks & HID_QUIRK_MULTI_INPUT)
    1915                 :          0 :                                 hidinput->report = report;
    1916                 :            : 
    1917                 :          3 :                         list_add_tail(&report->hidinput_list,
    1918                 :            :                                       &hidinput->reports);
    1919                 :            :                 }
    1920                 :            :         }
    1921                 :            : 
    1922                 :          3 :         hidinput_change_resolution_multipliers(hid);
    1923                 :            : 
    1924                 :          3 :         list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
    1925                 :          3 :                 if (drv->input_configured &&
    1926                 :          0 :                     drv->input_configured(hid, hidinput))
    1927                 :            :                         goto out_unwind;
    1928                 :            : 
    1929                 :          3 :                 if (!hidinput_has_been_populated(hidinput)) {
    1930                 :            :                         /* no need to register an input device not populated */
    1931                 :          0 :                         hidinput_cleanup_hidinput(hid, hidinput);
    1932                 :          0 :                         continue;
    1933                 :            :                 }
    1934                 :            : 
    1935                 :          3 :                 if (input_register_device(hidinput->input))
    1936                 :            :                         goto out_unwind;
    1937                 :          3 :                 hidinput->registered = true;
    1938                 :            :         }
    1939                 :            : 
    1940                 :          3 :         if (list_empty(&hid->inputs)) {
    1941                 :          0 :                 hid_err(hid, "No inputs registered, leaving\n");
    1942                 :          0 :                 goto out_unwind;
    1943                 :            :         }
    1944                 :            : 
    1945                 :            :         if (hid->status & HID_STAT_DUP_DETECTED)
    1946                 :            :                 hid_dbg(hid,
    1947                 :            :                         "Some usages could not be mapped, please use HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE if this is legitimate.\n");
    1948                 :            : 
    1949                 :            :         return 0;
    1950                 :            : 
    1951                 :            : out_unwind:
    1952                 :            :         /* unwind the ones we already registered */
    1953                 :          0 :         hidinput_disconnect(hid);
    1954                 :            : 
    1955                 :          0 :         return -1;
    1956                 :            : }
    1957                 :            : EXPORT_SYMBOL_GPL(hidinput_connect);
    1958                 :            : 
    1959                 :          0 : void hidinput_disconnect(struct hid_device *hid)
    1960                 :            : {
    1961                 :            :         struct hid_input *hidinput, *next;
    1962                 :            : 
    1963                 :          0 :         hidinput_cleanup_battery(hid);
    1964                 :            : 
    1965                 :          0 :         list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
    1966                 :            :                 list_del(&hidinput->list);
    1967                 :          0 :                 if (hidinput->registered)
    1968                 :          0 :                         input_unregister_device(hidinput->input);
    1969                 :            :                 else
    1970                 :          0 :                         input_free_device(hidinput->input);
    1971                 :          0 :                 kfree(hidinput->name);
    1972                 :          0 :                 kfree(hidinput);
    1973                 :            :         }
    1974                 :            : 
    1975                 :            :         /* led_work is spawned by input_dev callbacks, but doesn't access the
    1976                 :            :          * parent input_dev at all. Once all input devices are removed, we
    1977                 :            :          * know that led_work will never get restarted, so we can cancel it
    1978                 :            :          * synchronously and are safe. */
    1979                 :          0 :         cancel_work_sync(&hid->led_work);
    1980                 :          0 : }
    1981                 :            : EXPORT_SYMBOL_GPL(hidinput_disconnect);
    

Generated by: LCOV version 1.14