mirror of
https://github.com/hathach/tinyusb.git
synced 2025-03-23 22:43:49 +00:00
reworking host hid API
This commit is contained in:
hathach
parent
510beef9f8
commit
be165a6713
@ -162,19 +162,12 @@ void tuh_hid_mounted_cb(uint8_t dev_addr)
|
||||
tuh_hid_keyboard_get_report(dev_addr, &usb_keyboard_report);
|
||||
}
|
||||
|
||||
void tuh_hid_keyboard_unmounted_cb(uint8_t dev_addr)
|
||||
void tuh_hid_unmounted_cb(uint8_t dev_addr)
|
||||
{
|
||||
// application tear-down
|
||||
printf("A Keyboard device (address %d) is unmounted\r\n", dev_addr);
|
||||
}
|
||||
|
||||
// invoked ISR context
|
||||
void tuh_hid_keyboard_isr(uint8_t dev_addr, xfer_result_t event)
|
||||
{
|
||||
(void) dev_addr;
|
||||
(void) event;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#if CFG_TUH_HID_MOUSE
|
||||
@ -242,12 +235,6 @@ void tuh_hid_mouse_unmounted_cb(uint8_t dev_addr)
|
||||
printf("A Mouse device (address %d) is unmounted\r\n", dev_addr);
|
||||
}
|
||||
|
||||
// invoked ISR context
|
||||
void tuh_hid_mouse_isr(uint8_t dev_addr, xfer_result_t event)
|
||||
{
|
||||
(void) dev_addr;
|
||||
(void) event;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
@ -257,7 +244,7 @@ void hid_task(void)
|
||||
uint8_t const addr = 1;
|
||||
|
||||
#if CFG_TUH_HID_KEYBOARD
|
||||
if ( tuh_hid_keyboard_mounted(addr) )
|
||||
if ( tuh_n_hid_n_keyboard_mounted(addr, 0) )
|
||||
{
|
||||
if ( !tuh_hid_keyboard_is_busy(addr) )
|
||||
{
|
||||
|
||||
@ -50,6 +50,7 @@ typedef struct
|
||||
uint8_t ep_in;
|
||||
uint8_t ep_out;
|
||||
|
||||
uint8_t report_desc_type;
|
||||
uint16_t report_desc_len;
|
||||
|
||||
bool valid;
|
||||
@ -75,41 +76,50 @@ typedef struct
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint8_t inst_count;
|
||||
hidh_interface_t instance[CFG_TUH_HID];
|
||||
uint8_t itf_count;
|
||||
hidh_interface_t interface[CFG_TUH_HID];
|
||||
} hidh_device_t;
|
||||
|
||||
static hidh_device_t _hidh_dev[CFG_TUSB_HOST_DEVICE_MAX-1];
|
||||
|
||||
#if 0
|
||||
CFG_TUSB_MEM_SECTION uint8_t report_descriptor[256];
|
||||
#endif
|
||||
CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN uint8_t _report_desc_buf[256];
|
||||
|
||||
// Get Device by address
|
||||
TU_ATTR_ALWAYS_INLINE static inline hidh_device_t* get_dev(uint8_t dev_addr)
|
||||
{
|
||||
return &_hidh_dev[dev_addr-1];
|
||||
}
|
||||
|
||||
TU_ATTR_ALWAYS_INLINE static inline hidh_interface_t* get_instance(uint8_t dev_addr, uint8_t inst)
|
||||
// Get Interface by instance number
|
||||
TU_ATTR_ALWAYS_INLINE static inline hidh_interface_t* get_instance(uint8_t dev_addr, uint8_t instance)
|
||||
{
|
||||
return &_hidh_dev[dev_addr-1].instance[inst];
|
||||
return &_hidh_dev[dev_addr-1].interface[instance];
|
||||
}
|
||||
|
||||
// Get Interface by interface number
|
||||
static hidh_interface_t* get_interface(uint8_t dev_addr, uint8_t itf)
|
||||
{
|
||||
for(uint8_t inst=0; inst<CFG_TUH_HID; inst++)
|
||||
{
|
||||
hidh_interface_t* hid = get_instance(dev_addr, inst);
|
||||
|
||||
if ( (hid->itf_num == itf) && (hid->ep_in != 0) ) return hid;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// Application API
|
||||
//--------------------------------------------------------------------+
|
||||
uint8_t tuh_n_hid_instance_count(uint8_t daddr)
|
||||
{
|
||||
return get_dev(daddr)->itf_count;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// HID Interface common functions
|
||||
//--------------------------------------------------------------------+
|
||||
static inline bool hidh_interface_open(uint8_t rhport, uint8_t dev_addr, uint8_t interface_number, tusb_desc_endpoint_t const *desc_ep, hidh_interface_t *p_hid)
|
||||
{
|
||||
TU_ASSERT( usbh_edpt_open(rhport, dev_addr, desc_ep) );
|
||||
|
||||
p_hid->itf_num = interface_number;
|
||||
p_hid->ep_in = desc_ep->bEndpointAddress;
|
||||
p_hid->report_size = desc_ep->wMaxPacketSize.size; // TODO get size from report descriptor
|
||||
p_hid->valid = true;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline void hidh_interface_close(hidh_interface_t *p_hid)
|
||||
{
|
||||
@ -123,7 +133,7 @@ tusb_error_t hidh_interface_get_report(uint8_t dev_addr, void * report, hidh_int
|
||||
// TODO change to use is configured function
|
||||
TU_ASSERT(TUSB_DEVICE_STATE_CONFIGURED == tuh_device_get_state(dev_addr), TUSB_ERROR_DEVICE_NOT_READY);
|
||||
TU_VERIFY(report, TUSB_ERROR_INVALID_PARA);
|
||||
TU_ASSERT(!hcd_edpt_busy(dev_addr, p_hid->ep_in), TUSB_ERROR_INTERFACE_IS_BUSY);
|
||||
TU_VERIFY(!hcd_edpt_busy(dev_addr, p_hid->ep_in), TUSB_ERROR_INTERFACE_IS_BUSY);
|
||||
|
||||
TU_ASSERT( usbh_edpt_xfer(dev_addr, p_hid->ep_in, report, p_hid->report_size) ) ;
|
||||
|
||||
@ -134,10 +144,9 @@ tusb_error_t hidh_interface_get_report(uint8_t dev_addr, void * report, hidh_int
|
||||
// KEYBOARD
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
bool tuh_hid_keyboard_mounted(uint8_t dev_addr)
|
||||
bool tuh_n_hid_n_keyboard_mounted(uint8_t dev_addr, uint8_t instance)
|
||||
{
|
||||
uint8_t itf = 0;
|
||||
hidh_interface_t* hid_itf = get_instance(dev_addr, itf);
|
||||
hidh_interface_t* hid_itf = get_instance(dev_addr, instance);
|
||||
|
||||
// TODO check rid_keyboard
|
||||
return tuh_device_is_configured(dev_addr) && (hid_itf->ep_in != 0);
|
||||
@ -153,13 +162,12 @@ tusb_error_t tuh_hid_keyboard_get_report(uint8_t dev_addr, void* buffer)
|
||||
|
||||
bool tuh_hid_keyboard_is_busy(uint8_t dev_addr)
|
||||
{
|
||||
uint8_t itf = 0;
|
||||
hidh_interface_t* hid_itf = get_instance(dev_addr, itf);
|
||||
uint8_t instance = 0;
|
||||
hidh_interface_t* hid_itf = get_instance(dev_addr, instance);
|
||||
|
||||
return tuh_hid_keyboard_mounted(dev_addr) && hcd_edpt_busy(dev_addr, hid_itf->ep_in);
|
||||
return tuh_n_hid_n_keyboard_mounted(dev_addr, instance) && hcd_edpt_busy(dev_addr, hid_itf->ep_in);
|
||||
}
|
||||
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// MOUSE
|
||||
//--------------------------------------------------------------------+
|
||||
@ -191,138 +199,11 @@ tusb_error_t tuh_hid_mouse_get_report(uint8_t dev_addr, void * report)
|
||||
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// CLASS-USBH API (don't require to verify parameters)
|
||||
// USBH API
|
||||
//--------------------------------------------------------------------+
|
||||
void hidh_init(void)
|
||||
{
|
||||
tu_memclr(_hidh_dev, sizeof(_hidh_dev));
|
||||
|
||||
#if CFG_TUH_HID_MOUSE
|
||||
tu_memclr(&mouseh_data, sizeof(hidh_interface_t)*CFG_TUSB_HOST_DEVICE_MAX);
|
||||
#endif
|
||||
}
|
||||
|
||||
bool hidh_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *desc_itf, uint16_t *p_length)
|
||||
{
|
||||
TU_VERIFY(TUSB_CLASS_HID == desc_itf->bInterfaceClass);
|
||||
|
||||
uint8_t const *p_desc = (uint8_t const *) desc_itf;
|
||||
|
||||
//------------- HID descriptor -------------//
|
||||
p_desc = tu_desc_next(p_desc);
|
||||
tusb_hid_descriptor_hid_t const *desc_hid = (tusb_hid_descriptor_hid_t const *) p_desc;
|
||||
TU_ASSERT(HID_DESC_TYPE_HID == desc_hid->bDescriptorType);
|
||||
|
||||
// not enough interface, try to increase CFG_TUH_HID
|
||||
// TODO multiple devices
|
||||
hidh_device_t* hid_dev = get_dev(dev_addr);
|
||||
TU_ASSERT(hid_dev->inst_count < CFG_TUH_HID);
|
||||
|
||||
hidh_interface_t* hid_itf = get_instance(dev_addr, hid_dev->inst_count);
|
||||
hid_dev->inst_count++;
|
||||
|
||||
hid_itf->itf_num = desc_itf->bInterfaceNumber;
|
||||
hid_itf->boot_mode = false; // default is report mode
|
||||
hid_itf->report_desc_len = tu_unaligned_read16(&desc_hid->wReportLength);
|
||||
|
||||
//------------- Endpoint Descriptor -------------//
|
||||
p_desc = tu_desc_next(p_desc);
|
||||
tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) p_desc;
|
||||
TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType);
|
||||
|
||||
if ( HID_SUBCLASS_BOOT == desc_itf->bInterfaceSubClass )
|
||||
{
|
||||
hid_itf->boot_protocol = desc_itf->bInterfaceProtocol;
|
||||
|
||||
#if CFG_TUH_HID_KEYBOARD
|
||||
if ( HID_PROTOCOL_KEYBOARD == desc_itf->bInterfaceProtocol)
|
||||
{
|
||||
TU_ASSERT( hidh_interface_open(rhport, dev_addr, desc_itf->bInterfaceNumber, desc_ep, hid_itf) );
|
||||
TU_LOG2_HEX(hid_itf->ep_in);
|
||||
|
||||
hid_itf->report_count = 1;
|
||||
|
||||
hid_itf->reports[0].usage_page = HID_USAGE_PAGE_DESKTOP;
|
||||
hid_itf->reports[0].usage = HID_USAGE_DESKTOP_KEYBOARD;
|
||||
hid_itf->reports[0].in_len = 8;
|
||||
hid_itf->reports[0].out_len = 1;
|
||||
} else
|
||||
#endif
|
||||
|
||||
#if CFG_TUH_HID_MOUSE
|
||||
if ( HID_PROTOCOL_MOUSE == desc_itf->bInterfaceProtocol)
|
||||
{
|
||||
TU_ASSERT ( hidh_interface_open(rhport, dev_addr, desc_itf->bInterfaceNumber, desc_ep, &mouseh_data[dev_addr-1]) );
|
||||
TU_LOG2_HEX(mouseh_data[dev_addr-1].ep_in);
|
||||
} else
|
||||
#endif
|
||||
|
||||
{
|
||||
// Not supported protocol
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
*p_length = sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + desc_itf->bNumEndpoints*sizeof(tusb_desc_endpoint_t);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool hidh_set_config(uint8_t dev_addr, uint8_t itf_num)
|
||||
{
|
||||
#if 0
|
||||
//------------- Get Report Descriptor TODO HID parser -------------//
|
||||
if ( p_desc_hid->bNumDescriptors )
|
||||
{
|
||||
STASK_INVOKE(
|
||||
usbh_control_xfer_subtask( dev_addr, bm_request_type(TUSB_DIR_IN, TUSB_REQ_TYPE_STANDARD, TUSB_REQ_RCPT_INTERFACE),
|
||||
TUSB_REQ_GET_DESCRIPTOR, (p_desc_hid->bReportType << 8), 0,
|
||||
p_desc_hid->wReportLength, report_descriptor ),
|
||||
error
|
||||
);
|
||||
(void) error; // if error in getting report descriptor --> treating like there is none
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
// SET IDLE = 0 request
|
||||
// Device can stall if not support this request
|
||||
tusb_control_request_t const request =
|
||||
{
|
||||
.bmRequestType_bit =
|
||||
{
|
||||
.recipient = TUSB_REQ_RCPT_INTERFACE,
|
||||
.type = TUSB_REQ_TYPE_CLASS,
|
||||
.direction = TUSB_DIR_OUT
|
||||
},
|
||||
.bRequest = HID_REQ_CONTROL_SET_IDLE,
|
||||
.wValue = 0, // idle_rate = 0
|
||||
.wIndex = p_interface_desc->bInterfaceNumber,
|
||||
.wLength = 0
|
||||
};
|
||||
|
||||
// stall is a valid response for SET_IDLE, therefore we could ignore result of this request
|
||||
tuh_control_xfer(dev_addr, &request, NULL, NULL);
|
||||
#endif
|
||||
|
||||
usbh_driver_set_config_complete(dev_addr, itf_num);
|
||||
|
||||
// uint8_t itf = 0;
|
||||
// hidh_interface_t* hid_itf = &_hidh_itf[itf];
|
||||
|
||||
|
||||
if (itf_num == 0 ) {
|
||||
if (tuh_hid_mounted_cb) tuh_hid_mounted_cb(dev_addr);
|
||||
}
|
||||
|
||||
#if CFG_TUH_HID_MOUSE
|
||||
if (( mouseh_data[dev_addr-1].ep_in == itf_num ) && mouseh_data[dev_addr-1].valid)
|
||||
{
|
||||
tuh_hid_mouse_mounted_cb(dev_addr);
|
||||
}
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32_t xferred_bytes)
|
||||
@ -341,11 +222,11 @@ bool hidh_xfer_cb(uint8_t dev_addr, uint8_t ep_addr, xfer_result_t event, uint32
|
||||
#endif
|
||||
|
||||
#if CFG_TUH_HID_MOUSE
|
||||
if ( ep_addr == mouseh_data[dev_addr-1].ep_in )
|
||||
{
|
||||
tuh_hid_mouse_isr(dev_addr, event);
|
||||
return true;
|
||||
}
|
||||
// if ( ep_addr == mouseh_data[dev_addr-1].ep_in )
|
||||
// {
|
||||
// tuh_hid_mouse_isr(dev_addr, event);
|
||||
// return true;
|
||||
// }
|
||||
#endif
|
||||
|
||||
return true;
|
||||
@ -368,4 +249,163 @@ void hidh_close(uint8_t dev_addr)
|
||||
#endif
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// Enumeration
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
static bool config_set_idle_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result);
|
||||
static bool config_get_report_desc_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result);
|
||||
|
||||
bool hidh_open(uint8_t rhport, uint8_t dev_addr, tusb_desc_interface_t const *desc_itf, uint16_t *p_length)
|
||||
{
|
||||
TU_VERIFY(TUSB_CLASS_HID == desc_itf->bInterfaceClass);
|
||||
|
||||
uint8_t const *p_desc = (uint8_t const *) desc_itf;
|
||||
|
||||
//------------- HID descriptor -------------//
|
||||
p_desc = tu_desc_next(p_desc);
|
||||
tusb_hid_descriptor_hid_t const *desc_hid = (tusb_hid_descriptor_hid_t const *) p_desc;
|
||||
TU_ASSERT(HID_DESC_TYPE_HID == desc_hid->bDescriptorType);
|
||||
|
||||
// not enough interface, try to increase CFG_TUH_HID
|
||||
// TODO multiple devices
|
||||
hidh_device_t* hid_dev = get_dev(dev_addr);
|
||||
TU_ASSERT(hid_dev->itf_count < CFG_TUH_HID);
|
||||
|
||||
//------------- Endpoint Descriptor -------------//
|
||||
p_desc = tu_desc_next(p_desc);
|
||||
tusb_desc_endpoint_t const * desc_ep = (tusb_desc_endpoint_t const *) p_desc;
|
||||
TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType);
|
||||
|
||||
// TODO also open endpoint OUT
|
||||
TU_ASSERT( usbh_edpt_open(rhport, dev_addr, desc_ep) );
|
||||
|
||||
hidh_interface_t* hid_itf = get_instance(dev_addr, hid_dev->itf_count);
|
||||
hid_dev->itf_count++;
|
||||
|
||||
hid_itf->itf_num = desc_itf->bInterfaceNumber;
|
||||
hid_itf->ep_in = desc_ep->bEndpointAddress;
|
||||
hid_itf->report_size = desc_ep->wMaxPacketSize.size; // TODO get size from report descriptor
|
||||
hid_itf->valid = true;
|
||||
|
||||
TU_LOG2_HEX(hid_itf->ep_in);
|
||||
|
||||
// Assume bNumDescriptors = 1
|
||||
hid_itf->report_desc_type = desc_hid->bReportType;
|
||||
hid_itf->report_desc_len = tu_unaligned_read16(&desc_hid->wReportLength);
|
||||
|
||||
hid_itf->boot_mode = false; // default is report mode
|
||||
if ( HID_SUBCLASS_BOOT == desc_itf->bInterfaceSubClass )
|
||||
{
|
||||
hid_itf->boot_protocol = desc_itf->bInterfaceProtocol;
|
||||
|
||||
if ( HID_PROTOCOL_KEYBOARD == desc_itf->bInterfaceProtocol)
|
||||
{
|
||||
// TODO boot protocol may still have more report in report mode
|
||||
hid_itf->report_count = 1;
|
||||
|
||||
hid_itf->reports[0].usage_page = HID_USAGE_PAGE_DESKTOP;
|
||||
hid_itf->reports[0].usage = HID_USAGE_DESKTOP_KEYBOARD;
|
||||
hid_itf->reports[0].in_len = 8;
|
||||
hid_itf->reports[0].out_len = 1;
|
||||
}
|
||||
else if ( HID_PROTOCOL_MOUSE == desc_itf->bInterfaceProtocol)
|
||||
{
|
||||
// TODO boot protocol may still have more report in report mode
|
||||
hid_itf->report_count = 1;
|
||||
|
||||
hid_itf->reports[0].usage_page = HID_USAGE_PAGE_DESKTOP;
|
||||
hid_itf->reports[0].usage = HID_USAGE_DESKTOP_MOUSE;
|
||||
hid_itf->reports[0].in_len = 8;
|
||||
hid_itf->reports[0].out_len = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Unknown protocol
|
||||
TU_ASSERT(false);
|
||||
}
|
||||
}
|
||||
|
||||
*p_length = sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + desc_itf->bNumEndpoints*sizeof(tusb_desc_endpoint_t);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool hidh_set_config(uint8_t dev_addr, uint8_t itf_num)
|
||||
{
|
||||
// Idle rate = 0 mean only report when there is changes
|
||||
uint16_t const idle_rate = 0;
|
||||
|
||||
// SET IDLE request, device can stall if not support this request
|
||||
TU_LOG2("Set Idle \r\n");
|
||||
tusb_control_request_t const request =
|
||||
{
|
||||
.bmRequestType_bit =
|
||||
{
|
||||
.recipient = TUSB_REQ_RCPT_INTERFACE,
|
||||
.type = TUSB_REQ_TYPE_CLASS,
|
||||
.direction = TUSB_DIR_OUT
|
||||
},
|
||||
.bRequest = HID_REQ_CONTROL_SET_IDLE,
|
||||
.wValue = idle_rate,
|
||||
.wIndex = itf_num,
|
||||
.wLength = 0
|
||||
};
|
||||
|
||||
TU_ASSERT( tuh_control_xfer(dev_addr, &request, NULL, config_set_idle_complete) );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool config_set_idle_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
|
||||
{
|
||||
// Stall is a valid response for SET_IDLE, therefore we could ignore its result
|
||||
(void) result;
|
||||
|
||||
uint8_t const itf_num = (uint8_t) request->wIndex;
|
||||
|
||||
hidh_interface_t* hid_itf = get_interface(dev_addr, itf_num);
|
||||
|
||||
// Get Report Descriptor
|
||||
// using usbh enumeration buffer since report descriptor can be very long
|
||||
TU_ASSERT( hid_itf->report_desc_len <= CFG_TUH_ENUMERATION_BUFSZIE );
|
||||
|
||||
TU_LOG2("HID Get Report Descriptor\r\n");
|
||||
tusb_control_request_t const new_request =
|
||||
{
|
||||
.bmRequestType_bit =
|
||||
{
|
||||
.recipient = TUSB_REQ_RCPT_INTERFACE,
|
||||
.type = TUSB_REQ_TYPE_STANDARD,
|
||||
.direction = TUSB_DIR_IN
|
||||
},
|
||||
.bRequest = TUSB_REQ_GET_DESCRIPTOR,
|
||||
.wValue = tu_u16(hid_itf->report_desc_type, 0),
|
||||
.wIndex = itf_num,
|
||||
.wLength = hid_itf->report_desc_len
|
||||
};
|
||||
|
||||
TU_ASSERT(tuh_control_xfer(dev_addr, &new_request, usbh_get_enum_buf(), config_get_report_desc_complete));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool config_get_report_desc_complete(uint8_t dev_addr, tusb_control_request_t const * request, xfer_result_t result)
|
||||
{
|
||||
TU_ASSERT(XFER_RESULT_SUCCESS == result);
|
||||
uint8_t const itf_num = (uint8_t) request->wIndex;
|
||||
hidh_interface_t* hid_itf = get_interface(dev_addr, itf_num);
|
||||
|
||||
if (tuh_hid_descriptor_report_cb) tuh_hid_descriptor_report_cb(dev_addr, hid_itf->itf_num, usbh_get_enum_buf(), request->wLength);
|
||||
|
||||
// TODO Report descriptor parser
|
||||
|
||||
// enumeration is complete
|
||||
if (tuh_hid_mounted_cb) tuh_hid_mounted_cb(dev_addr);
|
||||
|
||||
// notify usbh that driver enumeration is complete
|
||||
usbh_driver_set_config_complete(dev_addr, itf_num);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -46,22 +46,51 @@
|
||||
#define CFG_TUH_HID_REPORT_MAX 4
|
||||
#endif
|
||||
|
||||
#ifndef CFG_TUH_HID_REPORT_DESCRIPTOR_BUFSIZE
|
||||
#define CFG_TUH_HID_REPORT_DESCRIPTOR_BUFSIZE 256
|
||||
#endif
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// Application API (Multiple Instances)
|
||||
// CFG_TUH_HID > 1
|
||||
// Application API (Multiple devices)
|
||||
// Note:
|
||||
// - tud_n : is multiple devices API
|
||||
// - class_n : is multiple instances API
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
// Get the number of HID instances
|
||||
uint8_t tuh_n_hid_instance_count(uint8_t daddr);
|
||||
|
||||
// Check if HID instance support keyboard
|
||||
bool tuh_n_hid_n_keyboard_mounted(uint8_t daddr, uint8_t instance);
|
||||
|
||||
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// Application API (Single Instance)
|
||||
// Application API (Single device)
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
// tuh_hid_instance_count()
|
||||
// Get the number of HID instances
|
||||
TU_ATTR_ALWAYS_INLINE static inline
|
||||
uint8_t tuh_hid_instance_count(void)
|
||||
{
|
||||
return tuh_n_hid_instance_count(1);
|
||||
}
|
||||
|
||||
//bool tuh_hid_get_report(uint8_t dev_addr, uint8_t report_id, void * p_report, uint8_t len);
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// Callbacks (Weak is optional)
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
// Invoked when report descriptor is received
|
||||
// Note: enumeration is still not complete yet
|
||||
TU_ATTR_WEAK void tuh_hid_descriptor_report_cb(uint8_t daddr, uint8_t instance, uint8_t const* report_desc, uint16_t desc_len);
|
||||
|
||||
TU_ATTR_WEAK void tuh_hid_mounted_cb(uint8_t dev_addr);
|
||||
TU_ATTR_WEAK void tuh_hid_unmounted_cb(uint8_t dev_addr);
|
||||
|
||||
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// KEYBOARD Application API
|
||||
//--------------------------------------------------------------------+
|
||||
@ -193,31 +222,6 @@ void tuh_hid_mouse_mounted_cb(uint8_t dev_addr);
|
||||
*/
|
||||
void tuh_hid_mouse_unmounted_cb(uint8_t dev_addr);
|
||||
|
||||
/** @} */ // Mouse_Host
|
||||
/** @} */ // ClassDriver_HID_Mouse
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// GENERIC Application API
|
||||
//--------------------------------------------------------------------+
|
||||
/** \addtogroup ClassDriver_HID_Generic Generic (not supported yet)
|
||||
* @{ */
|
||||
|
||||
/** \defgroup Generic_Host Host
|
||||
* The interface API includes status checking function, data transferring function and callback functions
|
||||
* @{ */
|
||||
|
||||
bool tuh_hid_generic_is_mounted(uint8_t dev_addr);
|
||||
tusb_error_t tuh_hid_generic_get_report(uint8_t dev_addr, void* p_report, bool int_on_complete);
|
||||
tusb_error_t tuh_hid_generic_set_report(uint8_t dev_addr, void* p_report, bool int_on_complete);
|
||||
tusb_interface_status_t tuh_hid_generic_get_status(uint8_t dev_addr);
|
||||
tusb_interface_status_t tuh_hid_generic_set_status(uint8_t dev_addr);
|
||||
|
||||
//------------- Application Callback -------------//
|
||||
void tuh_hid_generic_isr(uint8_t dev_addr, xfer_result_t event);
|
||||
|
||||
/** @} */ // Generic_Host
|
||||
/** @} */ // ClassDriver_HID_Generic
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// Internal Class Driver API
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user