documentation/api/hid_8h_source.html

/*

 * This file is part of the Ultibo project, https://ultibo.org/

 *

 * The MIT License (MIT)

 *

 * Copyright (c) 2026 Garry Wood <garry@softoz.com.au>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#ifndef _ULTIBO_HID_H

#define _ULTIBO_HID_H


#ifdef __cplusplus

extern "C" {

#endif


#include "ultibo/globaltypes.h"

#include "ultibo/globalconst.h"

#include "ultibo/devices.h"


#define HID_NAME_PREFIX "HID"


#define HID_TYPE_NONE   0

#define HID_TYPE_USB    1


#define HID_TYPE_MAX    1


#define HID_STATE_DETACHED  0

#define HID_STATE_DETACHING 1

#define HID_STATE_ATTACHING 2

#define HID_STATE_ATTACHED  3


#define HID_STATE_MAX   3


#define HID_FLAG_NONE   0x00000000


#define HID_SUBCLASS_NONE   0

#define HID_SUBCLASS_BOOT   1


#define HID_BOOT_PROTOCOL_NONE  0

#define HID_BOOT_PROTOCOL_KEYBOARD  1

#define HID_BOOT_PROTOCOL_MOUSE 2


#define HID_DESCRIPTOR_TYPE_HID 0x21

#define HID_DESCRIPTOR_TYPE_REPORT  0x22

#define HID_DESCRIPTOR_TYPE_PHYSICAL_DESCRIPTOR 0x23


#define HID_REQUEST_GET_REPORT  0x01

#define HID_REQUEST_GET_IDLE    0x02

#define HID_REQUEST_GET_PROTOCOL    0x03

#define HID_REQUEST_SET_REPORT  0x09

#define HID_REQUEST_SET_IDLE    0x0A

#define HID_REQUEST_SET_PROTOCOL    0x0B


#define HID_PROTOCOL_BOOT   0

#define HID_PROTOCOL_REPORT 1


#define HID_REPORT_INPUT    1

#define HID_REPORT_OUTPUT   2

#define HID_REPORT_FEATURE  3


#define HID_REPORTID_NONE   0


#define HID_SIZE_0  (0 << 0)

#define HID_SIZE_1  (1 << 0)

#define HID_SIZE_2  (2 << 0)

#define HID_SIZE_4  (3 << 0)

#define HID_SIZE_MASK   0x03


#define HID_TYPE_MAIN   (0 << 2)

#define HID_TYPE_GLOBAL (1 << 2)

#define HID_TYPE_LOCAL  (2 << 2)

#define HID_TYPE_RESERVED   (3 << 2)

#define HID_TYPE_MASK   0x0C


#define HID_TAG_MAIN_INPUT  0x80

#define HID_TAG_MAIN_OUTPUT 0x90

#define HID_TAG_MAIN_FEATURE    0xB0

#define HID_TAG_MAIN_COLLECTION 0xA0

#define HID_TAG_MAIN_END_COLLECTION 0xC0


#define HID_TAG_GLOBAL_USAGE_PAGE   0x04

#define HID_TAG_GLOBAL_LOGICAL_MINIMUM  0x14

#define HID_TAG_GLOBAL_LOGICAL_MAXIMUM  0x24

#define HID_TAG_GLOBAL_PHYSICAL_MINIMUM 0x34

#define HID_TAG_GLOBAL_PHYSICAL_MAXIMUM 0x44

#define HID_TAG_GLOBAL_UNIT_EXPONENT    0x54

#define HID_TAG_GLOBAL_UNIT 0x64

#define HID_TAG_GLOBAL_REPORT_SIZE  0x74

#define HID_TAG_GLOBAL_REPORT_ID    0x84

#define HID_TAG_GLOBAL_REPORT_COUNT 0x94

#define HID_TAG_GLOBAL_PUSH 0xA4

#define HID_TAG_GLOBAL_POP  0xB4


#define HID_TAG_LOCAL_USAGE 0x08

#define HID_TAG_LOCAL_USAGE_MINIMUM 0x18

#define HID_TAG_LOCAL_USAGE_MAXIMUM 0x28

#define HID_TAG_LOCAL_DESIGNATOR_INDEX  0x38

#define HID_TAG_LOCAL_DESIGNATOR_MINIMUM    0x48

#define HID_TAG_LOCAL_DESIGNATOR_MAXIMUM    0x58

#define HID_TAG_LOCAL_STRING_INDEX  0x78

#define HID_TAG_LOCAL_STRING_MINIMUM    0x88

#define HID_TAG_LOCAL_STRING_MAXIMUM    0x98

#define HID_TAG_LOCAL_DELIMITER 0xA8


#define HID_TAG_LONG    0xFC

#define HID_TAG_MASK    0xFC


#define HID_MAIN_ITEM_CONSTANT  (1 << 0)

#define HID_MAIN_ITEM_VARIABLE  (1 << 1)

#define HID_MAIN_ITEM_RELATIVE  (1 << 2)

#define HID_MAIN_ITEM_WRAP  (1 << 3)

#define HID_MAIN_ITEM_NON_LINEAR    (1 << 4)

#define HID_MAIN_ITEM_NO_PREFERRED  (1 << 5)

#define HID_MAIN_ITEM_NULL_STATE    (1 << 6)

#define HID_MAIN_ITEM_RESERVED1 (1 << 7)

#define HID_MAIN_ITEM_BUFFERED_BYTES    (1 << 8)

#define HID_MAIN_ITEM_RESERVED2 (0xFFFFFE00 << 9)


#define HID_MAIN_COLLECTION_PHYSICAL    0x00

#define HID_MAIN_COLLECTION_APPLICATION 0x01

#define HID_MAIN_COLLECTION_LOGICAL 0x02

#define HID_MAIN_COLLECTION_REPORT  0x03

#define HID_MAIN_COLLECTION_NAMED_ARRAY 0x04

#define HID_MAIN_COLLECTION_USAGE_SWITCH    0x05

#define HID_MAIN_COLLECTION_USAGE_MODIFIER  0x06


#define HID_GLOBAL_UNIT_SYSTEM_MASK 0xF

#define HID_GLOBAL_UNIT_SYSTEM_SHIFT    0


#define HID_GLOBAL_UNIT_SYSTEM_NONE 0

#define HID_GLOBAL_UNIT_SYSTEM_SI_LINEAR    1

#define HID_GLOBAL_UNIT_SYSTEM_SI_ROTATION  2

#define HID_GLOBAL_UNIT_SYSTEM_ENGLISH_LINEAR   3

#define HID_GLOBAL_UNIT_SYSTEM_ENGLISH_ROTATION 4


#define HID_GLOBAL_UNIT_LENGTH_MASK 0xF

#define HID_GLOBAL_UNIT_LENGTH_SHIFT    4


#define HID_GLOBAL_UNIT_ROTATION_MASK   0xF

#define HID_GLOBAL_UNIT_ROTATION_SHIFT  4


#define HID_GLOBAL_UNIT_MASS_MASK   0xF

#define HID_GLOBAL_UNIT_MASS_SHIFT  8


#define HID_GLOBAL_UNIT_TIME_MASK   0xF

#define HID_GLOBAL_UNIT_TIME_SHIFT  12


#define HID_GLOBAL_UNIT_TEMPERATURE_MASK    0xF

#define HID_GLOBAL_UNIT_TEMPERATURE_SHIFT   16


#define HID_GLOBAL_UNIT_CURRENT_MASK    0xF

#define HID_GLOBAL_UNIT_CURRENT_SHIFT   20


#define HID_GLOBAL_UNIT_LIGHT_MASK  0xF

#define HID_GLOBAL_UNIT_LIGHT_SHIFT 24


#define HID_GLOBAL_UNIT_SI_ROTATION 0x00000012

#define HID_GLOBAL_UNIT_SI_LENGTH   0x00000011

#define HID_GLOBAL_UNIT_SI_MASS 0x00000101

#define HID_GLOBAL_UNIT_SI_TIME 0x00001001

#define HID_GLOBAL_UNIT_SI_TEMPERATURE  0x00010001

#define HID_GLOBAL_UNIT_SI_CURRENT  0x00100001

#define HID_GLOBAL_UNIT_SI_LIGHT    0x01000001


#define HID_GLOBAL_UNIT_SI_AREA 0x00000021

#define HID_GLOBAL_UNIT_SI_VOLUME   0x00000031

#define HID_GLOBAL_UNIT_SI_VELOCITY 0x0000F011

#define HID_GLOBAL_UNIT_SI_ACCELERATION 0x0000E011


#define HID_GLOBAL_UNIT_SI_FREQUENCY    0x0000F001

#define HID_GLOBAL_UNIT_SI_FORCE    0x0000E111

#define HID_GLOBAL_UNIT_SI_PRESSURE 0x0000E1F1

#define HID_GLOBAL_UNIT_SI_ENERGY   0x0000E121

#define HID_GLOBAL_UNIT_SI_POWER    0x0000D121


#define HID_GLOBAL_UNIT_ENGLISH_ROTATION    0x00000014

#define HID_GLOBAL_UNIT_ENGLISH_LENGTH  0x00000013

#define HID_GLOBAL_UNIT_ENGLISH_TIME    0x00001003

#define HID_GLOBAL_UNIT_ENGLISH_TEMPERATURE 0x00010003

#define HID_GLOBAL_UNIT_ENGLISH_CURRENT 0x00100003

#define HID_GLOBAL_UNIT_ENGLISH_LIGHT   0x01000003


#define HID_GLOBAL_UNIT_ENGLISH_AREA    0x00000023

#define HID_GLOBAL_UNIT_ENGLISH_VOLUME  0x00000033


static const unsigned int HID_GLOBAL_UNIT_EXPONENTS[0x10] = {

    0,

    1,

    2,

    3,

    4,

    5,

    6,

    7,

    -8,

    -7,

    -6,

    -5,

    -4,

    -3,

    -2,

    -1};


static const double_t HID_GLOBAL_UNIT_MULTIPLIERS[0x10] = {

    1,

    10,

    100,

    1000,

    10000,

    100000,

    1000000,

    10000000,

    0.00000001,

    0.0000001,

    0.000001,

    0.00001,

    0.0001,

    0.001,

    0.01,

    0.1};


#define HID_LOCAL_DELIMITER_CLOSE   0

#define HID_LOCAL_DELIMITER_OPEN    1


#define HID_PHYSICAL_BIAS_NONE  (0 << 5)

#define HID_PHYSICAL_BIAS_RIGHT_HAND    (1 << 5)

#define HID_PHYSICAL_BIAS_LEFT_HAND (2 << 5)

#define HID_PHYSICAL_BIAS_BOTH_HANDS    (3 << 5)

#define HID_PHYSICAL_BIAS_EITHER_HAND   (4 << 5)


#define HID_PHYSICAL_DESIGNATOR_NONE    0x00

#define HID_PHYSICAL_DESIGNATOR_HAND    0x01

#define HID_PHYSICAL_DESIGNATOR_EYEBALL 0x02

#define HID_PHYSICAL_DESIGNATOR_EYEBROW 0x03

#define HID_PHYSICAL_DESIGNATOR_EYELID  0x04

#define HID_PHYSICAL_DESIGNATOR_EAR 0x05

#define HID_PHYSICAL_DESIGNATOR_NOSE    0x06

#define HID_PHYSICAL_DESIGNATOR_MOUTH   0x07

#define HID_PHYSICAL_DESIGNATOR_UPPER_LIP   0x08

#define HID_PHYSICAL_DESIGNATOR_LOWER_LIP   0x09

#define HID_PHYSICAL_DESIGNATOR_JAW 0x0A

#define HID_PHYSICAL_DESIGNATOR_NECK    0x0B

#define HID_PHYSICAL_DESIGNATOR_UPPER_ARM   0x0C

#define HID_PHYSICAL_DESIGNATOR_ELBOW   0x0D

#define HID_PHYSICAL_DESIGNATOR_FOREARM 0x0E

#define HID_PHYSICAL_DESIGNATOR_WRIST   0x0F

#define HID_PHYSICAL_DESIGNATOR_PALM    0x10

#define HID_PHYSICAL_DESIGNATOR_THUMB   0x11

#define HID_PHYSICAL_DESIGNATOR_INDEX_FINGER    0x12

#define HID_PHYSICAL_DESIGNATOR_MIDDLE_FINGER   0x13

#define HID_PHYSICAL_DESIGNATOR_RING_FINGER 0x14

#define HID_PHYSICAL_DESIGNATOR_LITTLE_FINGER   0x15

#define HID_PHYSICAL_DESIGNATOR_HEAD    0x16

#define HID_PHYSICAL_DESIGNATOR_SHOULDER    0x17

#define HID_PHYSICAL_DESIGNATOR_HIP 0x18

#define HID_PHYSICAL_DESIGNATOR_WAIST   0x19

#define HID_PHYSICAL_DESIGNATOR_THIGH   0x1A

#define HID_PHYSICAL_DESIGNATOR_KNEE    0x1B

#define HID_PHYSICAL_DESIGNATOR_CALF    0x1C

#define HID_PHYSICAL_DESIGNATOR_ANKLE   0x1D

#define HID_PHYSICAL_DESIGNATOR_FOOT    0x1E

#define HID_PHYSICAL_DESIGNATOR_HEEL    0x1F

#define HID_PHYSICAL_DESIGNATOR_BALL_OF_FOOT    0x20

#define HID_PHYSICAL_DESIGNATOR_BIG_TOE 0x21

#define HID_PHYSICAL_DESIGNATOR_SECOND_TOE  0x22

#define HID_PHYSICAL_DESIGNATOR_THIRD_TOE   0x23

#define HID_PHYSICAL_DESIGNATOR_FOURTH_TOE  0x24

#define HID_PHYSICAL_DESIGNATOR_LITTLE_TOE  0x25

#define HID_PHYSICAL_DESIGNATOR_BROW    0x26

#define HID_PHYSICAL_DESIGNATOR_CHEEK   0x27


#define HID_PHYSICAL_QUALIFIER_NONE (0 << 5)

#define HID_PHYSICAL_QUALIFIER_RIGHT    (1 << 5)

#define HID_PHYSICAL_QUALIFIER_LEFT (2 << 5)

#define HID_PHYSICAL_QUALIFIER_BOTH (3 << 5)

#define HID_PHYSICAL_QUALIFIER_EITHER   (4 << 5)

#define HID_PHYSICAL_QUALIFIER_CENTER   (5 << 5)


#define HID_PAGE_UNDEFINED  0x00

#define HID_PAGE_GENERIC_DESKTOP    0x01

#define HID_PAGE_SIMULATION_CONTROLS    0x02

#define HID_PAGE_VR_CONTROLS    0x03

#define HID_PAGE_SPORT_CONTROLS 0x04

#define HID_PAGE_GAME_CONTROLS  0x05

#define HID_PAGE_GENERIC_DEVICE_CONTROLS    0x06

#define HID_PAGE_KEYBOARD_KEYPAD    0x07

#define HID_PAGE_LED    0x08

#define HID_PAGE_BUTTON 0x09

#define HID_PAGE_ORDINAL    0x0A

#define HID_PAGE_TELEPHONY_DEVICE   0x0B

#define HID_PAGE_CONSUMER   0x0C

#define HID_PAGE_DIGITIZERS 0x0D

#define HID_PAGE_HAPTICS    0x0E

#define HID_PAGE_PHYSICAL_INPUT_DEVICE  0x0F

#define HID_PAGE_UNICODE    0x10

#define HID_PAGE_EYE_AND_HEAD_TRACKERS  0x12

#define HID_PAGE_AUXILIARY_DISPLAY  0x14

#define HID_PAGE_SENSORS    0x20

#define HID_PAGE_MEDICAL_INSTRUMENT 0x40

#define HID_PAGE_BRAILLE_DISPLAY    0x41

#define HID_PAGE_LIGHTING_AND_ILLUMINATION  0x59

#define HID_PAGE_MONITOR    0x80

#define HID_PAGE_MONITOR_ENUMERATED 0x81

#define HID_PAGE_VESA_VIRTUAL_CONTROLS  0x82

#define HID_PAGE_POWER  0x84

#define HID_PAGE_BATTERY_SYSTEM 0x85

#define HID_PAGE_BARCODE_SCANNER    0x8C

#define HID_PAGE_SCALES 0x8D

#define HID_PAGE_MAGNETIC_STRIPE_READER 0x8E

#define HID_PAGE_CAMERA_CONTROL 0x90

#define HID_PAGE_ARCADE 0x91

#define HID_PAGE_GAMING_DEVICE  0x92

#define HID_PAGE_FIDO_ALLIANCE  0xF1D0

#define HID_PAGE_VENDOR_MINIMUM 0xFF00

#define HID_PAGE_VENDOR_MAXIMUM 0xFFFF


#define HID_DESKTOP_UNDEFINED   0x00

#define HID_DESKTOP_POINTER 0x01

#define HID_DESKTOP_MOUSE   0x02

#define HID_DESKTOP_JOYSTICK    0x04

#define HID_DESKTOP_GAMEPAD 0x05

#define HID_DESKTOP_KEYBOARD    0x06

#define HID_DESKTOP_KEYPAD  0x07

#define HID_DESKTOP_MULTI_AXIS_CONTROLLER   0x08

#define HID_DESKTOP_TABLET_PC_SYSTEM_CONTROLS   0x09

#define HID_DESKTOP_WATER_COOLING_DEVICE    0x0A

#define HID_DESKTOP_COMPUTER_CHASSIS_DEVICE 0x0B

#define HID_DESKTOP_WIRELESS_RADIO_CONTROLS 0x0C

#define HID_DESKTOP_PORTABLE_DEVICE_CONTROL 0x0D

#define HID_DESKTOP_SYSTEM_MULTI_AXIS_CONTROLLER    0x0E

#define HID_DESKTOP_SPATIAL_CONTROLLER  0x0F

#define HID_DESKTOP_ASSISTIVE_CONTROL   0x10

#define HID_DESKTOP_DEVICE_DOCK 0x11

#define HID_DESKTOP_DOCKABLE_DEVICE 0x12

#define HID_DESKTOP_CALL_STATE_MANAGEMENT_CONTROL   0x13

#define HID_DESKTOP_X   0x30

#define HID_DESKTOP_Y   0x31

#define HID_DESKTOP_Z   0x32

#define HID_DESKTOP_RX  0x33

#define HID_DESKTOP_RY  0x34

#define HID_DESKTOP_RZ  0x35

#define HID_DESKTOP_SLIDER  0x36

#define HID_DESKTOP_DIAL    0x37

#define HID_DESKTOP_WHEEL   0x38

#define HID_DESKTOP_HAT_SWITCH  0x39

#define HID_DESKTOP_COUNTED_BUFFER  0x3A

#define HID_DESKTOP_BYTE_COUNT  0x3B

#define HID_DESKTOP_MOTION_WAKEUP   0x3C

#define HID_DESKTOP_START   0x3D

#define HID_DESKTOP_SELECT  0x3E

#define HID_DESKTOP_VX  0x40

#define HID_DESKTOP_VY  0x41

#define HID_DESKTOP_VZ  0x42

#define HID_DESKTOP_VBRX    0x43

#define HID_DESKTOP_VBRY    0x44

#define HID_DESKTOP_VBRZ    0x45

#define HID_DESKTOP_VNO 0x46

#define HID_DESKTOP_FEATURE_NOTIFICATION    0x47

#define HID_DESKTOP_RESOLUTION_MULTIPLIER   0x48

#define HID_DESKTOP_QX  0x49

#define HID_DESKTOP_QY  0x4A

#define HID_DESKTOP_QZ  0x4B

#define HID_DESKTOP_QW  0x4C


#define HID_LED_UNDEFINED   00

#define HID_LED_NUM_LOCK    01

#define HID_LED_CAPS_LOCK   02

#define HID_LED_SCROLL_LOCK 03

#define HID_LED_COMPOSE 04

#define HID_LED_KANA    05

#define HID_LED_POWER   06

#define HID_LED_SHIFT   07

#define HID_LED_DO_NOT_DISTURB  08

#define HID_LED_MUTE    09


#define HID_BUTTON_NONE 0

#define HID_BUTTON_1    1

#define HID_BUTTON_2    2

#define HID_BUTTON_3    3

#define HID_BUTTON_4    4

#define HID_BUTTON_5    5

#define HID_BUTTON_PRIMARY  HID_BUTTON_1

#define HID_BUTTON_SECONDARY    HID_BUTTON_2

#define HID_BUTTON_TERTIARY HID_BUTTON_3

#define HID_BUTTON_65535    0xFFFF


#define HID_DIGITIZERS_UNDEFINED    0x00

#define HID_DIGITIZERS_DIGITIZER    0x01

#define HID_DIGITIZERS_PEN  0x02

#define HID_DIGITIZERS_LIGHT_PEN    0x03

#define HID_DIGITIZERS_TOUCH_SCREEN 0x04

#define HID_DIGITIZERS_TOUCH_PAD    0x05

#define HID_DIGITIZERS_WHITEBOARD   0x06

#define HID_DIGITIZERS_COORD_MEASURING  0x07

#define HID_DIGITIZERS_3D_DIGITIZER 0x08

#define HID_DIGITIZERS_STEREO_PLOTTER   0x09

#define HID_DIGITIZERS_ARTICULATED_ARM  0x0A

#define HID_DIGITIZERS_ARMATURE 0x0B

#define HID_DIGITIZERS_MULTI_POINT_DIGITIZER    0x0C

#define HID_DIGITIZERS_FREE_SPACE_WAND  0x0D

#define HID_DIGITIZERS_DEVICE_CONFIGURATION 0x0E

#define HID_DIGITIZERS_CAPACITIVE_HEAT_MAP  0x0F

#define HID_DIGITIZERS_STYLUS   0x20

#define HID_DIGITIZERS_PUCK 0x21

#define HID_DIGITIZERS_FINGER   0x22

#define HID_DIGITIZERS_DEVICE_SETTINGS  0x23

#define HID_DIGITIZERS_CHARACTER_GESTURE    0x24

#define HID_DIGITIZERS_TIP_PRESSURE 0x30

#define HID_DIGITIZERS_BARREL_PRESSURE  0x31

#define HID_DIGITIZERS_IN_RANGE 0x32

#define HID_DIGITIZERS_TOUCH    0x33

#define HID_DIGITIZERS_UNTOUCH  0x34

#define HID_DIGITIZERS_TAP  0x35

#define HID_DIGITIZERS_QUALITY  0x36

#define HID_DIGITIZERS_DATA_VALID   0x37

#define HID_DIGITIZERS_TRANSDUCER_INDEX 0x38

#define HID_DIGITIZERS_TABLET_FUNCTION_KEYS 0x39

#define HID_DIGITIZERS_PROGRAM_CHANGE_KEYS  0x3A

#define HID_DIGITIZERS_BATTERY_STRENGTH 0x3B

#define HID_DIGITIZERS_INVERT   0x3C

#define HID_DIGITIZERS_X_TILT   0x3D

#define HID_DIGITIZERS_Y_TILT   0x3E

#define HID_DIGITIZERS_AZIMUTH  0x3F

#define HID_DIGITIZERS_ALTITUDE 0x40

#define HID_DIGITIZERS_TWIST    0x41

#define HID_DIGITIZERS_TIP_SWITCH   0x42

#define HID_DIGITIZERS_SECONDARY_TIP_SWITCH 0x43

#define HID_DIGITIZERS_BARREL_SWITCH    0x44

#define HID_DIGITIZERS_ERASER   0x45

#define HID_DIGITIZERS_TABLET_PICK  0x46

#define HID_DIGITIZERS_TOUCH_VALID  0x47

#define HID_DIGITIZERS_WIDTH    0x48

#define HID_DIGITIZERS_HEIGHT   0x49

#define HID_DIGITIZERS_CONTACT_IDENTIFIER   0x51

#define HID_DIGITIZERS_DEVICE_MODE  0x52

#define HID_DIGITIZERS_DEVICE_IDENTIFIER    0x53

#define HID_DIGITIZERS_CONTACT_COUNT    0x54

#define HID_DIGITIZERS_CONTACT_COUNT_MAXIMUM    0x55

#define HID_DIGITIZERS_SCAN_TIME    0x56


typedef struct _HID_DESCRIPTOR HID_DESCRIPTOR;


struct _HID_DESCRIPTOR

{

    uint8_t blength;

    uint8_t bdescriptortype;

    uint16_t bcdhid;

    uint8_t bcountrycode;

    uint8_t bnumdescriptors;

    uint8_t bhiddescriptortype;

    uint16_t whiddescriptorlength;

    // Note: Up to two optional bHIDDescriptorType/wHIDDescriptorLength pairs after the Report descriptor details

} PACKED;


typedef void HID_REPORT_DESCRIPTOR;


typedef struct _HID_PHYSICAL_DESCRIPTOR HID_PHYSICAL_DESCRIPTOR;


struct _HID_PHYSICAL_DESCRIPTOR

{

    uint8_t bdesignator;

    uint8_t bflags;

} PACKED;


typedef struct _HID_PHYSICAL_DESCRIPTOR_SET0 HID_PHYSICAL_DESCRIPTOR_SET0;


struct _HID_PHYSICAL_DESCRIPTOR_SET0

{

    uint8_t bnumber;

    uint16_t wlength;

} PACKED;


typedef struct _HID_PHYSICAL_DESCRIPTOR_SET HID_PHYSICAL_DESCRIPTOR_SET;


struct _HID_PHYSICAL_DESCRIPTOR_SET

{

    uint8_t bphysicalinfo;

    HID_PHYSICAL_DESCRIPTOR wphysicaldescriptor[1];

} PACKED;


typedef struct _HID_STATE HID_STATE;


struct _HID_STATE

{

    // Local State

    uint32_t usage;

    uint32_t usagecount;

    uint32_t designatorindex;

    uint32_t designatorcount;

    uint32_t stringindex;

    uint32_t stringcount;

    BOOL delimiter;

    // Global State

    uint16_t usagepage;

    int32_t logicalminimum;

    int32_t logicalmaximum;

    int32_t physicalminimum;

    int32_t physicalmaximum;

    uint32_t unittype;

    uint32_t unitexponent;

    uint32_t reportsize;

    uint32_t reportid;

    uint32_t reportcount;

};


typedef struct _HID_STACK HID_STACK;


struct _HID_STACK

{

    HID_STATE *state;

    HID_STACK *next;

};


typedef struct _HID_USAGE HID_USAGE;

typedef struct _HID_REPORT HID_REPORT;

typedef struct _HID_COLLECTION HID_COLLECTION;


typedef struct _HID_DEVICE HID_DEVICE;

typedef struct _HID_CONSUMER HID_CONSUMER;


struct _HID_USAGE

{

    uint16_t page;

    uint16_t usage;

    uint16_t count;

    uint32_t index;

    uint32_t stringindex;

    uint32_t stringcount;

    uint32_t designatorindex;

    uint32_t designatorcount;

    int32_t logicalminimum;

    int32_t logicalmaximum;

    int32_t physicalminimum;

    int32_t physicalmaximum;

    uint32_t unittype;

    uint32_t unitexponent;

    HID_USAGE *aliases;

    uint32_t aliascount;

    HID_REPORT *report;

};


struct _HID_REPORT

{

    uint8_t id;

    uint8_t kind;

    uint32_t flags;

    uint32_t size;

    uint32_t count;

    uint32_t index;

    uint32_t sequence;

    HID_USAGE *usages;

    uint32_t usagecount;

    HID_COLLECTION *collection;

};


struct _HID_COLLECTION

{

    uint16_t page;

    uint16_t usage;

    uint32_t flags;

    uint32_t start;

    HID_REPORT *reports;

    uint32_t reportcount;

    HID_COLLECTION *collections;

    uint32_t collectioncount;

    HID_COLLECTION *parent;

    HID_DEVICE *device;

    HID_CONSUMER *consumer;

    void *privatedata;

};


typedef uint32_t STDCALL (*hid_device_enumerate_cb)(HID_DEVICE *device, void *data);


typedef uint32_t STDCALL (*hid_device_notification_cb)(DEVICE *device, void *data, uint32_t notification);


typedef uint32_t STDCALL (*hid_device_get_idle_proc)(HID_DEVICE *device, uint16_t *duration, uint8_t reportid);

typedef uint32_t STDCALL (*hid_device_set_idle_proc)(HID_DEVICE *device, uint16_t duration, uint8_t reportid);


typedef uint32_t STDCALL (*hid_device_get_report_proc)(HID_DEVICE *device, uint8_t reporttype, uint8_t reportid, void *reportdata, uint32_t reportsize);

typedef uint32_t STDCALL (*hid_device_set_report_proc)(HID_DEVICE *device, uint8_t reporttype, uint8_t reportid, void *reportdata, uint32_t reportsize);


typedef uint32_t STDCALL (*hid_device_allocate_report_proc)(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t reportid, uint32_t reportsize);

typedef uint32_t STDCALL (*hid_device_release_report_proc)(HID_DEVICE *device, uint8_t reportid);


typedef uint32_t STDCALL (*hid_device_submit_report_proc)(HID_DEVICE *device, uint8_t reportid);

typedef uint32_t STDCALL (*hid_device_cancel_report_proc)(HID_DEVICE *device, uint8_t reportid);


typedef uint32_t STDCALL (*hid_device_get_protocol_proc)(HID_DEVICE *device, uint8_t *protocol);

typedef uint32_t STDCALL (*hid_device_set_protocol_proc)(HID_DEVICE *device, uint8_t protocol);


typedef uint32_t STDCALL (*hid_device_get_interval_proc)(HID_DEVICE *device, uint32_t *interval);

typedef uint32_t STDCALL (*hid_device_set_interval_proc)(HID_DEVICE *device, uint32_t interval);


typedef uint32_t STDCALL (*hid_device_get_report_descriptor_proc)(HID_DEVICE *device, HID_REPORT_DESCRIPTOR *descriptor, uint32_t size);

typedef uint32_t STDCALL (*hid_device_get_physical_descriptor_set0_proc)(HID_DEVICE *device, HID_PHYSICAL_DESCRIPTOR_SET0 *descriptor);

typedef uint32_t STDCALL (*hid_device_get_physical_descriptor_set_proc)(HID_DEVICE *device, HID_PHYSICAL_DESCRIPTOR_SET *descriptor, uint8_t index, uint32_t size);


struct _HID_DEVICE

{

    // Device Properties

    DEVICE device;

    // HID Properties

    uint32_t hidid;

    uint32_t hidstate;

    HID_CONSUMER *consumer;

    hid_device_get_idle_proc devicegetidle;

    hid_device_set_idle_proc devicesetidle;

    hid_device_get_report_proc devicegetreport;

    hid_device_set_report_proc devicesetreport;

    hid_device_allocate_report_proc deviceallocatereport;

    hid_device_release_report_proc devicereleasereport;

    hid_device_submit_report_proc devicesubmitreport;

    hid_device_cancel_report_proc devicecancelreport;

    hid_device_get_protocol_proc devicegetprotocol;

    hid_device_set_protocol_proc devicesetprotocol;

    hid_device_get_interval_proc devicegetinterval;

    hid_device_set_interval_proc devicesetinterval;

    hid_device_get_report_descriptor_proc devicegetreportdescriptor;

    hid_device_get_physical_descriptor_set0_proc devicegetphysicaldescriptorset0;

    hid_device_get_physical_descriptor_set_proc devicegetphysicaldescriptorset;

    // Driver Properties

    MUTEX_HANDLE lock;

    void *privatedata;

    HID_COLLECTION *collections;

    uint32_t collectioncount;

    HID_REPORT_DESCRIPTOR *descriptor;

    uint32_t descriptorsize;

    // Statistics Properties

    uint32_t receivecount;

    uint32_t receiveerrors;

    // Internal Properties

    HID_DEVICE *prev;

    HID_DEVICE *next;

};


typedef uint32_t STDCALL (*hid_consumer_enumerate_cb)(HID_CONSUMER *consumer, void *data);


typedef uint32_t STDCALL (*hid_device_bind_proc)(HID_DEVICE *device);

typedef uint32_t STDCALL (*hid_device_unbind_proc)(HID_DEVICE *device);


typedef uint32_t STDCALL (*hid_collection_bind_proc)(HID_DEVICE *device, HID_COLLECTION *collection);

typedef uint32_t STDCALL (*hid_collection_unbind_proc)(HID_DEVICE *device, HID_COLLECTION *collection);


typedef uint32_t STDCALL (*hid_report_receive_proc)(HID_COLLECTION *collection, uint8_t reportid, void *reportdata, uint32_t reportsize);


struct _HID_CONSUMER

{

    // Driver Properties

    DRIVER driver;

    // Consumer Properties

    hid_device_bind_proc devicebind;

    hid_device_unbind_proc deviceunbind;

    hid_collection_bind_proc collectionbind;

    hid_collection_unbind_proc collectionunbind;

    hid_report_receive_proc reportreceive;

    // Interface Properties

    MUTEX_HANDLE lock;

    // Internal Properties

    HID_CONSUMER *prev;

    HID_CONSUMER *next;

};


typedef struct _HID_EXTENT HID_EXTENT;


struct _HID_EXTENT

{

    int32_t minimum;

    int32_t maximum;

};


typedef struct _HID_FIELD HID_FIELD;


struct _HID_FIELD

{

    uint16_t page;

    uint16_t usage;

    uint32_t count;

    uint32_t flags;

    uint32_t size;

    uint32_t bits;

    uint32_t offset;

    uint32_t shift;

    HID_EXTENT logical;

    HID_EXTENT physical;

    double_t multiplier;

    double_t resolution;

    HID_FIELD *next;

};


typedef struct _HID_DEFINITION HID_DEFINITION;


struct _HID_DEFINITION

{

    uint8_t id;

    uint8_t kind;

    uint32_t size;

    HID_FIELD *fields;

    HID_DEFINITION *next;

};


uint32_t STDCALL hid_parser_parse_collections(HID_DEVICE *device, HID_COLLECTION **collections, uint32_t *count);


uint32_t STDCALL hid_parser_free_collections(HID_COLLECTION *collections, uint32_t count);


uint32_t STDCALL hid_parser_count_collections(HID_DEVICE *device, HID_COLLECTION *parent);


uint32_t STDCALL hid_parser_count_reports(HID_DEVICE *device, HID_COLLECTION *collection);


uint32_t STDCALL hid_parser_count_usages(HID_DEVICE *device, HID_REPORT *report);


HID_COLLECTION * STDCALL hid_parser_allocate_collection(HID_DEVICE *device, HID_COLLECTION *parent, HID_STATE *state, uint32_t flags, uint32_t start);


HID_REPORT * STDCALL hid_parser_allocate_report(HID_DEVICE *device, HID_COLLECTION *collection, HID_STATE *state, uint8_t kind, uint32_t flags, uint32_t index, uint32_t sequence);


HID_USAGE * STDCALL hid_parser_allocate_usage(HID_DEVICE *device, HID_REPORT *report, HID_STATE *state, uint32_t index);


BOOL STDCALL hid_parser_update_usage(HID_DEVICE *device, HID_REPORT *report, HID_STATE *state, HID_USAGE *usage);


BOOL STDCALL hid_parser_free_usage(HID_DEVICE *device, HID_USAGE *usage);


uint32_t STDCALL hid_parser_pop_stack(HID_STACK *stack, HID_STATE *state);


uint32_t STDCALL hid_parser_push_stack(HID_STACK *stack);


uint32_t STDCALL hid_parser_free_stack(HID_STACK *stack);


uint32_t STDCALL hid_parser_reset_state(HID_STATE *state);


uint32_t STDCALL hid_parser_clean_state(HID_STATE *state);


HID_COLLECTION * STDCALL hid_find_collection(HID_DEVICE *device, uint16_t page, uint16_t usage);


uint32_t STDCALL hid_find_report_ids(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t *minid, uint8_t *maxid);


uint32_t STDCALL hid_find_report_sizes(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t kind, uint32_t *minsize, uint32_t *maxsize);


uint32_t STDCALL hid_count_reports(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t kind, uint8_t id, uint32_t *count);


uint32_t STDCALL hid_find_reports(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t kind, uint8_t id, HID_REPORT *reports, uint32_t count);


HID_DEFINITION * STDCALL hid_allocate_definition(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t kind, uint8_t id);


uint32_t STDCALL hid_free_definition(HID_DEFINITION *definition);


uint32_t STDCALL hid_insert_bit_field(HID_FIELD *field, void *buffer, uint32_t size, BOOL value);


uint32_t STDCALL hid_insert_signed_field(HID_FIELD *field, void *buffer, uint32_t size, int32_t value);


uint32_t STDCALL hid_insert_unsigned_field(HID_FIELD *field, void *buffer, uint32_t size, uint32_t value);


uint32_t STDCALL hid_extract_bit_field(HID_FIELD *field, void *buffer, uint32_t size, BOOL *value);


uint32_t STDCALL hid_extract_signed_field(HID_FIELD *field, void *buffer, uint32_t size, int32_t *value);


uint32_t STDCALL hid_extract_unsigned_field(HID_FIELD *field, void *buffer, uint32_t size, uint32_t *value);


uint32_t STDCALL hid_device_set_state(HID_DEVICE *device, uint32_t state);


uint32_t STDCALL hid_device_get_idle(HID_DEVICE *device, uint16_t *duration, uint8_t reportid);


uint32_t STDCALL hid_device_set_idle(HID_DEVICE *device, uint16_t duration, uint8_t reportid);


uint32_t STDCALL hid_device_get_report(HID_DEVICE *device, uint8_t reporttype, uint8_t reportid, void *reportdata, uint32_t reportsize);


uint32_t STDCALL hid_device_set_report(HID_DEVICE *device, uint8_t reporttype, uint8_t reportid, void *reportdata, uint32_t reportsize);


uint32_t STDCALL hid_device_allocate_report(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t reportid, uint32_t reportsize);


uint32_t STDCALL hid_device_release_report(HID_DEVICE *device, uint8_t reportid);


uint32_t STDCALL hid_device_submit_report(HID_DEVICE *device, uint8_t reportid);


uint32_t STDCALL hid_device_cancel_report(HID_DEVICE *device, uint8_t reportid);


uint32_t STDCALL hid_device_get_protocol(HID_DEVICE *device, uint8_t *protocol);


uint32_t STDCALL hid_device_set_protocol(HID_DEVICE *device, uint8_t protocol);


uint32_t STDCALL hid_device_get_interval(HID_DEVICE *device, uint32_t *interval);


uint32_t STDCALL hid_device_set_interval(HID_DEVICE *device, uint32_t interval);


uint32_t STDCALL hid_device_get_report_descriptor(HID_DEVICE *device, HID_REPORT_DESCRIPTOR *descriptor, uint32_t size);


uint32_t STDCALL hid_device_get_physical_descriptor_set0(HID_DEVICE *device, HID_PHYSICAL_DESCRIPTOR_SET0 *descriptor);


uint32_t STDCALL hid_device_get_physical_descriptor_set(HID_DEVICE *device, HID_PHYSICAL_DESCRIPTOR_SET *descriptor, uint8_t index, uint32_t size);


uint32_t STDCALL hid_device_bind_device(HID_DEVICE *device);


uint32_t STDCALL hid_device_unbind_device(HID_DEVICE *device, HID_CONSUMER *consumer);


uint32_t STDCALL hid_device_bind_collections(HID_DEVICE *device);


uint32_t STDCALL hid_device_unbind_collections(HID_DEVICE *device, HID_CONSUMER *consumer);


HID_DEVICE * STDCALL hid_device_create(void);


HID_DEVICE * STDCALL hid_device_create_ex(uint32_t size);


uint32_t STDCALL hid_device_destroy(HID_DEVICE *device);


uint32_t STDCALL hid_device_register(HID_DEVICE *device);


uint32_t STDCALL hid_device_deregister(HID_DEVICE *device);


HID_DEVICE * STDCALL hid_device_find(uint32_t hidid);


HID_DEVICE * STDCALL hid_device_find_by_name(const char *name);


HID_DEVICE * STDCALL hid_device_find_by_description(const char *description);


uint32_t STDCALL hid_device_enumerate(hid_device_enumerate_cb callback, void *data);


uint32_t STDCALL hid_device_notification(HID_DEVICE *device, hid_device_notification_cb callback, void *data, uint32_t notification, uint32_t flags);


HID_CONSUMER * STDCALL hid_consumer_create(void);


HID_CONSUMER * STDCALL hid_consumer_create_ex(uint32_t size);


uint32_t STDCALL hid_consumer_destroy(HID_CONSUMER *consumer);


uint32_t STDCALL hid_consumer_register(HID_CONSUMER *consumer);


uint32_t STDCALL hid_consumer_deregister(HID_CONSUMER *consumer);


HID_CONSUMER * STDCALL hid_consumer_find(uint32_t consumerid);


HID_CONSUMER * STDCALL hid_consumer_find_by_name(const char *name);


uint32_t STDCALL hid_consumer_enumerate(hid_consumer_enumerate_cb callback, void *data);


BOOL STDCALL hid_is_bit_field(HID_FIELD *field);


BOOL STDCALL hid_is_byte_field(HID_FIELD *field);


BOOL STDCALL hid_is_word_field(HID_FIELD *field);


BOOL STDCALL hid_is_long_field(HID_FIELD *field);


BOOL STDCALL hid_is_signed_field(HID_FIELD *field);


uint32_t STDCALL hid_page_to_string(uint16_t page, char *string, uint32_t len);


uint32_t STDCALL hid_usage_to_string(uint16_t page, uint16_t usage, uint16_t count, char *string, uint32_t len);


uint32_t STDCALL hid_unit_type_to_string(uint32_t unittype, char *string, uint32_t len);


uint32_t STDCALL hid_report_kind_to_string(uint8_t kind, char *string, uint32_t len);


uint32_t STDCALL hid_report_flags_to_string(uint32_t flags, char *string, uint32_t len);


uint32_t STDCALL hid_collection_flags_to_string(uint32_t flags, char *string, uint32_t len);


uint32_t STDCALL hid_device_get_count(void);


HID_DEVICE * STDCALL hid_device_check(HID_DEVICE *device);


uint32_t STDCALL hid_device_type_to_string(uint32_t hidtype, char *string, uint32_t len);


uint32_t STDCALL hid_device_state_to_string(uint32_t hidstate, char *string, uint32_t len);


uint32_t STDCALL hid_device_state_to_notification(uint32_t state);


uint32_t STDCALL hid_consumer_get_count(void);


HID_CONSUMER * STDCALL hid_consumer_check(HID_CONSUMER *consumer);


#ifdef __cplusplus

}

#endif


#endif // _ULTIBO_HID_H

devices.h

DEVICE
struct _DEVICE DEVICE
Definition devices.h:373

DRIVER
struct _DRIVER DRIVER
Definition devices.h:465

globalconst.h

globaltypes.h

STDCALL
#define STDCALL
Definition globaltypes.h:45

PACKED
#define PACKED
Definition globaltypes.h:48

BOOL
_Bool BOOL
Built in Boolean type (1 byte) (Redeclared here for flexibility).
Definition globaltypes.h:55

MUTEX_HANDLE
HANDLE MUTEX_HANDLE
Definition globaltypes.h:105

hid_is_byte_field
BOOL STDCALL hid_is_byte_field(HID_FIELD *field)
Return True if the supplied HID field contains a 1 byte value.

hid_device_destroy
uint32_t STDCALL hid_device_destroy(HID_DEVICE *device)
Destroy an existing HID device entry.

hid_device_type_to_string
uint32_t STDCALL hid_device_type_to_string(uint32_t hidtype, char *string, uint32_t len)
Return a string describing the HID device type (eg HID_TYPE_USB).

hid_device_set_report
uint32_t STDCALL hid_device_set_report(HID_DEVICE *device, uint8_t reporttype, uint8_t reportid, void *reportdata, uint32_t reportsize)
Write a report by type and id to a HID device.

hid_device_unbind_device
uint32_t STDCALL hid_device_unbind_device(HID_DEVICE *device, HID_CONSUMER *consumer)
Unbind a HID device from a consumer.

hid_device_find_by_description
HID_DEVICE *STDCALL hid_device_find_by_description(const char *description)
Find a HID device by description in the device table.

hid_parser_allocate_collection
HID_COLLECTION *STDCALL hid_parser_allocate_collection(HID_DEVICE *device, HID_COLLECTION *parent, HID_STATE *state, uint32_t flags, uint32_t start)
Allocate a HID collection to contain a set of reports and usages from a HID report descriptor.

HID_PHYSICAL_DESCRIPTOR_SET0
struct _HID_PHYSICAL_DESCRIPTOR_SET0 HID_PHYSICAL_DESCRIPTOR_SET0
Definition hid.h:547

HID_DEVICE
struct _HID_DEVICE HID_DEVICE
Forward declared to satisfy HIDCollection.
Definition hid.h:604

hid_device_find_by_name
HID_DEVICE *STDCALL hid_device_find_by_name(const char *name)
Find a HID device by name in the device table.

hid_device_create_ex
HID_DEVICE *STDCALL hid_device_create_ex(uint32_t size)
Create a new HID device entry.

hid_device_unbind_proc
uint32_t STDCALL(* hid_device_unbind_proc)(HID_DEVICE *device)
Definition hid.h:739

hid_consumer_create_ex
HID_CONSUMER *STDCALL hid_consumer_create_ex(uint32_t size)
Create a new HID Consumer entry.

hid_consumer_get_count
uint32_t STDCALL hid_consumer_get_count(void)
Get the current HID Consumer count.

hid_device_register
uint32_t STDCALL hid_device_register(HID_DEVICE *device)
Register a new HID device in the HID device table.

hid_usage_to_string
uint32_t STDCALL hid_usage_to_string(uint16_t page, uint16_t usage, uint16_t count, char *string, uint32_t len)
Return a string describing a HID usage within the given page.

hid_device_get_count
uint32_t STDCALL hid_device_get_count(void)
Get the current HID Device count.

HID_CONSUMER
struct _HID_CONSUMER HID_CONSUMER
Forward declared to satisfy HIDCollection.
Definition hid.h:605

hid_device_deregister
uint32_t STDCALL hid_device_deregister(HID_DEVICE *device)
Deregister a HID device from the HID device table.

hid_consumer_enumerate
uint32_t STDCALL hid_consumer_enumerate(hid_consumer_enumerate_cb callback, void *data)
Enumerate all consumers in the HID Consumer table.

hid_find_report_sizes
uint32_t STDCALL hid_find_report_sizes(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t kind, uint32_t *minsize, uint32_t *maxsize)
Find the minimum and maximum report sizes contained in the specified HID collection or all collection...

hid_device_notification_cb
uint32_t STDCALL(* hid_device_notification_cb)(DEVICE *device, void *data, uint32_t notification)
Definition hid.h:668

hid_find_report_ids
uint32_t STDCALL hid_find_report_ids(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t *minid, uint8_t *maxid)
Find the minimum and maximum report ids contained in the specified HID collection or all collections.

HID_STATE
struct _HID_STATE HID_STATE
Definition hid.h:565

hid_page_to_string
uint32_t STDCALL hid_page_to_string(uint16_t page, char *string, uint32_t len)
Return a string describing a HID usage page.

hid_consumer_find
HID_CONSUMER *STDCALL hid_consumer_find(uint32_t consumerid)
Find a consumer by Id in the HID Consumer table.

HID_PHYSICAL_DESCRIPTOR
struct _HID_PHYSICAL_DESCRIPTOR HID_PHYSICAL_DESCRIPTOR
Definition hid.h:539

hid_device_allocate_report_proc
uint32_t STDCALL(* hid_device_allocate_report_proc)(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t reportid, uint32_t reportsize)
Definition hid.h:677

hid_parser_free_usage
BOOL STDCALL hid_parser_free_usage(HID_DEVICE *device, HID_USAGE *usage)
Free a HID usage and any associated usage aliases.

hid_consumer_destroy
uint32_t STDCALL hid_consumer_destroy(HID_CONSUMER *consumer)
Destroy an existing HID Consumer entry.

HID_REPORT
struct _HID_REPORT HID_REPORT
Forward declared to satisfy HIDUsage.
Definition hid.h:601

hid_parser_count_collections
uint32_t STDCALL hid_parser_count_collections(HID_DEVICE *device, HID_COLLECTION *parent)
Count the number of collections found in the HID report descriptor of the provided device.

hid_parser_reset_state
uint32_t STDCALL hid_parser_reset_state(HID_STATE *state)
Clear the Local and Global HID parser state.

hid_device_get_report_proc
uint32_t STDCALL(* hid_device_get_report_proc)(HID_DEVICE *device, uint8_t reporttype, uint8_t reportid, void *reportdata, uint32_t reportsize)
Definition hid.h:674

hid_insert_signed_field
uint32_t STDCALL hid_insert_signed_field(HID_FIELD *field, void *buffer, uint32_t size, int32_t value)
Insert a signed field value into a report buffer.

hid_consumer_check
HID_CONSUMER *STDCALL hid_consumer_check(HID_CONSUMER *consumer)
Check if the supplied HID Consumer is in the consumer table.

hid_device_release_report_proc
uint32_t STDCALL(* hid_device_release_report_proc)(HID_DEVICE *device, uint8_t reportid)
Definition hid.h:678

hid_device_allocate_report
uint32_t STDCALL hid_device_allocate_report(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t reportid, uint32_t reportsize)
Allocate and initialize an input report by id on a HID device.

hid_device_bind_proc
uint32_t STDCALL(* hid_device_bind_proc)(HID_DEVICE *device)
Definition hid.h:738

hid_device_set_interval
uint32_t STDCALL hid_device_set_interval(HID_DEVICE *device, uint32_t interval)
Set the polling interval for a HID device.

hid_is_signed_field
BOOL STDCALL hid_is_signed_field(HID_FIELD *field)
Return True if the supplied HID field contains a signed value.

HID_REPORT_DESCRIPTOR
void HID_REPORT_DESCRIPTOR
Definition hid.h:536

hid_device_set_interval_proc
uint32_t STDCALL(* hid_device_set_interval_proc)(HID_DEVICE *device, uint32_t interval)
Definition hid.h:687

hid_is_word_field
BOOL STDCALL hid_is_word_field(HID_FIELD *field)
Return True if the supplied HID field contains a 2 byte value.

hid_collection_flags_to_string
uint32_t STDCALL hid_collection_flags_to_string(uint32_t flags, char *string, uint32_t len)
Return a string describing the flags of a HID collection.

hid_device_cancel_report_proc
uint32_t STDCALL(* hid_device_cancel_report_proc)(HID_DEVICE *device, uint8_t reportid)
Definition hid.h:681

hid_parser_parse_collections
uint32_t STDCALL hid_parser_parse_collections(HID_DEVICE *device, HID_COLLECTION **collections, uint32_t *count)
Parse the HID report descriptor of the provided device and populate the collections,...

hid_count_reports
uint32_t STDCALL hid_count_reports(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t kind, uint8_t id, uint32_t *count)
Count the number of HID reports of the specified type and id in the specified collection.

HID_DEFINITION
struct _HID_DEFINITION HID_DEFINITION
Definition hid.h:795

hid_parser_free_stack
uint32_t STDCALL hid_parser_free_stack(HID_STACK *stack)
Free the HID parser stack and state.

hid_parser_allocate_report
HID_REPORT *STDCALL hid_parser_allocate_report(HID_DEVICE *device, HID_COLLECTION *collection, HID_STATE *state, uint8_t kind, uint32_t flags, uint32_t index, uint32_t sequence)
Allocate a HID report to contain a set of usages from a HID report descriptor.

HID_DESCRIPTOR
struct _HID_DESCRIPTOR HID_DESCRIPTOR
Definition hid.h:521

hid_consumer_deregister
uint32_t STDCALL hid_consumer_deregister(HID_CONSUMER *consumer)
Deregister a Consumer from the HID Consumer table.

hid_parser_count_usages
uint32_t STDCALL hid_parser_count_usages(HID_DEVICE *device, HID_REPORT *report)
Count the number of usages found in the HID report descriptor for the supplied device and report.

hid_device_state_to_string
uint32_t STDCALL hid_device_state_to_string(uint32_t hidstate, char *string, uint32_t len)
Return a string describing the HID device state (eg HID_STATE_ATTACHED).

hid_device_enumerate_cb
uint32_t STDCALL(* hid_device_enumerate_cb)(HID_DEVICE *device, void *data)
Definition hid.h:665

hid_parser_pop_stack
uint32_t STDCALL hid_parser_pop_stack(HID_STACK *stack, HID_STATE *state)
Replace the current HID parser state with the top item from the parser stack.

hid_device_get_interval_proc
uint32_t STDCALL(* hid_device_get_interval_proc)(HID_DEVICE *device, uint32_t *interval)
Definition hid.h:686

hid_extract_unsigned_field
uint32_t STDCALL hid_extract_unsigned_field(HID_FIELD *field, void *buffer, uint32_t size, uint32_t *value)
Extract an unsigned field value from a report buffer.

hid_extract_bit_field
uint32_t STDCALL hid_extract_bit_field(HID_FIELD *field, void *buffer, uint32_t size, BOOL *value)
Extract a bit field value from a report buffer.

hid_device_set_protocol_proc
uint32_t STDCALL(* hid_device_set_protocol_proc)(HID_DEVICE *device, uint8_t protocol)
Definition hid.h:684

HID_PHYSICAL_DESCRIPTOR_SET
struct _HID_PHYSICAL_DESCRIPTOR_SET HID_PHYSICAL_DESCRIPTOR_SET
Definition hid.h:555

hid_device_get_physical_descriptor_set0_proc
uint32_t STDCALL(* hid_device_get_physical_descriptor_set0_proc)(HID_DEVICE *device, HID_PHYSICAL_DESCRIPTOR_SET0 *descriptor)
Definition hid.h:690

hid_consumer_create
HID_CONSUMER *STDCALL hid_consumer_create(void)
Create a new HID Consumer entry.

hid_find_collection
HID_COLLECTION *STDCALL hid_find_collection(HID_DEVICE *device, uint16_t page, uint16_t usage)
Find the first HID collection matching the specified page and usage.

hid_is_bit_field
BOOL STDCALL hid_is_bit_field(HID_FIELD *field)
Return True if the supplied field contains a 1 bit value.

hid_device_set_idle_proc
uint32_t STDCALL(* hid_device_set_idle_proc)(HID_DEVICE *device, uint16_t duration, uint8_t reportid)
Definition hid.h:672

hid_device_set_state
uint32_t STDCALL hid_device_set_state(HID_DEVICE *device, uint32_t state)
Set the state of the specified HID device and send a notification.

HID_EXTENT
struct _HID_EXTENT HID_EXTENT
Definition hid.h:766

hid_consumer_enumerate_cb
uint32_t STDCALL(* hid_consumer_enumerate_cb)(HID_CONSUMER *consumer, void *data)
Definition hid.h:735

hid_parser_allocate_usage
HID_USAGE *STDCALL hid_parser_allocate_usage(HID_DEVICE *device, HID_REPORT *report, HID_STATE *state, uint32_t index)
Allocate a HID usage from a HID report descriptor.

hid_device_check
HID_DEVICE *STDCALL hid_device_check(HID_DEVICE *device)
Check if the supplied HID Device is in the device table.

hid_device_get_physical_descriptor_set0
uint32_t STDCALL hid_device_get_physical_descriptor_set0(HID_DEVICE *device, HID_PHYSICAL_DESCRIPTOR_SET0 *descriptor)
Get the HID Physical Descriptor Set 0 for a HID device.

hid_device_get_protocol
uint32_t STDCALL hid_device_get_protocol(HID_DEVICE *device, uint8_t *protocol)
Get the report protocol from a HID device.

HID_COLLECTION
struct _HID_COLLECTION HID_COLLECTION
Forward declared to satisfy HIDReport.
Definition hid.h:602

hid_device_get_protocol_proc
uint32_t STDCALL(* hid_device_get_protocol_proc)(HID_DEVICE *device, uint8_t *protocol)
Definition hid.h:683

hid_collection_unbind_proc
uint32_t STDCALL(* hid_collection_unbind_proc)(HID_DEVICE *device, HID_COLLECTION *collection)
Definition hid.h:742

hid_device_submit_report
uint32_t STDCALL hid_device_submit_report(HID_DEVICE *device, uint8_t reportid)
Submit an input report by id on a HID device.

hid_device_create
HID_DEVICE *STDCALL hid_device_create(void)
Create a new HID device entry.

hid_device_set_report_proc
uint32_t STDCALL(* hid_device_set_report_proc)(HID_DEVICE *device, uint8_t reporttype, uint8_t reportid, void *reportdata, uint32_t reportsize)
Definition hid.h:675

hid_is_long_field
BOOL STDCALL hid_is_long_field(HID_FIELD *field)
Return True if the supplied HID field contains a 3 or 4 byte value.

hid_device_notification
uint32_t STDCALL hid_device_notification(HID_DEVICE *device, hid_device_notification_cb callback, void *data, uint32_t notification, uint32_t flags)
Register a notification for HID device changes.

hid_parser_clean_state
uint32_t STDCALL hid_parser_clean_state(HID_STATE *state)
Clear the Local HID parser state.

HID_FIELD
struct _HID_FIELD HID_FIELD
Definition hid.h:775

hid_allocate_definition
HID_DEFINITION *STDCALL hid_allocate_definition(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t kind, uint8_t id)
Allocate a HID definition to describe an input, output or feature report contained in the specified c...

hid_device_unbind_collections
uint32_t STDCALL hid_device_unbind_collections(HID_DEVICE *device, HID_CONSUMER *consumer)
Unbind the HID collections in the specified device from a consumer.

hid_parser_update_usage
BOOL STDCALL hid_parser_update_usage(HID_DEVICE *device, HID_REPORT *report, HID_STATE *state, HID_USAGE *usage)
Update a HID usage from a HID report descriptor.

hid_collection_bind_proc
uint32_t STDCALL(* hid_collection_bind_proc)(HID_DEVICE *device, HID_COLLECTION *collection)
Definition hid.h:741

hid_consumer_find_by_name
HID_CONSUMER *STDCALL hid_consumer_find_by_name(const char *name)
Find a consumer by name in the Driver table.

hid_insert_bit_field
uint32_t STDCALL hid_insert_bit_field(HID_FIELD *field, void *buffer, uint32_t size, BOOL value)
Insert a bit field value into a report buffer.

hid_device_get_report_descriptor_proc
uint32_t STDCALL(* hid_device_get_report_descriptor_proc)(HID_DEVICE *device, HID_REPORT_DESCRIPTOR *descriptor, uint32_t size)
Definition hid.h:689

hid_device_submit_report_proc
uint32_t STDCALL(* hid_device_submit_report_proc)(HID_DEVICE *device, uint8_t reportid)
Definition hid.h:680

hid_device_get_report_descriptor
uint32_t STDCALL hid_device_get_report_descriptor(HID_DEVICE *device, HID_REPORT_DESCRIPTOR *descriptor, uint32_t size)
Get the Report Descriptor for a HID device.

hid_device_get_idle_proc
uint32_t STDCALL(* hid_device_get_idle_proc)(HID_DEVICE *device, uint16_t *duration, uint8_t reportid)
Definition hid.h:671

hid_device_cancel_report
uint32_t STDCALL hid_device_cancel_report(HID_DEVICE *device, uint8_t reportid)
Cancel an input report by id on a HID device.

hid_find_reports
uint32_t STDCALL hid_find_reports(HID_DEVICE *device, HID_COLLECTION *collection, uint8_t kind, uint8_t id, HID_REPORT *reports, uint32_t count)
Find all HID reports of the specified type and id in the specified collection.

HID_USAGE
struct _HID_USAGE HID_USAGE
Definition hid.h:600

hid_parser_push_stack
uint32_t STDCALL hid_parser_push_stack(HID_STACK *stack)
Place a copy of the current HID parser state on top of the parser stack.

hid_free_definition
uint32_t STDCALL hid_free_definition(HID_DEFINITION *definition)
Free a HID definition describing an input, output or feature report.

hid_extract_signed_field
uint32_t STDCALL hid_extract_signed_field(HID_FIELD *field, void *buffer, uint32_t size, int32_t *value)
Extract a signed field value from a report buffer.

hid_consumer_register
uint32_t STDCALL hid_consumer_register(HID_CONSUMER *consumer)
Register a new Consumer in the HID Consumer table.

hid_device_set_idle
uint32_t STDCALL hid_device_set_idle(HID_DEVICE *device, uint16_t duration, uint8_t reportid)
Set the idle rate on a HID device for the specified report id.

hid_device_enumerate
uint32_t STDCALL hid_device_enumerate(hid_device_enumerate_cb callback, void *data)
Enumerate all HID devices in the HID device table.

hid_report_kind_to_string
uint32_t STDCALL hid_report_kind_to_string(uint8_t kind, char *string, uint32_t len)
Return a string describing a HID report type.

hid_device_get_physical_descriptor_set
uint32_t STDCALL hid_device_get_physical_descriptor_set(HID_DEVICE *device, HID_PHYSICAL_DESCRIPTOR_SET *descriptor, uint8_t index, uint32_t size)
Get a HID Physical Descriptor Set for a HID device.

hid_device_state_to_notification
uint32_t STDCALL hid_device_state_to_notification(uint32_t state)
Convert a Device state value into the notification code for device notifications.

hid_device_release_report
uint32_t STDCALL hid_device_release_report(HID_DEVICE *device, uint8_t reportid)
Release an input report by id from a HID device.

hid_device_bind_collections
uint32_t STDCALL hid_device_bind_collections(HID_DEVICE *device)
Attempt to bind the HID collections in the specified device to one of the registered consumers.

hid_unit_type_to_string
uint32_t STDCALL hid_unit_type_to_string(uint32_t unittype, char *string, uint32_t len)
Return a string describing a HID unit type.

hid_device_find
HID_DEVICE *STDCALL hid_device_find(uint32_t hidid)
Find a HID device by ID in the HID device table.

hid_parser_count_reports
uint32_t STDCALL hid_parser_count_reports(HID_DEVICE *device, HID_COLLECTION *collection)
Count the number of reports found in the HID report descriptor of the supplied device and collection.

hid_device_bind_device
uint32_t STDCALL hid_device_bind_device(HID_DEVICE *device)
Attempt to bind a HID device to one of the registered consumers.

hid_device_get_idle
uint32_t STDCALL hid_device_get_idle(HID_DEVICE *device, uint16_t *duration, uint8_t reportid)
Get the idle rate from a HID device for the specified report id.

hid_device_get_interval
uint32_t STDCALL hid_device_get_interval(HID_DEVICE *device, uint32_t *interval)
Get the polling interval from a HID device.

hid_device_set_protocol
uint32_t STDCALL hid_device_set_protocol(HID_DEVICE *device, uint8_t protocol)
Set the report protocol for a HID device.

hid_device_get_physical_descriptor_set_proc
uint32_t STDCALL(* hid_device_get_physical_descriptor_set_proc)(HID_DEVICE *device, HID_PHYSICAL_DESCRIPTOR_SET *descriptor, uint8_t index, uint32_t size)
Definition hid.h:691

hid_device_get_report
uint32_t STDCALL hid_device_get_report(HID_DEVICE *device, uint8_t reporttype, uint8_t reportid, void *reportdata, uint32_t reportsize)
Read a report by type and id from a HID device.

hid_report_receive_proc
uint32_t STDCALL(* hid_report_receive_proc)(HID_COLLECTION *collection, uint8_t reportid, void *reportdata, uint32_t reportsize)
Definition hid.h:744

hid_parser_free_collections
uint32_t STDCALL hid_parser_free_collections(HID_COLLECTION *collections, uint32_t count)
Free the collections, reports and usages parsed from a HID report descriptor.

HID_STACK
struct _HID_STACK HID_STACK
Definition hid.h:591

hid_report_flags_to_string
uint32_t STDCALL hid_report_flags_to_string(uint32_t flags, char *string, uint32_t len)
Return a string describing the flags of a HID report.

hid_insert_unsigned_field
uint32_t STDCALL hid_insert_unsigned_field(HID_FIELD *field, void *buffer, uint32_t size, uint32_t value)
Insert an unsigned field value into a report buffer.

_HID_COLLECTION
Definition hid.h:647

_HID_COLLECTION::usage
uint16_t usage
The usage within the usage page (eg HID_DESKTOP_MOUSE).
Definition hid.h:649

_HID_COLLECTION::privatedata
void * privatedata
Private data for the consumer of this collection.
Definition hid.h:659

_HID_COLLECTION::consumer
HID_CONSUMER * consumer
The consumer which is bound to this collection (or nil if not bound).
Definition hid.h:658

_HID_COLLECTION::start
uint32_t start
The first byte of this collection in the report descriptor.
Definition hid.h:651

_HID_COLLECTION::flags
uint32_t flags
The main item flags for this collection (eg HID_MAIN_COLLECTION_APPLICATION).
Definition hid.h:650

_HID_COLLECTION::device
HID_DEVICE * device
The device this collection belongs to.
Definition hid.h:657

_HID_COLLECTION::collections
HID_COLLECTION * collections
The list of collections contained in this collection.
Definition hid.h:654

_HID_COLLECTION::page
uint16_t page
The usage page this collection refers to (eg HID_PAGE_GENERIC_DESKTOP).
Definition hid.h:648

_HID_COLLECTION::reportcount
uint32_t reportcount
The number of reports contained in this collection.
Definition hid.h:653

_HID_COLLECTION::parent
HID_COLLECTION * parent
The parent collection or nil if this is a top level collection.
Definition hid.h:656

_HID_COLLECTION::reports
HID_REPORT * reports
The list of reports contained in this collection.
Definition hid.h:652

_HID_COLLECTION::collectioncount
uint32_t collectioncount
The number of collections contained in this collection.
Definition hid.h:655

_HID_CONSUMER
Definition hid.h:747

_HID_CONSUMER::reportreceive
hid_report_receive_proc reportreceive
A Report Receive method to be called when a HID input report is received by a provider (Mandatory).
Definition hid.h:755

_HID_CONSUMER::lock
MUTEX_HANDLE lock
Consumer lock.
Definition hid.h:757

_HID_CONSUMER::driver
DRIVER driver
The Driver entry for this HID Consumer.
Definition hid.h:749

_HID_CONSUMER::deviceunbind
hid_device_unbind_proc deviceunbind
A Device Ubind method to be called when a HID device unbind is requested by a provider (Optional).
Definition hid.h:752

_HID_CONSUMER::collectionbind
hid_collection_bind_proc collectionbind
A Collection Bind method to be called when a HID collection bind is requested by a provider (Mandator...
Definition hid.h:753

_HID_CONSUMER::prev
HID_CONSUMER * prev
Previous entry in Consumer table.
Definition hid.h:759

_HID_CONSUMER::devicebind
hid_device_bind_proc devicebind
A Device Bind method to be called when a HID device bind is requested by a provider (Optional).
Definition hid.h:751

_HID_CONSUMER::collectionunbind
hid_collection_unbind_proc collectionunbind
A Collection Unbind method to be called when a HID collection unbind is requested by a provider (Mand...
Definition hid.h:754

_HID_CONSUMER::next
HID_CONSUMER * next
Next entry in Consumer table.
Definition hid.h:760

_HID_DEFINITION
Definition hid.h:797

_HID_DEFINITION::id
uint8_t id
The Id of this report.
Definition hid.h:798

_HID_DEFINITION::fields
HID_FIELD * fields
Linked list of fields in this input, output or feature report.
Definition hid.h:801

_HID_DEFINITION::kind
uint8_t kind
The type of this report (Input, Output or Feature).
Definition hid.h:799

_HID_DEFINITION::size
uint32_t size
The total length of this input, output or feature report in bytes (Including the Id byte).
Definition hid.h:800

_HID_DEFINITION::next
HID_DEFINITION * next
The next definition in the list.
Definition hid.h:802

_HID_DESCRIPTOR
Definition hid.h:523

_HID_DESCRIPTOR::whiddescriptorlength
uint16_t whiddescriptorlength
Definition hid.h:530

_HID_DESCRIPTOR::bnumdescriptors
uint8_t bnumdescriptors
Definition hid.h:528

_HID_DESCRIPTOR::bcdhid
uint16_t bcdhid
Definition hid.h:526

_HID_DESCRIPTOR::bdescriptortype
uint8_t bdescriptortype
Definition hid.h:525

_HID_DESCRIPTOR::bhiddescriptortype
uint8_t bhiddescriptortype
Definition hid.h:529

_HID_DESCRIPTOR::blength
uint8_t blength
Definition hid.h:524

_HID_DESCRIPTOR::bcountrycode
uint8_t bcountrycode
Definition hid.h:527

_HID_DEVICE
Definition hid.h:694

_HID_DEVICE::prev
HID_DEVICE * prev
Previous entry in Device table.
Definition hid.h:727

_HID_DEVICE::hidstate
uint32_t hidstate
HID device state (eg HID_STATE_ATTACHED).
Definition hid.h:699

_HID_DEVICE::lock
MUTEX_HANDLE lock
HID device lock.
Definition hid.h:717

_HID_DEVICE::privatedata
void * privatedata
Private data for the consumer of this HID device (If applicable).
Definition hid.h:718

_HID_DEVICE::consumer
HID_CONSUMER * consumer
The consumer which is bound to this device (or nil if not bound).
Definition hid.h:700

_HID_DEVICE::receiveerrors
uint32_t receiveerrors
Definition hid.h:725

_HID_DEVICE::descriptor
HID_REPORT_DESCRIPTOR * descriptor
The raw report descriptor obtained from the device.
Definition hid.h:721

_HID_DEVICE::next
HID_DEVICE * next
Next entry in Device table.
Definition hid.h:728

_HID_DEVICE::device
DEVICE device
The Device entry for this HID.
Definition hid.h:696

_HID_DEVICE::descriptorsize
uint32_t descriptorsize
The size of the data pointed to by Descriptor.
Definition hid.h:722

_HID_DEVICE::receivecount
uint32_t receivecount
Definition hid.h:724

_HID_DEVICE::devicesetprotocol
hid_device_set_protocol_proc devicesetprotocol
A device specific SetProtocol method (If supported by provider).
Definition hid.h:710

_HID_DEVICE::devicecancelreport
hid_device_cancel_report_proc devicecancelreport
A device specific CancelReport method (If supported by provider).
Definition hid.h:708

_HID_DEVICE::devicesetinterval
hid_device_set_interval_proc devicesetinterval
A device specific SetInterval method (If supported by provider).
Definition hid.h:712

_HID_DEVICE::devicegetphysicaldescriptorset
hid_device_get_physical_descriptor_set_proc devicegetphysicaldescriptorset
A device specific GetPhysicalDescriptorSet method (If supported by provider).
Definition hid.h:715

_HID_DEVICE::devicereleasereport
hid_device_release_report_proc devicereleasereport
A device specific ReleaseReport method (If supported by provider).
Definition hid.h:706

_HID_DEVICE::hidid
uint32_t hidid
Unique Id of this HID in the HID device table.
Definition hid.h:698

_HID_DEVICE::collections
HID_COLLECTION * collections
The parsed report descriptor with collections, reports and usages.
Definition hid.h:719

_HID_DEVICE::devicesetreport
hid_device_set_report_proc devicesetreport
A device specific SetReport method (If supported by provider).
Definition hid.h:704

_HID_DEVICE::devicegetreport
hid_device_get_report_proc devicegetreport
A device specific GetReport method (If supported by provider).
Definition hid.h:703

_HID_DEVICE::devicegetreportdescriptor
hid_device_get_report_descriptor_proc devicegetreportdescriptor
A device specific GetReportDescriptor method (If supported by provider).
Definition hid.h:713

_HID_DEVICE::devicegetinterval
hid_device_get_interval_proc devicegetinterval
A device specific GetInterval method (If supported by provider).
Definition hid.h:711

_HID_DEVICE::devicegetidle
hid_device_get_idle_proc devicegetidle
A device specific GetIdle method (If supported by provider).
Definition hid.h:701

_HID_DEVICE::devicesetidle
hid_device_set_idle_proc devicesetidle
A device specific SetIdle method (If supported by provider).
Definition hid.h:702

_HID_DEVICE::deviceallocatereport
hid_device_allocate_report_proc deviceallocatereport
A device specific AllocateReport method (If supported by provider).
Definition hid.h:705

_HID_DEVICE::devicegetphysicaldescriptorset0
hid_device_get_physical_descriptor_set0_proc devicegetphysicaldescriptorset0
A device specific GetPhysicalDescriptorSet0 method (If supported by provider).
Definition hid.h:714

_HID_DEVICE::devicegetprotocol
hid_device_get_protocol_proc devicegetprotocol
A device specific GetProtocol method (If supported by provider).
Definition hid.h:709

_HID_DEVICE::collectioncount
uint32_t collectioncount
The number of top level collections contained in the report descriptor.
Definition hid.h:720

_HID_DEVICE::devicesubmitreport
hid_device_submit_report_proc devicesubmitreport
A device specific SubmitReport method (If supported by provider).
Definition hid.h:707

_HID_EXTENT
Definition hid.h:768

_HID_EXTENT::maximum
int32_t maximum
The maximum value for this extent.
Definition hid.h:770

_HID_EXTENT::minimum
int32_t minimum
The minimum value for this extent.
Definition hid.h:769

_HID_FIELD
Definition hid.h:777

_HID_FIELD::usage
uint16_t usage
The usage within the usage page.
Definition hid.h:779

_HID_FIELD::multiplier
double_t multiplier
The conversion multiplier for this field from logical to physical units.
Definition hid.h:788

_HID_FIELD::logical
HID_EXTENT logical
The minimum and maximum logical values for this field.
Definition hid.h:786

_HID_FIELD::flags
uint32_t flags
The flags for this field.
Definition hid.h:781

_HID_FIELD::resolution
double_t resolution
The unit resolution for this field in counts per physical unit.
Definition hid.h:789

_HID_FIELD::count
uint32_t count
The total number of sequential usages where Usage represents the minimum value or 1 for a single usag...
Definition hid.h:780

_HID_FIELD::offset
uint32_t offset
The byte offset of this field within the input, output or feature report.
Definition hid.h:784

_HID_FIELD::page
uint16_t page
The usage page of this field.
Definition hid.h:778

_HID_FIELD::size
uint32_t size
The length in bytes of this field within the input, output or feature report.
Definition hid.h:782

_HID_FIELD::shift
uint32_t shift
The number shift bits to access this field in the input, output or feature report.
Definition hid.h:785

_HID_FIELD::physical
HID_EXTENT physical
The minimum and maximum physical values for this field.
Definition hid.h:787

_HID_FIELD::bits
uint32_t bits
The length in bits of this field within the input, output or feature report.
Definition hid.h:783

_HID_FIELD::next
HID_FIELD * next
The next field in the list.
Definition hid.h:790

_HID_PHYSICAL_DESCRIPTOR_SET0
Definition hid.h:549

_HID_PHYSICAL_DESCRIPTOR_SET0::bnumber
uint8_t bnumber
Number of Physical Descriptor sets not including Physical Descriptor set 0.
Definition hid.h:550

_HID_PHYSICAL_DESCRIPTOR_SET0::wlength
uint16_t wlength
Length of each Physical descriptor set.
Definition hid.h:551

_HID_PHYSICAL_DESCRIPTOR_SET
Definition hid.h:557

_HID_PHYSICAL_DESCRIPTOR_SET::wphysicaldescriptor
HID_PHYSICAL_DESCRIPTOR wphysicaldescriptor[1]
Physical descriptor data.
Definition hid.h:559

_HID_PHYSICAL_DESCRIPTOR_SET::bphysicalinfo
uint8_t bphysicalinfo
Bits specifying physical information (7..5 Bias / 4..0 Preference).
Definition hid.h:558

_HID_PHYSICAL_DESCRIPTOR
Definition hid.h:541

_HID_PHYSICAL_DESCRIPTOR::bflags
uint8_t bflags
Bits specifying flags (7..5 Qualifier / 4..0 Effort).
Definition hid.h:543

_HID_PHYSICAL_DESCRIPTOR::bdesignator
uint8_t bdesignator
Indicates which part of the body affects the item.
Definition hid.h:542

_HID_REPORT
Definition hid.h:631

_HID_REPORT::collection
HID_COLLECTION * collection
The collection this report belongs to.
Definition hid.h:641

_HID_REPORT::sequence
uint32_t sequence
The sequence of this report in all collections (First report is 0).
Definition hid.h:638

_HID_REPORT::id
uint8_t id
The Id of this report.
Definition hid.h:632

_HID_REPORT::usages
HID_USAGE * usages
The list of usages contained in this report.
Definition hid.h:639

_HID_REPORT::flags
uint32_t flags
The main item flags for this report (eg HID_MAIN_ITEM_VARIABLE).
Definition hid.h:634

_HID_REPORT::count
uint32_t count
The number of fields in this report.
Definition hid.h:636

_HID_REPORT::kind
uint8_t kind
The type of report (Input, Output or Feature) (eg HID_REPORT_INPUT).
Definition hid.h:633

_HID_REPORT::index
uint32_t index
The index of this report in the collection (First report is 0).
Definition hid.h:637

_HID_REPORT::size
uint32_t size
The number of bits per field in this report.
Definition hid.h:635

_HID_REPORT::usagecount
uint32_t usagecount
The number of usages contained in this report.
Definition hid.h:640

_HID_STACK
Definition hid.h:593

_HID_STACK::state
HID_STATE * state
Definition hid.h:594

_HID_STACK::next
HID_STACK * next
Definition hid.h:595

_HID_STATE
Definition hid.h:567

_HID_STATE::reportid
uint32_t reportid
Definition hid.h:585

_HID_STATE::physicalmaximum
int32_t physicalmaximum
Definition hid.h:581

_HID_STATE::delimiter
BOOL delimiter
Definition hid.h:575

_HID_STATE::stringindex
uint32_t stringindex
Definition hid.h:573

_HID_STATE::usagepage
uint16_t usagepage
Definition hid.h:577

_HID_STATE::logicalminimum
int32_t logicalminimum
Definition hid.h:578

_HID_STATE::physicalminimum
int32_t physicalminimum
Definition hid.h:580

_HID_STATE::designatorindex
uint32_t designatorindex
Definition hid.h:571

_HID_STATE::usage
uint32_t usage
Definition hid.h:569

_HID_STATE::stringcount
uint32_t stringcount
Provides StringMinimum/StringMaximum.
Definition hid.h:574

_HID_STATE::unitexponent
uint32_t unitexponent
Definition hid.h:583

_HID_STATE::reportcount
uint32_t reportcount
Definition hid.h:586

_HID_STATE::unittype
uint32_t unittype
Definition hid.h:582

_HID_STATE::designatorcount
uint32_t designatorcount
Provides DesignatorMinimum/DesignatorMaximum.
Definition hid.h:572

_HID_STATE::reportsize
uint32_t reportsize
Definition hid.h:584

_HID_STATE::logicalmaximum
int32_t logicalmaximum
Definition hid.h:579

_HID_STATE::usagecount
uint32_t usagecount
Provides UsageMinimum/UsageMaximum.
Definition hid.h:570

_HID_USAGE
Definition hid.h:608

_HID_USAGE::usage
uint16_t usage
The usage within the usage page.
Definition hid.h:610

_HID_USAGE::physicalmaximum
int32_t physicalmaximum
The physical maximum value for this usage (in Units).
Definition hid.h:620

_HID_USAGE::stringindex
uint32_t stringindex
The string index for this usage.
Definition hid.h:613

_HID_USAGE::logicalminimum
int32_t logicalminimum
The logical minimum value for this usage.
Definition hid.h:617

_HID_USAGE::physicalminimum
int32_t physicalminimum
The physical minimum value for this usage (in Units).
Definition hid.h:619

_HID_USAGE::aliascount
uint32_t aliascount
The number of aliased usages contained for this control.
Definition hid.h:624

_HID_USAGE::designatorindex
uint32_t designatorindex
The designator index for this usage.
Definition hid.h:615

_HID_USAGE::aliases
HID_USAGE * aliases
The list of aliased usages for this control (See Delimiters in Section 6.2.2.8).
Definition hid.h:623

_HID_USAGE::index
uint32_t index
The index of this usage in the report (First usage is 0).
Definition hid.h:612

_HID_USAGE::page
uint16_t page
The usage page this usage refers to.
Definition hid.h:609

_HID_USAGE::stringcount
uint32_t stringcount
The total number of sequential string index values where string index represents the minimum value or...
Definition hid.h:614

_HID_USAGE::report
HID_REPORT * report
The report this usage belongs to.
Definition hid.h:625

_HID_USAGE::unitexponent
uint32_t unitexponent
The unit exponent index for this usage.
Definition hid.h:622

_HID_USAGE::unittype
uint32_t unittype
The unit type for this usage.
Definition hid.h:621

_HID_USAGE::designatorcount
uint32_t designatorcount
The total number of sequential designator index values where designator index represents the minimum ...
Definition hid.h:616

_HID_USAGE::count
uint16_t count
The total number of sequential usages where Usage represents the minimum value or 1 for a single usag...
Definition hid.h:611

_HID_USAGE::logicalmaximum
int32_t logicalmaximum
The logical maximum value for this usage.
Definition hid.h:618