usb_hid.h

/* This file is the part of the Lightweight USB device Stack for STM32 microcontrollers
 *
 * Copyright ©2016 Dmitry Filimonchuk <dmitrystu[at]gmail[dot]com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *   http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _USB_HID_H_
#define _USB_HID_H_
#ifdef __cplusplus
    extern "C" {
#endif


#define USB_CLASS_HID               0x03    
#define USB_HID_SUBCLASS_NONBOOT    0x00    
#define USB_HID_SUBCLASS_BOOT       0x01    
#define USB_HID_PROTO_NONBOOT       0x00    
#define USB_HID_PROTO_KEYBOARD      0x01    
#define USB_HID_PROTO_MOUSE         0x02    
#define USB_HID_REPORT_IN           0x01    
#define USB_HID_REPORT_OUT          0x02    
#define USB_HID_REPORT_FEATURE      0x03    
#define USB_HID_GETREPORT           0x01    
#define USB_HID_GETIDLE             0x02    
#define USB_HID_GETPROTOCOL         0x03    
#define USB_HID_SETREPORT           0x09    
#define USB_HID_SETIDLE             0x0A    
#define USB_HID_SETPROTOCOL         0x0B    
#define USB_DTYPE_HID               0x21    
#define USB_DTYPE_HID_REPORT        0x22    
#define USB_HID_COUNTRY_NONE        0       
#define USB_HID_COUNTRY_AR          1       
#define USB_HID_COUNTRY_BE          2       
#define USB_HID_COUNTRY_CA_BI       3       
#define USB_HID_COUNTRY_CA_FR       4       
#define USB_HID_COUNTRY_CZ          5       
#define USB_HID_COUNTRY_DK          6       
#define USB_HID_COUNTRY_FI          7       
#define USB_HID_COUNTRY_FR          8       
#define USB_HID_COUNTRY_DE          9       
#define USB_HID_COUNTRY_GR          10      
#define USB_HID_COUNTRY_HEB         11      
#define USB_HID_COUNTRY_HU          12      
#define USB_HID_COUNTRY_ISO         13      
#define USB_HID_COUNTRY_IT          14      
#define USB_HID_COUNTRY_JP          15      
#define USB_HID_COUNTRY_KR          16      
#define USB_HID_COUNTRY_LAT         17      
#define USB_HID_COUNTRY_NL          18      
#define USB_HID_COUNTRY_NO          19      
#define USB_HID_COUNTRY_PER         20      
#define USB_HID_COUNTRY_PL          21      
#define USB_HID_COUNTRY_PO          22      
#define USB_HID_COUNTRY_RU          23      
#define USB_HID_COUNTRY_SK          24      
#define USB_HID_COUNTRY_ES          25      
#define USB_HID_COUNTRY_SE          26      
#define USB_HID_COUNTRY_CH_FR       26      
#define USB_HID_COUNTRY_CH_DE       27      
#define USB_HID_COUNTRY_CH          29      
#define USB_HID_COUNTRY_TW          30      
#define USB_HID_COUNTRY_TR_Q        31      
#define USB_HID_COUNTRY_UK          32      
#define USB_HID_COUNTRY_US          33      
#define USB_HID_COUNTRY_YU          34      
#define USB_HID_COUNTRY_TR_F        35      
#define HID_PHYSICAL_COLLECTION             0x00    
#define HID_APPLICATION_COLLECTION          0x01    
#define HID_LOGICAL_COLLECTION              0x02    
#define HID_REPORT_COLLECTION               0x03
#define HID_NARY_COLLECTION                 0x04    
#define HID_USAGE_SWITCH_COLLECTION         0x05    
#define HID_USAGE_MODIFIER_COLLECTION       0x06    
struct usb_hid_descriptor {
    uint8_t     bLength;            
    uint8_t     bDescriptorType;    
    uint16_t    bcdHID;             
    uint8_t     bCountryCode;       
    uint8_t     bNumDescriptors;    
    uint8_t     bDescriptorType0;   
    uint16_t    wDescriptorLength0; 
} __attribute__((packed));

struct usb_hid_descriptor_header {
    uint8_t     bLength;            
    uint8_t     bDescriptorType;    
    uint16_t    bcdHID;             
    uint8_t     bCountryCode;       
    uint8_t     bNumDescriptors;    
} __attribute__((packed));

struct usb_hid_report_descriptor {
    uint8_t     bDescriptorType;   
    uint16_t    wDescriptorLength; 
} __attribute__((packed));

#define DECLARE_USB_HID_DESCRIPTOR(p)               \
struct usb_hid_descriptor_##p {                     \
    uint8_t     bLength;                            \
    uint8_t     bDescriptorType;                    \
    uint16_t    bcdHID;                             \
    uint8_t     bCountryCode;                       \
    uint8_t     bNumDescriptors;                    \
    struct usb_hid_report_descriptor report[p];     \
} __attribute__((packed));


/* Private Interface - For use in library only: */
#if !defined(__DOXYGEN__)
    /* Macros: */
    #define CONCAT(x, y)            x ## y
    #define CONCAT_EXPANDED(x, y)   CONCAT(x, y)
    #define HID_RI_DATA_SIZE_MASK                   0x03
    #define HID_RI_TYPE_MASK                        0x0C
    #define HID_RI_TAG_MASK                         0xF0
    #define HID_RI_TYPE_MAIN                        0x00
    #define HID_RI_TYPE_GLOBAL                      0x04
    #define HID_RI_TYPE_LOCAL                       0x08
    #define HID_RI_DATA_BITS_0                      0x00
    #define HID_RI_DATA_BITS_8                      0x01
    #define HID_RI_DATA_BITS_16                     0x02
    #define HID_RI_DATA_BITS_32                     0x03
    #define HID_RI_DATA_BITS(DataBits)              CONCAT_EXPANDED(HID_RI_DATA_BITS_, DataBits)
    #define _HID_RI_ENCODE_0(Data)
    #define _HID_RI_ENCODE_8(Data)                  , (Data & 0xFF)
    #define _HID_RI_ENCODE_16(Data)                 _HID_RI_ENCODE_8(Data)  _HID_RI_ENCODE_8(Data >> 8)
    #define _HID_RI_ENCODE_32(Data)                 _HID_RI_ENCODE_16(Data) _HID_RI_ENCODE_16(Data >> 16)
    #define _HID_RI_ENCODE(DataBits, ...)           CONCAT_EXPANDED(_HID_RI_ENCODE_, DataBits(__VA_ARGS__))
    #define _HID_RI_ENTRY(Type, Tag, DataBits, ...) (Type | Tag | HID_RI_DATA_BITS(DataBits)) _HID_RI_ENCODE(DataBits, (__VA_ARGS__))
#endif
/* Public Interface - May be used in end-application: */
/* Macros: */
#define HID_IOF_CONSTANT                        (1 << 0)    
#define HID_IOF_DATA                            (0 << 0)    
#define HID_IOF_VARIABLE                        (1 << 1)    
#define HID_IOF_ARRAY                           (0 << 1)    
#define HID_IOF_RELATIVE                        (1 << 2)    
#define HID_IOF_ABSOLUTE                        (0 << 2)    
#define HID_IOF_WRAP                            (1 << 3)    
#define HID_IOF_NO_WRAP                         (0 << 3)    
#define HID_IOF_NON_LINEAR                      (1 << 4)    
#define HID_IOF_LINEAR                          (0 << 4)    
#define HID_IOF_NO_PREFERRED_STATE              (1 << 5)    
#define HID_IOF_PREFERRED_STATE                 (0 << 5)    
#define HID_IOF_NULLSTATE                       (1 << 6)    
#define HID_IOF_NO_NULL_POSITION                (0 << 6)    
#define HID_IOF_VOLATILE                        (1 << 7)    
#define HID_IOF_NON_VOLATILE                    (0 << 7)    
#define HID_IOF_BUFFERED_BYTES                  (1 << 8)    
#define HID_IOF_BITFIELD                        (0 << 8)    


#define HID_RI_INPUT(DataBits, ...)             _HID_RI_ENTRY(HID_RI_TYPE_MAIN  , 0x80, DataBits, __VA_ARGS__)

#define HID_RI_OUTPUT(DataBits, ...)            _HID_RI_ENTRY(HID_RI_TYPE_MAIN  , 0x90, DataBits, __VA_ARGS__)

#define HID_RI_COLLECTION(DataBits, ...)        _HID_RI_ENTRY(HID_RI_TYPE_MAIN  , 0xA0, DataBits, __VA_ARGS__)

#define HID_RI_FEATURE(DataBits, ...)           _HID_RI_ENTRY(HID_RI_TYPE_MAIN  , 0xB0, DataBits, __VA_ARGS__)

#define HID_RI_END_COLLECTION(DataBits, ...)    _HID_RI_ENTRY(HID_RI_TYPE_MAIN  , 0xC0, DataBits, __VA_ARGS__)


#define HID_RI_USAGE_PAGE(DataBits, ...)        _HID_RI_ENTRY(HID_RI_TYPE_GLOBAL, 0x00, DataBits, __VA_ARGS__)

#define HID_RI_LOGICAL_MINIMUM(DataBits, ...)   _HID_RI_ENTRY(HID_RI_TYPE_GLOBAL, 0x10, DataBits, __VA_ARGS__)

#define HID_RI_LOGICAL_MAXIMUM(DataBits, ...)   _HID_RI_ENTRY(HID_RI_TYPE_GLOBAL, 0x20, DataBits, __VA_ARGS__)

#define HID_RI_PHYSICAL_MINIMUM(DataBits, ...)  _HID_RI_ENTRY(HID_RI_TYPE_GLOBAL, 0x30, DataBits, __VA_ARGS__)

#define HID_RI_PHYSICAL_MAXIMUM(DataBits, ...)  _HID_RI_ENTRY(HID_RI_TYPE_GLOBAL, 0x40, DataBits, __VA_ARGS__)

#define HID_RI_UNIT_EXPONENT(DataBits, ...)     _HID_RI_ENTRY(HID_RI_TYPE_GLOBAL, 0x50, DataBits, __VA_ARGS__)

#define HID_RI_UNIT(DataBits, ...)              _HID_RI_ENTRY(HID_RI_TYPE_GLOBAL, 0x60, DataBits, __VA_ARGS__)

#define HID_RI_REPORT_SIZE(DataBits, ...)       _HID_RI_ENTRY(HID_RI_TYPE_GLOBAL, 0x70, DataBits, __VA_ARGS__)

#define HID_RI_REPORT_ID(DataBits, ...)         _HID_RI_ENTRY(HID_RI_TYPE_GLOBAL, 0x80, DataBits, __VA_ARGS__)

#define HID_RI_REPORT_COUNT(DataBits, ...)      _HID_RI_ENTRY(HID_RI_TYPE_GLOBAL, 0x90, DataBits, __VA_ARGS__)

#define HID_RI_PUSH(DataBits, ...)              _HID_RI_ENTRY(HID_RI_TYPE_GLOBAL, 0xA0, DataBits, __VA_ARGS__)

#define HID_RI_POP(DataBits, ...)               _HID_RI_ENTRY(HID_RI_TYPE_GLOBAL, 0xB0, DataBits, __VA_ARGS__)


#define HID_RI_USAGE(DataBits, ...)             _HID_RI_ENTRY(HID_RI_TYPE_LOCAL , 0x00, DataBits, __VA_ARGS__)

#define HID_RI_USAGE_MINIMUM(DataBits, ...)     _HID_RI_ENTRY(HID_RI_TYPE_LOCAL , 0x10, DataBits, __VA_ARGS__)

#define HID_RI_USAGE_MAXIMUM(DataBits, ...)     _HID_RI_ENTRY(HID_RI_TYPE_LOCAL , 0x20, DataBits, __VA_ARGS__)

#define HID_RI_DESIGNATOR_INDEX(DataBits, ...)  _HID_RI_ENTRY(HID_RI_TYPE_LOCAL , 0x30, DataBits, __VA_ARGS__)

#define HID_RI_DESIGNATOR_MIN(DataBits, ...)    _HID_RI_ENTRY(HID_RI_TYPE_LOCAL , 0x40, DataBits, __VA_ARGS__)

#define HID_RI_DESIGNATOR_MAX(DataBits, ...)    _HID_RI_ENTRY(HID_RI_TYPE_LOCAL , 0x50, DataBits, __VA_ARGS__)

#define HID_RI_STRING_INDEX(DataBits, ...)      _HID_RI_ENTRY(HID_RI_TYPE_LOCAL , 0x70, DataBits, __VA_ARGS__)

#define HID_RI_STRING_MINIMUM(DataBits, ...)    _HID_RI_ENTRY(HID_RI_TYPE_LOCAL , 0x80, DataBits, __VA_ARGS__)

#define HID_RI_STRING_MAXIMUM(DataBits, ...)    _HID_RI_ENTRY(HID_RI_TYPE_LOCAL , 0x90, DataBits, __VA_ARGS__)

#define HID_RI_DELIMITER(DataBits, ...)         _HID_RI_ENTRY(HID_RI_TYPE_LOCAL , 0xA0, DataBits, __VA_ARGS__)


#define HID_INPUT(data)                     HID_RI_INPUT(8, data)               
#define HID_OUTPUT(data)                    HID_RI_OUTPUT(8, data)              
#define HID_COLLECTION(data)                HID_RI_COLLECTION(8, data)          
#define HID_FEATURE(data)                   HID_RI_FEATURE(8, data)             
#define HID_END_COLLECTION                  HID_RI_END_COLLECTION(0)            
#define HID_USAGE_PAGE(data)                HID_RI_USAGE_PAGE(8, data)          
#define HID_LOGICAL_MINIMUM(data)           HID_RI_LOGICAL_MINIMUM(8, data)     
#define HID_LOGICAL_MAXIMUM(data)           HID_RI_LOGICAL_MAXIMUM(8, data)     
#define HID_PHYSICAL_MINIMUM(data)          HID_RI_PHYSICAL_MINIMUM(16, data)   
#define HID_PHYSICAL_MAXIMUM(data)          HID_RI_PHYSICAL_MAXIMUM(16, data)   
#define HID_UNIT_EXPONENT(data)             HID_RI_UNIT_EXPONENT(8, data)       
#define HID_UNIT(bits, data)                HID_RI_UNIT(bits, data)             
#define HID_REPORT_SIZE(data)               HID_RI_REPORT_SIZE(8, data)         
#define HID_REPORT_ID(data)                 HID_RI_REPORT_ID(8, data)           
#define HID_REPORT_COUNT(data)              HID_RI_REPORT_COUNT(8, data)        
#define HID_PUSH                            HID_RI_PUSH(0)                      
#define HID_POP                             HID_RI_POP(0)                       
#define HID_USAGE(data)                     HID_RI_USAGE(8, data)               
#define HID_USAGE_MINIMUM(data)             HID_RI_USAGE_MINIMUM(8, data)       
#define HID_USAGE_MAXIMUM(data)             HID_RI_USAGE_MAXIMUM(8, data)       


#define HID_UNIT_NONE                       0x00                    
#define HID_UNIT_CGS_LINEAR                 0x01                    
#define HID_UNIT_CGS_ROTATION               0x02                    
#define HID_UNIT_IMPERIAL_LINEAR            0x03                    
#define HID_UNIT_IMPERIAL_ROTATION          0x04                    
#define HID_UNIT_LENGTH(exp)                ((exp & 0x0F) << 4)     
#define HID_UNIT_ANGLE(exp)                 ((exp & 0x0F) << 4)     
#define HID_UNIT_MASS(exp)                  ((exp & 0x0F) << 8)     
#define HID_UNIT_TIME(exp)                  ((exp & 0x0F) << 12)    
#define HID_UNIT_TEMPERATURE(exp)           ((exp & 0x0F) << 16)    
#define HID_UNIT_CURRENT(exp)               ((exp & 0x0F) << 20)    
#define HID_UNIT_LUMINOUS(exp)              ((exp & 0x0F) << 24)    


#define HID_UNIT_METER(exp) \
    HID_UNIT(8, HID_UNIT_CGS_LINEAR | HID_UNIT_LENGTH(1)), \
    HID_UNIT_EXPONENT(exp + 2)

#define HID_UNIT_KG(exp) \
    HID_UNIT(16, HID_UNIT_CGS_LINEAR | HID_UNIT_MASS(1), \
    HID_UNIT_EXPONENT(exp + 3)

#define HID_UNIT_SECOND(exp) \
    HID_UNIT(16, HID_UNIT_CGS_LINEAR | HID_UNIT_TIME(1), \
    HID_UNIT_EXPONENT(exp + 0)

#define HID_UNIT_MPS(exp) \
    HID_UNIT(16, HID_UNIT_CGS_LINEAR | HID_UNIT_LENGTH(1) | HID_UNIT_TIME(-1)), \
    HID_UNIT_EXPONENT(exp + 2)

#define HID_UNIT_MPS2(exp) \
    HID_UNIT(16, HID_UNIT_CGS_LINEAR | HID_UNIT_LENGTH(1) | HID_UNIT_TIME(-2)), \
    HID_UNIT_EXPONENT(exp + 2)

#define HID_UNIT_NEWTON(exp) \
    HID_UNIT(16, HID_UNIT_CGS_LINEAR | HID_UNIT_MASS(1) | HID_UNIT_LENGTH(1) | HID_UNIT_TIME(-2)), \
    HID_UNIT_EXPONENT(exp + 5)

#define HID_UNIT_JOULE(exp) \
    HID_UNIT(16, HID_UNIT_CGS_LINEAR | HID_UNIT_MASS(1) | HID_UNIT_LENGTH(2) | HID_UNIT_TIME(-2)), \
    HID_UNIT_EXPONENT(exp + 7)

#define HID_UNIT_WATT(exp) \
    HID_UNIT(16, HID_UNIT_CGS_LINEAR | HID_UNIT_MASS(1) | HID_UNIT_LENGTH(2) | HID_UNIT_TIME(-3)), \
    HID_UNIT_EXPONENT(exp + 7)

#define HID_UNIT_PASCAL(exp) \
    HID_UNIT(16, HID_UNIT_CGS_LINEAR | HID_UNIT_MASS(1) | HID_UNIT_LENGTH(-1) | HID_UNIT_TIME(-2)), \
    HID_UNIT_EXPONENT(exp + 1)

#define HID_UNIT_HERTZ(exp) \
    HID_UNIT(16, HID_UNIT_CGS_LINEAR | HID_UNIT_TIME(-1)), \
    HID_UNIT_EXPONENT(exp + 0)

#define HID_UNIT_AMPERE(exp) \
    HID_UNIT(32, HID_UNIT_CGS_LINEAR | HID_UNIT_CURRENT(1)), \
    HID_UNIT_EXPONENT(exp)

#define HID_UNIT_VOLT(exp) \
    HID_UNIT(32, HID_UNIT_CGS_LINEAR | HID_UNIT_MASS(1) | HID_UNIT_LENGTH(2) |  HID_UNIT_TIME(-3) | HID_UNIT_CURRENT(-1)), \
    HID_UNIT_EXPONENT(exp + 7)

#define HID_UNIT_OHM(exp) \
    HID_UNIT(32, HID_UNIT_CGS_LINEAR | HID_UNIT_MASS(1) | HID_UNIT_LENGTH(2) |  HID_UNIT_TIME(-3) | HID_UNIT_CURRENT(-2)), \
    HID_UNIT_EXPONENT(exp + 7)

#define HID_UNIT_HENRY(exp) \
    HID_UNIT(32, HID_UNIT_CGS_LINEAR | HID_UNIT_MASS(1) | HID_UNIT_LENGTH(2) |  HID_UNIT_TIME(-2) | HID_UNIT_CURRENT(-2)), \
    HID_UNIT_EXPONENT(exp + 7)

#define HID_UNIT_FARAD(exp) \
    HID_UNIT(32, HID_UNIT_CGS_LINEAR | HID_UNIT_MASS(-1) | HID_UNIT_LENGTH(-2) |  HID_UNIT_TIME(4) | HID_UNIT_CURRENT(2)), \
    HID_UNIT_EXPONENT(exp - 7)

#define HID_UNIT_COULOMB(exp) \
    HID_UNIT(32, HID_UNIT_CGS_LINEAR | HID_UNIT_TIME(1) | HID_UNIT_CURRENT(1)), \
    HID_UNIT_EXPONENT(exp)

#define HID_UNIT_TESLA(exp) \
    HID_UNIT(32, HID_UNIT_CGS_LINEAR | HID_UNIT_MASS(1) | HID_UNIT_TIME(-2) | HID_UNIT_CURRENT(-1)), \
    HID_UNIT_EXPONENT(exp)

#define HID_UNIT_LUX(exp) \
    HID_UNIT(32, HID_UNIT_CGS_LINEAR | HID_UNIT_LENGTH(-1) | HID_UNIT_LUMINOUS(1)), \
    HID_UNIT_EXPONENT(exp)


#ifdef __cplusplus
    }
#endif

#endif