|
// http://www.frank-zhao.com/cache/hid_tutorial_1.php
|
|
|
|
//#include <inttypes.h>
|
|
//#include <stdbool.h>
|
|
//#include <stdio.h>
|
|
|
|
#include "hidparser.h"
|
|
#include "debug.h"
|
|
//#include "printf.h"
|
|
//#include <stdio.h>
|
|
|
|
#if 0
|
|
#define hidp_extreme_debugf(...) hidp_debugf(__VA_ARGS__)
|
|
#else
|
|
#define hidp_extreme_debugf(...)
|
|
#endif
|
|
|
|
//#define hidp_debugf printf
|
|
|
|
typedef struct {
|
|
uint8_t bSize: 2;
|
|
uint8_t bType: 2;
|
|
uint8_t bTag: 4;
|
|
} __attribute__((packed)) item_t;
|
|
|
|
// flags for joystick components required
|
|
#define JOYSTICK_REQ_AXIS_X 0x01
|
|
#define JOYSTICK_REQ_AXIS_Y 0x02
|
|
#define JOYSTICK_REQ_BTN_0 0x04
|
|
#define JOYSTICK_COMPLETE (JOYSTICK_REQ_AXIS_X | JOYSTICK_REQ_AXIS_Y | JOYSTICK_REQ_BTN_0)
|
|
|
|
#define USAGE_PAGE_GENERIC_DESKTOP 1
|
|
#define USAGE_PAGE_SIMULATION 2
|
|
#define USAGE_PAGE_VR 3
|
|
#define USAGE_PAGE_SPORT 4
|
|
#define USAGE_PAGE_GAMING 5
|
|
#define USAGE_PAGE_GENERIC_DEVICE 6
|
|
#define USAGE_PAGE_KEYBOARD 7
|
|
#define USAGE_PAGE_LEDS 8
|
|
#define USAGE_PAGE_BUTTON 9
|
|
#define USAGE_PAGE_ORDINAL 10
|
|
#define USAGE_PAGE_TELEPHONY 11
|
|
#define USAGE_PAGE_CONSUMER 12
|
|
|
|
|
|
#define USAGE_POINTER 1
|
|
#define USAGE_MOUSE 2
|
|
#define USAGE_JOYSTICK 4
|
|
#define USAGE_GAMEPAD 5
|
|
#define USAGE_KEYBOARD 6
|
|
#define USAGE_KEYPAD 7
|
|
#define USAGE_MULTIAXIS 8
|
|
|
|
#define USAGE_X 48
|
|
#define USAGE_Y 49
|
|
#define USAGE_Z 50
|
|
#define USAGE_WHEEL 56
|
|
|
|
bool parse_report_descriptor(uint8_t *rep, uint16_t rep_size, hid_config_t *conf) {
|
|
int8_t app_collection = 0;
|
|
int8_t phys_log_collection = 0;
|
|
uint8_t skip_collection = 0;
|
|
int8_t generic_desktop = -1; // depth at which first gen_desk was found
|
|
uint8_t collection_depth = 0;
|
|
|
|
uint8_t i;
|
|
|
|
//
|
|
uint8_t report_size, report_count;
|
|
uint16_t bit_count = 0, usage_count = 0;
|
|
uint16_t logical_minimum=0, logical_maximum=0;
|
|
|
|
// mask used to check of all required components have been found, so
|
|
// that e.g. both axes and the button of a joystick are ready to be used
|
|
uint8_t setup_complete = 0;
|
|
|
|
/*printf("PARSE:");
|
|
int j = 0;
|
|
for (j=0; j!=rep_size; ++j)
|
|
{
|
|
printf("%02x",rep[j]);
|
|
}
|
|
printf(" ");*/
|
|
|
|
// joystick/mouse components
|
|
int8_t axis[2]; // MWW = { -1, -1}; (this instantiates memcpy!)
|
|
axis[0] = -1;
|
|
axis[1] = -1;
|
|
uint8_t btns = 0;
|
|
|
|
conf->type = CONFIG_TYPE_NONE;
|
|
|
|
while(rep_size) {
|
|
// extract short item
|
|
/* uint8_t tag = ((item_t*)rep)->bTag;
|
|
uint8_t type = ((item_t*)rep)->bType;
|
|
uint8_t size = ((item_t*)rep)->bSize;*/
|
|
/*typedef struct {
|
|
uint8_t bSize: 2;
|
|
uint8_t bType: 2;
|
|
uint8_t bTag: 4;
|
|
} __attribute__((packed)) item_t;*/
|
|
// MWW - bitfields are not working
|
|
uint8_t tag = (rep[0]&0xf0)>>4;
|
|
uint8_t type = (rep[0]&0x0c)>>2;
|
|
uint8_t size = rep[0]&0x03;
|
|
// printf("WTF:%02x %02x %02x %02x\n",rep[0],tag,type,size);
|
|
|
|
rep++;
|
|
rep_size--; // one byte consumed
|
|
|
|
uint32_t value = 0;
|
|
if(size) { // size 1/2/3
|
|
value = *rep++;
|
|
rep_size--;
|
|
}
|
|
|
|
if(size > 1) { // size 2/3
|
|
value = (value & 0xff) + ((uint32_t)(*rep++)<<8);
|
|
rep_size--;
|
|
}
|
|
|
|
if(size > 2) { // size 3
|
|
value &= 0xffff;
|
|
value |= ((uint32_t)(*rep++)<<16);
|
|
value |= ((uint32_t)(*rep++)<<24);
|
|
rep_size-=2;
|
|
}
|
|
|
|
// hidp_extreme_debugf("Value = %d (%u)\n", value, value);
|
|
|
|
// we are currently skipping an unknown/unsupported collection)
|
|
if(skip_collection) {
|
|
if(!type) { // main item
|
|
// any new collection increases the depth of collections to skip
|
|
if(tag == 10) {
|
|
skip_collection++;
|
|
collection_depth++;
|
|
}
|
|
|
|
// any end collection decreases it
|
|
if(tag == 12) {
|
|
skip_collection--;
|
|
collection_depth--;
|
|
|
|
// leaving the depth the generic desktop was valid for
|
|
if(generic_desktop > collection_depth)
|
|
generic_desktop = -1;
|
|
}
|
|
}
|
|
|
|
|
|
} else {
|
|
// hidp_extreme_debugf("-> Item tag=%d type=%d size=%d\n", tag, type, size);
|
|
|
|
switch(type) {
|
|
case 0:
|
|
// main item
|
|
|
|
switch(tag) {
|
|
case 8:
|
|
//
|
|
if(btns) {
|
|
if(conf->type == CONFIG_TYPE_JOYSTICK) {
|
|
// scan for up to 24 buttons
|
|
char b;
|
|
for(b=0;b<24;b++) {
|
|
if(report_count > b) {
|
|
uint16_t this_bit = bit_count+b;
|
|
|
|
hidp_debugf("BUTTON%d @ %d (byte %d, mask %d)\n", b,
|
|
this_bit, this_bit/8, 1 << (this_bit%8));
|
|
|
|
conf->joystick.button[b].byte_offset = this_bit/8;
|
|
conf->joystick.button[b].bitmask = 1 << (this_bit%8);
|
|
}
|
|
}
|
|
|
|
// we found at least one button which is all we want to accept this as a valid
|
|
// joystick
|
|
setup_complete |= JOYSTICK_REQ_BTN_0;
|
|
}
|
|
}
|
|
|
|
//
|
|
char c;
|
|
for(c=0;c<2;c++) {
|
|
if(axis[c] >= 0) {
|
|
uint16_t cnt = bit_count + report_size * axis[c];
|
|
hidp_debugf(" (%c-AXIS @ %d (byte %d))\n", 'X'+c,
|
|
cnt, cnt/8);
|
|
|
|
// only 8/16 bit axes at byte boundaries are supported for
|
|
// joysticks
|
|
if((conf->type == CONFIG_TYPE_JOYSTICK) &&
|
|
((report_size == 8) || (report_size == 16)) && ((cnt&7) == 0)) {
|
|
// save in joystick config
|
|
conf->joystick.axis[c].byte_offset = cnt/8;
|
|
conf->joystick.axis[c].size = report_size;
|
|
conf->joystick.axis[c].logical.min = logical_minimum;
|
|
conf->joystick.axis[c].logical.max = logical_maximum;
|
|
conf->joystick.axis[c].size = report_size;
|
|
if(c==0) setup_complete |= JOYSTICK_REQ_AXIS_X;
|
|
if(c==1) setup_complete |= JOYSTICK_REQ_AXIS_Y;
|
|
}
|
|
|
|
if((report_size != 8) && (report_size != 16))
|
|
hidp_debugf("Unsupported report size %d\n", report_size);
|
|
|
|
if((cnt&7) != 0)
|
|
hidp_debugf("Unsupported bit offset %d\n", cnt&7);
|
|
}
|
|
}
|
|
|
|
hidp_extreme_debugf("INPUT(%d)\n", value);
|
|
|
|
// reset for next inputs
|
|
bit_count += report_count * report_size;
|
|
usage_count = 0;
|
|
btns = 0;
|
|
axis[0] = axis[1] = -1;
|
|
break;
|
|
|
|
case 9:
|
|
hidp_extreme_debugf("OUTPUT(%d)\n", value);
|
|
break;
|
|
|
|
case 11:
|
|
hidp_extreme_debugf("FEATURE(%d)\n", value);
|
|
break;
|
|
|
|
case 10:
|
|
hidp_extreme_debugf("COLLECTION(%d)\n", value);
|
|
collection_depth++;
|
|
usage_count = 0;
|
|
|
|
if(value == 1) { // app collection
|
|
hidp_extreme_debugf(" -> application\n");
|
|
app_collection++;
|
|
} else if(value == 0) { // physical collection
|
|
hidp_extreme_debugf(" -> physical\n");
|
|
phys_log_collection++;
|
|
} else if(value == 2) { // logical collection
|
|
hidp_extreme_debugf(" -> logical\n");
|
|
phys_log_collection++;
|
|
} else {
|
|
hidp_extreme_debugf("skipping unsupported collection\n");
|
|
skip_collection++;
|
|
}
|
|
break;
|
|
|
|
case 12:
|
|
hidp_extreme_debugf("END_COLLECTION(%d)\n", value);
|
|
collection_depth--;
|
|
|
|
// leaving the depth the generic desktop was valid for
|
|
if(generic_desktop > collection_depth)
|
|
generic_desktop = -1;
|
|
|
|
if(phys_log_collection) {
|
|
hidp_extreme_debugf(" -> phys/log end\n");
|
|
phys_log_collection--;
|
|
} else if(app_collection) {
|
|
hidp_extreme_debugf(" -> app end\n");
|
|
app_collection--;
|
|
} else {
|
|
hidp_debugf(" -> unexpected\n");
|
|
return false;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
hidp_debugf("unexpected main item %d\n", tag);
|
|
return false;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
// global item
|
|
switch(tag) {
|
|
case 0:
|
|
hidp_extreme_debugf("USAGE_PAGE(%d/0x%x)\n", value, value);
|
|
|
|
if(value == USAGE_PAGE_KEYBOARD) {
|
|
hidp_extreme_debugf(" -> Keyboard\n");
|
|
} else if(value == USAGE_PAGE_GAMING) {
|
|
hidp_extreme_debugf(" -> Game device\n");
|
|
} else if(value == USAGE_PAGE_LEDS) {
|
|
hidp_extreme_debugf(" -> LEDs\n");
|
|
} else if(value == USAGE_PAGE_CONSUMER) {
|
|
hidp_extreme_debugf(" -> Consumer\n");
|
|
} else if(value == USAGE_PAGE_BUTTON) {
|
|
hidp_extreme_debugf(" -> Buttons\n");
|
|
btns = 1;
|
|
} else if(value == USAGE_PAGE_GENERIC_DESKTOP) {
|
|
hidp_extreme_debugf(" -> Generic Desktop\n");
|
|
|
|
if(generic_desktop < 0)
|
|
generic_desktop = collection_depth;
|
|
} else
|
|
hidp_extreme_debugf(" -> UNSUPPORTED USAGE_PAGE\n");
|
|
|
|
break;
|
|
|
|
case 1:
|
|
hidp_extreme_debugf("LOGICAL_MINIMUM(%d/%d)\n", value, (int8_t)value);
|
|
logical_minimum = value;
|
|
break;
|
|
|
|
case 2:
|
|
hidp_extreme_debugf("LOGICAL_MAXIMUM(%d)\n", value);
|
|
logical_maximum = value;
|
|
break;
|
|
|
|
case 3:
|
|
hidp_extreme_debugf("PHYSICAL_MINIMUM(%d/%d)\n", value, (int8_t)value);
|
|
break;
|
|
|
|
case 4:
|
|
hidp_extreme_debugf("PHYSICAL_MAXIMUM(%d)\n", value);
|
|
break;
|
|
|
|
case 5:
|
|
hidp_extreme_debugf("UNIT_EXPONENT(%d)\n", value);
|
|
break;
|
|
|
|
case 6:
|
|
hidp_extreme_debugf("UNIT(%d)\n", value);
|
|
break;
|
|
|
|
case 7:
|
|
hidp_extreme_debugf("REPORT_SIZE(%d)\n", value);
|
|
report_size = value;
|
|
break;
|
|
|
|
case 8:
|
|
hidp_extreme_debugf("REPORT_ID(%d)\n", value);
|
|
conf->report_id = value;
|
|
break;
|
|
|
|
case 9:
|
|
hidp_extreme_debugf("REPORT_COUNT(%d)\n", value);
|
|
report_count = value;
|
|
break;
|
|
|
|
default:
|
|
hidp_debugf("unexpected global item %d\n", tag);
|
|
return false;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
// local item
|
|
switch(tag) {
|
|
case 0:
|
|
// we only support mice, keyboards and joysticks
|
|
hidp_extreme_debugf("USAGE(%d/0x%x)\n", value, value);
|
|
|
|
if( !collection_depth && (value == USAGE_KEYBOARD)) {
|
|
// usage(keyboard) is always allowed
|
|
hidp_debugf(" -> Keyboard\n");
|
|
conf->type = CONFIG_TYPE_KEYBOARD;
|
|
} else if(!collection_depth && (value == USAGE_MOUSE)) {
|
|
// usage(mouse) is always allowed
|
|
hidp_debugf(" -> Mouse\n");
|
|
conf->type = CONFIG_TYPE_MOUSE;
|
|
} else if(!collection_depth &&
|
|
((value == USAGE_GAMEPAD) || (value == USAGE_JOYSTICK))) {
|
|
hidp_extreme_debugf(" -> Gamepad/Joystick\n");
|
|
hidp_debugf("Gamepad/Joystick usage found\n");
|
|
conf->type = CONFIG_TYPE_JOYSTICK;
|
|
} else if(value == USAGE_POINTER && app_collection) {
|
|
// usage(pointer) is allowed within the application collection
|
|
|
|
hidp_debugf(" -> Pointer\n");
|
|
|
|
} else if((value == USAGE_X || value == USAGE_Y) && app_collection) {
|
|
// usage(x) and usage(y) are allowed within the app collection
|
|
hidp_extreme_debugf(" -> axis usage\n");
|
|
|
|
// we support x and y axis on joysticks
|
|
if(conf->type == CONFIG_TYPE_JOYSTICK) {
|
|
if(value == USAGE_X) {
|
|
hidp_extreme_debugf("JOYSTICK: found x axis @ %d\n", usage_count);
|
|
axis[0] = usage_count;
|
|
}
|
|
if(value == USAGE_Y) {
|
|
hidp_extreme_debugf("JOYSTICK: found y axis @ %d\n", usage_count);
|
|
axis[1] = usage_count;
|
|
}
|
|
}
|
|
} else {
|
|
hidp_extreme_debugf(" -> UNSUPPORTED USAGE\n");
|
|
// return false;
|
|
}
|
|
|
|
usage_count++;
|
|
break;
|
|
|
|
case 1:
|
|
hidp_extreme_debugf("USAGE_MINIMUM(%d)\n", value);
|
|
usage_count -= (value-1);
|
|
break;
|
|
|
|
case 2:
|
|
hidp_extreme_debugf("USAGE_MAXIMUM(%d)\n", value);
|
|
usage_count += value;
|
|
break;
|
|
|
|
default:
|
|
hidp_extreme_debugf("unexpected local item %d\n", tag);
|
|
// return false;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// reserved
|
|
hidp_extreme_debugf("unexpected resreved item %d\n", tag);
|
|
// return false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
hidp_debugf("total bit count: %d (%d bytes, %d bits)\n",
|
|
bit_count, bit_count/8, bit_count%8);
|
|
|
|
conf->report_size = bit_count/8;
|
|
|
|
// check if something useful was detected
|
|
if(conf->type == CONFIG_TYPE_JOYSTICK) {
|
|
if(setup_complete == JOYSTICK_COMPLETE) {
|
|
hidp_debugf("Joystick ok\n");
|
|
return true;
|
|
}
|
|
|
|
hidp_debugf("Ignoring incomplete joystick %x\n", setup_complete);
|
|
} else
|
|
hidp_debugf("No joystick\n");
|
|
|
|
return false;
|
|
}
|