LCOV - code coverage report
Current view: top level - include/linux - hid.h (source / functions) Hit Total Coverage
Test: Real Lines: 27 41 65.9 %
Date: 2020-10-17 15:46:16 Functions: 1 4 25.0 %
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) 1999 Andreas Gal
       4                 :            :  *  Copyright (c) 2000-2001 Vojtech Pavlik
       5                 :            :  *  Copyright (c) 2006-2007 Jiri Kosina
       6                 :            :  */
       7                 :            : /*
       8                 :            :  *
       9                 :            :  * Should you need to contact me, the author, you can do so either by
      10                 :            :  * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
      11                 :            :  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
      12                 :            :  */
      13                 :            : #ifndef __HID_H
      14                 :            : #define __HID_H
      15                 :            : 
      16                 :            : 
      17                 :            : #include <linux/bitops.h>
      18                 :            : #include <linux/types.h>
      19                 :            : #include <linux/slab.h>
      20                 :            : #include <linux/list.h>
      21                 :            : #include <linux/mod_devicetable.h> /* hid_device_id */
      22                 :            : #include <linux/timer.h>
      23                 :            : #include <linux/workqueue.h>
      24                 :            : #include <linux/input.h>
      25                 :            : #include <linux/semaphore.h>
      26                 :            : #include <linux/mutex.h>
      27                 :            : #include <linux/power_supply.h>
      28                 :            : #include <uapi/linux/hid.h>
      29                 :            : 
      30                 :            : /*
      31                 :            :  * We parse each description item into this structure. Short items data
      32                 :            :  * values are expanded to 32-bit signed int, long items contain a pointer
      33                 :            :  * into the data area.
      34                 :            :  */
      35                 :            : 
      36                 :            : struct hid_item {
      37                 :            :         unsigned  format;
      38                 :            :         __u8      size;
      39                 :            :         __u8      type;
      40                 :            :         __u8      tag;
      41                 :            :         union {
      42                 :            :             __u8   u8;
      43                 :            :             __s8   s8;
      44                 :            :             __u16  u16;
      45                 :            :             __s16  s16;
      46                 :            :             __u32  u32;
      47                 :            :             __s32  s32;
      48                 :            :             __u8  *longdata;
      49                 :            :         } data;
      50                 :            : };
      51                 :            : 
      52                 :            : /*
      53                 :            :  * HID report item format
      54                 :            :  */
      55                 :            : 
      56                 :            : #define HID_ITEM_FORMAT_SHORT   0
      57                 :            : #define HID_ITEM_FORMAT_LONG    1
      58                 :            : 
      59                 :            : /*
      60                 :            :  * Special tag indicating long items
      61                 :            :  */
      62                 :            : 
      63                 :            : #define HID_ITEM_TAG_LONG       15
      64                 :            : 
      65                 :            : /*
      66                 :            :  * HID report descriptor item type (prefix bit 2,3)
      67                 :            :  */
      68                 :            : 
      69                 :            : #define HID_ITEM_TYPE_MAIN              0
      70                 :            : #define HID_ITEM_TYPE_GLOBAL            1
      71                 :            : #define HID_ITEM_TYPE_LOCAL             2
      72                 :            : #define HID_ITEM_TYPE_RESERVED          3
      73                 :            : 
      74                 :            : /*
      75                 :            :  * HID report descriptor main item tags
      76                 :            :  */
      77                 :            : 
      78                 :            : #define HID_MAIN_ITEM_TAG_INPUT                 8
      79                 :            : #define HID_MAIN_ITEM_TAG_OUTPUT                9
      80                 :            : #define HID_MAIN_ITEM_TAG_FEATURE               11
      81                 :            : #define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION      10
      82                 :            : #define HID_MAIN_ITEM_TAG_END_COLLECTION        12
      83                 :            : 
      84                 :            : /*
      85                 :            :  * HID report descriptor main item contents
      86                 :            :  */
      87                 :            : 
      88                 :            : #define HID_MAIN_ITEM_CONSTANT          0x001
      89                 :            : #define HID_MAIN_ITEM_VARIABLE          0x002
      90                 :            : #define HID_MAIN_ITEM_RELATIVE          0x004
      91                 :            : #define HID_MAIN_ITEM_WRAP              0x008
      92                 :            : #define HID_MAIN_ITEM_NONLINEAR         0x010
      93                 :            : #define HID_MAIN_ITEM_NO_PREFERRED      0x020
      94                 :            : #define HID_MAIN_ITEM_NULL_STATE        0x040
      95                 :            : #define HID_MAIN_ITEM_VOLATILE          0x080
      96                 :            : #define HID_MAIN_ITEM_BUFFERED_BYTE     0x100
      97                 :            : 
      98                 :            : /*
      99                 :            :  * HID report descriptor collection item types
     100                 :            :  */
     101                 :            : 
     102                 :            : #define HID_COLLECTION_PHYSICAL         0
     103                 :            : #define HID_COLLECTION_APPLICATION      1
     104                 :            : #define HID_COLLECTION_LOGICAL          2
     105                 :            : 
     106                 :            : /*
     107                 :            :  * HID report descriptor global item tags
     108                 :            :  */
     109                 :            : 
     110                 :            : #define HID_GLOBAL_ITEM_TAG_USAGE_PAGE          0
     111                 :            : #define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM     1
     112                 :            : #define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM     2
     113                 :            : #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM    3
     114                 :            : #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM    4
     115                 :            : #define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT       5
     116                 :            : #define HID_GLOBAL_ITEM_TAG_UNIT                6
     117                 :            : #define HID_GLOBAL_ITEM_TAG_REPORT_SIZE         7
     118                 :            : #define HID_GLOBAL_ITEM_TAG_REPORT_ID           8
     119                 :            : #define HID_GLOBAL_ITEM_TAG_REPORT_COUNT        9
     120                 :            : #define HID_GLOBAL_ITEM_TAG_PUSH                10
     121                 :            : #define HID_GLOBAL_ITEM_TAG_POP                 11
     122                 :            : 
     123                 :            : /*
     124                 :            :  * HID report descriptor local item tags
     125                 :            :  */
     126                 :            : 
     127                 :            : #define HID_LOCAL_ITEM_TAG_USAGE                0
     128                 :            : #define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM        1
     129                 :            : #define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM        2
     130                 :            : #define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX     3
     131                 :            : #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM   4
     132                 :            : #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM   5
     133                 :            : #define HID_LOCAL_ITEM_TAG_STRING_INDEX         7
     134                 :            : #define HID_LOCAL_ITEM_TAG_STRING_MINIMUM       8
     135                 :            : #define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM       9
     136                 :            : #define HID_LOCAL_ITEM_TAG_DELIMITER            10
     137                 :            : 
     138                 :            : /*
     139                 :            :  * HID usage tables
     140                 :            :  */
     141                 :            : 
     142                 :            : #define HID_USAGE_PAGE          0xffff0000
     143                 :            : 
     144                 :            : #define HID_UP_UNDEFINED        0x00000000
     145                 :            : #define HID_UP_GENDESK          0x00010000
     146                 :            : #define HID_UP_SIMULATION       0x00020000
     147                 :            : #define HID_UP_GENDEVCTRLS      0x00060000
     148                 :            : #define HID_UP_KEYBOARD         0x00070000
     149                 :            : #define HID_UP_LED              0x00080000
     150                 :            : #define HID_UP_BUTTON           0x00090000
     151                 :            : #define HID_UP_ORDINAL          0x000a0000
     152                 :            : #define HID_UP_TELEPHONY        0x000b0000
     153                 :            : #define HID_UP_CONSUMER         0x000c0000
     154                 :            : #define HID_UP_DIGITIZER        0x000d0000
     155                 :            : #define HID_UP_PID              0x000f0000
     156                 :            : #define HID_UP_HPVENDOR         0xff7f0000
     157                 :            : #define HID_UP_HPVENDOR2        0xff010000
     158                 :            : #define HID_UP_MSVENDOR         0xff000000
     159                 :            : #define HID_UP_CUSTOM           0x00ff0000
     160                 :            : #define HID_UP_LOGIVENDOR       0xffbc0000
     161                 :            : #define HID_UP_LOGIVENDOR2   0xff090000
     162                 :            : #define HID_UP_LOGIVENDOR3   0xff430000
     163                 :            : #define HID_UP_LNVENDOR         0xffa00000
     164                 :            : #define HID_UP_SENSOR           0x00200000
     165                 :            : #define HID_UP_ASUSVENDOR       0xff310000
     166                 :            : 
     167                 :            : #define HID_USAGE               0x0000ffff
     168                 :            : 
     169                 :            : #define HID_GD_POINTER          0x00010001
     170                 :            : #define HID_GD_MOUSE            0x00010002
     171                 :            : #define HID_GD_JOYSTICK         0x00010004
     172                 :            : #define HID_GD_GAMEPAD          0x00010005
     173                 :            : #define HID_GD_KEYBOARD         0x00010006
     174                 :            : #define HID_GD_KEYPAD           0x00010007
     175                 :            : #define HID_GD_MULTIAXIS        0x00010008
     176                 :            : /*
     177                 :            :  * Microsoft Win8 Wireless Radio Controls extensions CA, see:
     178                 :            :  * http://www.usb.org/developers/hidpage/HUTRR40RadioHIDUsagesFinal.pdf
     179                 :            :  */
     180                 :            : #define HID_GD_WIRELESS_RADIO_CTLS      0x0001000c
     181                 :            : /*
     182                 :            :  * System Multi-Axis, see:
     183                 :            :  * http://www.usb.org/developers/hidpage/HUTRR62_-_Generic_Desktop_CA_for_System_Multi-Axis_Controllers.txt
     184                 :            :  */
     185                 :            : #define HID_GD_SYSTEM_MULTIAXIS 0x0001000e
     186                 :            : 
     187                 :            : #define HID_GD_X                0x00010030
     188                 :            : #define HID_GD_Y                0x00010031
     189                 :            : #define HID_GD_Z                0x00010032
     190                 :            : #define HID_GD_RX               0x00010033
     191                 :            : #define HID_GD_RY               0x00010034
     192                 :            : #define HID_GD_RZ               0x00010035
     193                 :            : #define HID_GD_SLIDER           0x00010036
     194                 :            : #define HID_GD_DIAL             0x00010037
     195                 :            : #define HID_GD_WHEEL            0x00010038
     196                 :            : #define HID_GD_HATSWITCH        0x00010039
     197                 :            : #define HID_GD_BUFFER           0x0001003a
     198                 :            : #define HID_GD_BYTECOUNT        0x0001003b
     199                 :            : #define HID_GD_MOTION           0x0001003c
     200                 :            : #define HID_GD_START            0x0001003d
     201                 :            : #define HID_GD_SELECT           0x0001003e
     202                 :            : #define HID_GD_VX               0x00010040
     203                 :            : #define HID_GD_VY               0x00010041
     204                 :            : #define HID_GD_VZ               0x00010042
     205                 :            : #define HID_GD_VBRX             0x00010043
     206                 :            : #define HID_GD_VBRY             0x00010044
     207                 :            : #define HID_GD_VBRZ             0x00010045
     208                 :            : #define HID_GD_VNO              0x00010046
     209                 :            : #define HID_GD_FEATURE          0x00010047
     210                 :            : #define HID_GD_RESOLUTION_MULTIPLIER    0x00010048
     211                 :            : #define HID_GD_SYSTEM_CONTROL   0x00010080
     212                 :            : #define HID_GD_UP               0x00010090
     213                 :            : #define HID_GD_DOWN             0x00010091
     214                 :            : #define HID_GD_RIGHT            0x00010092
     215                 :            : #define HID_GD_LEFT             0x00010093
     216                 :            : /* Microsoft Win8 Wireless Radio Controls CA usage codes */
     217                 :            : #define HID_GD_RFKILL_BTN       0x000100c6
     218                 :            : #define HID_GD_RFKILL_LED       0x000100c7
     219                 :            : #define HID_GD_RFKILL_SWITCH    0x000100c8
     220                 :            : 
     221                 :            : #define HID_DC_BATTERYSTRENGTH  0x00060020
     222                 :            : 
     223                 :            : #define HID_CP_CONSUMER_CONTROL 0x000c0001
     224                 :            : #define HID_CP_AC_PAN           0x000c0238
     225                 :            : 
     226                 :            : #define HID_DG_DIGITIZER        0x000d0001
     227                 :            : #define HID_DG_PEN              0x000d0002
     228                 :            : #define HID_DG_LIGHTPEN         0x000d0003
     229                 :            : #define HID_DG_TOUCHSCREEN      0x000d0004
     230                 :            : #define HID_DG_TOUCHPAD         0x000d0005
     231                 :            : #define HID_DG_WHITEBOARD       0x000d0006
     232                 :            : #define HID_DG_STYLUS           0x000d0020
     233                 :            : #define HID_DG_PUCK             0x000d0021
     234                 :            : #define HID_DG_FINGER           0x000d0022
     235                 :            : #define HID_DG_TIPPRESSURE      0x000d0030
     236                 :            : #define HID_DG_BARRELPRESSURE   0x000d0031
     237                 :            : #define HID_DG_INRANGE          0x000d0032
     238                 :            : #define HID_DG_TOUCH            0x000d0033
     239                 :            : #define HID_DG_UNTOUCH          0x000d0034
     240                 :            : #define HID_DG_TAP              0x000d0035
     241                 :            : #define HID_DG_TABLETFUNCTIONKEY        0x000d0039
     242                 :            : #define HID_DG_PROGRAMCHANGEKEY 0x000d003a
     243                 :            : #define HID_DG_BATTERYSTRENGTH  0x000d003b
     244                 :            : #define HID_DG_INVERT           0x000d003c
     245                 :            : #define HID_DG_TILT_X           0x000d003d
     246                 :            : #define HID_DG_TILT_Y           0x000d003e
     247                 :            : #define HID_DG_TWIST            0x000d0041
     248                 :            : #define HID_DG_TIPSWITCH        0x000d0042
     249                 :            : #define HID_DG_TIPSWITCH2       0x000d0043
     250                 :            : #define HID_DG_BARRELSWITCH     0x000d0044
     251                 :            : #define HID_DG_ERASER           0x000d0045
     252                 :            : #define HID_DG_TABLETPICK       0x000d0046
     253                 :            : 
     254                 :            : #define HID_CP_CONSUMERCONTROL  0x000c0001
     255                 :            : #define HID_CP_NUMERICKEYPAD    0x000c0002
     256                 :            : #define HID_CP_PROGRAMMABLEBUTTONS      0x000c0003
     257                 :            : #define HID_CP_MICROPHONE       0x000c0004
     258                 :            : #define HID_CP_HEADPHONE        0x000c0005
     259                 :            : #define HID_CP_GRAPHICEQUALIZER 0x000c0006
     260                 :            : #define HID_CP_FUNCTIONBUTTONS  0x000c0036
     261                 :            : #define HID_CP_SELECTION        0x000c0080
     262                 :            : #define HID_CP_MEDIASELECTION   0x000c0087
     263                 :            : #define HID_CP_SELECTDISC       0x000c00ba
     264                 :            : #define HID_CP_PLAYBACKSPEED    0x000c00f1
     265                 :            : #define HID_CP_PROXIMITY        0x000c0109
     266                 :            : #define HID_CP_SPEAKERSYSTEM    0x000c0160
     267                 :            : #define HID_CP_CHANNELLEFT      0x000c0161
     268                 :            : #define HID_CP_CHANNELRIGHT     0x000c0162
     269                 :            : #define HID_CP_CHANNELCENTER    0x000c0163
     270                 :            : #define HID_CP_CHANNELFRONT     0x000c0164
     271                 :            : #define HID_CP_CHANNELCENTERFRONT       0x000c0165
     272                 :            : #define HID_CP_CHANNELSIDE      0x000c0166
     273                 :            : #define HID_CP_CHANNELSURROUND  0x000c0167
     274                 :            : #define HID_CP_CHANNELLOWFREQUENCYENHANCEMENT   0x000c0168
     275                 :            : #define HID_CP_CHANNELTOP       0x000c0169
     276                 :            : #define HID_CP_CHANNELUNKNOWN   0x000c016a
     277                 :            : #define HID_CP_APPLICATIONLAUNCHBUTTONS 0x000c0180
     278                 :            : #define HID_CP_GENERICGUIAPPLICATIONCONTROLS    0x000c0200
     279                 :            : 
     280                 :            : #define HID_DG_DEVICECONFIG     0x000d000e
     281                 :            : #define HID_DG_DEVICESETTINGS   0x000d0023
     282                 :            : #define HID_DG_AZIMUTH          0x000d003f
     283                 :            : #define HID_DG_CONFIDENCE       0x000d0047
     284                 :            : #define HID_DG_WIDTH            0x000d0048
     285                 :            : #define HID_DG_HEIGHT           0x000d0049
     286                 :            : #define HID_DG_CONTACTID        0x000d0051
     287                 :            : #define HID_DG_INPUTMODE        0x000d0052
     288                 :            : #define HID_DG_DEVICEINDEX      0x000d0053
     289                 :            : #define HID_DG_CONTACTCOUNT     0x000d0054
     290                 :            : #define HID_DG_CONTACTMAX       0x000d0055
     291                 :            : #define HID_DG_SCANTIME         0x000d0056
     292                 :            : #define HID_DG_SURFACESWITCH    0x000d0057
     293                 :            : #define HID_DG_BUTTONSWITCH     0x000d0058
     294                 :            : #define HID_DG_BUTTONTYPE       0x000d0059
     295                 :            : #define HID_DG_BARRELSWITCH2    0x000d005a
     296                 :            : #define HID_DG_TOOLSERIALNUMBER 0x000d005b
     297                 :            : #define HID_DG_LATENCYMODE      0x000d0060
     298                 :            : 
     299                 :            : #define HID_VD_ASUS_CUSTOM_MEDIA_KEYS   0xff310076
     300                 :            : /*
     301                 :            :  * HID report types --- Ouch! HID spec says 1 2 3!
     302                 :            :  */
     303                 :            : 
     304                 :            : #define HID_INPUT_REPORT        0
     305                 :            : #define HID_OUTPUT_REPORT       1
     306                 :            : #define HID_FEATURE_REPORT      2
     307                 :            : 
     308                 :            : #define HID_REPORT_TYPES        3
     309                 :            : 
     310                 :            : /*
     311                 :            :  * HID connect requests
     312                 :            :  */
     313                 :            : 
     314                 :            : #define HID_CONNECT_HIDINPUT            BIT(0)
     315                 :            : #define HID_CONNECT_HIDINPUT_FORCE      BIT(1)
     316                 :            : #define HID_CONNECT_HIDRAW              BIT(2)
     317                 :            : #define HID_CONNECT_HIDDEV              BIT(3)
     318                 :            : #define HID_CONNECT_HIDDEV_FORCE        BIT(4)
     319                 :            : #define HID_CONNECT_FF                  BIT(5)
     320                 :            : #define HID_CONNECT_DRIVER              BIT(6)
     321                 :            : #define HID_CONNECT_DEFAULT     (HID_CONNECT_HIDINPUT|HID_CONNECT_HIDRAW| \
     322                 :            :                 HID_CONNECT_HIDDEV|HID_CONNECT_FF)
     323                 :            : 
     324                 :            : /*
     325                 :            :  * HID device quirks.
     326                 :            :  */
     327                 :            : 
     328                 :            : /* 
     329                 :            :  * Increase this if you need to configure more HID quirks at module load time
     330                 :            :  */
     331                 :            : #define MAX_USBHID_BOOT_QUIRKS 4
     332                 :            : 
     333                 :            : #define HID_QUIRK_INVERT                        BIT(0)
     334                 :            : #define HID_QUIRK_NOTOUCH                       BIT(1)
     335                 :            : #define HID_QUIRK_IGNORE                        BIT(2)
     336                 :            : #define HID_QUIRK_NOGET                         BIT(3)
     337                 :            : #define HID_QUIRK_HIDDEV_FORCE                  BIT(4)
     338                 :            : #define HID_QUIRK_BADPAD                        BIT(5)
     339                 :            : #define HID_QUIRK_MULTI_INPUT                   BIT(6)
     340                 :            : #define HID_QUIRK_HIDINPUT_FORCE                BIT(7)
     341                 :            : /* BIT(8) reserved for backward compatibility, was HID_QUIRK_NO_EMPTY_INPUT */
     342                 :            : /* BIT(9) reserved for backward compatibility, was NO_INIT_INPUT_REPORTS */
     343                 :            : #define HID_QUIRK_ALWAYS_POLL                   BIT(10)
     344                 :            : #define HID_QUIRK_INPUT_PER_APP                 BIT(11)
     345                 :            : #define HID_QUIRK_SKIP_OUTPUT_REPORTS           BIT(16)
     346                 :            : #define HID_QUIRK_SKIP_OUTPUT_REPORT_ID         BIT(17)
     347                 :            : #define HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP  BIT(18)
     348                 :            : #define HID_QUIRK_HAVE_SPECIAL_DRIVER           BIT(19)
     349                 :            : #define HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE  BIT(20)
     350                 :            : #define HID_QUIRK_FULLSPEED_INTERVAL            BIT(28)
     351                 :            : #define HID_QUIRK_NO_INIT_REPORTS               BIT(29)
     352                 :            : #define HID_QUIRK_NO_IGNORE                     BIT(30)
     353                 :            : #define HID_QUIRK_NO_INPUT_SYNC                 BIT(31)
     354                 :            : 
     355                 :            : /*
     356                 :            :  * HID device groups
     357                 :            :  *
     358                 :            :  * Note: HID_GROUP_ANY is declared in linux/mod_devicetable.h
     359                 :            :  * and has a value of 0x0000
     360                 :            :  */
     361                 :            : #define HID_GROUP_GENERIC                       0x0001
     362                 :            : #define HID_GROUP_MULTITOUCH                    0x0002
     363                 :            : #define HID_GROUP_SENSOR_HUB                    0x0003
     364                 :            : #define HID_GROUP_MULTITOUCH_WIN_8              0x0004
     365                 :            : 
     366                 :            : /*
     367                 :            :  * Vendor specific HID device groups
     368                 :            :  */
     369                 :            : #define HID_GROUP_RMI                           0x0100
     370                 :            : #define HID_GROUP_WACOM                         0x0101
     371                 :            : #define HID_GROUP_LOGITECH_DJ_DEVICE            0x0102
     372                 :            : #define HID_GROUP_STEAM                         0x0103
     373                 :            : #define HID_GROUP_LOGITECH_27MHZ_DEVICE         0x0104
     374                 :            : 
     375                 :            : /*
     376                 :            :  * HID protocol status
     377                 :            :  */
     378                 :            : #define HID_REPORT_PROTOCOL     1
     379                 :            : #define HID_BOOT_PROTOCOL       0
     380                 :            : 
     381                 :            : /*
     382                 :            :  * This is the global environment of the parser. This information is
     383                 :            :  * persistent for main-items. The global environment can be saved and
     384                 :            :  * restored with PUSH/POP statements.
     385                 :            :  */
     386                 :            : 
     387                 :            : struct hid_global {
     388                 :            :         unsigned usage_page;
     389                 :            :         __s32    logical_minimum;
     390                 :            :         __s32    logical_maximum;
     391                 :            :         __s32    physical_minimum;
     392                 :            :         __s32    physical_maximum;
     393                 :            :         __s32    unit_exponent;
     394                 :            :         unsigned unit;
     395                 :            :         unsigned report_id;
     396                 :            :         unsigned report_size;
     397                 :            :         unsigned report_count;
     398                 :            : };
     399                 :            : 
     400                 :            : /*
     401                 :            :  * This is the local environment. It is persistent up the next main-item.
     402                 :            :  */
     403                 :            : 
     404                 :            : #define HID_MAX_USAGES                  12288
     405                 :            : #define HID_DEFAULT_NUM_COLLECTIONS     16
     406                 :            : 
     407                 :            : struct hid_local {
     408                 :            :         unsigned usage[HID_MAX_USAGES]; /* usage array */
     409                 :            :         u8 usage_size[HID_MAX_USAGES]; /* usage size array */
     410                 :            :         unsigned collection_index[HID_MAX_USAGES]; /* collection index array */
     411                 :            :         unsigned usage_index;
     412                 :            :         unsigned usage_minimum;
     413                 :            :         unsigned delimiter_depth;
     414                 :            :         unsigned delimiter_branch;
     415                 :            : };
     416                 :            : 
     417                 :            : /*
     418                 :            :  * This is the collection stack. We climb up the stack to determine
     419                 :            :  * application and function of each field.
     420                 :            :  */
     421                 :            : 
     422                 :            : struct hid_collection {
     423                 :            :         int parent_idx; /* device->collection */
     424                 :            :         unsigned type;
     425                 :            :         unsigned usage;
     426                 :            :         unsigned level;
     427                 :            : };
     428                 :            : 
     429                 :            : struct hid_usage {
     430                 :            :         unsigned  hid;                  /* hid usage code */
     431                 :            :         unsigned  collection_index;     /* index into collection array */
     432                 :            :         unsigned  usage_index;          /* index into usage array */
     433                 :            :         __s8      resolution_multiplier;/* Effective Resolution Multiplier
     434                 :            :                                            (HUT v1.12, 4.3.1), default: 1 */
     435                 :            :         /* hidinput data */
     436                 :            :         __s8      wheel_factor;         /* 120/resolution_multiplier */
     437                 :            :         __u16     code;                 /* input driver code */
     438                 :            :         __u8      type;                 /* input driver type */
     439                 :            :         __s8      hat_min;              /* hat switch fun */
     440                 :            :         __s8      hat_max;              /* ditto */
     441                 :            :         __s8      hat_dir;              /* ditto */
     442                 :            :         __s16     wheel_accumulated;    /* hi-res wheel */
     443                 :            : };
     444                 :            : 
     445                 :            : struct hid_input;
     446                 :            : 
     447                 :            : struct hid_field {
     448                 :            :         unsigned  physical;             /* physical usage for this field */
     449                 :            :         unsigned  logical;              /* logical usage for this field */
     450                 :            :         unsigned  application;          /* application usage for this field */
     451                 :            :         struct hid_usage *usage;        /* usage table for this function */
     452                 :            :         unsigned  maxusage;             /* maximum usage index */
     453                 :            :         unsigned  flags;                /* main-item flags (i.e. volatile,array,constant) */
     454                 :            :         unsigned  report_offset;        /* bit offset in the report */
     455                 :            :         unsigned  report_size;          /* size of this field in the report */
     456                 :            :         unsigned  report_count;         /* number of this field in the report */
     457                 :            :         unsigned  report_type;          /* (input,output,feature) */
     458                 :            :         __s32    *value;                /* last known value(s) */
     459                 :            :         __s32     logical_minimum;
     460                 :            :         __s32     logical_maximum;
     461                 :            :         __s32     physical_minimum;
     462                 :            :         __s32     physical_maximum;
     463                 :            :         __s32     unit_exponent;
     464                 :            :         unsigned  unit;
     465                 :            :         struct hid_report *report;      /* associated report */
     466                 :            :         unsigned index;                 /* index into report->field[] */
     467                 :            :         /* hidinput data */
     468                 :            :         struct hid_input *hidinput;     /* associated input structure */
     469                 :            :         __u16 dpad;                     /* dpad input code */
     470                 :            : };
     471                 :            : 
     472                 :            : #define HID_MAX_FIELDS 256
     473                 :            : 
     474                 :            : struct hid_report {
     475                 :            :         struct list_head list;
     476                 :            :         struct list_head hidinput_list;
     477                 :            :         unsigned int id;                                /* id of this report */
     478                 :            :         unsigned int type;                              /* report type */
     479                 :            :         unsigned int application;                       /* application usage for this report */
     480                 :            :         struct hid_field *field[HID_MAX_FIELDS];        /* fields of the report */
     481                 :            :         unsigned maxfield;                              /* maximum valid field index */
     482                 :            :         unsigned size;                                  /* size of the report (bits) */
     483                 :            :         struct hid_device *device;                      /* associated device */
     484                 :            : };
     485                 :            : 
     486                 :            : #define HID_MAX_IDS 256
     487                 :            : 
     488                 :            : struct hid_report_enum {
     489                 :            :         unsigned numbered;
     490                 :            :         struct list_head report_list;
     491                 :            :         struct hid_report *report_id_hash[HID_MAX_IDS];
     492                 :            : };
     493                 :            : 
     494                 :            : #define HID_MIN_BUFFER_SIZE     64              /* make sure there is at least a packet size of space */
     495                 :            : #define HID_MAX_BUFFER_SIZE     8192            /* 8kb */
     496                 :            : #define HID_CONTROL_FIFO_SIZE   256             /* to init devices with >100 reports */
     497                 :            : #define HID_OUTPUT_FIFO_SIZE    64
     498                 :            : 
     499                 :            : struct hid_control_fifo {
     500                 :            :         unsigned char dir;
     501                 :            :         struct hid_report *report;
     502                 :            :         char *raw_report;
     503                 :            : };
     504                 :            : 
     505                 :            : struct hid_output_fifo {
     506                 :            :         struct hid_report *report;
     507                 :            :         char *raw_report;
     508                 :            : };
     509                 :            : 
     510                 :            : #define HID_CLAIMED_INPUT       BIT(0)
     511                 :            : #define HID_CLAIMED_HIDDEV      BIT(1)
     512                 :            : #define HID_CLAIMED_HIDRAW      BIT(2)
     513                 :            : #define HID_CLAIMED_DRIVER      BIT(3)
     514                 :            : 
     515                 :            : #define HID_STAT_ADDED          BIT(0)
     516                 :            : #define HID_STAT_PARSED         BIT(1)
     517                 :            : #define HID_STAT_DUP_DETECTED   BIT(2)
     518                 :            : #define HID_STAT_REPROBED       BIT(3)
     519                 :            : 
     520                 :            : struct hid_input {
     521                 :            :         struct list_head list;
     522                 :            :         struct hid_report *report;
     523                 :            :         struct input_dev *input;
     524                 :            :         const char *name;
     525                 :            :         bool registered;
     526                 :            :         struct list_head reports;       /* the list of reports */
     527                 :            :         unsigned int application;       /* application usage for this input */
     528                 :            : };
     529                 :            : 
     530                 :            : enum hid_type {
     531                 :            :         HID_TYPE_OTHER = 0,
     532                 :            :         HID_TYPE_USBMOUSE,
     533                 :            :         HID_TYPE_USBNONE
     534                 :            : };
     535                 :            : 
     536                 :            : enum hid_battery_status {
     537                 :            :         HID_BATTERY_UNKNOWN = 0,
     538                 :            :         HID_BATTERY_QUERIED,            /* Kernel explicitly queried battery strength */
     539                 :            :         HID_BATTERY_REPORTED,           /* Device sent unsolicited battery strength report */
     540                 :            : };
     541                 :            : 
     542                 :            : struct hid_driver;
     543                 :            : struct hid_ll_driver;
     544                 :            : 
     545                 :            : struct hid_device {                                                     /* device report descriptor */
     546                 :            :         __u8 *dev_rdesc;
     547                 :            :         unsigned dev_rsize;
     548                 :            :         __u8 *rdesc;
     549                 :            :         unsigned rsize;
     550                 :            :         struct hid_collection *collection;                              /* List of HID collections */
     551                 :            :         unsigned collection_size;                                       /* Number of allocated hid_collections */
     552                 :            :         unsigned maxcollection;                                         /* Number of parsed collections */
     553                 :            :         unsigned maxapplication;                                        /* Number of applications */
     554                 :            :         __u16 bus;                                                      /* BUS ID */
     555                 :            :         __u16 group;                                                    /* Report group */
     556                 :            :         __u32 vendor;                                                   /* Vendor ID */
     557                 :            :         __u32 product;                                                  /* Product ID */
     558                 :            :         __u32 version;                                                  /* HID version */
     559                 :            :         enum hid_type type;                                             /* device type (mouse, kbd, ...) */
     560                 :            :         unsigned country;                                               /* HID country */
     561                 :            :         struct hid_report_enum report_enum[HID_REPORT_TYPES];
     562                 :            :         struct work_struct led_work;                                    /* delayed LED worker */
     563                 :            : 
     564                 :            :         struct semaphore driver_input_lock;                             /* protects the current driver */
     565                 :            :         struct device dev;                                              /* device */
     566                 :            :         struct hid_driver *driver;
     567                 :            : 
     568                 :            :         struct hid_ll_driver *ll_driver;
     569                 :            :         struct mutex ll_open_lock;
     570                 :            :         unsigned int ll_open_count;
     571                 :            : 
     572                 :            : #ifdef CONFIG_HID_BATTERY_STRENGTH
     573                 :            :         /*
     574                 :            :          * Power supply information for HID devices which report
     575                 :            :          * battery strength. power_supply was successfully registered if
     576                 :            :          * battery is non-NULL.
     577                 :            :          */
     578                 :            :         struct power_supply *battery;
     579                 :            :         __s32 battery_capacity;
     580                 :            :         __s32 battery_min;
     581                 :            :         __s32 battery_max;
     582                 :            :         __s32 battery_report_type;
     583                 :            :         __s32 battery_report_id;
     584                 :            :         enum hid_battery_status battery_status;
     585                 :            :         bool battery_avoid_query;
     586                 :            : #endif
     587                 :            : 
     588                 :            :         unsigned long status;                                           /* see STAT flags above */
     589                 :            :         unsigned claimed;                                               /* Claimed by hidinput, hiddev? */
     590                 :            :         unsigned quirks;                                                /* Various quirks the device can pull on us */
     591                 :            :         bool io_started;                                                /* If IO has started */
     592                 :            : 
     593                 :            :         struct list_head inputs;                                        /* The list of inputs */
     594                 :            :         void *hiddev;                                                   /* The hiddev structure */
     595                 :            :         void *hidraw;
     596                 :            : 
     597                 :            :         char name[128];                                                 /* Device name */
     598                 :            :         char phys[64];                                                  /* Device physical location */
     599                 :            :         char uniq[64];                                                  /* Device unique identifier (serial #) */
     600                 :            : 
     601                 :            :         void *driver_data;
     602                 :            : 
     603                 :            :         /* temporary hid_ff handling (until moved to the drivers) */
     604                 :            :         int (*ff_init)(struct hid_device *);
     605                 :            : 
     606                 :            :         /* hiddev event handler */
     607                 :            :         int (*hiddev_connect)(struct hid_device *, unsigned int);
     608                 :            :         void (*hiddev_disconnect)(struct hid_device *);
     609                 :            :         void (*hiddev_hid_event) (struct hid_device *, struct hid_field *field,
     610                 :            :                                   struct hid_usage *, __s32);
     611                 :            :         void (*hiddev_report_event) (struct hid_device *, struct hid_report *);
     612                 :            : 
     613                 :            :         /* debugging support via debugfs */
     614                 :            :         unsigned short debug;
     615                 :            :         struct dentry *debug_dir;
     616                 :            :         struct dentry *debug_rdesc;
     617                 :            :         struct dentry *debug_events;
     618                 :            :         struct list_head debug_list;
     619                 :            :         spinlock_t  debug_list_lock;
     620                 :            :         wait_queue_head_t debug_wait;
     621                 :            : };
     622                 :            : 
     623                 :            : #define to_hid_device(pdev) \
     624                 :            :         container_of(pdev, struct hid_device, dev)
     625                 :            : 
     626                 :            : static inline void *hid_get_drvdata(struct hid_device *hdev)
     627                 :            : {
     628                 :            :         return dev_get_drvdata(&hdev->dev);
     629                 :            : }
     630                 :            : 
     631                 :            : static inline void hid_set_drvdata(struct hid_device *hdev, void *data)
     632                 :            : {
     633                 :            :         dev_set_drvdata(&hdev->dev, data);
     634                 :            : }
     635                 :            : 
     636                 :            : #define HID_GLOBAL_STACK_SIZE 4
     637                 :            : #define HID_COLLECTION_STACK_SIZE 4
     638                 :            : 
     639                 :            : #define HID_SCAN_FLAG_MT_WIN_8                  BIT(0)
     640                 :            : #define HID_SCAN_FLAG_VENDOR_SPECIFIC           BIT(1)
     641                 :            : #define HID_SCAN_FLAG_GD_POINTER                BIT(2)
     642                 :            : 
     643                 :            : struct hid_parser {
     644                 :            :         struct hid_global     global;
     645                 :            :         struct hid_global     global_stack[HID_GLOBAL_STACK_SIZE];
     646                 :            :         unsigned int          global_stack_ptr;
     647                 :            :         struct hid_local      local;
     648                 :            :         unsigned int         *collection_stack;
     649                 :            :         unsigned int          collection_stack_ptr;
     650                 :            :         unsigned int          collection_stack_size;
     651                 :            :         struct hid_device    *device;
     652                 :            :         unsigned int          scan_flags;
     653                 :            : };
     654                 :            : 
     655                 :            : struct hid_class_descriptor {
     656                 :            :         __u8  bDescriptorType;
     657                 :            :         __le16 wDescriptorLength;
     658                 :            : } __attribute__ ((packed));
     659                 :            : 
     660                 :            : struct hid_descriptor {
     661                 :            :         __u8  bLength;
     662                 :            :         __u8  bDescriptorType;
     663                 :            :         __le16 bcdHID;
     664                 :            :         __u8  bCountryCode;
     665                 :            :         __u8  bNumDescriptors;
     666                 :            : 
     667                 :            :         struct hid_class_descriptor desc[1];
     668                 :            : } __attribute__ ((packed));
     669                 :            : 
     670                 :            : #define HID_DEVICE(b, g, ven, prod)                                     \
     671                 :            :         .bus = (b), .group = (g), .vendor = (ven), .product = (prod)
     672                 :            : #define HID_USB_DEVICE(ven, prod)                               \
     673                 :            :         .bus = BUS_USB, .vendor = (ven), .product = (prod)
     674                 :            : #define HID_BLUETOOTH_DEVICE(ven, prod)                                 \
     675                 :            :         .bus = BUS_BLUETOOTH, .vendor = (ven), .product = (prod)
     676                 :            : #define HID_I2C_DEVICE(ven, prod)                               \
     677                 :            :         .bus = BUS_I2C, .vendor = (ven), .product = (prod)
     678                 :            : 
     679                 :            : #define HID_REPORT_ID(rep) \
     680                 :            :         .report_type = (rep)
     681                 :            : #define HID_USAGE_ID(uhid, utype, ucode) \
     682                 :            :         .usage_hid = (uhid), .usage_type = (utype), .usage_code = (ucode)
     683                 :            : /* we don't want to catch types and codes equal to 0 */
     684                 :            : #define HID_TERMINATOR          (HID_ANY_ID - 1)
     685                 :            : 
     686                 :            : struct hid_report_id {
     687                 :            :         __u32 report_type;
     688                 :            : };
     689                 :            : struct hid_usage_id {
     690                 :            :         __u32 usage_hid;
     691                 :            :         __u32 usage_type;
     692                 :            :         __u32 usage_code;
     693                 :            : };
     694                 :            : 
     695                 :            : /**
     696                 :            :  * struct hid_driver
     697                 :            :  * @name: driver name (e.g. "Footech_bar-wheel")
     698                 :            :  * @id_table: which devices is this driver for (must be non-NULL for probe
     699                 :            :  *            to be called)
     700                 :            :  * @dyn_list: list of dynamically added device ids
     701                 :            :  * @dyn_lock: lock protecting @dyn_list
     702                 :            :  * @match: check if the given device is handled by this driver
     703                 :            :  * @probe: new device inserted
     704                 :            :  * @remove: device removed (NULL if not a hot-plug capable driver)
     705                 :            :  * @report_table: on which reports to call raw_event (NULL means all)
     706                 :            :  * @raw_event: if report in report_table, this hook is called (NULL means nop)
     707                 :            :  * @usage_table: on which events to call event (NULL means all)
     708                 :            :  * @event: if usage in usage_table, this hook is called (NULL means nop)
     709                 :            :  * @report: this hook is called after parsing a report (NULL means nop)
     710                 :            :  * @report_fixup: called before report descriptor parsing (NULL means nop)
     711                 :            :  * @input_mapping: invoked on input registering before mapping an usage
     712                 :            :  * @input_mapped: invoked on input registering after mapping an usage
     713                 :            :  * @input_configured: invoked just before the device is registered
     714                 :            :  * @feature_mapping: invoked on feature registering
     715                 :            :  * @suspend: invoked on suspend (NULL means nop)
     716                 :            :  * @resume: invoked on resume if device was not reset (NULL means nop)
     717                 :            :  * @reset_resume: invoked on resume if device was reset (NULL means nop)
     718                 :            :  *
     719                 :            :  * probe should return -errno on error, or 0 on success. During probe,
     720                 :            :  * input will not be passed to raw_event unless hid_device_io_start is
     721                 :            :  * called.
     722                 :            :  *
     723                 :            :  * raw_event and event should return negative on error, any other value will
     724                 :            :  * pass the event on to .event() typically return 0 for success.
     725                 :            :  *
     726                 :            :  * input_mapping shall return a negative value to completely ignore this usage
     727                 :            :  * (e.g. doubled or invalid usage), zero to continue with parsing of this
     728                 :            :  * usage by generic code (no special handling needed) or positive to skip
     729                 :            :  * generic parsing (needed special handling which was done in the hook already)
     730                 :            :  * input_mapped shall return negative to inform the layer that this usage
     731                 :            :  * should not be considered for further processing or zero to notify that
     732                 :            :  * no processing was performed and should be done in a generic manner
     733                 :            :  * Both these functions may be NULL which means the same behavior as returning
     734                 :            :  * zero from them.
     735                 :            :  */
     736                 :            : struct hid_driver {
     737                 :            :         char *name;
     738                 :            :         const struct hid_device_id *id_table;
     739                 :            : 
     740                 :            :         struct list_head dyn_list;
     741                 :            :         spinlock_t dyn_lock;
     742                 :            : 
     743                 :            :         bool (*match)(struct hid_device *dev, bool ignore_special_driver);
     744                 :            :         int (*probe)(struct hid_device *dev, const struct hid_device_id *id);
     745                 :            :         void (*remove)(struct hid_device *dev);
     746                 :            : 
     747                 :            :         const struct hid_report_id *report_table;
     748                 :            :         int (*raw_event)(struct hid_device *hdev, struct hid_report *report,
     749                 :            :                         u8 *data, int size);
     750                 :            :         const struct hid_usage_id *usage_table;
     751                 :            :         int (*event)(struct hid_device *hdev, struct hid_field *field,
     752                 :            :                         struct hid_usage *usage, __s32 value);
     753                 :            :         void (*report)(struct hid_device *hdev, struct hid_report *report);
     754                 :            : 
     755                 :            :         __u8 *(*report_fixup)(struct hid_device *hdev, __u8 *buf,
     756                 :            :                         unsigned int *size);
     757                 :            : 
     758                 :            :         int (*input_mapping)(struct hid_device *hdev,
     759                 :            :                         struct hid_input *hidinput, struct hid_field *field,
     760                 :            :                         struct hid_usage *usage, unsigned long **bit, int *max);
     761                 :            :         int (*input_mapped)(struct hid_device *hdev,
     762                 :            :                         struct hid_input *hidinput, struct hid_field *field,
     763                 :            :                         struct hid_usage *usage, unsigned long **bit, int *max);
     764                 :            :         int (*input_configured)(struct hid_device *hdev,
     765                 :            :                                 struct hid_input *hidinput);
     766                 :            :         void (*feature_mapping)(struct hid_device *hdev,
     767                 :            :                         struct hid_field *field,
     768                 :            :                         struct hid_usage *usage);
     769                 :            : #ifdef CONFIG_PM
     770                 :            :         int (*suspend)(struct hid_device *hdev, pm_message_t message);
     771                 :            :         int (*resume)(struct hid_device *hdev);
     772                 :            :         int (*reset_resume)(struct hid_device *hdev);
     773                 :            : #endif
     774                 :            : /* private: */
     775                 :            :         struct device_driver driver;
     776                 :            : };
     777                 :            : 
     778                 :            : #define to_hid_driver(pdrv) \
     779                 :            :         container_of(pdrv, struct hid_driver, driver)
     780                 :            : 
     781                 :            : /**
     782                 :            :  * hid_ll_driver - low level driver callbacks
     783                 :            :  * @start: called on probe to start the device
     784                 :            :  * @stop: called on remove
     785                 :            :  * @open: called by input layer on open
     786                 :            :  * @close: called by input layer on close
     787                 :            :  * @power: request underlying hardware to enter requested power mode
     788                 :            :  * @parse: this method is called only once to parse the device data,
     789                 :            :  *         shouldn't allocate anything to not leak memory
     790                 :            :  * @request: send report request to device (e.g. feature report)
     791                 :            :  * @wait: wait for buffered io to complete (send/recv reports)
     792                 :            :  * @raw_request: send raw report request to device (e.g. feature report)
     793                 :            :  * @output_report: send output report to device
     794                 :            :  * @idle: send idle request to device
     795                 :            :  */
     796                 :            : struct hid_ll_driver {
     797                 :            :         int (*start)(struct hid_device *hdev);
     798                 :            :         void (*stop)(struct hid_device *hdev);
     799                 :            : 
     800                 :            :         int (*open)(struct hid_device *hdev);
     801                 :            :         void (*close)(struct hid_device *hdev);
     802                 :            : 
     803                 :            :         int (*power)(struct hid_device *hdev, int level);
     804                 :            : 
     805                 :            :         int (*parse)(struct hid_device *hdev);
     806                 :            : 
     807                 :            :         void (*request)(struct hid_device *hdev,
     808                 :            :                         struct hid_report *report, int reqtype);
     809                 :            : 
     810                 :            :         int (*wait)(struct hid_device *hdev);
     811                 :            : 
     812                 :            :         int (*raw_request) (struct hid_device *hdev, unsigned char reportnum,
     813                 :            :                             __u8 *buf, size_t len, unsigned char rtype,
     814                 :            :                             int reqtype);
     815                 :            : 
     816                 :            :         int (*output_report) (struct hid_device *hdev, __u8 *buf, size_t len);
     817                 :            : 
     818                 :            :         int (*idle)(struct hid_device *hdev, int report, int idle, int reqtype);
     819                 :            : };
     820                 :            : 
     821                 :            : extern struct hid_ll_driver i2c_hid_ll_driver;
     822                 :            : extern struct hid_ll_driver hidp_hid_driver;
     823                 :            : extern struct hid_ll_driver uhid_hid_driver;
     824                 :            : extern struct hid_ll_driver usb_hid_driver;
     825                 :            : 
     826                 :            : static inline bool hid_is_using_ll_driver(struct hid_device *hdev,
     827                 :            :                 struct hid_ll_driver *driver)
     828                 :            : {
     829                 :            :         return hdev->ll_driver == driver;
     830                 :            : }
     831                 :            : 
     832                 :            : #define PM_HINT_FULLON  1<<5
     833                 :            : #define PM_HINT_NORMAL  1<<1
     834                 :            : 
     835                 :            : /* Applications from HID Usage Tables 4/8/99 Version 1.1 */
     836                 :            : /* We ignore a few input applications that are not widely used */
     837                 :            : #define IS_INPUT_APPLICATION(a) \
     838                 :            :                 (((a >= HID_UP_GENDESK) && (a <= HID_GD_MULTIAXIS)) \
     839                 :            :                 || ((a >= HID_DG_PEN) && (a <= HID_DG_WHITEBOARD)) \
     840                 :            :                 || (a == HID_GD_SYSTEM_CONTROL) || (a == HID_CP_CONSUMER_CONTROL) \
     841                 :            :                 || (a == HID_GD_WIRELESS_RADIO_CTLS))
     842                 :            : 
     843                 :            : /* HID core API */
     844                 :            : 
     845                 :            : extern int hid_debug;
     846                 :            : 
     847                 :            : extern bool hid_ignore(struct hid_device *);
     848                 :            : extern int hid_add_device(struct hid_device *);
     849                 :            : extern void hid_destroy_device(struct hid_device *);
     850                 :            : 
     851                 :            : extern struct bus_type hid_bus_type;
     852                 :            : 
     853                 :            : extern int __must_check __hid_register_driver(struct hid_driver *,
     854                 :            :                 struct module *, const char *mod_name);
     855                 :            : 
     856                 :            : /* use a define to avoid include chaining to get THIS_MODULE & friends */
     857                 :            : #define hid_register_driver(driver) \
     858                 :            :         __hid_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
     859                 :            : 
     860                 :            : extern void hid_unregister_driver(struct hid_driver *);
     861                 :            : 
     862                 :            : /**
     863                 :            :  * module_hid_driver() - Helper macro for registering a HID driver
     864                 :            :  * @__hid_driver: hid_driver struct
     865                 :            :  *
     866                 :            :  * Helper macro for HID drivers which do not do anything special in module
     867                 :            :  * init/exit. This eliminates a lot of boilerplate. Each module may only
     868                 :            :  * use this macro once, and calling it replaces module_init() and module_exit()
     869                 :            :  */
     870                 :            : #define module_hid_driver(__hid_driver) \
     871                 :            :         module_driver(__hid_driver, hid_register_driver, \
     872                 :            :                       hid_unregister_driver)
     873                 :            : 
     874                 :            : extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
     875                 :            : extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);
     876                 :            : extern int hidinput_connect(struct hid_device *hid, unsigned int force);
     877                 :            : extern void hidinput_disconnect(struct hid_device *);
     878                 :            : 
     879                 :            : int hid_set_field(struct hid_field *, unsigned, __s32);
     880                 :            : int hid_input_report(struct hid_device *, int type, u8 *, u32, int);
     881                 :            : int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field);
     882                 :            : struct hid_field *hidinput_get_led_field(struct hid_device *hid);
     883                 :            : unsigned int hidinput_count_leds(struct hid_device *hid);
     884                 :            : __s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code);
     885                 :            : void hid_output_report(struct hid_report *report, __u8 *data);
     886                 :            : int __hid_request(struct hid_device *hid, struct hid_report *rep, int reqtype);
     887                 :            : u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags);
     888                 :            : struct hid_device *hid_allocate_device(void);
     889                 :            : struct hid_report *hid_register_report(struct hid_device *device,
     890                 :            :                                        unsigned int type, unsigned int id,
     891                 :            :                                        unsigned int application);
     892                 :            : int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size);
     893                 :            : struct hid_report *hid_validate_values(struct hid_device *hid,
     894                 :            :                                        unsigned int type, unsigned int id,
     895                 :            :                                        unsigned int field_index,
     896                 :            :                                        unsigned int report_counts);
     897                 :            : 
     898                 :            : void hid_setup_resolution_multiplier(struct hid_device *hid);
     899                 :            : int hid_open_report(struct hid_device *device);
     900                 :            : int hid_check_keys_pressed(struct hid_device *hid);
     901                 :            : int hid_connect(struct hid_device *hid, unsigned int connect_mask);
     902                 :            : void hid_disconnect(struct hid_device *hid);
     903                 :            : bool hid_match_one_id(const struct hid_device *hdev,
     904                 :            :                       const struct hid_device_id *id);
     905                 :            : const struct hid_device_id *hid_match_id(const struct hid_device *hdev,
     906                 :            :                                          const struct hid_device_id *id);
     907                 :            : const struct hid_device_id *hid_match_device(struct hid_device *hdev,
     908                 :            :                                              struct hid_driver *hdrv);
     909                 :            : bool hid_compare_device_paths(struct hid_device *hdev_a,
     910                 :            :                               struct hid_device *hdev_b, char separator);
     911                 :            : s32 hid_snto32(__u32 value, unsigned n);
     912                 :            : __u32 hid_field_extract(const struct hid_device *hid, __u8 *report,
     913                 :            :                      unsigned offset, unsigned n);
     914                 :            : 
     915                 :            : /**
     916                 :            :  * hid_device_io_start - enable HID input during probe, remove
     917                 :            :  *
     918                 :            :  * @hid - the device
     919                 :            :  *
     920                 :            :  * This should only be called during probe or remove and only be
     921                 :            :  * called by the thread calling probe or remove. It will allow
     922                 :            :  * incoming packets to be delivered to the driver.
     923                 :            :  */
     924                 :          3 : static inline void hid_device_io_start(struct hid_device *hid) {
     925                 :          3 :         if (hid->io_started) {
     926                 :          0 :                 dev_warn(&hid->dev, "io already started\n");
     927                 :          3 :                 return;
     928                 :            :         }
     929                 :          3 :         hid->io_started = true;
     930                 :          3 :         up(&hid->driver_input_lock);
     931                 :            : }
     932                 :            : 
     933                 :            : /**
     934                 :            :  * hid_device_io_stop - disable HID input during probe, remove
     935                 :            :  *
     936                 :            :  * @hid - the device
     937                 :            :  *
     938                 :            :  * Should only be called after hid_device_io_start. It will prevent
     939                 :            :  * incoming packets from going to the driver for the duration of
     940                 :            :  * probe, remove. If called during probe, packets will still go to the
     941                 :            :  * driver after probe is complete. This function should only be called
     942                 :            :  * by the thread calling probe or remove.
     943                 :            :  */
     944                 :          3 : static inline void hid_device_io_stop(struct hid_device *hid) {
     945                 :          3 :         if (!hid->io_started) {
     946                 :          0 :                 dev_warn(&hid->dev, "io already stopped\n");
     947                 :          3 :                 return;
     948                 :            :         }
     949                 :          3 :         hid->io_started = false;
     950                 :          3 :         down(&hid->driver_input_lock);
     951                 :            : }
     952                 :            : 
     953                 :            : /**
     954                 :            :  * hid_map_usage - map usage input bits
     955                 :            :  *
     956                 :            :  * @hidinput: hidinput which we are interested in
     957                 :            :  * @usage: usage to fill in
     958                 :            :  * @bit: pointer to input->{}bit (out parameter)
     959                 :            :  * @max: maximal valid usage->code to consider later (out parameter)
     960                 :            :  * @type: input event type (EV_KEY, EV_REL, ...)
     961                 :            :  * @c: code which corresponds to this usage and type
     962                 :            :  */
     963                 :            : static inline void hid_map_usage(struct hid_input *hidinput,
     964                 :            :                 struct hid_usage *usage, unsigned long **bit, int *max,
     965                 :            :                 __u8 type, __u16 c)
     966                 :            : {
     967                 :          3 :         struct input_dev *input = hidinput->input;
     968                 :            : 
     969                 :          3 :         usage->type = type;
     970                 :          3 :         usage->code = c;
     971                 :            : 
     972                 :          3 :         switch (type) {
     973                 :            :         case EV_ABS:
     974                 :          2 :                 *bit = input->absbit;
     975                 :          2 :                 *max = ABS_MAX;
     976                 :            :                 break;
     977                 :            :         case EV_REL:
     978                 :          3 :                 *bit = input->relbit;
     979                 :          3 :                 *max = REL_MAX;
     980                 :            :                 break;
     981                 :            :         case EV_KEY:
     982                 :          3 :                 *bit = input->keybit;
     983                 :          3 :                 *max = KEY_MAX;
     984                 :            :                 break;
     985                 :            :         case EV_LED:
     986                 :          3 :                 *bit = input->ledbit;
     987                 :          3 :                 *max = LED_MAX;
     988                 :            :                 break;
     989                 :            :         }
     990                 :            : }
     991                 :            : 
     992                 :            : /**
     993                 :            :  * hid_map_usage_clear - map usage input bits and clear the input bit
     994                 :            :  *
     995                 :            :  * The same as hid_map_usage, except the @c bit is also cleared in supported
     996                 :            :  * bits (@bit).
     997                 :            :  */
     998                 :          3 : static inline void hid_map_usage_clear(struct hid_input *hidinput,
     999                 :            :                 struct hid_usage *usage, unsigned long **bit, int *max,
    1000                 :            :                 __u8 type, __u16 c)
    1001                 :            : {
    1002                 :            :         hid_map_usage(hidinput, usage, bit, max, type, c);
    1003                 :          3 :         clear_bit(c, *bit);
    1004                 :          3 : }
    1005                 :            : 
    1006                 :            : /**
    1007                 :            :  * hid_parse - parse HW reports
    1008                 :            :  *
    1009                 :            :  * @hdev: hid device
    1010                 :            :  *
    1011                 :            :  * Call this from probe after you set up the device (if needed). Your
    1012                 :            :  * report_fixup will be called (if non-NULL) after reading raw report from
    1013                 :            :  * device before passing it to hid layer for real parsing.
    1014                 :            :  */
    1015                 :            : static inline int __must_check hid_parse(struct hid_device *hdev)
    1016                 :            : {
    1017                 :          3 :         return hid_open_report(hdev);
    1018                 :            : }
    1019                 :            : 
    1020                 :            : int __must_check hid_hw_start(struct hid_device *hdev,
    1021                 :            :                               unsigned int connect_mask);
    1022                 :            : void hid_hw_stop(struct hid_device *hdev);
    1023                 :            : int __must_check hid_hw_open(struct hid_device *hdev);
    1024                 :            : void hid_hw_close(struct hid_device *hdev);
    1025                 :            : 
    1026                 :            : /**
    1027                 :            :  * hid_hw_power - requests underlying HW to go into given power mode
    1028                 :            :  *
    1029                 :            :  * @hdev: hid device
    1030                 :            :  * @level: requested power level (one of %PM_HINT_* defines)
    1031                 :            :  *
    1032                 :            :  * This function requests underlying hardware to enter requested power
    1033                 :            :  * mode.
    1034                 :            :  */
    1035                 :            : 
    1036                 :            : static inline int hid_hw_power(struct hid_device *hdev, int level)
    1037                 :            : {
    1038                 :          0 :         return hdev->ll_driver->power ? hdev->ll_driver->power(hdev, level) : 0;
    1039                 :            : }
    1040                 :            : 
    1041                 :            : 
    1042                 :            : /**
    1043                 :            :  * hid_hw_request - send report request to device
    1044                 :            :  *
    1045                 :            :  * @hdev: hid device
    1046                 :            :  * @report: report to send
    1047                 :            :  * @reqtype: hid request type
    1048                 :            :  */
    1049                 :          0 : static inline void hid_hw_request(struct hid_device *hdev,
    1050                 :            :                                   struct hid_report *report, int reqtype)
    1051                 :            : {
    1052                 :          0 :         if (hdev->ll_driver->request)
    1053                 :          0 :                 return hdev->ll_driver->request(hdev, report, reqtype);
    1054                 :            : 
    1055                 :          0 :         __hid_request(hdev, report, reqtype);
    1056                 :            : }
    1057                 :            : 
    1058                 :            : /**
    1059                 :            :  * hid_hw_raw_request - send report request to device
    1060                 :            :  *
    1061                 :            :  * @hdev: hid device
    1062                 :            :  * @reportnum: report ID
    1063                 :            :  * @buf: in/out data to transfer
    1064                 :            :  * @len: length of buf
    1065                 :            :  * @rtype: HID report type
    1066                 :            :  * @reqtype: HID_REQ_GET_REPORT or HID_REQ_SET_REPORT
    1067                 :            :  *
    1068                 :            :  * @return: count of data transfered, negative if error
    1069                 :            :  *
    1070                 :            :  * Same behavior as hid_hw_request, but with raw buffers instead.
    1071                 :            :  */
    1072                 :            : static inline int hid_hw_raw_request(struct hid_device *hdev,
    1073                 :            :                                   unsigned char reportnum, __u8 *buf,
    1074                 :            :                                   size_t len, unsigned char rtype, int reqtype)
    1075                 :            : {
    1076                 :          0 :         if (len < 1 || len > HID_MAX_BUFFER_SIZE || !buf)
    1077                 :            :                 return -EINVAL;
    1078                 :            : 
    1079                 :          0 :         return hdev->ll_driver->raw_request(hdev, reportnum, buf, len,
    1080                 :            :                                                     rtype, reqtype);
    1081                 :            : }
    1082                 :            : 
    1083                 :            : /**
    1084                 :            :  * hid_hw_output_report - send output report to device
    1085                 :            :  *
    1086                 :            :  * @hdev: hid device
    1087                 :            :  * @buf: raw data to transfer
    1088                 :            :  * @len: length of buf
    1089                 :            :  *
    1090                 :            :  * @return: count of data transfered, negative if error
    1091                 :            :  */
    1092                 :            : static inline int hid_hw_output_report(struct hid_device *hdev, __u8 *buf,
    1093                 :            :                                         size_t len)
    1094                 :            : {
    1095                 :          0 :         if (len < 1 || len > HID_MAX_BUFFER_SIZE || !buf)
    1096                 :            :                 return -EINVAL;
    1097                 :            : 
    1098                 :          0 :         if (hdev->ll_driver->output_report)
    1099                 :          0 :                 return hdev->ll_driver->output_report(hdev, buf, len);
    1100                 :            : 
    1101                 :            :         return -ENOSYS;
    1102                 :            : }
    1103                 :            : 
    1104                 :            : /**
    1105                 :            :  * hid_hw_idle - send idle request to device
    1106                 :            :  *
    1107                 :            :  * @hdev: hid device
    1108                 :            :  * @report: report to control
    1109                 :            :  * @idle: idle state
    1110                 :            :  * @reqtype: hid request type
    1111                 :            :  */
    1112                 :            : static inline int hid_hw_idle(struct hid_device *hdev, int report, int idle,
    1113                 :            :                 int reqtype)
    1114                 :            : {
    1115                 :            :         if (hdev->ll_driver->idle)
    1116                 :            :                 return hdev->ll_driver->idle(hdev, report, idle, reqtype);
    1117                 :            : 
    1118                 :            :         return 0;
    1119                 :            : }
    1120                 :            : 
    1121                 :            : /**
    1122                 :            :  * hid_hw_wait - wait for buffered io to complete
    1123                 :            :  *
    1124                 :            :  * @hdev: hid device
    1125                 :            :  */
    1126                 :            : static inline void hid_hw_wait(struct hid_device *hdev)
    1127                 :            : {
    1128                 :          0 :         if (hdev->ll_driver->wait)
    1129                 :          0 :                 hdev->ll_driver->wait(hdev);
    1130                 :            : }
    1131                 :            : 
    1132                 :            : /**
    1133                 :            :  * hid_report_len - calculate the report length
    1134                 :            :  *
    1135                 :            :  * @report: the report we want to know the length
    1136                 :            :  */
    1137                 :            : static inline u32 hid_report_len(struct hid_report *report)
    1138                 :            : {
    1139                 :            :         /* equivalent to DIV_ROUND_UP(report->size, 8) + !!(report->id > 0) */
    1140                 :          3 :         return ((report->size - 1) >> 3) + 1 + (report->id > 0);
    1141                 :            : }
    1142                 :            : 
    1143                 :            : int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size,
    1144                 :            :                 int interrupt);
    1145                 :            : 
    1146                 :            : /* HID quirks API */
    1147                 :            : unsigned long hid_lookup_quirk(const struct hid_device *hdev);
    1148                 :            : int hid_quirks_init(char **quirks_param, __u16 bus, int count);
    1149                 :            : void hid_quirks_exit(__u16 bus);
    1150                 :            : 
    1151                 :            : #ifdef CONFIG_HID_PID
    1152                 :            : int hid_pidff_init(struct hid_device *hid);
    1153                 :            : #else
    1154                 :            : #define hid_pidff_init NULL
    1155                 :            : #endif
    1156                 :            : 
    1157                 :            : #define dbg_hid(fmt, ...)                                               \
    1158                 :            : do {                                                                    \
    1159                 :            :         if (hid_debug)                                                  \
    1160                 :            :                 printk(KERN_DEBUG "%s: " fmt, __FILE__, ##__VA_ARGS__);       \
    1161                 :            : } while (0)
    1162                 :            : 
    1163                 :            : #define hid_err(hid, fmt, ...)                          \
    1164                 :            :         dev_err(&(hid)->dev, fmt, ##__VA_ARGS__)
    1165                 :            : #define hid_notice(hid, fmt, ...)                       \
    1166                 :            :         dev_notice(&(hid)->dev, fmt, ##__VA_ARGS__)
    1167                 :            : #define hid_warn(hid, fmt, ...)                         \
    1168                 :            :         dev_warn(&(hid)->dev, fmt, ##__VA_ARGS__)
    1169                 :            : #define hid_info(hid, fmt, ...)                         \
    1170                 :            :         dev_info(&(hid)->dev, fmt, ##__VA_ARGS__)
    1171                 :            : #define hid_dbg(hid, fmt, ...)                          \
    1172                 :            :         dev_dbg(&(hid)->dev, fmt, ##__VA_ARGS__)
    1173                 :            : 
    1174                 :            : #define hid_err_once(hid, fmt, ...)                     \
    1175                 :            :         dev_err_once(&(hid)->dev, fmt, ##__VA_ARGS__)
    1176                 :            : #define hid_notice_once(hid, fmt, ...)                  \
    1177                 :            :         dev_notice_once(&(hid)->dev, fmt, ##__VA_ARGS__)
    1178                 :            : #define hid_warn_once(hid, fmt, ...)                    \
    1179                 :            :         dev_warn_once(&(hid)->dev, fmt, ##__VA_ARGS__)
    1180                 :            : #define hid_info_once(hid, fmt, ...)                    \
    1181                 :            :         dev_info_once(&(hid)->dev, fmt, ##__VA_ARGS__)
    1182                 :            : #define hid_dbg_once(hid, fmt, ...)                     \
    1183                 :            :         dev_dbg_once(&(hid)->dev, fmt, ##__VA_ARGS__)
    1184                 :            : 
    1185                 :            : #endif
    

Generated by: LCOV version 1.14