| 0,0 → 1,720 |
|---|
| /* MAX3421E USB Host controller configuration descriptor parser */ |
| #include <Spi.h> |
| #include <Max3421e.h> |
| #include <Usb.h> |
| #include "descriptor_parser.h" |
| |
| #define LOBYTE(x) ((char*)(&(x)))[0] |
| #define HIBYTE(x) ((char*)(&(x)))[1] |
| #define BUFSIZE 256 //buffer size |
| #define DEVADDR 1 |
| |
| #define getReportDescr( addr, ep, nbytes, parse_func, nak_limit ) ctrlXfer( addr, ep, bmREQ_HIDREPORT, USB_REQUEST_GET_DESCRIPTOR, 0x00, HID_DESCRIPTOR_REPORT, 0x0000, nbytes, parse_func, nak_limit ) |
| #define getReport( addr, ep, nbytes, interface, report_type, report_id, parse_func, nak_limit ) ctrlXfer( addr, ep, bmREQ_HIDIN, HID_REQUEST_GET_REPORT, report_id, report_type, interface, nbytes, parse_func, nak_limit ) |
| |
| /* Foeward declarations */ |
| void setup(); |
| void loop(); |
| byte ctrlXfer( byte addr, byte ep, byte bmReqType, byte bRequest, byte wValLo, byte wValHi, unsigned int wInd, uint16_t nbytes, PARSE parse_func, uint16_t nak_limit ); |
| void HIDreport_parse( uint8_t* buf, uint8_t* head, uint8_t* tail); |
| |
| typedef struct { |
| uint8_t bDescriptorType; |
| uint16_t wDescriptorLength; |
| } HID_CLASS_DESCRIPTOR; |
| |
| |
| //typedef void (*PARSE)( int8_t*, int8_t*, int8_t ); |
| |
| MAX3421E Max; |
| USB Usb; |
| |
| void setup() |
| { |
| Serial.begin( 115200 ); |
| printProgStr(PSTR("\r\nStart")); |
| Max.powerOn(); |
| delay( 200 ); |
| } |
| |
| void loop() |
| { |
| uint8_t rcode; |
| uint8_t tmpbyte = 0; |
| //PARSE pf = &HIDreport_parse; |
| /**/ |
| Max.Task(); |
| Usb.Task(); |
| if( Usb.getUsbTaskState() >= USB_STATE_CONFIGURING ) { //state configuring or higher |
| /* printing device descriptor */ |
| printProgStr(PSTR("\r\nDevice addressed... ")); |
| printProgStr(PSTR("Requesting device descriptor.")); |
| tmpbyte = getdevdescr( DEVADDR ); //number of configurations, 0 if error |
| if( tmpbyte == 0 ) { |
| printProgStr(PSTR("\r\nDevice descriptor cannot be retrieved. Program Halted\r\n")); |
| while( 1 ); //stop |
| }//if( tmpbyte |
| /* print configuration descriptors for all configurations */ |
| for( uint8_t i = 0; i < tmpbyte; i++ ) { |
| getconfdescr( DEVADDR, i ); |
| } |
| /* Stop */ |
| while( 1 ); //stop |
| } |
| } |
| |
| /* Prints device descriptor. Returns number of configurations or zero if request error occured */ |
| byte getdevdescr( byte addr ) |
| { |
| USB_DEVICE_DESCRIPTOR buf; |
| byte rcode; |
| //Max.toggle( BPNT_0 ); |
| rcode = Usb.getDevDescr( addr, 0, 0x12, ( char *)&buf ); |
| if( rcode ) { |
| printProgStr( rcode_error_msg ); |
| print_hex( rcode, 8 ); |
| return( 0 ); |
| } |
| printProgStr(PSTR("\r\nDevice descriptor: \r\n")); |
| //Descriptor length |
| printProgStr( descr_len ); |
| print_hex( buf.bLength, 8 ); |
| //Descriptor type |
| // printProgStr( descr_type ); |
| // print_hex( buf.bDescriptorType, 8 ); |
| // printProgStr( descrtype_parse( buf.bDescriptorType )); |
| //USB Version |
| printProgStr(PSTR("\r\nUSB version:\t\t")); |
| Serial.print(( HIBYTE( buf.bcdUSB )), HEX ); |
| Serial.print("."); |
| Serial.print(( LOBYTE( buf.bcdUSB )), HEX ); |
| //Device class |
| printProgStr( class_str ); |
| print_hex( buf.bDeviceClass, 8 ); |
| printProgStr( classname_parse( buf.bDeviceClass )); |
| //Device Subclass |
| printProgStr( subclass_str ); |
| print_hex( buf.bDeviceSubClass, 8 ); |
| //Device Protocol |
| printProgStr( protocol_str ); |
| print_hex( buf.bDeviceProtocol, 8 ); |
| //Max.packet size |
| printProgStr( maxpktsize_str ); |
| print_hex( buf.bMaxPacketSize0, 8 ); |
| //VID |
| printProgStr(PSTR("\r\nVendor ID:\t\t")); |
| print_hex( buf.idVendor, 16 ); |
| //PID |
| printProgStr(PSTR("\r\nProduct ID:\t\t")); |
| print_hex( buf.idProduct, 16 ); |
| //Revision |
| printProgStr(PSTR("\r\nRevision ID:\t\t")); |
| print_hex( buf.bcdDevice, 16 ); |
| //Mfg.string |
| printProgStr (PSTR("\r\nMfg.string index:\t")); |
| print_hex( buf.iManufacturer, 8 ); |
| getstrdescr( addr, buf.iManufacturer ); |
| //Prod.string |
| printProgStr(PSTR("\r\nProd.string index:\t")); |
| print_hex( buf.iProduct, 8 ); |
| //printProgStr( str_cont ); |
| getstrdescr( addr, buf.iProduct ); |
| //Serial number string |
| printProgStr(PSTR("\r\nSerial number index:\t")); |
| print_hex( buf.iSerialNumber, 8 ); |
| //printProgStr( str_cont ); |
| getstrdescr( addr, buf.iSerialNumber ); |
| //Number of configurations |
| printProgStr(PSTR("\r\nNumber of conf.:\t")); |
| print_hex( buf.bNumConfigurations, 8 ); |
| return( buf.bNumConfigurations ); |
| } |
| /* Get string descriptor. Takes device address and string index */ |
| byte getstrdescr( byte addr, byte idx ) |
| { |
| char buf[ BUFSIZE ]; |
| byte rcode; |
| byte length; |
| byte i; |
| unsigned int langid; |
| if( idx == 0 ) { //don't try to get index zero |
| return( 0 ); |
| } |
| rcode = Usb.getStrDescr( addr, 0, 1, 0, 0, buf ); //get language table length |
| if( rcode ) { |
| printProgStr(PSTR("\r\nError retrieving LangID table length")); |
| return( rcode ); |
| } |
| length = buf[ 0 ]; //length is the first byte |
| rcode = Usb.getStrDescr( addr, 0, length, 0, 0, buf ); //get language table |
| if( rcode ) { |
| printProgStr(PSTR("\r\nError retrieving LangID table")); |
| return( rcode ); |
| } |
| HIBYTE( langid ) = buf[ 3 ]; //get first langid |
| LOBYTE( langid ) = buf[ 2 ]; //bytes are swapped to account for endiannes |
| //printProgStr(PSTR("\r\nLanguage ID: ")); |
| //print_hex( langid, 16 ); |
| rcode = Usb.getStrDescr( addr, 0, 1, idx, langid, buf ); |
| if( rcode ) { |
| printProgStr(PSTR("\r\nError retrieving string length")); |
| return( rcode ); |
| } |
| length = ( buf[ 0 ] < 254 ? buf[ 0 ] : 254 ); |
| printProgStr(PSTR(" Length: ")); |
| Serial.print( length, DEC ); |
| rcode = Usb.getStrDescr( addr, 0, length, idx, langid, buf ); |
| if( rcode ) { |
| printProgStr(PSTR("\r\nError retrieveing string")); |
| return( rcode ); |
| } |
| printProgStr(PSTR(" Contents: ")); |
| for( i = 2; i < length; i+=2 ) { |
| Serial.print( buf[ i ] ); |
| } |
| return( idx ); |
| } |
| /* Returns string to class name */ |
| const char* classname_parse( byte class_number ) |
| { |
| switch( class_number ) { |
| case 0x00: |
| return PSTR(" Use class information in the Interface Descriptor"); |
| case 0x01: |
| return PSTR(" Audio"); |
| case 0x02: |
| return PSTR(" Communications and CDC Control"); |
| case 0x03: |
| return PSTR(" HID (Human Interface Device)"); |
| case 0x05: |
| return PSTR(" Physical"); |
| case 0x06: |
| return PSTR(" Image"); |
| case 0x07: |
| return PSTR(" Printer"); |
| case 0x08: |
| return PSTR(" Mass Storage"); |
| case 0x09: |
| return PSTR(" Hub"); |
| case 0x0a: |
| return PSTR(" CDC-Data"); |
| case 0x0b: |
| return PSTR(" Smart Card"); |
| case 0x0d: |
| return PSTR(" Content Security"); |
| case 0x0e: |
| return PSTR(" Video"); |
| case 0x0f: |
| return PSTR(" Personal Healthcare"); |
| case 0xdc: |
| return PSTR("Diagnostic Device"); |
| case 0xe0: |
| return PSTR(" Wireless Controller"); |
| case 0xef: |
| return PSTR(" Miscellaneous"); |
| case 0xfe: |
| return PSTR(" Application Specific"); |
| case 0xff: |
| return PSTR(" Vendor Specific"); |
| default: |
| return unk_msg; |
| }//switch( class_number |
| } |
| /* Getting configuration descriptor */ |
| byte getconfdescr( byte addr, byte conf ) |
| { |
| char buf[ BUFSIZE ]; |
| char* buf_ptr = buf; |
| byte rcode; |
| byte descr_length; |
| byte descr_type; |
| unsigned int total_length; |
| printProgStr(PSTR("\r\n\nConfiguration number ")); |
| Serial.print( conf, HEX ); |
| rcode = Usb.getConfDescr( addr, 0, 4, conf, buf ); //get total length |
| if( rcode ) { |
| printProgStr(PSTR("Error retrieving configuration length. Error code ")); |
| Serial.println( rcode, HEX ); |
| return( 0 ); |
| }//if( rcode |
| LOBYTE( total_length ) = buf[ 2 ]; |
| HIBYTE( total_length ) = buf[ 3 ]; |
| printProgStr(PSTR("\r\nTotal configuration length: ")); |
| Serial.print( total_length, DEC ); |
| printProgStr(PSTR(" bytes")); |
| if( total_length > BUFSIZE ) { //check if total length is larger than buffer |
| printProgStr(PSTR("Total length truncated to ")); |
| Serial.print( BUFSIZE, DEC); |
| printProgStr(PSTR("bytes")); |
| total_length = BUFSIZE; |
| } |
| rcode = Usb.getConfDescr( addr, 0, total_length, conf, buf ); //get the whole descriptor |
| while( buf_ptr < buf + total_length ) { //parsing descriptors |
| descr_length = *( buf_ptr ); |
| descr_type = *( buf_ptr + 1 ); |
| switch( descr_type ) { |
| case( USB_DESCRIPTOR_CONFIGURATION ): |
| printconfdescr( buf_ptr ); |
| break; |
| case( USB_DESCRIPTOR_INTERFACE ): |
| printintfdescr( buf_ptr ); |
| break; |
| case( USB_DESCRIPTOR_ENDPOINT ): |
| printepdescr( buf_ptr ); |
| break; |
| case( HID_DESCRIPTOR_HID ): |
| printhid_descr( buf_ptr ); |
| break; |
| default: |
| printunkdescr( buf_ptr ); |
| break; |
| }//switch( descr_type |
| Serial.println(""); |
| buf_ptr = ( buf_ptr + descr_length ); //advance buffer pointer |
| }//while( buf_ptr <=... |
| return( 0 ); |
| } |
| /* function to print configuration descriptor */ |
| void printconfdescr( char* descr_ptr ) |
| { |
| USB_CONFIGURATION_DESCRIPTOR* conf_ptr = ( USB_CONFIGURATION_DESCRIPTOR* )descr_ptr; |
| uint8_t tmpbyte; |
| printProgStr(PSTR("\r\n\nConfiguration descriptor:")); |
| printProgStr(PSTR("\r\nTotal length:\t\t")); |
| print_hex( conf_ptr->wTotalLength, 16 ); |
| printProgStr(PSTR("\r\nNumber of interfaces:\t")); |
| print_hex( conf_ptr->bNumInterfaces, 8 ); |
| printProgStr(PSTR("\r\nConfiguration value:\t")); |
| print_hex( conf_ptr->bConfigurationValue, 8 ); |
| printProgStr(PSTR("\r\nConfiguration string:\t")); |
| tmpbyte = conf_ptr->iConfiguration; |
| print_hex( tmpbyte, 8 ); |
| getstrdescr( DEVADDR, tmpbyte ); |
| printProgStr(PSTR("\r\nAttributes:\t\t")); |
| tmpbyte = conf_ptr->bmAttributes; |
| print_hex( tmpbyte, 8 ); |
| if( tmpbyte & 0x40 ) { //D6 |
| printProgStr(PSTR(" Self-powered")); |
| } |
| if( tmpbyte & 0x20 ) { //D5 |
| printProgStr(PSTR(" Remote Wakeup")); |
| } |
| printProgStr(PSTR("\r\nMax.power:\t\t")); |
| tmpbyte = conf_ptr->bMaxPower; |
| print_hex( tmpbyte, 8 ); |
| printProgStr(PSTR(" ")); |
| Serial.print(( tmpbyte * 2 ), DEC); |
| printProgStr(PSTR("ma")); |
| return; |
| } |
| /* function to print interface descriptor */ |
| void printintfdescr( char* descr_ptr ) |
| { |
| USB_INTERFACE_DESCRIPTOR* intf_ptr = ( USB_INTERFACE_DESCRIPTOR* )descr_ptr; |
| uint8_t tmpbyte; |
| printProgStr(PSTR("\r\nInterface descriptor:")); |
| printProgStr(PSTR("\r\nInterface number:\t")); |
| print_hex( intf_ptr->bInterfaceNumber, 8 ); |
| printProgStr(PSTR("\r\nAlternate setting:\t")); |
| print_hex( intf_ptr->bAlternateSetting, 8 ); |
| printProgStr(PSTR("\r\nEndpoints:\t\t")); |
| print_hex( intf_ptr->bNumEndpoints, 8 ); |
| printProgStr( class_str ); |
| tmpbyte = intf_ptr->bInterfaceClass; |
| print_hex( tmpbyte, 8 ); |
| printProgStr(classname_parse( tmpbyte )); |
| printProgStr( subclass_str ); |
| print_hex( intf_ptr->bInterfaceSubClass, 8 ); |
| printProgStr( protocol_str ); |
| print_hex( intf_ptr->bInterfaceProtocol, 8 ); |
| printProgStr(PSTR("\r\nInterface string:\t")); |
| tmpbyte = intf_ptr->iInterface; |
| print_hex( tmpbyte, 8 ); |
| getstrdescr( DEVADDR, tmpbyte ); |
| return; |
| } |
| /* function to print endpoint descriptor */ |
| void printepdescr( char* descr_ptr ) |
| { |
| USB_ENDPOINT_DESCRIPTOR* ep_ptr = ( USB_ENDPOINT_DESCRIPTOR* )descr_ptr; |
| uint8_t tmpbyte; |
| printProgStr(PSTR("\r\nEndpoint descriptor:")); |
| printProgStr(PSTR("\r\nEndpoint address:\t")); |
| tmpbyte = ep_ptr->bEndpointAddress; |
| print_hex( tmpbyte & 0x0f, 8 ); |
| printProgStr(PSTR(" Direction: ")); |
| ( tmpbyte & 0x80 ) ? printProgStr(PSTR("IN")) : printProgStr(PSTR("OUT")); |
| printProgStr(PSTR("\r\nAttributes:\t\t")); |
| tmpbyte = ep_ptr->bmAttributes; |
| print_hex( tmpbyte, 8 ); |
| printProgStr(PSTR(" Transfer type: ")); |
| printProgStr((char*)pgm_read_word(&transfer_types[(tmpbyte & 0x03)])); |
| if(( tmpbyte & 0x03 ) == 1 ) { //Isochronous Transfer |
| printProgStr(PSTR(", Sync Type: ")); |
| printProgStr((char*)pgm_read_word(&sync_types[(tmpbyte & 0x0c)])); |
| printProgStr(PSTR(", Usage Type: ")); |
| printProgStr((char*)pgm_read_word(&usage_types[(tmpbyte & 0x30)])); |
| }//if( tmpbyte & 0x01 |
| printProgStr( maxpktsize_str ); |
| print_hex( ep_ptr->wMaxPacketSize, 16 ); |
| printProgStr(PSTR("\r\nPolling interval:\t")); |
| tmpbyte = ep_ptr->bInterval; |
| print_hex( tmpbyte, 8 ); |
| printProgStr(PSTR(" ")); |
| Serial.print( tmpbyte, DEC ); |
| printProgStr(PSTR(" ms")); |
| return; |
| } |
| /* function to print HID descriptor */ |
| void printhid_descr( char* descr_ptr ) |
| { |
| PARSE pf = &HIDreport_parse; |
| USB_HID_DESCRIPTOR* hid_ptr = ( USB_HID_DESCRIPTOR* )descr_ptr; |
| uint8_t tmpbyte; |
| /**/ |
| printProgStr(PSTR("\r\nHID descriptor:")); |
| printProgStr(PSTR("\r\nDescriptor length:\t")); |
| tmpbyte = hid_ptr->bLength; |
| print_hex( tmpbyte, 8 ); |
| printProgStr(PSTR(" ")); |
| Serial.print( tmpbyte, DEC ); |
| printProgStr(PSTR(" bytes")); |
| printProgStr(PSTR("\r\nHID version:\t\t")); |
| Serial.print(( HIBYTE( hid_ptr->bcdHID )), HEX ); |
| Serial.print("."); |
| Serial.print(( LOBYTE( hid_ptr->bcdHID )), HEX ); |
| tmpbyte = hid_ptr->bCountryCode; |
| printProgStr(PSTR("\r\nCountry Code:\t\t")); |
| Serial.print( tmpbyte, DEC ); |
| printProgStr(PSTR(" ")); |
| ( tmpbyte > 35 ) ? printProgStr(PSTR("Reserved")) : printProgStr((char*)pgm_read_word(&HID_Country_Codes[ tmpbyte ])); |
| tmpbyte = hid_ptr->bNumDescriptors; |
| printProgStr(PSTR("\r\nClass Descriptors:\t")); |
| Serial.print( tmpbyte, DEC ); |
| //Printing class descriptors |
| descr_ptr += 6; //advance buffer pointer |
| for( uint8_t i = 0; i < tmpbyte; i++ ) { |
| uint8_t tmpdata; |
| HID_CLASS_DESCRIPTOR* hidclass_ptr = ( HID_CLASS_DESCRIPTOR* )descr_ptr; |
| tmpdata = hidclass_ptr->bDescriptorType; |
| printProgStr(PSTR("\r\nClass Descriptor Type:\t")); |
| Serial.print( tmpdata, HEX ); |
| if(( tmpdata < 0x21 ) || ( tmpdata > 0x2f )) { |
| printProgStr(PSTR(" Invalid")); |
| } |
| switch( tmpdata ) { |
| case 0x21: |
| printProgStr(PSTR(" HID")); |
| break; |
| case 0x22: |
| printProgStr(PSTR(" Report")); |
| break; |
| case 0x23: |
| printProgStr(PSTR(" Physical")); |
| break; |
| default: |
| printProgStr(PSTR(" Reserved")); |
| break; |
| }//switch( tmpdata |
| printProgStr(PSTR("\r\nClass Descriptor Length:")); |
| Serial.print( hidclass_ptr->wDescriptorLength ); |
| printProgStr(PSTR(" bytes")); |
| printProgStr(PSTR("\r\n\nHID report descriptor:\r\n")); |
| getReportDescr( DEVADDR, 0 , hidclass_ptr->wDescriptorLength, pf, USB_NAK_LIMIT ); |
| descr_ptr += 3; //advance to the next record |
| }//for( uint8_t i=... |
| return; |
| } |
| /*function to print unknown descriptor */ |
| void printunkdescr( char* descr_ptr ) |
| { |
| byte length = *descr_ptr; |
| byte i; |
| printProgStr(PSTR("\r\nUnknown descriptor:")); |
| printProgStr(PSTR("Length:\t\t")); |
| print_hex( *descr_ptr, 8 ); |
| printProgStr(PSTR("\r\nType:\t\t")); |
| print_hex( *(descr_ptr + 1 ), 8 ); |
| printProgStr(PSTR("\r\nContents:\t")); |
| descr_ptr += 2; |
| for( i = 0; i < length; i++ ) { |
| print_hex( *descr_ptr, 8 ); |
| descr_ptr++; |
| } |
| } |
| /* Control-IN transfer with callback. Sets address, endpoint, fills control packet with necessary data, dispatches control packet, and initiates bulk IN transfer */ |
| /* Control, data, and setup stages combined from standard USB library to be able to read large data blocks. Restricted to control-IN transfers with data stage */ |
| /* data read and MAX3421E RECV FIFO buffer release shall be performed by parse_func callback */ |
| /* return codes: */ |
| /* 00 = success */ |
| /* 01-0f = non-zero HRSLT */ |
| byte ctrlXfer( byte addr, byte ep, byte bmReqType, byte bRequest, byte wValLo, byte wValHi, unsigned int wInd, uint16_t nbytes, PARSE parse_func, uint16_t nak_limit = USB_NAK_LIMIT ) |
| { |
| byte rcode; |
| SETUP_PKT sp; |
| EP_RECORD* ep_rec = Usb.getDevTableEntry( addr, ep ); |
| byte pktsize; |
| byte maxpktsize = ep_rec->MaxPktSize; |
| unsigned int xfrlen = 0; |
| /**/ |
| Max.regWr( rPERADDR, addr ); //set peripheral address |
| /* fill in setup packet */ |
| sp.ReqType_u.bmRequestType = bmReqType; |
| sp.bRequest = bRequest; |
| sp.wVal_u.wValueLo = wValLo; |
| sp.wVal_u.wValueHi = wValHi; |
| sp.wIndex = wInd; |
| sp.wLength = nbytes; |
| Max.bytesWr( rSUDFIFO, 8, ( char *)&sp ); //transfer to setup packet FIFO |
| rcode = Usb.dispatchPkt( tokSETUP, ep, nak_limit ); //dispatch packet |
| //Serial.println("Setup packet"); //DEBUG |
| if( rcode ) { //return HRSLT if not zero |
| printProgStr(PSTR("\r\nSetup packet error: ")); |
| Serial.print( rcode, HEX ); |
| return( rcode ); |
| } |
| /* Data stage */ |
| //ep_rec->rcvToggle = bmRCVTOG1; |
| Max.regWr( rHCTL, bmRCVTOG1 ); //set toggle |
| while( 1 ) { //exited by break |
| /* request data */ |
| rcode = Usb.dispatchPkt( tokIN, ep, nak_limit ); |
| if( rcode ) { |
| printProgStr(PSTR("\r\nData Stage Error: ")); |
| Serial.print( rcode, HEX ); |
| return( rcode ); |
| } |
| /* check for RCVDAVIRQ and generate error if not present */ |
| /* the only case when absense of RCVDAVIRQ makes sense is when toggle error occured. Need to add handling for that */ |
| if(( Max.regRd( rHIRQ ) & bmRCVDAVIRQ ) == 0 ) { |
| printProgStr(PSTR("\r\nData Toggle error.")); |
| return ( 0xf0 ); |
| } |
| pktsize = Max.regRd( rRCVBC ); //get received bytes count |
| parse_func( pktsize ); //call parse function. Parse is expected to read the FIFO completely |
| Max.regWr( rHIRQ, bmRCVDAVIRQ ); // Clear the IRQ & free the buffer |
| xfrlen += pktsize; // add this packet's byte count to total transfer length |
| /* The transfer is complete under two conditions: */ |
| /* 1. The device sent a short packet (L.T. maxPacketSize) */ |
| /* 2. 'nbytes' have been transferred. */ |
| if (( pktsize < maxpktsize ) || (xfrlen >= nbytes )) { // have we transferred 'nbytes' bytes? |
| break; |
| } |
| }//while( 1 ) |
| rcode = Usb.dispatchPkt( tokOUTHS, ep, nak_limit ); |
| if( rcode ) { //return error |
| printProgStr(PSTR("Status packet error: ")); |
| Serial.print( rcode, HEX ); |
| } |
| return( rcode ); |
| } |
| /* Parses bitfields in main items */ |
| void print_mainbitfield( uint8_t byte_toparse ) |
| { |
| ( byte_toparse & 0x01 ) ? printProgStr(PSTR("Constant,")) : printProgStr(PSTR("Data,")); //bit 0 |
| ( byte_toparse & 0x02 ) ? printProgStr(PSTR("Variable,")) : printProgStr(PSTR("Array,")); //bit 1 |
| ( byte_toparse & 0x04 ) ? printProgStr(PSTR("Relative,")) : printProgStr(PSTR("Absolute,")); //... |
| ( byte_toparse & 0x08 ) ? printProgStr(PSTR("Wrap,")) : printProgStr(PSTR("No Wrap,")); |
| ( byte_toparse & 0x10 ) ? printProgStr(PSTR("Non Linear,")) : printProgStr(PSTR("Linear,")); |
| ( byte_toparse & 0x20 ) ? printProgStr(PSTR("No preferred,")) : printProgStr(PSTR("Preferred State,")); |
| ( byte_toparse & 0x40 ) ? printProgStr(PSTR("Null State,")) : printProgStr(PSTR("No Null Position,")); //bit 6 |
| ( byte_toparse & 0x40 ) ? printProgStr(PSTR("Volatile( ignore for Input),")) : printProgStr(PSTR("Non-volatile(Ignore for Input),")); //bit 7 |
| } |
| /* HID Report Desriptor Parser Callback */ |
| /* called repeatedly from Control transfer function */ |
| void HIDreport_parse( uint8_t pkt_size ) |
| { |
| #define B_SIZE 0x03 //bSize bitmask |
| #define B_TYPE 0x0c //bType bitmask |
| #define B_TAG 0xf0 //bTag bitmask |
| /* parser states */ |
| enum STATE { ITEM_START, DATA_PARSE }; |
| static STATE state = ITEM_START; |
| static uint8_t databytes_left = 0; |
| static uint8_t prefix; //item prefix - type and tag |
| uint8_t byte_toparse; |
| uint8_t bType; |
| uint8_t tmpbyte; |
| /**/ |
| while( 1 ) { |
| if( pkt_size ) { |
| byte_toparse = Max.regRd( rRCVFIFO ); //read a byte from FIFO |
| pkt_size--; |
| } |
| else { |
| return; //all bytes read |
| } |
| switch( state ) { |
| case ITEM_START: //start of the record |
| prefix = byte_toparse >>2; //store prefix for databyte parsing |
| tmpbyte = byte_toparse & B_SIZE; |
| /* get item length */ |
| ( tmpbyte == 0x03 ) ? databytes_left = 4 : databytes_left = tmpbyte; |
| if( databytes_left ) { |
| state = DATA_PARSE; //read bytes after prefix |
| } |
| printProgStr(PSTR("\r\nLength: ")); |
| Serial.print( databytes_left, DEC ); |
| /* get item type */ |
| bType = ( byte_toparse & B_TYPE ) >>2; |
| printProgStr(PSTR(" Type: ")); |
| printProgStr((char*)pgm_read_word(&btypes[ bType ])); |
| /* get item tag */ |
| printProgStr(PSTR("\t\tTag: ")); |
| tmpbyte = ( byte_toparse & B_TAG ) >>4 ; |
| switch( bType ) { |
| case 0: //Main |
| if( tmpbyte < 0x08 ) { |
| printProgStr(PSTR("Invalid Tag")); |
| } |
| else if( tmpbyte > 0x0c ) { |
| printProgStr( reserved_msg ); |
| } |
| else { |
| printProgStr((char*)pgm_read_word(&maintags[ tmpbyte - 8 /* & 0x03 */])); |
| //Serial.print("Byte: "); |
| //Serial.println( tmpbyte, HEX ); |
| } |
| break;//case 0 Main |
| case 1: //Global |
| ( tmpbyte > 0x0b ) ? printProgStr( reserved_msg ) : printProgStr((char*)pgm_read_word(&globaltags[ tmpbyte ])); |
| break;//case 1 Global |
| case 2: //Local |
| ( tmpbyte > 0x0a ) ? printProgStr( reserved_msg ) : printProgStr((char*)pgm_read_word(&localtags[ tmpbyte ])); |
| break;//case 2 Local |
| default: |
| break; |
| }//switch( bType... |
| break;//case ITEM_START |
| case DATA_PARSE: |
| switch( prefix ) { |
| case 0x20: //Main Input |
| case 0x24: //Main Output |
| case 0x2c: //Main Feature |
| /* todo: add parsing 8th bit */ |
| print_mainbitfield( byte_toparse ); |
| break; |
| case 0x28: //Main Collection |
| if(( byte_toparse > 0x06 ) && ( byte_toparse < 0x80 )) { |
| printProgStr( reserved_msg ); |
| } |
| else if(( byte_toparse > 0x7f ) && ( byte_toparse <= 0xff )) { |
| printProgStr(PSTR("Vendor-defined")); |
| } |
| else { |
| printProgStr((char*)pgm_read_word(&collections[ byte_toparse ])); |
| } |
| break;//case 0x28 Main Collection |
| //case 0x30: //Main End Collection |
| case 0x01: //Global Usage Page |
| switch( byte_toparse ) { //see HID Usage Tables doc v.1.12 page 14 |
| case 0x00: |
| case 0x01: |
| case 0x02: |
| case 0x03: |
| case 0x04: |
| case 0x05: |
| case 0x06: |
| case 0x07: |
| case 0x08: |
| case 0x09: |
| case 0x0a: |
| case 0x0b: |
| case 0x0c: |
| case 0x0d: |
| case 0x0e: |
| case 0x0f: |
| case 0x10: |
| printProgStr((char*)pgm_read_word(&usage_pages[ byte_toparse ])); |
| break; |
| case 0x14: |
| printProgStr(PSTR("Alphanumeric Display")); |
| break; |
| case 0x40: |
| printProgStr(PSTR("Medical Instruments")); |
| break; |
| case 0x80: |
| case 0x81: |
| case 0x82: |
| case 0x83: |
| printProgStr(PSTR("Monitor page")); |
| break; |
| case 0x84: |
| case 0x85: |
| case 0x86: |
| case 0x87: |
| printProgStr(PSTR("Power page")); |
| break; |
| case 0x8c: |
| printProgStr(PSTR("Bar Code Scanner page")); |
| break; |
| case 0x8d: |
| printProgStr(PSTR("Scale page")); |
| break; |
| case 0x8e: |
| printProgStr(PSTR("Magnetic Stripe Reading (MSR) Devices")); |
| break; |
| case 0x8f: |
| printProgStr(PSTR("Reserved Point of Sale pages")); |
| break; |
| case 0x90: |
| printProgStr(PSTR("Camera Control Page")); |
| break; |
| case 0x91: |
| printProgStr(PSTR("Arcade Page")); |
| break; |
| default: |
| // printProgStr(PSTR("Data: ")); |
| // print_hex( byte_toparse, 8 ); |
| //databytes_left--; |
| break; |
| }//switch case 0x01: //Global Usage Page |
| }//switch( prefix ... |
| printProgStr(PSTR(" Data: ")); |
| print_hex( byte_toparse, 8 ); |
| databytes_left--; |
| if( !databytes_left ) { |
| state = ITEM_START; |
| } |
| break; |
| }//switch( state... |
| }//while( 1 ... |
| } |
| /* prints hex numbers with leading zeroes */ |
| // copyright, Peter H Anderson, Baltimore, MD, Nov, '07 |
| // source: http://www.phanderson.com/arduino/arduino_display.html |
| void print_hex(int v, int num_places) |
| { |
| int mask=0, n, num_nibbles, digit; |
| |
| for (n=1; n<=num_places; n++) { |
| mask = (mask << 1) | 0x0001; |
| } |
| v = v & mask; // truncate v to specified number of places |
| |
| num_nibbles = num_places / 4; |
| if ((num_places % 4) != 0) { |
| ++num_nibbles; |
| } |
| do { |
| digit = ((v >> (num_nibbles-1) * 4)) & 0x0f; |
| Serial.print(digit, HEX); |
| } |
| while(--num_nibbles); |
| } |
| |
| /* given a PROGMEM string, use Serial.print() to send it out */ |
| /* Some non-intuitive casting necessary: */ |
| /* printProgStr(PSTR("Func.Mode:\t0x")); */ |
| /* printProgStr((char*)pgm_read_word(&mtpopNames[(op & 0xFF)])); */ |
| void printProgStr(const char* str) |
| { |
| if(!str) { |
| return; |
| } |
| char c; |
| while((c = pgm_read_byte(str++))) { |
| Serial.print(c,BYTE); |
| } |
| return; |
| } |