drivers/hid/hid-input.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Copyright (c) 2000-2001 Vojtech Pavlik
0004  *  Copyright (c) 2006-2010 Jiri Kosina
0005  *
0006  *  HID to Linux Input mapping
0007  */
0008
0009 /*
0010  *
0011  * Should you need to contact me, the author, you can do so either by
0012  * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
0013  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
0014  */
0015
0016 #include <linux/module.h>
0017 #include <linux/slab.h>
0018 #include <linux/kernel.h>
0019
0020 #include <linux/hid.h>
0021 #include <linux/hid-debug.h>
0022
0023 #include "hid-ids.h"
0024
0025 #define unk KEY_UNKNOWN
0026
0027 static const unsigned char hid_keyboard[256] = {
0028       0,  0,  0,  0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
0029      50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44,  2,  3,
0030       4,  5,  6,  7,  8,  9, 10, 11, 28,  1, 14, 15, 57, 12, 13, 26,
0031      27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
0032      65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
0033     105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
0034      72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
0035     191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
0036     115,114,unk,unk,unk,121,unk, 89, 93,124, 92, 94, 95,unk,unk,unk,
0037     122,123, 90, 91, 85,unk,unk,unk,unk,unk,unk,unk,111,unk,unk,unk,
0038     unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
0039     unk,unk,unk,unk,unk,unk,179,180,unk,unk,unk,unk,unk,unk,unk,unk,
0040     unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
0041     unk,unk,unk,unk,unk,unk,unk,unk,111,unk,unk,unk,unk,unk,unk,unk,
0042      29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
0043     150,158,159,128,136,177,178,176,142,152,173,140,unk,unk,unk,unk
0044 };
0045
0046 static const struct {
0047     __s32 x;
0048     __s32 y;
0049 }  hid_hat_to_axis[] = {{ 0, 0}, { 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
0050
0051 struct usage_priority {
0052     __u32 usage;            /* the HID usage associated */
0053     bool global;            /* we assume all usages to be slotted,
0054                      * unless global
0055                      */
0056     unsigned int slot_overwrite;    /* for globals: allows to set the usage
0057                      * before or after the slots
0058                      */
0059 };
0060
0061 /*
0062  * hid-input will convert this list into priorities:
0063  * the first element will have the highest priority
0064  * (the length of the following array) and the last
0065  * element the lowest (1).
0066  *
0067  * hid-input will then shift the priority by 8 bits to leave some space
0068  * in case drivers want to interleave other fields.
0069  *
0070  * To accommodate slotted devices, the slot priority is
0071  * defined in the next 8 bits (defined by 0xff - slot).
0072  *
0073  * If drivers want to add fields before those, hid-input will
0074  * leave out the first 8 bits of the priority value.
0075  *
0076  * This still leaves us 65535 individual priority values.
0077  */
0078 static const struct usage_priority hidinput_usages_priorities[] = {
0079     { /* Eraser (eraser touching) must always come before tipswitch */
0080       .usage = HID_DG_ERASER,
0081     },
0082     { /* Invert must always come before In Range */
0083       .usage = HID_DG_INVERT,
0084     },
0085     { /* Is the tip of the tool touching? */
0086       .usage = HID_DG_TIPSWITCH,
0087     },
0088     { /* Tip Pressure might emulate tip switch */
0089       .usage = HID_DG_TIPPRESSURE,
0090     },
0091     { /* In Range needs to come after the other tool states */
0092       .usage = HID_DG_INRANGE,
0093     },
0094 };
0095
0096 #define map_abs(c)  hid_map_usage(hidinput, usage, &bit, &max, EV_ABS, (c))
0097 #define map_rel(c)  hid_map_usage(hidinput, usage, &bit, &max, EV_REL, (c))
0098 #define map_key(c)  hid_map_usage(hidinput, usage, &bit, &max, EV_KEY, (c))
0099 #define map_led(c)  hid_map_usage(hidinput, usage, &bit, &max, EV_LED, (c))
0100 #define map_msc(c)  hid_map_usage(hidinput, usage, &bit, &max, EV_MSC, (c))
0101
0102 #define map_abs_clear(c)    hid_map_usage_clear(hidinput, usage, &bit, \
0103         &max, EV_ABS, (c))
0104 #define map_key_clear(c)    hid_map_usage_clear(hidinput, usage, &bit, \
0105         &max, EV_KEY, (c))
0106
0107 static bool match_scancode(struct hid_usage *usage,
0108                unsigned int cur_idx, unsigned int scancode)
0109 {
0110     return (usage->hid & (HID_USAGE_PAGE | HID_USAGE)) == scancode;
0111 }
0112
0113 static bool match_keycode(struct hid_usage *usage,
0114               unsigned int cur_idx, unsigned int keycode)
0115 {
0116     /*
0117      * We should exclude unmapped usages when doing lookup by keycode.
0118      */
0119     return (usage->type == EV_KEY && usage->code == keycode);
0120 }
0121
0122 static bool match_index(struct hid_usage *usage,
0123             unsigned int cur_idx, unsigned int idx)
0124 {
0125     return cur_idx == idx;
0126 }
0127
0128 typedef bool (*hid_usage_cmp_t)(struct hid_usage *usage,
0129                 unsigned int cur_idx, unsigned int val);
0130
0131 static struct hid_usage *hidinput_find_key(struct hid_device *hid,
0132                        hid_usage_cmp_t match,
0133                        unsigned int value,
0134                        unsigned int *usage_idx)
0135 {
0136     unsigned int i, j, k, cur_idx = 0;
0137     struct hid_report *report;
0138     struct hid_usage *usage;
0139
0140     for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
0141         list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
0142             for (i = 0; i < report->maxfield; i++) {
0143                 for (j = 0; j < report->field[i]->maxusage; j++) {
0144                     usage = report->field[i]->usage + j;
0145                     if (usage->type == EV_KEY || usage->type == 0) {
0146                         if (match(usage, cur_idx, value)) {
0147                             if (usage_idx)
0148                                 *usage_idx = cur_idx;
0149                             return usage;
0150                         }
0151                         cur_idx++;
0152                     }
0153                 }
0154             }
0155         }
0156     }
0157     return NULL;
0158 }
0159
0160 static struct hid_usage *hidinput_locate_usage(struct hid_device *hid,
0161                     const struct input_keymap_entry *ke,
0162                     unsigned int *index)
0163 {
0164     struct hid_usage *usage;
0165     unsigned int scancode;
0166
0167     if (ke->flags & INPUT_KEYMAP_BY_INDEX)
0168         usage = hidinput_find_key(hid, match_index, ke->index, index);
0169     else if (input_scancode_to_scalar(ke, &scancode) == 0)
0170         usage = hidinput_find_key(hid, match_scancode, scancode, index);
0171     else
0172         usage = NULL;
0173
0174     return usage;
0175 }
0176
0177 static int hidinput_getkeycode(struct input_dev *dev,
0178                    struct input_keymap_entry *ke)
0179 {
0180     struct hid_device *hid = input_get_drvdata(dev);
0181     struct hid_usage *usage;
0182     unsigned int scancode, index;
0183
0184     usage = hidinput_locate_usage(hid, ke, &index);
0185     if (usage) {
0186         ke->keycode = usage->type == EV_KEY ?
0187                 usage->code : KEY_RESERVED;
0188         ke->index = index;
0189         scancode = usage->hid & (HID_USAGE_PAGE | HID_USAGE);
0190         ke->len = sizeof(scancode);
0191         memcpy(ke->scancode, &scancode, sizeof(scancode));
0192         return 0;
0193     }
0194
0195     return -EINVAL;
0196 }
0197
0198 static int hidinput_setkeycode(struct input_dev *dev,
0199                    const struct input_keymap_entry *ke,
0200                    unsigned int *old_keycode)
0201 {
0202     struct hid_device *hid = input_get_drvdata(dev);
0203     struct hid_usage *usage;
0204
0205     usage = hidinput_locate_usage(hid, ke, NULL);
0206     if (usage) {
0207         *old_keycode = usage->type == EV_KEY ?
0208                 usage->code : KEY_RESERVED;
0209         usage->type = EV_KEY;
0210         usage->code = ke->keycode;
0211
0212         clear_bit(*old_keycode, dev->keybit);
0213         set_bit(usage->code, dev->keybit);
0214         dbg_hid("Assigned keycode %d to HID usage code %x\n",
0215             usage->code, usage->hid);
0216
0217         /*
0218          * Set the keybit for the old keycode if the old keycode is used
0219          * by another key
0220          */
0221         if (hidinput_find_key(hid, match_keycode, *old_keycode, NULL))
0222             set_bit(*old_keycode, dev->keybit);
0223
0224         return 0;
0225     }
0226
0227     return -EINVAL;
0228 }
0229
0230
0231 /**
0232  * hidinput_calc_abs_res - calculate an absolute axis resolution
0233  * @field: the HID report field to calculate resolution for
0234  * @code: axis code
0235  *
0236  * The formula is:
0237  *                         (logical_maximum - logical_minimum)
0238  * resolution = ----------------------------------------------------------
0239  *              (physical_maximum - physical_minimum) * 10 ^ unit_exponent
0240  *
0241  * as seen in the HID specification v1.11 6.2.2.7 Global Items.
0242  *
0243  * Only exponent 1 length units are processed. Centimeters and inches are
0244  * converted to millimeters. Degrees are converted to radians.
0245  */
0246 __s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code)
0247 {
0248     __s32 unit_exponent = field->unit_exponent;
0249     __s32 logical_extents = field->logical_maximum -
0250                     field->logical_minimum;
0251     __s32 physical_extents = field->physical_maximum -
0252                     field->physical_minimum;
0253     __s32 prev;
0254
0255     /* Check if the extents are sane */
0256     if (logical_extents <= 0 || physical_extents <= 0)
0257         return 0;
0258
0259     /*
0260      * Verify and convert units.
0261      * See HID specification v1.11 6.2.2.7 Global Items for unit decoding
0262      */
0263     switch (code) {
0264     case ABS_X:
0265     case ABS_Y:
0266     case ABS_Z:
0267     case ABS_MT_POSITION_X:
0268     case ABS_MT_POSITION_Y:
0269     case ABS_MT_TOOL_X:
0270     case ABS_MT_TOOL_Y:
0271     case ABS_MT_TOUCH_MAJOR:
0272     case ABS_MT_TOUCH_MINOR:
0273         if (field->unit == 0x11) {      /* If centimeters */
0274             /* Convert to millimeters */
0275             unit_exponent += 1;
0276         } else if (field->unit == 0x13) {   /* If inches */
0277             /* Convert to millimeters */
0278             prev = physical_extents;
0279             physical_extents *= 254;
0280             if (physical_extents < prev)
0281                 return 0;
0282             unit_exponent -= 1;
0283         } else {
0284             return 0;
0285         }
0286         break;
0287
0288     case ABS_RX:
0289     case ABS_RY:
0290     case ABS_RZ:
0291     case ABS_WHEEL:
0292     case ABS_TILT_X:
0293     case ABS_TILT_Y:
0294         if (field->unit == 0x14) {      /* If degrees */
0295             /* Convert to radians */
0296             prev = logical_extents;
0297             logical_extents *= 573;
0298             if (logical_extents < prev)
0299                 return 0;
0300             unit_exponent += 1;
0301         } else if (field->unit != 0x12) {   /* If not radians */
0302             return 0;
0303         }
0304         break;
0305
0306     default:
0307         return 0;
0308     }
0309
0310     /* Apply negative unit exponent */
0311     for (; unit_exponent < 0; unit_exponent++) {
0312         prev = logical_extents;
0313         logical_extents *= 10;
0314         if (logical_extents < prev)
0315             return 0;
0316     }
0317     /* Apply positive unit exponent */
0318     for (; unit_exponent > 0; unit_exponent--) {
0319         prev = physical_extents;
0320         physical_extents *= 10;
0321         if (physical_extents < prev)
0322             return 0;
0323     }
0324
0325     /* Calculate resolution */
0326     return DIV_ROUND_CLOSEST(logical_extents, physical_extents);
0327 }
0328 EXPORT_SYMBOL_GPL(hidinput_calc_abs_res);
0329
0330 #ifdef CONFIG_HID_BATTERY_STRENGTH
0331 static enum power_supply_property hidinput_battery_props[] = {
0332     POWER_SUPPLY_PROP_PRESENT,
0333     POWER_SUPPLY_PROP_ONLINE,
0334     POWER_SUPPLY_PROP_CAPACITY,
0335     POWER_SUPPLY_PROP_MODEL_NAME,
0336     POWER_SUPPLY_PROP_STATUS,
0337     POWER_SUPPLY_PROP_SCOPE,
0338 };
0339
0340 #define HID_BATTERY_QUIRK_PERCENT   (1 << 0) /* always reports percent */
0341 #define HID_BATTERY_QUIRK_FEATURE   (1 << 1) /* ask for feature report */
0342 #define HID_BATTERY_QUIRK_IGNORE    (1 << 2) /* completely ignore the battery */
0343
0344 static const struct hid_device_id hid_battery_quirks[] = {
0345     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
0346         USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
0347       HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
0348     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
0349         USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI),
0350       HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
0351     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
0352         USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI),
0353       HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
0354     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
0355                    USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO),
0356       HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
0357     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
0358         USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
0359       HID_BATTERY_QUIRK_PERCENT | HID_BATTERY_QUIRK_FEATURE },
0360     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM,
0361         USB_DEVICE_ID_ELECOM_BM084),
0362       HID_BATTERY_QUIRK_IGNORE },
0363     { HID_USB_DEVICE(USB_VENDOR_ID_SYMBOL,
0364         USB_DEVICE_ID_SYMBOL_SCANNER_3),
0365       HID_BATTERY_QUIRK_IGNORE },
0366     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ASUSTEK,
0367         USB_DEVICE_ID_ASUSTEK_T100CHI_KEYBOARD),
0368       HID_BATTERY_QUIRK_IGNORE },
0369     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH,
0370         USB_DEVICE_ID_LOGITECH_DINOVO_EDGE_KBD),
0371       HID_BATTERY_QUIRK_IGNORE },
0372     { HID_USB_DEVICE(USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ASUS_UX550_TOUCHSCREEN),
0373       HID_BATTERY_QUIRK_IGNORE },
0374     { HID_USB_DEVICE(USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ASUS_UX550VE_TOUCHSCREEN),
0375       HID_BATTERY_QUIRK_IGNORE },
0376     { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_HP_ENVY_X360_15),
0377       HID_BATTERY_QUIRK_IGNORE },
0378     { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_HP_ENVY_X360_15T_DR100),
0379       HID_BATTERY_QUIRK_IGNORE },
0380     { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_HP_SPECTRE_X360_15),
0381       HID_BATTERY_QUIRK_IGNORE },
0382     { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_SURFACE_GO_TOUCHSCREEN),
0383       HID_BATTERY_QUIRK_IGNORE },
0384     { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_SURFACE_GO2_TOUCHSCREEN),
0385       HID_BATTERY_QUIRK_IGNORE },
0386     { HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_LENOVO_YOGA_C630_TOUCHSCREEN),
0387       HID_BATTERY_QUIRK_IGNORE },
0388     {}
0389 };
0390
0391 static unsigned find_battery_quirk(struct hid_device *hdev)
0392 {
0393     unsigned quirks = 0;
0394     const struct hid_device_id *match;
0395
0396     match = hid_match_id(hdev, hid_battery_quirks);
0397     if (match != NULL)
0398         quirks = match->driver_data;
0399
0400     return quirks;
0401 }
0402
0403 static int hidinput_scale_battery_capacity(struct hid_device *dev,
0404                        int value)
0405 {
0406     if (dev->battery_min < dev->battery_max &&
0407         value >= dev->battery_min && value <= dev->battery_max)
0408         value = ((value - dev->battery_min) * 100) /
0409             (dev->battery_max - dev->battery_min);
0410
0411     return value;
0412 }
0413
0414 static int hidinput_query_battery_capacity(struct hid_device *dev)
0415 {
0416     u8 *buf;
0417     int ret;
0418
0419     buf = kmalloc(4, GFP_KERNEL);
0420     if (!buf)
0421         return -ENOMEM;
0422
0423     ret = hid_hw_raw_request(dev, dev->battery_report_id, buf, 4,
0424                  dev->battery_report_type, HID_REQ_GET_REPORT);
0425     if (ret < 2) {
0426         kfree(buf);
0427         return -ENODATA;
0428     }
0429
0430     ret = hidinput_scale_battery_capacity(dev, buf[1]);
0431     kfree(buf);
0432     return ret;
0433 }
0434
0435 static int hidinput_get_battery_property(struct power_supply *psy,
0436                      enum power_supply_property prop,
0437                      union power_supply_propval *val)
0438 {
0439     struct hid_device *dev = power_supply_get_drvdata(psy);
0440     int value;
0441     int ret = 0;
0442
0443     switch (prop) {
0444     case POWER_SUPPLY_PROP_PRESENT:
0445     case POWER_SUPPLY_PROP_ONLINE:
0446         val->intval = 1;
0447         break;
0448
0449     case POWER_SUPPLY_PROP_CAPACITY:
0450         if (dev->battery_status != HID_BATTERY_REPORTED &&
0451             !dev->battery_avoid_query) {
0452             value = hidinput_query_battery_capacity(dev);
0453             if (value < 0)
0454                 return value;
0455         } else  {
0456             value = dev->battery_capacity;
0457         }
0458
0459         val->intval = value;
0460         break;
0461
0462     case POWER_SUPPLY_PROP_MODEL_NAME:
0463         val->strval = dev->name;
0464         break;
0465
0466     case POWER_SUPPLY_PROP_STATUS:
0467         if (dev->battery_status != HID_BATTERY_REPORTED &&
0468             !dev->battery_avoid_query) {
0469             value = hidinput_query_battery_capacity(dev);
0470             if (value < 0)
0471                 return value;
0472
0473             dev->battery_capacity = value;
0474             dev->battery_status = HID_BATTERY_QUERIED;
0475         }
0476
0477         if (dev->battery_status == HID_BATTERY_UNKNOWN)
0478             val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
0479         else
0480             val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
0481         break;
0482
0483     case POWER_SUPPLY_PROP_SCOPE:
0484         val->intval = POWER_SUPPLY_SCOPE_DEVICE;
0485         break;
0486
0487     default:
0488         ret = -EINVAL;
0489         break;
0490     }
0491
0492     return ret;
0493 }
0494
0495 static int hidinput_setup_battery(struct hid_device *dev, unsigned report_type,
0496                   struct hid_field *field, bool is_percentage)
0497 {
0498     struct power_supply_desc *psy_desc;
0499     struct power_supply_config psy_cfg = { .drv_data = dev, };
0500     unsigned quirks;
0501     s32 min, max;
0502     int error;
0503
0504     if (dev->battery)
0505         return 0;   /* already initialized? */
0506
0507     quirks = find_battery_quirk(dev);
0508
0509     hid_dbg(dev, "device %x:%x:%x %d quirks %d\n",
0510         dev->bus, dev->vendor, dev->product, dev->version, quirks);
0511
0512     if (quirks & HID_BATTERY_QUIRK_IGNORE)
0513         return 0;
0514
0515     psy_desc = kzalloc(sizeof(*psy_desc), GFP_KERNEL);
0516     if (!psy_desc)
0517         return -ENOMEM;
0518
0519     psy_desc->name = kasprintf(GFP_KERNEL, "hid-%s-battery",
0520                    strlen(dev->uniq) ?
0521                     dev->uniq : dev_name(&dev->dev));
0522     if (!psy_desc->name) {
0523         error = -ENOMEM;
0524         goto err_free_mem;
0525     }
0526
0527     psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;
0528     psy_desc->properties = hidinput_battery_props;
0529     psy_desc->num_properties = ARRAY_SIZE(hidinput_battery_props);
0530     psy_desc->use_for_apm = 0;
0531     psy_desc->get_property = hidinput_get_battery_property;
0532
0533     min = field->logical_minimum;
0534     max = field->logical_maximum;
0535
0536     if (is_percentage || (quirks & HID_BATTERY_QUIRK_PERCENT)) {
0537         min = 0;
0538         max = 100;
0539     }
0540
0541     if (quirks & HID_BATTERY_QUIRK_FEATURE)
0542         report_type = HID_FEATURE_REPORT;
0543
0544     dev->battery_min = min;
0545     dev->battery_max = max;
0546     dev->battery_report_type = report_type;
0547     dev->battery_report_id = field->report->id;
0548
0549     /*
0550      * Stylus is normally not connected to the device and thus we
0551      * can't query the device and get meaningful battery strength.
0552      * We have to wait for the device to report it on its own.
0553      */
0554     dev->battery_avoid_query = report_type == HID_INPUT_REPORT &&
0555                    field->physical == HID_DG_STYLUS;
0556
0557     dev->battery = power_supply_register(&dev->dev, psy_desc, &psy_cfg);
0558     if (IS_ERR(dev->battery)) {
0559         error = PTR_ERR(dev->battery);
0560         hid_warn(dev, "can't register power supply: %d\n", error);
0561         goto err_free_name;
0562     }
0563
0564     power_supply_powers(dev->battery, &dev->dev);
0565     return 0;
0566
0567 err_free_name:
0568     kfree(psy_desc->name);
0569 err_free_mem:
0570     kfree(psy_desc);
0571     dev->battery = NULL;
0572     return error;
0573 }
0574
0575 static void hidinput_cleanup_battery(struct hid_device *dev)
0576 {
0577     const struct power_supply_desc *psy_desc;
0578
0579     if (!dev->battery)
0580         return;
0581
0582     psy_desc = dev->battery->desc;
0583     power_supply_unregister(dev->battery);
0584     kfree(psy_desc->name);
0585     kfree(psy_desc);
0586     dev->battery = NULL;
0587 }
0588
0589 static void hidinput_update_battery(struct hid_device *dev, int value)
0590 {
0591     int capacity;
0592
0593     if (!dev->battery)
0594         return;
0595
0596     if (value == 0 || value < dev->battery_min || value > dev->battery_max)
0597         return;
0598
0599     capacity = hidinput_scale_battery_capacity(dev, value);
0600
0601     if (dev->battery_status != HID_BATTERY_REPORTED ||
0602         capacity != dev->battery_capacity ||
0603         ktime_after(ktime_get_coarse(), dev->battery_ratelimit_time)) {
0604         dev->battery_capacity = capacity;
0605         dev->battery_status = HID_BATTERY_REPORTED;
0606         dev->battery_ratelimit_time =
0607             ktime_add_ms(ktime_get_coarse(), 30 * 1000);
0608         power_supply_changed(dev->battery);
0609     }
0610 }
0611 #else  /* !CONFIG_HID_BATTERY_STRENGTH */
0612 static int hidinput_setup_battery(struct hid_device *dev, unsigned report_type,
0613                   struct hid_field *field, bool is_percentage)
0614 {
0615     return 0;
0616 }
0617
0618 static void hidinput_cleanup_battery(struct hid_device *dev)
0619 {
0620 }
0621
0622 static void hidinput_update_battery(struct hid_device *dev, int value)
0623 {
0624 }
0625 #endif  /* CONFIG_HID_BATTERY_STRENGTH */
0626
0627 static bool hidinput_field_in_collection(struct hid_device *device, struct hid_field *field,
0628                      unsigned int type, unsigned int usage)
0629 {
0630     struct hid_collection *collection;
0631
0632     collection = &device->collection[field->usage->collection_index];
0633
0634     return collection->type == type && collection->usage == usage;
0635 }
0636
0637 static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_field *field,
0638                      struct hid_usage *usage, unsigned int usage_index)
0639 {
0640     struct input_dev *input = hidinput->input;
0641     struct hid_device *device = input_get_drvdata(input);
0642     const struct usage_priority *usage_priority = NULL;
0643     int max = 0, code;
0644     unsigned int i = 0;
0645     unsigned long *bit = NULL;
0646
0647     field->hidinput = hidinput;
0648
0649     if (field->flags & HID_MAIN_ITEM_CONSTANT)
0650         goto ignore;
0651
0652     /* Ignore if report count is out of bounds. */
0653     if (field->report_count < 1)
0654         goto ignore;
0655
0656     /* only LED usages are supported in output fields */
0657     if (field->report_type == HID_OUTPUT_REPORT &&
0658             (usage->hid & HID_USAGE_PAGE) != HID_UP_LED) {
0659         goto ignore;
0660     }
0661
0662     /* assign a priority based on the static list declared here */
0663     for (i = 0; i < ARRAY_SIZE(hidinput_usages_priorities); i++) {
0664         if (usage->hid == hidinput_usages_priorities[i].usage) {
0665             usage_priority = &hidinput_usages_priorities[i];
0666
0667             field->usages_priorities[usage_index] =
0668                 (ARRAY_SIZE(hidinput_usages_priorities) - i) << 8;
0669             break;
0670         }
0671     }
0672
0673     /*
0674      * For slotted devices, we need to also add the slot index
0675      * in the priority.
0676      */
0677     if (usage_priority && usage_priority->global)
0678         field->usages_priorities[usage_index] |=
0679             usage_priority->slot_overwrite;
0680     else
0681         field->usages_priorities[usage_index] |=
0682             (0xff - field->slot_idx) << 16;
0683
0684     if (device->driver->input_mapping) {
0685         int ret = device->driver->input_mapping(device, hidinput, field,
0686                 usage, &bit, &max);
0687         if (ret > 0)
0688             goto mapped;
0689         if (ret < 0)
0690             goto ignore;
0691     }
0692
0693     switch (usage->hid & HID_USAGE_PAGE) {
0694     case HID_UP_UNDEFINED:
0695         goto ignore;
0696
0697     case HID_UP_KEYBOARD:
0698         set_bit(EV_REP, input->evbit);
0699
0700         if ((usage->hid & HID_USAGE) < 256) {
0701             if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;
0702             map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);
0703         } else
0704             map_key(KEY_UNKNOWN);
0705
0706         break;
0707
0708     case HID_UP_BUTTON:
0709         code = ((usage->hid - 1) & HID_USAGE);
0710
0711         switch (field->application) {
0712         case HID_GD_MOUSE:
0713         case HID_GD_POINTER:  code += BTN_MOUSE; break;
0714         case HID_GD_JOYSTICK:
0715                 if (code <= 0xf)
0716                     code += BTN_JOYSTICK;
0717                 else
0718                     code += BTN_TRIGGER_HAPPY - 0x10;
0719                 break;
0720         case HID_GD_GAMEPAD:
0721                 if (code <= 0xf)
0722                     code += BTN_GAMEPAD;
0723                 else
0724                     code += BTN_TRIGGER_HAPPY - 0x10;
0725                 break;
0726         case HID_CP_CONSUMER_CONTROL:
0727                 if (hidinput_field_in_collection(device, field,
0728                                  HID_COLLECTION_NAMED_ARRAY,
0729                                  HID_CP_PROGRAMMABLEBUTTONS)) {
0730                     if (code <= 0x1d)
0731                         code += KEY_MACRO1;
0732                     else
0733                         code += BTN_TRIGGER_HAPPY - 0x1e;
0734                     break;
0735                 }
0736                 fallthrough;
0737         default:
0738             switch (field->physical) {
0739             case HID_GD_MOUSE:
0740             case HID_GD_POINTER:  code += BTN_MOUSE; break;
0741             case HID_GD_JOYSTICK: code += BTN_JOYSTICK; break;
0742             case HID_GD_GAMEPAD:  code += BTN_GAMEPAD; break;
0743             default:              code += BTN_MISC;
0744             }
0745         }
0746
0747         map_key(code);
0748         break;
0749
0750     case HID_UP_SIMULATION:
0751         switch (usage->hid & 0xffff) {
0752         case 0xba: map_abs(ABS_RUDDER);   break;
0753         case 0xbb: map_abs(ABS_THROTTLE); break;
0754         case 0xc4: map_abs(ABS_GAS);      break;
0755         case 0xc5: map_abs(ABS_BRAKE);    break;
0756         case 0xc8: map_abs(ABS_WHEEL);    break;
0757         default:   goto ignore;
0758         }
0759         break;
0760
0761     case HID_UP_GENDESK:
0762         if ((usage->hid & 0xf0) == 0x80) {  /* SystemControl */
0763             switch (usage->hid & 0xf) {
0764             case 0x1: map_key_clear(KEY_POWER);  break;
0765             case 0x2: map_key_clear(KEY_SLEEP);  break;
0766             case 0x3: map_key_clear(KEY_WAKEUP); break;
0767             case 0x4: map_key_clear(KEY_CONTEXT_MENU); break;
0768             case 0x5: map_key_clear(KEY_MENU); break;
0769             case 0x6: map_key_clear(KEY_PROG1); break;
0770             case 0x7: map_key_clear(KEY_HELP); break;
0771             case 0x8: map_key_clear(KEY_EXIT); break;
0772             case 0x9: map_key_clear(KEY_SELECT); break;
0773             case 0xa: map_key_clear(KEY_RIGHT); break;
0774             case 0xb: map_key_clear(KEY_LEFT); break;
0775             case 0xc: map_key_clear(KEY_UP); break;
0776             case 0xd: map_key_clear(KEY_DOWN); break;
0777             case 0xe: map_key_clear(KEY_POWER2); break;
0778             case 0xf: map_key_clear(KEY_RESTART); break;
0779             default: goto unknown;
0780             }
0781             break;
0782         }
0783
0784         if ((usage->hid & 0xf0) == 0xb0) {  /* SC - Display */
0785             switch (usage->hid & 0xf) {
0786             case 0x05: map_key_clear(KEY_SWITCHVIDEOMODE); break;
0787             default: goto ignore;
0788             }
0789             break;
0790         }
0791
0792         /*
0793          * Some lazy vendors declare 255 usages for System Control,
0794          * leading to the creation of ABS_X|Y axis and too many others.
0795          * It wouldn't be a problem if joydev doesn't consider the
0796          * device as a joystick then.
0797          */
0798         if (field->application == HID_GD_SYSTEM_CONTROL)
0799             goto ignore;
0800
0801         if ((usage->hid & 0xf0) == 0x90) {  /* D-pad */
0802             switch (usage->hid) {
0803             case HID_GD_UP:    usage->hat_dir = 1; break;
0804             case HID_GD_DOWN:  usage->hat_dir = 5; break;
0805             case HID_GD_RIGHT: usage->hat_dir = 3; break;
0806             case HID_GD_LEFT:  usage->hat_dir = 7; break;
0807             default: goto unknown;
0808             }
0809             if (field->dpad) {
0810                 map_abs(field->dpad);
0811                 goto ignore;
0812             }
0813             map_abs(ABS_HAT0X);
0814             break;
0815         }
0816
0817         switch (usage->hid) {
0818         /* These usage IDs map directly to the usage codes. */
0819         case HID_GD_X: case HID_GD_Y: case HID_GD_Z:
0820         case HID_GD_RX: case HID_GD_RY: case HID_GD_RZ:
0821             if (field->flags & HID_MAIN_ITEM_RELATIVE)
0822                 map_rel(usage->hid & 0xf);
0823             else
0824                 map_abs_clear(usage->hid & 0xf);
0825             break;
0826
0827         case HID_GD_WHEEL:
0828             if (field->flags & HID_MAIN_ITEM_RELATIVE) {
0829                 set_bit(REL_WHEEL, input->relbit);
0830                 map_rel(REL_WHEEL_HI_RES);
0831             } else {
0832                 map_abs(usage->hid & 0xf);
0833             }
0834             break;
0835         case HID_GD_SLIDER: case HID_GD_DIAL:
0836             if (field->flags & HID_MAIN_ITEM_RELATIVE)
0837                 map_rel(usage->hid & 0xf);
0838             else
0839                 map_abs(usage->hid & 0xf);
0840             break;
0841
0842         case HID_GD_HATSWITCH:
0843             usage->hat_min = field->logical_minimum;
0844             usage->hat_max = field->logical_maximum;
0845             map_abs(ABS_HAT0X);
0846             break;
0847
0848         case HID_GD_START:  map_key_clear(BTN_START);   break;
0849         case HID_GD_SELECT: map_key_clear(BTN_SELECT);  break;
0850
0851         case HID_GD_RFKILL_BTN:
0852             /* MS wireless radio ctl extension, also check CA */
0853             if (field->application == HID_GD_WIRELESS_RADIO_CTLS) {
0854                 map_key_clear(KEY_RFKILL);
0855                 /* We need to simulate the btn release */
0856                 field->flags |= HID_MAIN_ITEM_RELATIVE;
0857                 break;
0858             }
0859             goto unknown;
0860
0861         default: goto unknown;
0862         }
0863
0864         break;
0865
0866     case HID_UP_LED:
0867         switch (usage->hid & 0xffff) {            /* HID-Value:                   */
0868         case 0x01:  map_led (LED_NUML);     break;    /*   "Num Lock"                 */
0869         case 0x02:  map_led (LED_CAPSL);    break;    /*   "Caps Lock"                */
0870         case 0x03:  map_led (LED_SCROLLL);  break;    /*   "Scroll Lock"              */
0871         case 0x04:  map_led (LED_COMPOSE);  break;    /*   "Compose"                  */
0872         case 0x05:  map_led (LED_KANA);     break;    /*   "Kana"                     */
0873         case 0x27:  map_led (LED_SLEEP);    break;    /*   "Stand-By"                 */
0874         case 0x4c:  map_led (LED_SUSPEND);  break;    /*   "System Suspend"           */
0875         case 0x09:  map_led (LED_MUTE);     break;    /*   "Mute"                     */
0876         case 0x4b:  map_led (LED_MISC);     break;    /*   "Generic Indicator"        */
0877         case 0x19:  map_led (LED_MAIL);     break;    /*   "Message Waiting"          */
0878         case 0x4d:  map_led (LED_CHARGING); break;    /*   "External Power Connected" */
0879
0880         default: goto ignore;
0881         }
0882         break;
0883
0884     case HID_UP_DIGITIZER:
0885         if ((field->application & 0xff) == 0x01) /* Digitizer */
0886             __set_bit(INPUT_PROP_POINTER, input->propbit);
0887         else if ((field->application & 0xff) == 0x02) /* Pen */
0888             __set_bit(INPUT_PROP_DIRECT, input->propbit);
0889
0890         switch (usage->hid & 0xff) {
0891         case 0x00: /* Undefined */
0892             goto ignore;
0893
0894         case 0x30: /* TipPressure */
0895             if (!test_bit(BTN_TOUCH, input->keybit)) {
0896                 device->quirks |= HID_QUIRK_NOTOUCH;
0897                 set_bit(EV_KEY, input->evbit);
0898                 set_bit(BTN_TOUCH, input->keybit);
0899             }
0900             map_abs_clear(ABS_PRESSURE);
0901             break;
0902
0903         case 0x32: /* InRange */
0904             switch (field->physical) {
0905             case HID_DG_PUCK:
0906                 map_key(BTN_TOOL_MOUSE);
0907                 break;
0908             case HID_DG_FINGER:
0909                 map_key(BTN_TOOL_FINGER);
0910                 break;
0911             default:
0912                 /*
0913                  * If the physical is not given,
0914                  * rely on the application.
0915                  */
0916                 if (!field->physical) {
0917                     switch (field->application) {
0918                     case HID_DG_TOUCHSCREEN:
0919                     case HID_DG_TOUCHPAD:
0920                         map_key_clear(BTN_TOOL_FINGER);
0921                         break;
0922                     default:
0923                         map_key_clear(BTN_TOOL_PEN);
0924                     }
0925                 } else {
0926                     map_key(BTN_TOOL_PEN);
0927                 }
0928                 break;
0929             }
0930             break;
0931
0932         case 0x3b: /* Battery Strength */
0933             hidinput_setup_battery(device, HID_INPUT_REPORT, field, false);
0934             usage->type = EV_PWR;
0935             return;
0936
0937         case 0x3c: /* Invert */
0938             map_key_clear(BTN_TOOL_RUBBER);
0939             break;
0940
0941         case 0x3d: /* X Tilt */
0942             map_abs_clear(ABS_TILT_X);
0943             break;
0944
0945         case 0x3e: /* Y Tilt */
0946             map_abs_clear(ABS_TILT_Y);
0947             break;
0948
0949         case 0x33: /* Touch */
0950         case 0x42: /* TipSwitch */
0951         case 0x43: /* TipSwitch2 */
0952             device->quirks &= ~HID_QUIRK_NOTOUCH;
0953             map_key_clear(BTN_TOUCH);
0954             break;
0955
0956         case 0x44: /* BarrelSwitch */
0957             map_key_clear(BTN_STYLUS);
0958             break;
0959
0960         case 0x45: /* ERASER */
0961             /*
0962              * This event is reported when eraser tip touches the surface.
0963              * Actual eraser (BTN_TOOL_RUBBER) is set by Invert usage when
0964              * tool gets in proximity.
0965              */
0966             map_key_clear(BTN_TOUCH);
0967             break;
0968
0969         case 0x46: /* TabletPick */
0970         case 0x5a: /* SecondaryBarrelSwitch */
0971             map_key_clear(BTN_STYLUS2);
0972             break;
0973
0974         case 0x5b: /* TransducerSerialNumber */
0975         case 0x6e: /* TransducerSerialNumber2 */
0976             map_msc(MSC_SERIAL);
0977             break;
0978
0979         default:  goto unknown;
0980         }
0981         break;
0982
0983     case HID_UP_TELEPHONY:
0984         switch (usage->hid & HID_USAGE) {
0985         case 0x2f: map_key_clear(KEY_MICMUTE);      break;
0986         case 0xb0: map_key_clear(KEY_NUMERIC_0);    break;
0987         case 0xb1: map_key_clear(KEY_NUMERIC_1);    break;
0988         case 0xb2: map_key_clear(KEY_NUMERIC_2);    break;
0989         case 0xb3: map_key_clear(KEY_NUMERIC_3);    break;
0990         case 0xb4: map_key_clear(KEY_NUMERIC_4);    break;
0991         case 0xb5: map_key_clear(KEY_NUMERIC_5);    break;
0992         case 0xb6: map_key_clear(KEY_NUMERIC_6);    break;
0993         case 0xb7: map_key_clear(KEY_NUMERIC_7);    break;
0994         case 0xb8: map_key_clear(KEY_NUMERIC_8);    break;
0995         case 0xb9: map_key_clear(KEY_NUMERIC_9);    break;
0996         case 0xba: map_key_clear(KEY_NUMERIC_STAR); break;
0997         case 0xbb: map_key_clear(KEY_NUMERIC_POUND);    break;
0998         case 0xbc: map_key_clear(KEY_NUMERIC_A);    break;
0999         case 0xbd: map_key_clear(KEY_NUMERIC_B);    break;
1000         case 0xbe: map_key_clear(KEY_NUMERIC_C);    break;
1001         case 0xbf: map_key_clear(KEY_NUMERIC_D);    break;
1002         default: goto ignore;
1003         }
1004         break;
1005
1006     case HID_UP_CONSUMER:   /* USB HUT v1.12, pages 75-84 */
1007         switch (usage->hid & HID_USAGE) {
1008         case 0x000: goto ignore;
1009         case 0x030: map_key_clear(KEY_POWER);       break;
1010         case 0x031: map_key_clear(KEY_RESTART);     break;
1011         case 0x032: map_key_clear(KEY_SLEEP);       break;
1012         case 0x034: map_key_clear(KEY_SLEEP);       break;
1013         case 0x035: map_key_clear(KEY_KBDILLUMTOGGLE);  break;
1014         case 0x036: map_key_clear(BTN_MISC);        break;
1015
1016         case 0x040: map_key_clear(KEY_MENU);        break; /* Menu */
1017         case 0x041: map_key_clear(KEY_SELECT);      break; /* Menu Pick */
1018         case 0x042: map_key_clear(KEY_UP);      break; /* Menu Up */
1019         case 0x043: map_key_clear(KEY_DOWN);        break; /* Menu Down */
1020         case 0x044: map_key_clear(KEY_LEFT);        break; /* Menu Left */
1021         case 0x045: map_key_clear(KEY_RIGHT);       break; /* Menu Right */
1022         case 0x046: map_key_clear(KEY_ESC);     break; /* Menu Escape */
1023         case 0x047: map_key_clear(KEY_KPPLUS);      break; /* Menu Value Increase */
1024         case 0x048: map_key_clear(KEY_KPMINUS);     break; /* Menu Value Decrease */
1025
1026         case 0x060: map_key_clear(KEY_INFO);        break; /* Data On Screen */
1027         case 0x061: map_key_clear(KEY_SUBTITLE);    break; /* Closed Caption */
1028         case 0x063: map_key_clear(KEY_VCR);     break; /* VCR/TV */
1029         case 0x065: map_key_clear(KEY_CAMERA);      break; /* Snapshot */
1030         case 0x069: map_key_clear(KEY_RED);     break;
1031         case 0x06a: map_key_clear(KEY_GREEN);       break;
1032         case 0x06b: map_key_clear(KEY_BLUE);        break;
1033         case 0x06c: map_key_clear(KEY_YELLOW);      break;
1034         case 0x06d: map_key_clear(KEY_ASPECT_RATIO);    break;
1035
1036         case 0x06f: map_key_clear(KEY_BRIGHTNESSUP);        break;
1037         case 0x070: map_key_clear(KEY_BRIGHTNESSDOWN);      break;
1038         case 0x072: map_key_clear(KEY_BRIGHTNESS_TOGGLE);   break;
1039         case 0x073: map_key_clear(KEY_BRIGHTNESS_MIN);      break;
1040         case 0x074: map_key_clear(KEY_BRIGHTNESS_MAX);      break;
1041         case 0x075: map_key_clear(KEY_BRIGHTNESS_AUTO);     break;
1042
1043         case 0x079: map_key_clear(KEY_KBDILLUMUP);  break;
1044         case 0x07a: map_key_clear(KEY_KBDILLUMDOWN);    break;
1045         case 0x07c: map_key_clear(KEY_KBDILLUMTOGGLE);  break;
1046
1047         case 0x082: map_key_clear(KEY_VIDEO_NEXT);  break;
1048         case 0x083: map_key_clear(KEY_LAST);        break;
1049         case 0x084: map_key_clear(KEY_ENTER);       break;
1050         case 0x088: map_key_clear(KEY_PC);      break;
1051         case 0x089: map_key_clear(KEY_TV);      break;
1052         case 0x08a: map_key_clear(KEY_WWW);     break;
1053         case 0x08b: map_key_clear(KEY_DVD);     break;
1054         case 0x08c: map_key_clear(KEY_PHONE);       break;
1055         case 0x08d: map_key_clear(KEY_PROGRAM);     break;
1056         case 0x08e: map_key_clear(KEY_VIDEOPHONE);  break;
1057         case 0x08f: map_key_clear(KEY_GAMES);       break;
1058         case 0x090: map_key_clear(KEY_MEMO);        break;
1059         case 0x091: map_key_clear(KEY_CD);      break;
1060         case 0x092: map_key_clear(KEY_VCR);     break;
1061         case 0x093: map_key_clear(KEY_TUNER);       break;
1062         case 0x094: map_key_clear(KEY_EXIT);        break;
1063         case 0x095: map_key_clear(KEY_HELP);        break;
1064         case 0x096: map_key_clear(KEY_TAPE);        break;
1065         case 0x097: map_key_clear(KEY_TV2);     break;
1066         case 0x098: map_key_clear(KEY_SAT);     break;
1067         case 0x09a: map_key_clear(KEY_PVR);     break;
1068
1069         case 0x09c: map_key_clear(KEY_CHANNELUP);   break;
1070         case 0x09d: map_key_clear(KEY_CHANNELDOWN); break;
1071         case 0x0a0: map_key_clear(KEY_VCR2);        break;
1072
1073         case 0x0b0: map_key_clear(KEY_PLAY);        break;
1074         case 0x0b1: map_key_clear(KEY_PAUSE);       break;
1075         case 0x0b2: map_key_clear(KEY_RECORD);      break;
1076         case 0x0b3: map_key_clear(KEY_FASTFORWARD); break;
1077         case 0x0b4: map_key_clear(KEY_REWIND);      break;
1078         case 0x0b5: map_key_clear(KEY_NEXTSONG);    break;
1079         case 0x0b6: map_key_clear(KEY_PREVIOUSSONG);    break;
1080         case 0x0b7: map_key_clear(KEY_STOPCD);      break;
1081         case 0x0b8: map_key_clear(KEY_EJECTCD);     break;
1082         case 0x0bc: map_key_clear(KEY_MEDIA_REPEAT);    break;
1083         case 0x0b9: map_key_clear(KEY_SHUFFLE);     break;
1084         case 0x0bf: map_key_clear(KEY_SLOW);        break;
1085
1086         case 0x0cd: map_key_clear(KEY_PLAYPAUSE);   break;
1087         case 0x0cf: map_key_clear(KEY_VOICECOMMAND);    break;
1088
1089         case 0x0d8: map_key_clear(KEY_DICTATE);     break;
1090         case 0x0d9: map_key_clear(KEY_EMOJI_PICKER);    break;
1091
1092         case 0x0e0: map_abs_clear(ABS_VOLUME);      break;
1093         case 0x0e2: map_key_clear(KEY_MUTE);        break;
1094         case 0x0e5: map_key_clear(KEY_BASSBOOST);   break;
1095         case 0x0e9: map_key_clear(KEY_VOLUMEUP);    break;
1096         case 0x0ea: map_key_clear(KEY_VOLUMEDOWN);  break;
1097         case 0x0f5: map_key_clear(KEY_SLOW);        break;
1098
1099         case 0x181: map_key_clear(KEY_BUTTONCONFIG);    break;
1100         case 0x182: map_key_clear(KEY_BOOKMARKS);   break;
1101         case 0x183: map_key_clear(KEY_CONFIG);      break;
1102         case 0x184: map_key_clear(KEY_WORDPROCESSOR);   break;
1103         case 0x185: map_key_clear(KEY_EDITOR);      break;
1104         case 0x186: map_key_clear(KEY_SPREADSHEET); break;
1105         case 0x187: map_key_clear(KEY_GRAPHICSEDITOR);  break;
1106         case 0x188: map_key_clear(KEY_PRESENTATION);    break;
1107         case 0x189: map_key_clear(KEY_DATABASE);    break;
1108         case 0x18a: map_key_clear(KEY_MAIL);        break;
1109         case 0x18b: map_key_clear(KEY_NEWS);        break;
1110         case 0x18c: map_key_clear(KEY_VOICEMAIL);   break;
1111         case 0x18d: map_key_clear(KEY_ADDRESSBOOK); break;
1112         case 0x18e: map_key_clear(KEY_CALENDAR);    break;
1113         case 0x18f: map_key_clear(KEY_TASKMANAGER); break;
1114         case 0x190: map_key_clear(KEY_JOURNAL);     break;
1115         case 0x191: map_key_clear(KEY_FINANCE);     break;
1116         case 0x192: map_key_clear(KEY_CALC);        break;
1117         case 0x193: map_key_clear(KEY_PLAYER);      break;
1118         case 0x194: map_key_clear(KEY_FILE);        break;
1119         case 0x196: map_key_clear(KEY_WWW);     break;
1120         case 0x199: map_key_clear(KEY_CHAT);        break;
1121         case 0x19c: map_key_clear(KEY_LOGOFF);      break;
1122         case 0x19e: map_key_clear(KEY_COFFEE);      break;
1123         case 0x19f: map_key_clear(KEY_CONTROLPANEL);        break;
1124         case 0x1a2: map_key_clear(KEY_APPSELECT);       break;
1125         case 0x1a3: map_key_clear(KEY_NEXT);        break;
1126         case 0x1a4: map_key_clear(KEY_PREVIOUS);    break;
1127         case 0x1a6: map_key_clear(KEY_HELP);        break;
1128         case 0x1a7: map_key_clear(KEY_DOCUMENTS);   break;
1129         case 0x1ab: map_key_clear(KEY_SPELLCHECK);  break;
1130         case 0x1ae: map_key_clear(KEY_KEYBOARD);    break;
1131         case 0x1b1: map_key_clear(KEY_SCREENSAVER);     break;
1132         case 0x1b4: map_key_clear(KEY_FILE);        break;
1133         case 0x1b6: map_key_clear(KEY_IMAGES);      break;
1134         case 0x1b7: map_key_clear(KEY_AUDIO);       break;
1135         case 0x1b8: map_key_clear(KEY_VIDEO);       break;
1136         case 0x1bc: map_key_clear(KEY_MESSENGER);   break;
1137         case 0x1bd: map_key_clear(KEY_INFO);        break;
1138         case 0x1cb: map_key_clear(KEY_ASSISTANT);   break;
1139         case 0x201: map_key_clear(KEY_NEW);     break;
1140         case 0x202: map_key_clear(KEY_OPEN);        break;
1141         case 0x203: map_key_clear(KEY_CLOSE);       break;
1142         case 0x204: map_key_clear(KEY_EXIT);        break;
1143         case 0x207: map_key_clear(KEY_SAVE);        break;
1144         case 0x208: map_key_clear(KEY_PRINT);       break;
1145         case 0x209: map_key_clear(KEY_PROPS);       break;
1146         case 0x21a: map_key_clear(KEY_UNDO);        break;
1147         case 0x21b: map_key_clear(KEY_COPY);        break;
1148         case 0x21c: map_key_clear(KEY_CUT);     break;
1149         case 0x21d: map_key_clear(KEY_PASTE);       break;
1150         case 0x21f: map_key_clear(KEY_FIND);        break;
1151         case 0x221: map_key_clear(KEY_SEARCH);      break;
1152         case 0x222: map_key_clear(KEY_GOTO);        break;
1153         case 0x223: map_key_clear(KEY_HOMEPAGE);    break;
1154         case 0x224: map_key_clear(KEY_BACK);        break;
1155         case 0x225: map_key_clear(KEY_FORWARD);     break;
1156         case 0x226: map_key_clear(KEY_STOP);        break;
1157         case 0x227: map_key_clear(KEY_REFRESH);     break;
1158         case 0x22a: map_key_clear(KEY_BOOKMARKS);   break;
1159         case 0x22d: map_key_clear(KEY_ZOOMIN);      break;
1160         case 0x22e: map_key_clear(KEY_ZOOMOUT);     break;
1161         case 0x22f: map_key_clear(KEY_ZOOMRESET);   break;
1162         case 0x232: map_key_clear(KEY_FULL_SCREEN); break;
1163         case 0x233: map_key_clear(KEY_SCROLLUP);    break;
1164         case 0x234: map_key_clear(KEY_SCROLLDOWN);  break;
1165         case 0x238: /* AC Pan */
1166             set_bit(REL_HWHEEL, input->relbit);
1167             map_rel(REL_HWHEEL_HI_RES);
1168             break;
1169         case 0x23d: map_key_clear(KEY_EDIT);        break;
1170         case 0x25f: map_key_clear(KEY_CANCEL);      break;
1171         case 0x269: map_key_clear(KEY_INSERT);      break;
1172         case 0x26a: map_key_clear(KEY_DELETE);      break;
1173         case 0x279: map_key_clear(KEY_REDO);        break;
1174
1175         case 0x289: map_key_clear(KEY_REPLY);       break;
1176         case 0x28b: map_key_clear(KEY_FORWARDMAIL); break;
1177         case 0x28c: map_key_clear(KEY_SEND);        break;
1178
1179         case 0x29d: map_key_clear(KEY_KBD_LAYOUT_NEXT); break;
1180
1181         case 0x2a2: map_key_clear(KEY_ALL_APPLICATIONS);    break;
1182
1183         case 0x2c7: map_key_clear(KEY_KBDINPUTASSIST_PREV);     break;
1184         case 0x2c8: map_key_clear(KEY_KBDINPUTASSIST_NEXT);     break;
1185         case 0x2c9: map_key_clear(KEY_KBDINPUTASSIST_PREVGROUP);        break;
1186         case 0x2ca: map_key_clear(KEY_KBDINPUTASSIST_NEXTGROUP);        break;
1187         case 0x2cb: map_key_clear(KEY_KBDINPUTASSIST_ACCEPT);   break;
1188         case 0x2cc: map_key_clear(KEY_KBDINPUTASSIST_CANCEL);   break;
1189
1190         case 0x29f: map_key_clear(KEY_SCALE);       break;
1191
1192         default: map_key_clear(KEY_UNKNOWN);
1193         }
1194         break;
1195
1196     case HID_UP_GENDEVCTRLS:
1197         switch (usage->hid) {
1198         case HID_DC_BATTERYSTRENGTH:
1199             hidinput_setup_battery(device, HID_INPUT_REPORT, field, false);
1200             usage->type = EV_PWR;
1201             return;
1202         }
1203         goto unknown;
1204
1205     case HID_UP_BATTERY:
1206         switch (usage->hid) {
1207         case HID_BAT_ABSOLUTESTATEOFCHARGE:
1208             hidinput_setup_battery(device, HID_INPUT_REPORT, field, true);
1209             usage->type = EV_PWR;
1210             return;
1211         }
1212         goto unknown;
1213
1214     case HID_UP_HPVENDOR:   /* Reported on a Dutch layout HP5308 */
1215         set_bit(EV_REP, input->evbit);
1216         switch (usage->hid & HID_USAGE) {
1217         case 0x021: map_key_clear(KEY_PRINT);           break;
1218         case 0x070: map_key_clear(KEY_HP);      break;
1219         case 0x071: map_key_clear(KEY_CAMERA);      break;
1220         case 0x072: map_key_clear(KEY_SOUND);       break;
1221         case 0x073: map_key_clear(KEY_QUESTION);    break;
1222         case 0x080: map_key_clear(KEY_EMAIL);       break;
1223         case 0x081: map_key_clear(KEY_CHAT);        break;
1224         case 0x082: map_key_clear(KEY_SEARCH);      break;
1225         case 0x083: map_key_clear(KEY_CONNECT);         break;
1226         case 0x084: map_key_clear(KEY_FINANCE);     break;
1227         case 0x085: map_key_clear(KEY_SPORT);       break;
1228         case 0x086: map_key_clear(KEY_SHOP);            break;
1229         default:    goto ignore;
1230         }
1231         break;
1232
1233     case HID_UP_HPVENDOR2:
1234         set_bit(EV_REP, input->evbit);
1235         switch (usage->hid & HID_USAGE) {
1236         case 0x001: map_key_clear(KEY_MICMUTE);     break;
1237         case 0x003: map_key_clear(KEY_BRIGHTNESSDOWN);  break;
1238         case 0x004: map_key_clear(KEY_BRIGHTNESSUP);    break;
1239         default:    goto ignore;
1240         }
1241         break;
1242
1243     case HID_UP_MSVENDOR:
1244         goto ignore;
1245
1246     case HID_UP_CUSTOM: /* Reported on Logitech and Apple USB keyboards */
1247         set_bit(EV_REP, input->evbit);
1248         goto ignore;
1249
1250     case HID_UP_LOGIVENDOR:
1251         /* intentional fallback */
1252     case HID_UP_LOGIVENDOR2:
1253         /* intentional fallback */
1254     case HID_UP_LOGIVENDOR3:
1255         goto ignore;
1256
1257     case HID_UP_PID:
1258         switch (usage->hid & HID_USAGE) {
1259         case 0xa4: map_key_clear(BTN_DEAD); break;
1260         default: goto ignore;
1261         }
1262         break;
1263
1264     default:
1265     unknown:
1266         if (field->report_size == 1) {
1267             if (field->report->type == HID_OUTPUT_REPORT) {
1268                 map_led(LED_MISC);
1269                 break;
1270             }
1271             map_key(BTN_MISC);
1272             break;
1273         }
1274         if (field->flags & HID_MAIN_ITEM_RELATIVE) {
1275             map_rel(REL_MISC);
1276             break;
1277         }
1278         map_abs(ABS_MISC);
1279         break;
1280     }
1281
1282 mapped:
1283     /* Mapping failed, bail out */
1284     if (!bit)
1285         return;
1286
1287     if (device->driver->input_mapped &&
1288         device->driver->input_mapped(device, hidinput, field, usage,
1289                      &bit, &max) < 0) {
1290         /*
1291          * The driver indicated that no further generic handling
1292          * of the usage is desired.
1293          */
1294         return;
1295     }
1296
1297     set_bit(usage->type, input->evbit);
1298
1299     /*
1300      * This part is *really* controversial:
1301      * - HID aims at being generic so we should do our best to export
1302      *   all incoming events
1303      * - HID describes what events are, so there is no reason for ABS_X
1304      *   to be mapped to ABS_Y
1305      * - HID is using *_MISC+N as a default value, but nothing prevents
1306      *   *_MISC+N to overwrite a legitimate even, which confuses userspace
1307      *   (for instance ABS_MISC + 7 is ABS_MT_SLOT, which has a different
1308      *   processing)
1309      *
1310      * If devices still want to use this (at their own risk), they will
1311      * have to use the quirk HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE, but
1312      * the default should be a reliable mapping.
1313      */
1314     while (usage->code <= max && test_and_set_bit(usage->code, bit)) {
1315         if (device->quirks & HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE) {
1316             usage->code = find_next_zero_bit(bit,
1317                              max + 1,
1318                              usage->code);
1319         } else {
1320             device->status |= HID_STAT_DUP_DETECTED;
1321             goto ignore;
1322         }
1323     }
1324
1325     if (usage->code > max)
1326         goto ignore;
1327
1328     if (usage->type == EV_ABS) {
1329
1330         int a = field->logical_minimum;
1331         int b = field->logical_maximum;
1332
1333         if ((device->quirks & HID_QUIRK_BADPAD) && (usage->code == ABS_X || usage->code == ABS_Y)) {
1334             a = field->logical_minimum = 0;
1335             b = field->logical_maximum = 255;
1336         }
1337
1338         if (field->application == HID_GD_GAMEPAD || field->application == HID_GD_JOYSTICK)
1339             input_set_abs_params(input, usage->code, a, b, (b - a) >> 8, (b - a) >> 4);
1340         else    input_set_abs_params(input, usage->code, a, b, 0, 0);
1341
1342         input_abs_set_res(input, usage->code,
1343                   hidinput_calc_abs_res(field, usage->code));
1344
1345         /* use a larger default input buffer for MT devices */
1346         if (usage->code == ABS_MT_POSITION_X && input->hint_events_per_packet == 0)
1347             input_set_events_per_packet(input, 60);
1348     }
1349
1350     if (usage->type == EV_ABS &&
1351         (usage->hat_min < usage->hat_max || usage->hat_dir)) {
1352         int i;
1353         for (i = usage->code; i < usage->code + 2 && i <= max; i++) {
1354             input_set_abs_params(input, i, -1, 1, 0, 0);
1355             set_bit(i, input->absbit);
1356         }
1357         if (usage->hat_dir && !field->dpad)
1358             field->dpad = usage->code;
1359     }
1360
1361     /* for those devices which produce Consumer volume usage as relative,
1362      * we emulate pressing volumeup/volumedown appropriate number of times
1363      * in hidinput_hid_event()
1364      */
1365     if ((usage->type == EV_ABS) && (field->flags & HID_MAIN_ITEM_RELATIVE) &&
1366             (usage->code == ABS_VOLUME)) {
1367         set_bit(KEY_VOLUMEUP, input->keybit);
1368         set_bit(KEY_VOLUMEDOWN, input->keybit);
1369     }
1370
1371     if (usage->type == EV_KEY) {
1372         set_bit(EV_MSC, input->evbit);
1373         set_bit(MSC_SCAN, input->mscbit);
1374     }
1375
1376     return;
1377
1378 ignore:
1379     usage->type = 0;
1380     usage->code = 0;
1381 }
1382
1383 static void hidinput_handle_scroll(struct hid_usage *usage,
1384                    struct input_dev *input,
1385                    __s32 value)
1386 {
1387     int code;
1388     int hi_res, lo_res;
1389
1390     if (value == 0)
1391         return;
1392
1393     if (usage->code == REL_WHEEL_HI_RES)
1394         code = REL_WHEEL;
1395     else
1396         code = REL_HWHEEL;
1397
1398     /*
1399      * Windows reports one wheel click as value 120. Where a high-res
1400      * scroll wheel is present, a fraction of 120 is reported instead.
1401      * Our REL_WHEEL_HI_RES axis does the same because all HW must
1402      * adhere to the 120 expectation.
1403      */
1404     hi_res = value * 120/usage->resolution_multiplier;
1405
1406     usage->wheel_accumulated += hi_res;
1407     lo_res = usage->wheel_accumulated/120;
1408     if (lo_res)
1409         usage->wheel_accumulated -= lo_res * 120;
1410
1411     input_event(input, EV_REL, code, lo_res);
1412     input_event(input, EV_REL, usage->code, hi_res);
1413 }
1414
1415 static void hid_report_release_tool(struct hid_report *report, struct input_dev *input,
1416                     unsigned int tool)
1417 {
1418     /* if the given tool is not currently reported, ignore */
1419     if (!test_bit(tool, input->key))
1420         return;
1421
1422     /*
1423      * if the given tool was previously set, release it,
1424      * release any TOUCH and send an EV_SYN
1425      */
1426     input_event(input, EV_KEY, BTN_TOUCH, 0);
1427     input_event(input, EV_KEY, tool, 0);
1428     input_event(input, EV_SYN, SYN_REPORT, 0);
1429
1430     report->tool = 0;
1431 }
1432
1433 static void hid_report_set_tool(struct hid_report *report, struct input_dev *input,
1434                 unsigned int new_tool)
1435 {
1436     if (report->tool != new_tool)
1437         hid_report_release_tool(report, input, report->tool);
1438
1439     input_event(input, EV_KEY, new_tool, 1);
1440     report->tool = new_tool;
1441 }
1442
1443 void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value)
1444 {
1445     struct input_dev *input;
1446     struct hid_report *report = field->report;
1447     unsigned *quirks = &hid->quirks;
1448
1449     if (!usage->type)
1450         return;
1451
1452     if (usage->type == EV_PWR) {
1453         hidinput_update_battery(hid, value);
1454         return;
1455     }
1456
1457     if (!field->hidinput)
1458         return;
1459
1460     input = field->hidinput->input;
1461
1462     if (usage->hat_min < usage->hat_max || usage->hat_dir) {
1463         int hat_dir = usage->hat_dir;
1464         if (!hat_dir)
1465             hat_dir = (value - usage->hat_min) * 8 / (usage->hat_max - usage->hat_min + 1) + 1;
1466         if (hat_dir < 0 || hat_dir > 8) hat_dir = 0;
1467         input_event(input, usage->type, usage->code    , hid_hat_to_axis[hat_dir].x);
1468         input_event(input, usage->type, usage->code + 1, hid_hat_to_axis[hat_dir].y);
1469         return;
1470     }
1471
1472     /*
1473      * Ignore out-of-range values as per HID specification,
1474      * section 5.10 and 6.2.25, when NULL state bit is present.
1475      * When it's not, clamp the value to match Microsoft's input
1476      * driver as mentioned in "Required HID usages for digitizers":
1477      * https://msdn.microsoft.com/en-us/library/windows/hardware/dn672278(v=vs.85).asp
1478      *
1479      * The logical_minimum < logical_maximum check is done so that we
1480      * don't unintentionally discard values sent by devices which
1481      * don't specify logical min and max.
1482      */
1483     if ((field->flags & HID_MAIN_ITEM_VARIABLE) &&
1484         field->logical_minimum < field->logical_maximum) {
1485         if (field->flags & HID_MAIN_ITEM_NULL_STATE &&
1486             (value < field->logical_minimum ||
1487              value > field->logical_maximum)) {
1488             dbg_hid("Ignoring out-of-range value %x\n", value);
1489             return;
1490         }
1491         value = clamp(value,
1492                   field->logical_minimum,
1493                   field->logical_maximum);
1494     }
1495
1496     switch (usage->hid) {
1497     case HID_DG_ERASER:
1498         report->tool_active |= !!value;
1499
1500         /*
1501          * if eraser is set, we must enforce BTN_TOOL_RUBBER
1502          * to accommodate for devices not following the spec.
1503          */
1504         if (value)
1505             hid_report_set_tool(report, input, BTN_TOOL_RUBBER);
1506         else if (report->tool != BTN_TOOL_RUBBER)
1507             /* value is off, tool is not rubber, ignore */
1508             return;
1509
1510         /* let hid-input set BTN_TOUCH */
1511         break;
1512
1513     case HID_DG_INVERT:
1514         report->tool_active |= !!value;
1515
1516         /*
1517          * If invert is set, we store BTN_TOOL_RUBBER.
1518          */
1519         if (value)
1520             hid_report_set_tool(report, input, BTN_TOOL_RUBBER);
1521         else if (!report->tool_active)
1522             /* tool_active not set means Invert and Eraser are not set */
1523             hid_report_release_tool(report, input, BTN_TOOL_RUBBER);
1524
1525         /* no further processing */
1526         return;
1527
1528     case HID_DG_INRANGE:
1529         report->tool_active |= !!value;
1530
1531         if (report->tool_active) {
1532             /*
1533              * if tool is not set but is marked as active,
1534              * assume ours
1535              */
1536             if (!report->tool)
1537                 report->tool = usage->code;
1538
1539             /* drivers may have changed the value behind our back, resend it */
1540             hid_report_set_tool(report, input, report->tool);
1541         } else {
1542             hid_report_release_tool(report, input, usage->code);
1543         }
1544
1545         /* reset tool_active for the next event */
1546         report->tool_active = false;
1547
1548         /* no further processing */
1549         return;
1550
1551     case HID_DG_TIPSWITCH:
1552         report->tool_active |= !!value;
1553
1554         /* if tool is set to RUBBER we should ignore the current value */
1555         if (report->tool == BTN_TOOL_RUBBER)
1556             return;
1557
1558         break;
1559
1560     case HID_DG_TIPPRESSURE:
1561         if (*quirks & HID_QUIRK_NOTOUCH) {
1562             int a = field->logical_minimum;
1563             int b = field->logical_maximum;
1564
1565             if (value > a + ((b - a) >> 3)) {
1566                 input_event(input, EV_KEY, BTN_TOUCH, 1);
1567                 report->tool_active = true;
1568             }
1569         }
1570         break;
1571
1572     case HID_UP_PID | 0x83UL: /* Simultaneous Effects Max */
1573         dbg_hid("Maximum Effects - %d\n",value);
1574         return;
1575
1576     case HID_UP_PID | 0x7fUL:
1577         dbg_hid("PID Pool Report\n");
1578         return;
1579     }
1580
1581     switch (usage->type) {
1582     case EV_KEY:
1583         if (usage->code == 0) /* Key 0 is "unassigned", not KEY_UNKNOWN */
1584             return;
1585         break;
1586
1587     case EV_REL:
1588         if (usage->code == REL_WHEEL_HI_RES ||
1589             usage->code == REL_HWHEEL_HI_RES) {
1590             hidinput_handle_scroll(usage, input, value);
1591             return;
1592         }
1593         break;
1594
1595     case EV_ABS:
1596         if ((field->flags & HID_MAIN_ITEM_RELATIVE) &&
1597             usage->code == ABS_VOLUME) {
1598             int count = abs(value);
1599             int direction = value > 0 ? KEY_VOLUMEUP : KEY_VOLUMEDOWN;
1600             int i;
1601
1602             for (i = 0; i < count; i++) {
1603                 input_event(input, EV_KEY, direction, 1);
1604                 input_sync(input);
1605                 input_event(input, EV_KEY, direction, 0);
1606                 input_sync(input);
1607             }
1608             return;
1609
1610         } else if (((*quirks & HID_QUIRK_X_INVERT) && usage->code == ABS_X) ||
1611                ((*quirks & HID_QUIRK_Y_INVERT) && usage->code == ABS_Y))
1612             value = field->logical_maximum - value;
1613         break;
1614     }
1615
1616     /*
1617      * Ignore reports for absolute data if the data didn't change. This is
1618      * not only an optimization but also fixes 'dead' key reports. Some
1619      * RollOver implementations for localized keys (like BACKSLASH/PIPE; HID
1620      * 0x31 and 0x32) report multiple keys, even though a localized keyboard
1621      * can only have one of them physically available. The 'dead' keys
1622      * report constant 0. As all map to the same keycode, they'd confuse
1623      * the input layer. If we filter the 'dead' keys on the HID level, we
1624      * skip the keycode translation and only forward real events.
1625      */
1626     if (!(field->flags & (HID_MAIN_ITEM_RELATIVE |
1627                           HID_MAIN_ITEM_BUFFERED_BYTE)) &&
1628                   (field->flags & HID_MAIN_ITEM_VARIABLE) &&
1629         usage->usage_index < field->maxusage &&
1630         value == field->value[usage->usage_index])
1631         return;
1632
1633     /* report the usage code as scancode if the key status has changed */
1634     if (usage->type == EV_KEY &&
1635         (!test_bit(usage->code, input->key)) == value)
1636         input_event(input, EV_MSC, MSC_SCAN, usage->hid);
1637
1638     input_event(input, usage->type, usage->code, value);
1639
1640     if ((field->flags & HID_MAIN_ITEM_RELATIVE) &&
1641         usage->type == EV_KEY && value) {
1642         input_sync(input);
1643         input_event(input, usage->type, usage->code, 0);
1644     }
1645 }
1646
1647 void hidinput_report_event(struct hid_device *hid, struct hid_report *report)
1648 {
1649     struct hid_input *hidinput;
1650
1651     if (hid->quirks & HID_QUIRK_NO_INPUT_SYNC)
1652         return;
1653
1654     list_for_each_entry(hidinput, &hid->inputs, list)
1655         input_sync(hidinput->input);
1656 }
1657 EXPORT_SYMBOL_GPL(hidinput_report_event);
1658
1659 static int hidinput_find_field(struct hid_device *hid, unsigned int type,
1660                    unsigned int code, struct hid_field **field)
1661 {
1662     struct hid_report *report;
1663     int i, j;
1664
1665     list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {
1666         for (i = 0; i < report->maxfield; i++) {
1667             *field = report->field[i];
1668             for (j = 0; j < (*field)->maxusage; j++)
1669                 if ((*field)->usage[j].type == type && (*field)->usage[j].code == code)
1670                     return j;
1671         }
1672     }
1673     return -1;
1674 }
1675
1676 struct hid_field *hidinput_get_led_field(struct hid_device *hid)
1677 {
1678     struct hid_report *report;
1679     struct hid_field *field;
1680     int i, j;
1681
1682     list_for_each_entry(report,
1683                 &hid->report_enum[HID_OUTPUT_REPORT].report_list,
1684                 list) {
1685         for (i = 0; i < report->maxfield; i++) {
1686             field = report->field[i];
1687             for (j = 0; j < field->maxusage; j++)
1688                 if (field->usage[j].type == EV_LED)
1689                     return field;
1690         }
1691     }
1692     return NULL;
1693 }
1694 EXPORT_SYMBOL_GPL(hidinput_get_led_field);
1695
1696 unsigned int hidinput_count_leds(struct hid_device *hid)
1697 {
1698     struct hid_report *report;
1699     struct hid_field *field;
1700     int i, j;
1701     unsigned int count = 0;
1702
1703     list_for_each_entry(report,
1704                 &hid->report_enum[HID_OUTPUT_REPORT].report_list,
1705                 list) {
1706         for (i = 0; i < report->maxfield; i++) {
1707             field = report->field[i];
1708             for (j = 0; j < field->maxusage; j++)
1709                 if (field->usage[j].type == EV_LED &&
1710                     field->value[j])
1711                     count += 1;
1712         }
1713     }
1714     return count;
1715 }
1716 EXPORT_SYMBOL_GPL(hidinput_count_leds);
1717
1718 static void hidinput_led_worker(struct work_struct *work)
1719 {
1720     struct hid_device *hid = container_of(work, struct hid_device,
1721                           led_work);
1722     struct hid_field *field;
1723     struct hid_report *report;
1724     int ret;
1725     u32 len;
1726     __u8 *buf;
1727
1728     field = hidinput_get_led_field(hid);
1729     if (!field)
1730         return;
1731
1732     /*
1733      * field->report is accessed unlocked regarding HID core. So there might
1734      * be another incoming SET-LED request from user-space, which changes
1735      * the LED state while we assemble our outgoing buffer. However, this
1736      * doesn't matter as hid_output_report() correctly converts it into a
1737      * boolean value no matter what information is currently set on the LED
1738      * field (even garbage). So the remote device will always get a valid
1739      * request.
1740      * And in case we send a wrong value, a next led worker is spawned
1741      * for every SET-LED request so the following worker will send the
1742      * correct value, guaranteed!
1743      */
1744
1745     report = field->report;
1746
1747     /* use custom SET_REPORT request if possible (asynchronous) */
1748     if (hid->ll_driver->request)
1749         return hid->ll_driver->request(hid, report, HID_REQ_SET_REPORT);
1750
1751     /* fall back to generic raw-output-report */
1752     len = hid_report_len(report);
1753     buf = hid_alloc_report_buf(report, GFP_KERNEL);
1754     if (!buf)
1755         return;
1756
1757     hid_output_report(report, buf);
1758     /* synchronous output report */
1759     ret = hid_hw_output_report(hid, buf, len);
1760     if (ret == -ENOSYS)
1761         hid_hw_raw_request(hid, report->id, buf, len, HID_OUTPUT_REPORT,
1762                 HID_REQ_SET_REPORT);
1763     kfree(buf);
1764 }
1765
1766 static int hidinput_input_event(struct input_dev *dev, unsigned int type,
1767                 unsigned int code, int value)
1768 {
1769     struct hid_device *hid = input_get_drvdata(dev);
1770     struct hid_field *field;
1771     int offset;
1772
1773     if (type == EV_FF)
1774         return input_ff_event(dev, type, code, value);
1775
1776     if (type != EV_LED)
1777         return -1;
1778
1779     if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
1780         hid_warn(dev, "event field not found\n");
1781         return -1;
1782     }
1783
1784     hid_set_field(field, offset, value);
1785
1786     schedule_work(&hid->led_work);
1787     return 0;
1788 }
1789
1790 static int hidinput_open(struct input_dev *dev)
1791 {
1792     struct hid_device *hid = input_get_drvdata(dev);
1793
1794     return hid_hw_open(hid);
1795 }
1796
1797 static void hidinput_close(struct input_dev *dev)
1798 {
1799     struct hid_device *hid = input_get_drvdata(dev);
1800
1801     hid_hw_close(hid);
1802 }
1803
1804 static bool __hidinput_change_resolution_multipliers(struct hid_device *hid,
1805         struct hid_report *report, bool use_logical_max)
1806 {
1807     struct hid_usage *usage;
1808     bool update_needed = false;
1809     bool get_report_completed = false;
1810     int i, j;
1811
1812     if (report->maxfield == 0)
1813         return false;
1814
1815     for (i = 0; i < report->maxfield; i++) {
1816         __s32 value = use_logical_max ?
1817                   report->field[i]->logical_maximum :
1818                   report->field[i]->logical_minimum;
1819
1820         /* There is no good reason for a Resolution
1821          * Multiplier to have a count other than 1.
1822          * Ignore that case.
1823          */
1824         if (report->field[i]->report_count != 1)
1825             continue;
1826
1827         for (j = 0; j < report->field[i]->maxusage; j++) {
1828             usage = &report->field[i]->usage[j];
1829
1830             if (usage->hid != HID_GD_RESOLUTION_MULTIPLIER)
1831                 continue;
1832
1833             /*
1834              * If we have more than one feature within this
1835              * report we need to fill in the bits from the
1836              * others before we can overwrite the ones for the
1837              * Resolution Multiplier.
1838              *
1839              * But if we're not allowed to read from the device,
1840              * we just bail. Such a device should not exist
1841              * anyway.
1842              */
1843             if (!get_report_completed && report->maxfield > 1) {
1844                 if (hid->quirks & HID_QUIRK_NO_INIT_REPORTS)
1845                     return update_needed;
1846
1847                 hid_hw_request(hid, report, HID_REQ_GET_REPORT);
1848                 hid_hw_wait(hid);
1849                 get_report_completed = true;
1850             }
1851
1852             report->field[i]->value[j] = value;
1853             update_needed = true;
1854         }
1855     }
1856
1857     return update_needed;
1858 }
1859
1860 static void hidinput_change_resolution_multipliers(struct hid_device *hid)
1861 {
1862     struct hid_report_enum *rep_enum;
1863     struct hid_report *rep;
1864     int ret;
1865
1866     rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
1867     list_for_each_entry(rep, &rep_enum->report_list, list) {
1868         bool update_needed = __hidinput_change_resolution_multipliers(hid,
1869                                      rep, true);
1870
1871         if (update_needed) {
1872             ret = __hid_request(hid, rep, HID_REQ_SET_REPORT);
1873             if (ret) {
1874                 __hidinput_change_resolution_multipliers(hid,
1875                                     rep, false);
1876                 return;
1877             }
1878         }
1879     }
1880
1881     /* refresh our structs */
1882     hid_setup_resolution_multiplier(hid);
1883 }
1884
1885 static void report_features(struct hid_device *hid)
1886 {
1887     struct hid_driver *drv = hid->driver;
1888     struct hid_report_enum *rep_enum;
1889     struct hid_report *rep;
1890     struct hid_usage *usage;
1891     int i, j;
1892
1893     rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
1894     list_for_each_entry(rep, &rep_enum->report_list, list)
1895         for (i = 0; i < rep->maxfield; i++) {
1896             /* Ignore if report count is out of bounds. */
1897             if (rep->field[i]->report_count < 1)
1898                 continue;
1899
1900             for (j = 0; j < rep->field[i]->maxusage; j++) {
1901                 usage = &rep->field[i]->usage[j];
1902
1903                 /* Verify if Battery Strength feature is available */
1904                 if (usage->hid == HID_DC_BATTERYSTRENGTH)
1905                     hidinput_setup_battery(hid, HID_FEATURE_REPORT,
1906                                    rep->field[i], false);
1907
1908                 if (drv->feature_mapping)
1909                     drv->feature_mapping(hid, rep->field[i], usage);
1910             }
1911         }
1912 }
1913
1914 static struct hid_input *hidinput_allocate(struct hid_device *hid,
1915                        unsigned int application)
1916 {
1917     struct hid_input *hidinput = kzalloc(sizeof(*hidinput), GFP_KERNEL);
1918     struct input_dev *input_dev = input_allocate_device();
1919     const char *suffix = NULL;
1920     size_t suffix_len, name_len;
1921
1922     if (!hidinput || !input_dev)
1923         goto fail;
1924
1925     if ((hid->quirks & HID_QUIRK_INPUT_PER_APP) &&
1926         hid->maxapplication > 1) {
1927         switch (application) {
1928         case HID_GD_KEYBOARD:
1929             suffix = "Keyboard";
1930             break;
1931         case HID_GD_KEYPAD:
1932             suffix = "Keypad";
1933             break;
1934         case HID_GD_MOUSE:
1935             suffix = "Mouse";
1936             break;
1937         case HID_DG_PEN:
1938             /*
1939              * yes, there is an issue here:
1940              *  DG_PEN -> "Stylus"
1941              *  DG_STYLUS -> "Pen"
1942              * But changing this now means users with config snippets
1943              * will have to change it and the test suite will not be happy.
1944              */
1945             suffix = "Stylus";
1946             break;
1947         case HID_DG_STYLUS:
1948             suffix = "Pen";
1949             break;
1950         case HID_DG_TOUCHSCREEN:
1951             suffix = "Touchscreen";
1952             break;
1953         case HID_DG_TOUCHPAD:
1954             suffix = "Touchpad";
1955             break;
1956         case HID_GD_SYSTEM_CONTROL:
1957             suffix = "System Control";
1958             break;
1959         case HID_CP_CONSUMER_CONTROL:
1960             suffix = "Consumer Control";
1961             break;
1962         case HID_GD_WIRELESS_RADIO_CTLS:
1963             suffix = "Wireless Radio Control";
1964             break;
1965         case HID_GD_SYSTEM_MULTIAXIS:
1966             suffix = "System Multi Axis";
1967             break;
1968         default:
1969             break;
1970         }
1971     }
1972
1973     if (suffix) {
1974         name_len = strlen(hid->name);
1975         suffix_len = strlen(suffix);
1976         if ((name_len < suffix_len) ||
1977             strcmp(hid->name + name_len - suffix_len, suffix)) {
1978             hidinput->name = kasprintf(GFP_KERNEL, "%s %s",
1979                            hid->name, suffix);
1980             if (!hidinput->name)
1981                 goto fail;
1982         }
1983     }
1984
1985     input_set_drvdata(input_dev, hid);
1986     input_dev->event = hidinput_input_event;
1987     input_dev->open = hidinput_open;
1988     input_dev->close = hidinput_close;
1989     input_dev->setkeycode = hidinput_setkeycode;
1990     input_dev->getkeycode = hidinput_getkeycode;
1991
1992     input_dev->name = hidinput->name ? hidinput->name : hid->name;
1993     input_dev->phys = hid->phys;
1994     input_dev->uniq = hid->uniq;
1995     input_dev->id.bustype = hid->bus;
1996     input_dev->id.vendor  = hid->vendor;
1997     input_dev->id.product = hid->product;
1998     input_dev->id.version = hid->version;
1999     input_dev->dev.parent = &hid->dev;
2000
2001     hidinput->input = input_dev;
2002     hidinput->application = application;
2003     list_add_tail(&hidinput->list, &hid->inputs);
2004
2005     INIT_LIST_HEAD(&hidinput->reports);
2006
2007     return hidinput;
2008
2009 fail:
2010     kfree(hidinput);
2011     input_free_device(input_dev);
2012     hid_err(hid, "Out of memory during hid input probe\n");
2013     return NULL;
2014 }
2015
2016 static bool hidinput_has_been_populated(struct hid_input *hidinput)
2017 {
2018     int i;
2019     unsigned long r = 0;
2020
2021     for (i = 0; i < BITS_TO_LONGS(EV_CNT); i++)
2022         r |= hidinput->input->evbit[i];
2023
2024     for (i = 0; i < BITS_TO_LONGS(KEY_CNT); i++)
2025         r |= hidinput->input->keybit[i];
2026
2027     for (i = 0; i < BITS_TO_LONGS(REL_CNT); i++)
2028         r |= hidinput->input->relbit[i];
2029
2030     for (i = 0; i < BITS_TO_LONGS(ABS_CNT); i++)
2031         r |= hidinput->input->absbit[i];
2032
2033     for (i = 0; i < BITS_TO_LONGS(MSC_CNT); i++)
2034         r |= hidinput->input->mscbit[i];
2035
2036     for (i = 0; i < BITS_TO_LONGS(LED_CNT); i++)
2037         r |= hidinput->input->ledbit[i];
2038
2039     for (i = 0; i < BITS_TO_LONGS(SND_CNT); i++)
2040         r |= hidinput->input->sndbit[i];
2041
2042     for (i = 0; i < BITS_TO_LONGS(FF_CNT); i++)
2043         r |= hidinput->input->ffbit[i];
2044
2045     for (i = 0; i < BITS_TO_LONGS(SW_CNT); i++)
2046         r |= hidinput->input->swbit[i];
2047
2048     return !!r;
2049 }
2050
2051 static void hidinput_cleanup_hidinput(struct hid_device *hid,
2052         struct hid_input *hidinput)
2053 {
2054     struct hid_report *report;
2055     int i, k;
2056
2057     list_del(&hidinput->list);
2058     input_free_device(hidinput->input);
2059     kfree(hidinput->name);
2060
2061     for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
2062         if (k == HID_OUTPUT_REPORT &&
2063             hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
2064             continue;
2065
2066         list_for_each_entry(report, &hid->report_enum[k].report_list,
2067                     list) {
2068
2069             for (i = 0; i < report->maxfield; i++)
2070                 if (report->field[i]->hidinput == hidinput)
2071                     report->field[i]->hidinput = NULL;
2072         }
2073     }
2074
2075     kfree(hidinput);
2076 }
2077
2078 static struct hid_input *hidinput_match(struct hid_report *report)
2079 {
2080     struct hid_device *hid = report->device;
2081     struct hid_input *hidinput;
2082
2083     list_for_each_entry(hidinput, &hid->inputs, list) {
2084         if (hidinput->report &&
2085             hidinput->report->id == report->id)
2086             return hidinput;
2087     }
2088
2089     return NULL;
2090 }
2091
2092 static struct hid_input *hidinput_match_application(struct hid_report *report)
2093 {
2094     struct hid_device *hid = report->device;
2095     struct hid_input *hidinput;
2096
2097     list_for_each_entry(hidinput, &hid->inputs, list) {
2098         if (hidinput->application == report->application)
2099             return hidinput;
2100
2101         /*
2102          * Keep SystemControl and ConsumerControl applications together
2103          * with the main keyboard, if present.
2104          */
2105         if ((report->application == HID_GD_SYSTEM_CONTROL ||
2106              report->application == HID_CP_CONSUMER_CONTROL) &&
2107             hidinput->application == HID_GD_KEYBOARD) {
2108             return hidinput;
2109         }
2110     }
2111
2112     return NULL;
2113 }
2114
2115 static inline void hidinput_configure_usages(struct hid_input *hidinput,
2116                          struct hid_report *report)
2117 {
2118     int i, j, k;
2119     int first_field_index = 0;
2120     int slot_collection_index = -1;
2121     int prev_collection_index = -1;
2122     unsigned int slot_idx = 0;
2123     struct hid_field *field;
2124
2125     /*
2126      * First tag all the fields that are part of a slot,
2127      * a slot needs to have one Contact ID in the collection
2128      */
2129     for (i = 0; i < report->maxfield; i++) {
2130         field = report->field[i];
2131
2132         /* ignore fields without usage */
2133         if (field->maxusage < 1)
2134             continue;
2135
2136         /*
2137          * janitoring when collection_index changes
2138          */
2139         if (prev_collection_index != field->usage->collection_index) {
2140             prev_collection_index = field->usage->collection_index;
2141             first_field_index = i;
2142         }
2143
2144         /*
2145          * if we already found a Contact ID in the collection,
2146          * tag and continue to the next.
2147          */
2148         if (slot_collection_index == field->usage->collection_index) {
2149             field->slot_idx = slot_idx;
2150             continue;
2151         }
2152
2153         /* check if the current field has Contact ID */
2154         for (j = 0; j < field->maxusage; j++) {
2155             if (field->usage[j].hid == HID_DG_CONTACTID) {
2156                 slot_collection_index = field->usage->collection_index;
2157                 slot_idx++;
2158
2159                 /*
2160                  * mark all previous fields and this one in the
2161                  * current collection to be slotted.
2162                  */
2163                 for (k = first_field_index; k <= i; k++)
2164                     report->field[k]->slot_idx = slot_idx;
2165                 break;
2166             }
2167         }
2168     }
2169
2170     for (i = 0; i < report->maxfield; i++)
2171         for (j = 0; j < report->field[i]->maxusage; j++)
2172             hidinput_configure_usage(hidinput, report->field[i],
2173                          report->field[i]->usage + j,
2174                          j);
2175 }
2176
2177 /*
2178  * Register the input device; print a message.
2179  * Configure the input layer interface
2180  * Read all reports and initialize the absolute field values.
2181  */
2182
2183 int hidinput_connect(struct hid_device *hid, unsigned int force)
2184 {
2185     struct hid_driver *drv = hid->driver;
2186     struct hid_report *report;
2187     struct hid_input *next, *hidinput = NULL;
2188     unsigned int application;
2189     int i, k;
2190
2191     INIT_LIST_HEAD(&hid->inputs);
2192     INIT_WORK(&hid->led_work, hidinput_led_worker);
2193
2194     hid->status &= ~HID_STAT_DUP_DETECTED;
2195
2196     if (!force) {
2197         for (i = 0; i < hid->maxcollection; i++) {
2198             struct hid_collection *col = &hid->collection[i];
2199             if (col->type == HID_COLLECTION_APPLICATION ||
2200                     col->type == HID_COLLECTION_PHYSICAL)
2201                 if (IS_INPUT_APPLICATION(col->usage))
2202                     break;
2203         }
2204
2205         if (i == hid->maxcollection)
2206             return -1;
2207     }
2208
2209     report_features(hid);
2210
2211     for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
2212         if (k == HID_OUTPUT_REPORT &&
2213             hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
2214             continue;
2215
2216         list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
2217
2218             if (!report->maxfield)
2219                 continue;
2220
2221             application = report->application;
2222
2223             /*
2224              * Find the previous hidinput report attached
2225              * to this report id.
2226              */
2227             if (hid->quirks & HID_QUIRK_MULTI_INPUT)
2228                 hidinput = hidinput_match(report);
2229             else if (hid->maxapplication > 1 &&
2230                  (hid->quirks & HID_QUIRK_INPUT_PER_APP))
2231                 hidinput = hidinput_match_application(report);
2232
2233             if (!hidinput) {
2234                 hidinput = hidinput_allocate(hid, application);
2235                 if (!hidinput)
2236                     goto out_unwind;
2237             }
2238
2239             hidinput_configure_usages(hidinput, report);
2240
2241             if (hid->quirks & HID_QUIRK_MULTI_INPUT)
2242                 hidinput->report = report;
2243
2244             list_add_tail(&report->hidinput_list,
2245                       &hidinput->reports);
2246         }
2247     }
2248
2249     hidinput_change_resolution_multipliers(hid);
2250
2251     list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
2252         if (drv->input_configured &&
2253             drv->input_configured(hid, hidinput))
2254             goto out_unwind;
2255
2256         if (!hidinput_has_been_populated(hidinput)) {
2257             /* no need to register an input device not populated */
2258             hidinput_cleanup_hidinput(hid, hidinput);
2259             continue;
2260         }
2261
2262         if (input_register_device(hidinput->input))
2263             goto out_unwind;
2264         hidinput->registered = true;
2265     }
2266
2267     if (list_empty(&hid->inputs)) {
2268         hid_err(hid, "No inputs registered, leaving\n");
2269         goto out_unwind;
2270     }
2271
2272     if (hid->status & HID_STAT_DUP_DETECTED)
2273         hid_dbg(hid,
2274             "Some usages could not be mapped, please use HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE if this is legitimate.\n");
2275
2276     return 0;
2277
2278 out_unwind:
2279     /* unwind the ones we already registered */
2280     hidinput_disconnect(hid);
2281
2282     return -1;
2283 }
2284 EXPORT_SYMBOL_GPL(hidinput_connect);
2285
2286 void hidinput_disconnect(struct hid_device *hid)
2287 {
2288     struct hid_input *hidinput, *next;
2289
2290     hidinput_cleanup_battery(hid);
2291
2292     list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
2293         list_del(&hidinput->list);
2294         if (hidinput->registered)
2295             input_unregister_device(hidinput->input);
2296         else
2297             input_free_device(hidinput->input);
2298         kfree(hidinput->name);
2299         kfree(hidinput);
2300     }
2301
2302     /* led_work is spawned by input_dev callbacks, but doesn't access the
2303      * parent input_dev at all. Once all input devices are removed, we
2304      * know that led_work will never get restarted, so we can cancel it
2305      * synchronously and are safe. */
2306     cancel_work_sync(&hid->led_work);
2307 }
2308 EXPORT_SYMBOL_GPL(hidinput_disconnect);