M480 BSP  V3.05.001
The Board Support Package for M480 Series
hid_core.c
Go to the documentation of this file.
1 /**************************************************************************/
10 #include <stdio.h>
11 #include <string.h>
12 #include <stdlib.h>
13 
14 #include "NuMicro.h"
15 
16 #include "usb.h"
17 #include "usbh_lib.h"
18 #include "usbh_hid.h"
19 
20 
22 
23 HID_MOUSE_FUNC *_mouse_callback = NULL;
24 HID_KEYBOARD_FUNC *_keyboard_callback = NULL;
25 
26 #include "hid_parser.c"
27 
28 #define USB_CTRL_TIMEOUT_MS 100
29 
30 
31 static int get_free_utr_slot(HID_DEV_T *hdev)
32 {
33  int i;
34 
35  for (i = 0; i < CONFIG_HID_DEV_MAX_PIPE; i++)
36  {
37  if (hdev->utr_list[i] == NULL)
38  return i;
39  }
40  return -1;
41 }
42 
43 
45 
46 
56 int32_t usbh_hid_get_report_descriptor(HID_DEV_T *hdev, uint8_t *desc_buf, int buf_max_len)
57 {
58  IFACE_T *iface;
59  uint32_t xfer_len;
60  int ret;
61 
62  if (buf_max_len < 9)
63  return HID_RET_INVALID_PARAMETER;
64 
65  if (!hdev || !hdev->iface)
66  return USBH_ERR_NOT_FOUND;
67 
68  iface = (IFACE_T *)hdev->iface;
69 
70  ret = usbh_ctrl_xfer(iface->udev,
71  REQ_TYPE_IN | REQ_TYPE_STD_DEV | REQ_TYPE_TO_IFACE, /* bmRequestType */
72  USB_REQ_GET_DESCRIPTOR, /* bRequest */
73  (USB_DT_REPORT << 8) + 0, /* wValue */
74  iface->if_num, /* wIndex */
75  buf_max_len, /* wLength */
76  desc_buf, &xfer_len, USB_CTRL_TIMEOUT_MS);
77 
78  if ((ret < 0) || (xfer_len == 0))
79  {
80  HID_DBGMSG("failed to get HID descriptor.\n");
81  return HID_RET_IO_ERR;
82  }
83  return (int)xfer_len;
84 }
85 
86 
102 int32_t usbh_hid_get_report(HID_DEV_T *hdev, int rtp_typ, int rtp_id,
103  uint8_t *data, int len)
104 {
105  IFACE_T *iface;
106  uint32_t xfer_len;
107  int ret;
108 
109  if (!hdev || !hdev->iface)
110  return USBH_ERR_NOT_FOUND;
111 
112  iface = (IFACE_T *)hdev->iface;
113 
114  ret = usbh_ctrl_xfer(iface->udev,
115  REQ_TYPE_IN | REQ_TYPE_CLASS_DEV | REQ_TYPE_TO_IFACE, /* bmRequestType */
116  HID_REPORT_GET, /* bRequest */
117  rtp_id + (rtp_typ << 8), /* wValue */
118  iface->if_num, /* wIndex */
119  len, /* wLength */
120  data, &xfer_len, USB_CTRL_TIMEOUT_MS);
121  if (ret < 0)
122  {
123  HID_DBGMSG("failed to get report!\n");
124  return HID_RET_IO_ERR;
125  }
126  return (int)xfer_len;
127 }
128 
129 
147 int32_t usbh_hid_set_report(HID_DEV_T *hdev, int rtp_typ, int rtp_id,
148  uint8_t *data, int len)
149 {
150  IFACE_T *iface;
151  uint32_t xfer_len;
152  int ret;
153 
154  if (!hdev || !hdev->iface)
155  return USBH_ERR_NOT_FOUND;
156 
157  iface = (IFACE_T *)hdev->iface;
158 
159  ret = usbh_ctrl_xfer(iface->udev,
160  REQ_TYPE_OUT | REQ_TYPE_CLASS_DEV | REQ_TYPE_TO_IFACE, /* bmRequestType */
161  HID_REPORT_SET, /* bRequest */
162  rtp_id + (rtp_typ << 8), /* wValue */
163  iface->if_num, /* wIndex */
164  len, /* wLength */
165  data, &xfer_len, USB_CTRL_TIMEOUT_MS);
166  if (ret < 0)
167  {
168  HID_DBGMSG("failed to set report!\n");
169  return HID_RET_IO_ERR;
170  }
171  return (int)xfer_len;
172 }
173 
174 
176 
177 static void led_ctrl_irq(UTR_T *utr)
178 {
179  // HID_DBGMSG("Set LED control xfer done.\n");
180  utr->bIsTransferDone = 1;
181 }
182 
183 int32_t usbh_hid_set_report_non_blocking(HID_DEV_T *hdev, int rtp_typ, int rtp_id,
184  uint8_t *data, int len)
185 {
186  IFACE_T *iface;
187  UTR_T *utr;
188  int status;
189 
190  if (!hdev || !hdev->iface)
191  return USBH_ERR_NOT_FOUND;
192 
193  iface = (IFACE_T *)hdev->iface;
194 
195  utr = hdev->rpd.utr_led;
196  if (utr == NULL)
197  {
198  utr = alloc_utr(iface->udev);
199  if (utr == NULL)
200  return USBH_ERR_MEMORY_OUT;
201  hdev->rpd.utr_led = utr;
202  }
203  else
204  {
205  if (utr->bIsTransferDone == 0)
206  return HID_RET_IO_ERR; /* unlikely! the last LED control trnasfer is not completed */
207  }
208 
209  utr->setup.bmRequestType = REQ_TYPE_OUT | REQ_TYPE_CLASS_DEV | REQ_TYPE_TO_IFACE;
210  utr->setup.bRequest = HID_REPORT_SET;
211  utr->setup.wValue = rtp_id + (rtp_typ << 8);
212  utr->setup.wIndex = iface->if_num;
213  utr->setup.wLength = len;
214 
215  utr->buff = data;
216  utr->data_len = len;
217  utr->func = led_ctrl_irq;
218  utr->bIsTransferDone = 0;
219 
220  status = iface->udev->hc_driver->ctrl_xfer(utr);
221  if (status < 0)
222  {
223  iface->udev->ep0.hw_pipe = NULL;
224  return status;
225  }
226  return 0;
227 }
228 
230 
231 
243 int32_t usbh_hid_get_idle(HID_DEV_T *hdev, int rtp_id, uint8_t *idle_rate)
244 {
245  IFACE_T *iface;
246  uint32_t xfer_len;
247  int ret;
248 
249  if (!hdev || !hdev->iface)
250  return USBH_ERR_NOT_FOUND;
251 
252  iface = (IFACE_T *)hdev->iface;
253 
254  ret = usbh_ctrl_xfer(iface->udev,
255  REQ_TYPE_IN | REQ_TYPE_CLASS_DEV | REQ_TYPE_TO_IFACE, /* bmRequestType */
256  HID_GET_IDLE, /* bRequest */
257  rtp_id, /* wValue */
258  iface->if_num, /* wIndex */
259  1, /* wLength */
260  idle_rate, &xfer_len, USB_CTRL_TIMEOUT_MS);
261 
262  if ((ret < 0) || (xfer_len != 1))
263  {
264  HID_DBGMSG("failed to get idle rate! %d\n", ret);
265  return HID_RET_IO_ERR;
266  }
267  return HID_RET_OK;
268 }
269 
270 
283 int32_t usbh_hid_set_idle(HID_DEV_T *hdev, int rtp_id, uint8_t idle_rate)
284 {
285  IFACE_T *iface;
286  uint32_t xfer_len;
287  uint16_t wValue = idle_rate;
288  int ret;
289 
290  if (!hdev || !hdev->iface)
291  return USBH_ERR_NOT_FOUND;
292 
293  iface = (IFACE_T *)hdev->iface;
294 
295  ret = usbh_ctrl_xfer(iface->udev,
296  REQ_TYPE_OUT | REQ_TYPE_CLASS_DEV | REQ_TYPE_TO_IFACE, /* bmRequestType */
297  HID_SET_IDLE, /* bRequest */
298  rtp_id + (wValue << 8), /* wValue */
299  iface->if_num, /* wIndex */
300  0, /* wLength */
301  NULL, &xfer_len, USB_CTRL_TIMEOUT_MS);
302 
303  if (ret < 0)
304  {
305  HID_DBGMSG("failed to set idle rate! %d\n", ret);
306  return HID_RET_IO_ERR;
307  }
308  return HID_RET_OK;
309 }
310 
311 
323 int32_t usbh_hid_get_protocol(HID_DEV_T *hdev, uint8_t *protocol)
324 {
325  IFACE_T *iface;
326  uint32_t xfer_len;
327  int ret;
328 
329  if (!hdev || !hdev->iface)
330  return USBH_ERR_NOT_FOUND;
331 
332  iface = (IFACE_T *)hdev->iface;
333 
334  ret = usbh_ctrl_xfer(iface->udev,
335  REQ_TYPE_IN | REQ_TYPE_CLASS_DEV | REQ_TYPE_TO_IFACE, /* bmRequestType */
336  HID_GET_PROTOCOL, /* bRequest */
337  0, /* wValue */
338  iface->if_num, /* wIndex */
339  1, /* wLength */
340  protocol, &xfer_len, USB_CTRL_TIMEOUT_MS);
341 
342  if ((ret < 0) || (xfer_len != 1))
343  {
344  HID_DBGMSG("failed to get idle rate! %d\n", ret);
345  return HID_RET_IO_ERR;
346  }
347  return HID_RET_OK;
348 }
349 
350 
362 int32_t usbh_hid_set_protocol(HID_DEV_T *hdev, uint8_t protocol)
363 {
364  IFACE_T *iface;
365  uint32_t xfer_len;
366  int ret;
367 
368  if (!hdev || !hdev->iface)
369  return USBH_ERR_NOT_FOUND;
370 
371  iface = (IFACE_T *)hdev->iface;
372 
373  ret = usbh_ctrl_xfer(iface->udev,
374  REQ_TYPE_OUT | REQ_TYPE_CLASS_DEV | REQ_TYPE_TO_IFACE, /* bmRequestType */
375  HID_SET_PROTOCOL, /* bRequest */
376  protocol, /* wValue */
377  iface->if_num, /* wIndex */
378  0, /* wLength */
379  NULL, &xfer_len, USB_CTRL_TIMEOUT_MS);
380 
381  if (ret < 0)
382  {
383  HID_DBGMSG("failed to set idle rate! %d\n", ret);
384  return HID_RET_IO_ERR;
385  }
386  return HID_RET_OK;
387 }
388 
389 
391 
392 
393 /*
394  * HID int-in complete function
395  */
396 static void hid_read_irq(UTR_T *utr)
397 {
398  HID_DEV_T *hdev;
399  int ret;
400 
401  //HID_DBGMSG("hid_read_irq. %d\n", utr->xfer_len);
402 
403  hdev = (HID_DEV_T *)utr->context;
404 
405  if (utr->status != 0)
406  {
407  HID_DBGMSG("hid_read_irq - has error: 0x%x\n", utr->status);
408  if (hdev->read_func)
409  hdev->read_func(hdev, utr->ep->bEndpointAddress, utr->status, utr->buff, 0);
410  return;
411  }
412 
413  if (hdev->bSubClassCode == HID_SUBCLASS_BOOT_DEVICE)
414  {
415  if (hdev->bProtocolCode == HID_PROTOCOL_MOUSE)
416  hid_parse_mouse_reports(hdev, utr->buff, utr->xfer_len);
417 
418  if (hdev->bProtocolCode == HID_PROTOCOL_KEYBOARD)
419  hid_parse_keyboard_reports(hdev, utr->buff, utr->xfer_len);
420  }
421 
422  if (hdev->read_func && utr->xfer_len)
423  hdev->read_func(hdev, utr->ep->bEndpointAddress, utr->status, utr->buff, utr->xfer_len);
424 
425  utr->xfer_len = 0;
426  ret = usbh_int_xfer(utr);
427  if (ret)
428  {
429  HID_DBGMSG("hid_read_irq - failed to submit interrupt-in request (%d)", ret);
430  if (hdev->read_func)
431  hdev->read_func(hdev, utr->ep->bEndpointAddress, ret, utr->buff, 0);
432  usbh_free_mem(utr->buff, utr->data_len);
433  free_utr(utr);
434  }
435 }
436 
437 /*
438  * HID int-out complete function
439  */
440 static void hid_write_irq(UTR_T *utr)
441 {
442  HID_DEV_T *hdev;
443  int ret;
444 
445  //HID_DBGMSG("hid_write_irq. %d\n", urb->actual_length);
446 
447  hdev = (HID_DEV_T *)utr->context;
448 
449  if (utr->status)
450  {
451  HID_DBGMSG("hid_write_irq - has error: 0x%x\n", utr->status);
452  hdev->write_func(hdev, utr->ep->bEndpointAddress, utr->status, utr->buff, &(utr->data_len));
453  return;
454  }
455 
456  if (hdev->write_func)
457  {
458  utr->data_len = utr->ep->wMaxPacketSize;
459  hdev->write_func(hdev, utr->ep->bEndpointAddress, utr->status, utr->buff, &(utr->data_len));
460  }
461 
462  utr->xfer_len = 0;
463  ret = usbh_int_xfer(utr);
464  if (ret)
465  {
466  HID_DBGMSG("hid_write_irq - failed to submit interrupt-out request (%d)", ret);
467  hdev->write_func(hdev, utr->ep->bEndpointAddress, ret, utr->buff, &(utr->data_len));
468  free_utr(utr);
469  }
470 }
471 
472 
474 
485 int32_t usbh_hid_start_int_read(HID_DEV_T *hdev, uint8_t ep_addr, HID_IR_FUNC *func)
486 {
487  IFACE_T *iface = (IFACE_T *)hdev->iface;
488  UTR_T *utr;
489  EP_INFO_T *ep;
490  int i, ret;
491 
492  if ((!iface) || (!iface->udev))
493  return HID_RET_DEV_NOT_FOUND;
494 
495  if (!func)
496  return HID_RET_INVALID_PARAMETER;
497 
498  if (ep_addr == 0)
499  ep = usbh_iface_find_ep(iface, 0, EP_ADDR_DIR_IN | EP_ATTR_TT_INT);
500  else
501  ep = usbh_iface_find_ep(iface, ep_addr, 0);
502 
503  if (ep == NULL)
504  return USBH_ERR_EP_NOT_FOUND;
505 
506  utr = alloc_utr(iface->udev);
507  if (!utr)
508  return USBH_ERR_MEMORY_OUT;
509 
510  utr->buff = usbh_alloc_mem(ep->wMaxPacketSize);
511  if (utr->buff == NULL)
512  {
513  free_utr(utr);
514  return USBH_ERR_MEMORY_OUT;
515  }
516 
517  hdev->read_func = func;
518  utr->context = hdev;
519  utr->ep = ep;
520  utr->data_len = ep->wMaxPacketSize;
521  utr->xfer_len = 0;
522  utr->func = hid_read_irq;
523 
524  ret = usbh_int_xfer(utr);
525  if (ret < 0)
526  {
527  HID_DBGMSG("Error - failed to submit interrupt read request (%d)", ret);
528  usbh_free_mem(utr->buff, utr->data_len);
529  free_utr(utr);
530  return HID_RET_IO_ERR;
531  }
532 
533  i = get_free_utr_slot(hdev);
534  if (i < 0)
535  {
536  HID_DBGMSG("Error - No free HID slot!\n");
537  usbh_quit_utr(utr);
538  usbh_free_mem(utr->buff, utr->data_len);
539  free_utr(utr);
540  return USBH_ERR_MEMORY_OUT; /* no free UTR slot. */
541  }
542  else
543  {
544  hdev->utr_list[i] = utr;
545  }
546 
547  return HID_RET_OK;
548 }
549 
559 int32_t usbh_hid_stop_int_read(HID_DEV_T *hdev, uint8_t ep_addr)
560 {
561  IFACE_T *iface = (IFACE_T *)hdev->iface;
562  UTR_T *utr;
563  int i, ret;
564 
565  if ((!iface) || (!iface->udev))
566  return HID_RET_DEV_NOT_FOUND;
567 
568  for (i = 0; i < CONFIG_HID_DEV_MAX_PIPE; i++)
569  {
570  utr = hdev->utr_list[i];
571  if (ep_addr == 0)
572  {
573  /* Find any running UTR whose endpoint direction is IN */
574  if ((utr != NULL) && (utr->ep != NULL) &&
575  ((utr->ep->bEndpointAddress & EP_ADDR_DIR_MASK) == EP_ADDR_DIR_IN))
576  {
577  break;
578  }
579  }
580  else
581  {
582  /* Find any running UTR whose endpoint address is matched with ep_addr */
583  if ((utr != NULL) && (utr->ep != NULL) && (utr->ep->bEndpointAddress == ep_addr))
584  {
585  break; /* UTR found */
586  }
587  }
588  utr = NULL;
589  }
590 
591  if (utr == NULL)
592  return HID_RET_DEV_NOT_FOUND;
593 
594  hdev->utr_list[i] = NULL; /* remove it from HID UTR list */
595 
596  ret = usbh_quit_utr(utr); /* force to stop the transfer */
597 
598  usbh_free_mem(utr->buff, utr->ep->wMaxPacketSize);
599  free_utr(utr);
600 
601  return ret;
602 }
603 
614 int32_t usbh_hid_start_int_write(HID_DEV_T *hdev, uint8_t ep_addr, HID_IW_FUNC *func)
615 {
616  IFACE_T *iface = (IFACE_T *)hdev->iface;
617  UTR_T *utr;
618  EP_INFO_T *ep;
619  int i, ret;
620 
621  if ((!iface) || (!iface->udev))
622  return HID_RET_DEV_NOT_FOUND;
623 
624  if (!func)
625  return HID_RET_INVALID_PARAMETER;
626 
627  if (ep_addr == 0)
628  ep = usbh_iface_find_ep(iface, 0, EP_ADDR_DIR_OUT | EP_ATTR_TT_INT);
629  else
630  ep = usbh_iface_find_ep(iface, ep_addr, 0);
631 
632  if (ep == NULL)
633  return USBH_ERR_EP_NOT_FOUND;
634 
635  utr = alloc_utr(iface->udev);
636  if (!utr)
637  return USBH_ERR_MEMORY_OUT;
638 
639  utr->buff = usbh_alloc_mem(ep->wMaxPacketSize);
640  if (utr->buff == NULL)
641  {
642  free_utr(utr);
643  return USBH_ERR_MEMORY_OUT;
644  }
645 
646  hdev->write_func = func;
647 
648  utr->context = hdev;
649  utr->ep = ep;
650  utr->data_len = ep->wMaxPacketSize;
651  utr->xfer_len = 0;
652  utr->func = hid_write_irq;
653 
654  /* first time interrupt write call-back to get first data packet */
655  func(hdev, ep->bEndpointAddress, 0, utr->buff, &(utr->data_len));
656 
657  ret = usbh_int_xfer(utr);
658  if (ret < 0)
659  {
660  HID_DBGMSG("Error - failed to submit interrupt read request (%d)", ret);
661  free_utr(utr);
662  return HID_RET_IO_ERR;
663  }
664 
665  i = get_free_utr_slot(hdev);
666  if (i < 0)
667  {
668  HID_DBGMSG("Error - No free HID slot!\n");
669  usbh_quit_utr(utr);
670  usbh_free_mem(utr->buff, utr->data_len);
671  free_utr(utr);
672  return USBH_ERR_MEMORY_OUT; /* no free UTR slot. */
673  }
674  else
675  {
676  hdev->utr_list[i] = utr;
677  }
678 
679  return HID_RET_OK;
680 }
681 
691 int32_t usbh_hid_stop_int_write(HID_DEV_T *hdev, uint8_t ep_addr)
692 {
693  IFACE_T *iface = (IFACE_T *)hdev->iface;
694  UTR_T *utr;
695  int i, ret;
696 
697  if ((!iface) || (!iface->udev))
698  return HID_RET_DEV_NOT_FOUND;
699 
700  for (i = 0; i < CONFIG_HID_DEV_MAX_PIPE; i++)
701  {
702  utr = hdev->utr_list[i];
703  if (ep_addr == 0)
704  {
705  /* Find any running UTR whose endpoint direction is OUT */
706  if ((utr != NULL) && (utr->ep != NULL) &&
707  ((utr->ep->bEndpointAddress & EP_ADDR_DIR_MASK) == EP_ADDR_DIR_OUT))
708  {
709  break;
710  }
711  }
712  else
713  {
714  /* Find any running UTR whose endpoint address is matched with ep_addr */
715  if ((utr != NULL) && (utr->ep != NULL) && (utr->ep->bEndpointAddress == ep_addr))
716  {
717  break; /* UTR found */
718  }
719  }
720  utr = NULL;
721  }
722 
723  if (utr == NULL)
724  return HID_RET_DEV_NOT_FOUND;
725 
726  hdev->utr_list[i] = NULL; /* remove it from HID UTR list */
727 
728  ret = usbh_quit_utr(utr);
729 
730  usbh_free_mem(utr->buff, utr->ep->wMaxPacketSize);
731  free_utr(utr);
732 
733  return ret;
734 }
735 
743 void usbh_hid_regitser_mouse_callback(HID_MOUSE_FUNC *func)
744 {
745  _mouse_callback = func;
746 }
747 
755 void usbh_hid_regitser_keyboard_callback(HID_KEYBOARD_FUNC *func)
756 {
757  _keyboard_callback = func;
758 }
759 
760 
USBH_ERR_NOT_FOUND
#define USBH_ERR_NOT_FOUND
Definition: usbh_lib.h:39
usbh_hid_stop_int_write
int32_t usbh_hid_stop_int_write(HID_DEV_T *hdev, uint8_t ep_addr)
stop purge the USB interrupt out transfer.
Definition: hid_core.c:691
HID_GET_IDLE
#define HID_GET_IDLE
Definition: usbh_hid.h:157
HID_SET_PROTOCOL
#define HID_SET_PROTOCOL
Definition: usbh_hid.h:161
hid_parser.c
M480 MCU USB Host HID report descriptor parser.
HID_KEYBOARD_FUNC
void() HID_KEYBOARD_FUNC(struct usbhid_dev *hdev, KEYBOARD_EVENT_T *kbd)
Definition: usbh_hid.h:320
usbh_hid_stop_int_read
int32_t usbh_hid_stop_int_read(HID_DEV_T *hdev, uint8_t ep_addr)
Stop purge the USB interrupt in transfer.
Definition: hid_core.c:559
HID_GET_PROTOCOL
#define HID_GET_PROTOCOL
Definition: usbh_hid.h:158
HID_IR_FUNC
void() HID_IR_FUNC(struct usbhid_dev *hdev, uint16_t ep_addr, int status, uint8_t *rdata, uint32_t data_len)
Definition: usbh_lib.h:123
usbh_hid_get_report_descriptor
int32_t usbh_hid_get_report_descriptor(HID_DEV_T *hdev, uint8_t *desc_buf, int buf_max_len)
Read report descriptor from HID device.
Definition: hid_core.c:56
NuMicro.h
NuMicro peripheral access layer header file.
HID_MOUSE_FUNC
void() HID_MOUSE_FUNC(struct usbhid_dev *hdev, MOUSE_EVENT_T *mouse)
Definition: usbh_hid.h:319
usbh_hid_set_protocol
int32_t usbh_hid_set_protocol(HID_DEV_T *hdev, uint8_t protocol)
Issue a HID class SET_PROTOCOL request. The SET_PROTOCOL switches between the boot protocol and the r...
Definition: hid_core.c:362
usbh_hid.h
USB Host HID class driver header file.
usbh_lib.h
USB Host library exported header file.
usbh_hid_get_protocol
int32_t usbh_hid_get_protocol(HID_DEV_T *hdev, uint8_t *protocol)
Issue a HID class GET_PROTOCOL request. The GET_PROTOCOL request reads which protocol is currently ac...
Definition: hid_core.c:323
HID_RET_OK
#define HID_RET_OK
Definition: usbh_lib.h:85
HID_RET_INVALID_PARAMETER
#define HID_RET_INVALID_PARAMETER
Definition: usbh_lib.h:88
HID_IW_FUNC
void() HID_IW_FUNC(struct usbhid_dev *hdev, uint16_t ep_addr, int status, uint8_t *wbuff, uint32_t *data_len)
Definition: usbh_lib.h:124
usbh_hid_get_idle
HIDDEN_SYMBOLS int32_t usbh_hid_get_idle(HID_DEV_T *hdev, int rtp_id, uint8_t *idle_rate)
Issue a HID class GET_IDLE request. The GET_IDLE request reads the current idle rate for a particular...
Definition: hid_core.c:243
USBH_ERR_MEMORY_OUT
#define USBH_ERR_MEMORY_OUT
Definition: usbh_lib.h:32
USBH_ERR_EP_NOT_FOUND
#define USBH_ERR_EP_NOT_FOUND
Definition: usbh_lib.h:40
HID_RET_IO_ERR
#define HID_RET_IO_ERR
Definition: usbh_lib.h:87
HID_RET_DEV_NOT_FOUND
#define HID_RET_DEV_NOT_FOUND
Definition: usbh_lib.h:86
HID_REPORT_SET
#define HID_REPORT_SET
Definition: usbh_hid.h:159
usbh_hid_start_int_write
int32_t usbh_hid_start_int_write(HID_DEV_T *hdev, uint8_t ep_addr, HID_IW_FUNC *func)
Start purge the USB interrupt out transfer.
Definition: hid_core.c:614
usbh_hid_set_idle
int32_t usbh_hid_set_idle(HID_DEV_T *hdev, int rtp_id, uint8_t idle_rate)
Issue a HID class SET_IDLE request. The SET_IDLE request silences a particular report on the Interrup...
Definition: hid_core.c:283
HID_SET_IDLE
#define HID_SET_IDLE
Definition: usbh_hid.h:160
usbh_hid_regitser_keyboard_callback
void usbh_hid_regitser_keyboard_callback(HID_KEYBOARD_FUNC *func)
Register the keyboard event callback function to HID class driver. Any keyboard reports will be sent ...
Definition: hid_core.c:755
usbh_hid_regitser_mouse_callback
void usbh_hid_regitser_mouse_callback(HID_MOUSE_FUNC *func)
Register the mouse event callback function to HID class driver. Any mouse reports will be sent to use...
Definition: hid_core.c:743
usb.h
USB Host library header file.
usbh_hid_set_report
int32_t usbh_hid_set_report(HID_DEV_T *hdev, int rtp_typ, int rtp_id, uint8_t *data, int len)
Issue a HID class SET_REPORT request. The Set_Report request allows the host to send a report to the ...
Definition: hid_core.c:147
HID_REPORT_GET
#define HID_REPORT_GET
Definition: usbh_hid.h:156
usbh_hid_start_int_read
HIDDEN_SYMBOLS int32_t usbh_hid_start_int_read(HID_DEV_T *hdev, uint8_t ep_addr, HID_IR_FUNC *func)
Start purge the USB interrupt in transfer.
Definition: hid_core.c:485
CONFIG_HID_DEV_MAX_PIPE
#define CONFIG_HID_DEV_MAX_PIPE
Definition: usbh_hid.h:53
NULL
#define NULL
NULL pointer.
Definition: M480.h:604
usbh_hid_get_report
int32_t usbh_hid_get_report(HID_DEV_T *hdev, int rtp_typ, int rtp_id, uint8_t *data, int len)
Issue a HID class GET_REPORT request.
Definition: hid_core.c:102
HID_DEV_T
HIDDEN_SYMBOLS struct usbhid_dev HID_DEV_T
Generated on Wed Oct 7 2020 09:26:15 for M480 BSP by   doxygen 1.8.15