1 /*
2 ********************************************************************************
3 * USB Hid Driver
4 *
5 * (c) Copyright 2006-2010, All winners Co,Ld.
6 * All Right Reserved
7 *
8 * FileName : Hid.c
9 *
10 * Author : Javen
11 *
12 * Date : 2010/06/02
13 *
14 * Description : Hid Driver中对USB接口设备的处理
15 *
16 * Others : NULL
17 *
18 * History:
19 * <time> <author> <version > <desc>
20 * 2010.06.02 Javen 1.0 build this file
21 *
22 ********************************************************************************
23 */
24 //#include "usb_host_config.h"
25 //#include "usb_host_base_types.h"
26 #include "usb_os_platform.h"
27 #include "error.h"
28
29 #include "usb_utils_find_zero_bit.h"
30 #include "usb_list.h"
31 #include "urb.h"
32 #include "list_head_ext.h"
33 #include "usb_host_common.h"
34 #include "usb_gen_dev_mod.h"
35 #include "usb_core_interface.h"
36 #include "usb_msg.h"
37 #include "HidSpec.h"
38 #include "Hid.h"
39 #include "Hid_i.h"
40 #include "HidTransport.h"
41 #include "HidProtocol.h"
42 #include "HidFunDrv.h"
43
44 #define HID_DRV_NAME "HID Class"
45 #define HID_DRV_AUTHOR "Host Driver Author"
46 #if 0
47 #define DMSG_HID_TEST hal_log_info
48 #else
49 #define DMSG_HID_TEST(...)
50 #endif
51
52 //---------------------------------------------------------------
53 // 宏定义区
54 //---------------------------------------------------------------
55
56 //---------------------------------------------------------------
57 // 全局变量区
58 //---------------------------------------------------------------
59 static struct usb_host_func_drv HidDrv;
60 static u32 HidDev_id_array; /* 记录了设备的编号 */
61
62 static struct usb_drv_dev_match_table Hid_match_table[] = {
63 {
64 USB_DEVICE_ID_MATCH_INT_CLASS, //match_flags;
65
66 0, //idVendor;
67 0, //idProduct;
68 0, //bcdDevice_lo;
69 0, //bcdDevice_hi;
70
71 //Used for device class matches
72 0, //bDeviceClass;
73 0, //bDeviceSubClass;
74 0, //bDeviceProtocol;
75
76 //Used for interface class matches
77 USB_CLASS_HID, //bInterfaceClass;
78 0, //bInterfaceSubClass;
79 0, //bInterfaceProtocol;
80
81 //not matched against
82 0, //driver_info;
83 },
84
85 {
86 0, //match_flags;
87
88 0, //idVendor;
89 0, //idProduct;
90 0, //bcdDevice_lo;
91 0, //bcdDevice_hi;
92
93 //Used for device class matches
94 0, //bDeviceClass;
95 0, //bDeviceSubClass;
96 0, //bDeviceProtocol;
97
98 //Used for interface class matches
99 0, //bInterfaceClass;
100 0, //bInterfaceSubClass;
101 0, //bInterfaceProtocol;
102
103 //not matched against
104 0, //driver_info;
105 }/* Terminating entry */
106 };
107
108 //---------------------------------------------------------------
109 // 函数区定义区
110 //---------------------------------------------------------------
111
112 /*
113 *******************************************************************************
114 * get_HidDev_id
115 *
116 * Description:
117 * 给新插入的设备分配ID
118 *
119 * Parameters:
120 * void
121 *
122 * Return value:
123 * 返回分配的ID
124 *
125 * note:
126 * 无
127 *
128 *******************************************************************************
129 */
get_HidDev_id(void)130 static unsigned int get_HidDev_id(void)
131 {
132 unsigned int bit = 0;
133
134 bit = find_next_zero_bit((const volatile u32 *)&HidDev_id_array, (1 * 32), 0);
135 if(bit > 32){
136 hal_log_err("ERR: find_next_zero_bit failed\n");
137 return 31;
138 }
139
140 usb_set_bit(bit, (volatile uint32_t *)&HidDev_id_array);
141
142 return bit;
143 }
144
145 /*
146 *******************************************************************************
147 * free_HidDev_id
148 *
149 * Description:
150 * 释放分配的ID
151 *
152 * Parameters:
153 * bit : input. mscDev的ID号
154 *
155 * Return value:
156 * 0 ：成功
157 * !0 ：失败
158 *
159 * note:
160 * 无
161 *
162 *******************************************************************************
163 */
free_HidDev_id(unsigned int bit)164 static int free_HidDev_id(unsigned int bit)
165 {
166 if(usb_test_bit(bit, (volatile uint32_t *)&HidDev_id_array) == 0){
167 hal_log_err("ERR: free_host_id: invalid bit(%d)\n", bit);
168 return -1;
169 }
170
171 /* 回收该位 */
172 usb_clear_bit(bit, (volatile uint32_t *)&HidDev_id_array);
173
174 return 0;
175 }
176
177 /*
178 *******************************************************************************
179 * HidDevInit
180 *
181 * Description:
182 *
183 *
184 * Parameters:
185 *
186 *
187 * Return value:
188 *
189 *
190 * note:
191 * 无
192 *
193 *******************************************************************************
194 */
HidDevInit(HidDev_t * HidDev,struct usb_interface * intf)195 static int HidDevInit(HidDev_t *HidDev, struct usb_interface *intf)
196 {
197 int ret = 0;
198
199 if(HidDev == NULL || intf == NULL){
200 hal_log_err("ERR: HidDevInit: input error\n");
201 return USB_ERR_BAD_ARGUMENTS;
202 }
203
204 HidDev->pusb_dev = usb_mod_interface_to_usbdev(intf);
205 if(HidDev->pusb_dev == NULL){
206 hal_log_err("ERR: HidDevInit: HidDev->pusb_dev == NULL\n");
207 return USB_ERR_BAD_ARGUMENTS;
208 }
209
210 HidDev->pusb_intf = intf;
211 HidDev->DevNo = get_HidDev_id();
212
213 /* Store our private data in the interface */
214 usb_mod_usb_set_intf_priv_data(intf, (void *)HidDev);
215
216 /* alloc urb */
217 HidDev->CurrentUrb = usb_alloc_urb(0);
218 if(HidDev->CurrentUrb == NULL){
219 hal_log_err("ERR: HidDevInit: usb_alloc_urb failed\n");
220 return USB_ERR_ALLOC_URB_FAILED;
221 }
222
223 HidDev->CtrlReq = (struct usb_ctrlrequest *)usb_buffer_alloc(HidDev->pusb_dev,
224 sizeof(struct usb_ctrlrequest),
225 0,
226 NULL);
227 if(HidDev->CtrlReq == NULL){
228 hal_log_err("ERR: usb_buffer_alloc CtrlReq failed\n");
229 ret = USB_ERR_MALLOC_FAILED;
230 goto error0;
231 }
232
233 HidDev->ReportDesc = (unsigned char *)hal_malloc(USB_HID_MAX_DESCRIPTOR_SIZE);
234 if(HidDev->ReportDesc == NULL){
235 hal_log_err("ERR: hal_malloc failed\n");
236 goto error1;
237 }
238
239 HidDev->UrbWait = hal_sem_create(0);
240 if(HidDev->UrbWait == NULL){
241 hal_log_err("ERR: USB_OS_SemCreate UrbWait failed\n");
242 ret = USB_ERR_CREATE_SIME_FAILED;
243 goto error2;
244 }
245
246 return USB_ERR_SUCCESS;
247
248 error2:
249 hal_free(HidDev->ReportDesc);
250 HidDev->ReportDesc = NULL;
251
252 error1:
253 usb_buffer_free(HidDev->pusb_dev, sizeof(struct usb_ctrlrequest), (void *)(HidDev->CtrlReq), 0);
254 HidDev->CtrlReq = NULL;
255
256 error0:
257 usb_free_urb(HidDev->CurrentUrb);
258 HidDev->CurrentUrb = NULL;
259
260 return ret;
261 }
262
263 /*
264 *******************************************************************************
265 * HidDevFree
266 *
267 * Description:
268 *
269 *
270 * Parameters:
271 *
272 *
273 * Return value:
274 *
275 *
276 * note:
277 * 无
278 *
279 *******************************************************************************
280 */
HidDevFree(HidDev_t * HidDev)281 static int HidDevFree(HidDev_t *HidDev)
282 {
283 unsigned char err = 0;
284
285 if(HidDev == NULL){
286 hal_log_err("ERR: input error\n");
287 return USB_ERR_BAD_ARGUMENTS;
288 }
289
290 if(HidDev->CurrentUrb){
291 usb_free_urb(HidDev->CurrentUrb);
292 HidDev->CurrentUrb = NULL;
293 }
294
295 if(HidDev->CtrlReq){
296 usb_buffer_free(HidDev->pusb_dev, sizeof(struct usb_ctrlrequest), (void *)(HidDev->CtrlReq), 0);
297 HidDev->CtrlReq = NULL;
298 }
299
300 if(HidDev->ReportDesc){
301 hal_free(HidDev->ReportDesc);
302 }
303
304 if(HidDev->UrbWait){
305 hal_sem_delete(HidDev->UrbWait);
306 HidDev->UrbWait = NULL;
307 }
308
309 /* Remove our private data from the interface */
310 usb_mod_usb_set_intf_priv_data(HidDev->pusb_intf, NULL);
311
312 free_HidDev_id(HidDev->DevNo);
313
314 return 0;
315 }
316
317 /*
318 *******************************************************************************
319 * HidGetDeviceInfo
320 *
321 * Description:
322 *
323 *
324 * Parameters:
325 *
326 *
327 * Return value:
328 * 无
329 *
330 * note:
331 * 无
332 *
333 *******************************************************************************
334 */
HidGetDeviceInfo(HidDev_t * HidDev,unsigned int index)335 static void HidGetDeviceInfo(HidDev_t *HidDev, unsigned int index)
336 {
337 struct usb_interface_descriptor *idesc = &(HidDev->pusb_intf->cur_altsetting->desc);
338
339 HidDev->InterfaceNo = idesc->bInterfaceNumber;
340 HidDev->SubClass = idesc->bInterfaceSubClass;
341 HidDev->Protocol = idesc->bInterfaceProtocol;
342
343 return;
344 }
345
346 /*
347 *******************************************************************************
348 * HidGetTransport
349 *
350 * Description:
351 *
352 *
353 * Parameters:
354 *
355 *
356 * Return value:
357 *
358 *
359 * note:
360 * 无
361 *
362 *******************************************************************************
363 */
HidGetTransport(HidDev_t * HidDev)364 static int HidGetTransport(HidDev_t *HidDev)
365 {
366 HidDev->ResetRecovery = HidResetRecovery;
367 HidDev->SoftReset = HidSoftReset;
368 HidDev->Transport = HidTransport;
369 HidDev->StopTransport = HidStopTransport;
370
371 return USB_ERR_SUCCESS;
372 }
373
374 /*
375 *******************************************************************************
376 * HidCreatePipes
377 *
378 * Description:
379 *
380 *
381 * Parameters:
382 *
383 *
384 * Return value:
385 *
386 *
387 * note:
388 * 无
389 *
390 *******************************************************************************
391 */
HidCreatePipes(HidDev_t * HidDev)392 static int HidCreatePipes(HidDev_t *HidDev)
393 {
394 struct usb_host_virt_interface *altsetting = HidDev->pusb_intf->cur_altsetting;
395 struct usb_endpoint_descriptor *ep = NULL;
396 struct usb_endpoint_descriptor *ep_int = NULL;
397 int i = 0;
398
399 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
400 ep = &altsetting->endpoint[i].desc;
401
402 /* Is it an interrupt endpoint? */
403 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) {
404 ep_int = ep;
405 }
406 }
407
408 if(ep_int == NULL){
409 hal_log_err("HidCreatePipes: Endpoint sanity check failed! Rejecting dev.\n");
410 return USB_ERR_UNKOWN_ERROR;
411 }
412
413 /* create ctrl and int pipes */
414 HidDev->CtrlOut = usb_sndctrlpipe(HidDev->pusb_dev, 0);
415 HidDev->CtrlIn = usb_rcvctrlpipe(HidDev->pusb_dev, 0);
416 HidDev->IntIn = usb_rcvintpipe(HidDev->pusb_dev,
417 ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
418 HidDev->EpInterval = ep_int->bInterval;
419 HidDev->OnceTransferLength = ep_int->wMaxPacketSize;
420
421 return USB_ERR_SUCCESS;
422 }
423
424 /*
425 *******************************************************************************
426 * HidSetDeviceState
427 *
428 * Description:
429 *
430 *
431 * Parameters:
432 *
433 *
434 * Return value:
435 *
436 *
437 * note:
438 * 无
439 *
440 *******************************************************************************
441 */
HidSetDeviceState(HidDev_t * HidDev,HidDev_State_t state)442 void HidSetDeviceState(HidDev_t *HidDev, HidDev_State_t state)
443 {
444 unsigned int cup_sr = 0;
445
446 ENTER_CRITICAL(cup_sr);
447 HidDev->State = state;
448 EXIT_CRITICAL(cup_sr);
449 }
450
451 /*
452 *******************************************************************************
453 * HidParseReport
454 *
455 * Description:
456 *
457 *
458 * Parameters:
459 *
460 *
461 * Return value:
462 *
463 *
464 * note:
465 * 无
466 *
467 *******************************************************************************
468 */
HidGetInputReport(HidDev_t * HidDev,unsigned int Usagepage,unsigned int Usage,unsigned int * BitOffset,unsigned int * BitCount)469 int HidGetInputReport(HidDev_t *HidDev,
470 unsigned int Usagepage,
471 unsigned int Usage,
472 unsigned int *BitOffset,
473 unsigned int *BitCount)
474 {
475 usbHidReportEnum_t *InputReport = NULL;
476 usbHidReport_t *Report = NULL;
477 usbHidField_t *Field = NULL;
478 usbHidUsage_t *ReportUsage = NULL;
479 unsigned int Offset_ReportId = 0; /* 如果有ReportId, 那么data[0]就不能够算在BitOffset里 */
480 unsigned int i = 0;
481 unsigned int j = 0;
482 unsigned int k = 0;
483
484 InputReport = HidDev->HidReportEnum + USB_HID_REPORT_INPUT;
485 if(InputReport == NULL){
486 hal_log_err("ERR: InputReport is NULL\n");
487 return USB_ERR_BAD_ARGUMENTS;
488 }
489
490 /* Device uses numbered reports, data[0] is report number */
491 if(InputReport->numbered){
492 Offset_ReportId = 8;
493 }
494 hal_log_info("InputReport ReportNum = %d\n", InputReport->ReportNum);
495
496 /* report */
497 for(i = 0; i < InputReport->ReportNum; i++){
498 Report = InputReport->Report[i];
499 if(Report == NULL){
500 hal_log_err("ERR: Report is NULL\n");
501 continue;
502 }
503
504 /* field */
505 for(j = 0; j < Report->Maxfield; j++){
506 Field = Report->Field[j];
507 if(Field == NULL){
508 hal_log_err("ERR: Field is NULL\n");
509 continue;
510 }
511
512 /* Usage */
513 for(k = 0; k < Field->maxusage; k++){
514 ReportUsage = &Field->usage[k];
515 if(ReportUsage == NULL){
516 hal_log_err("ERR: Usage is NULL\n");
517 continue;
518 }
519
520 if(Usage == USB_HID_GENERIC_DESKTOP_PAGE_UNDEFINED){
521 if(((ReportUsage->hid >> 16) & 0xffff) == Usagepage){
522 DMSG_HID_TEST("Find Bitmap: Usage(%x), Id = %d, report_offset = %d, report_size = %d\n",
523 Usagepage, ((Offset_ReportId == 0) ? 0 : 1),
524 Field->report_offset, (Field->report_size * k));
525 *BitOffset = Offset_ReportId + Field->report_offset + (Field->report_size * k);
526 *BitCount = Field->report_size * Field->report_count;
527
528 DMSG_HID_TEST("Usage(%x), BitOffset = %d, BitCount = %d\n",
529 Usagepage, *BitOffset, *BitCount);
530
531 return USB_ERR_SUCCESS;
532 }
533 }else{
534 if(ReportUsage->hid == ((Usagepage << 16) | Usage)){
535 DMSG_HID_TEST("Find Bitmap: usage(%x, %x), Id = %d, report_offset = %d, report_size = %d\n",
536 Usagepage, Usage, ((Offset_ReportId == 0) ? 0 : 1),
537 Field->report_offset, (Field->report_size * k));
538 *BitOffset = Offset_ReportId + Field->report_offset + (Field->report_size * k);
539 *BitCount = Field->report_size;
540
541 DMSG_HID_TEST("usage(%x, %x), BitOffset = %d, BitCount = %d\n",
542 Usagepage, Usage, *BitOffset, *BitCount);
543
544 return USB_ERR_SUCCESS;
545 }
546 }
547 }
548 }
549 }
550
551 return USB_ERR_UNKOWN_ERROR;
552 }
553
554
555 /*
556 *******************************************************************************
557 * HidDevScan
558 *
559 * Description:
560 *
561 *
562 * Parameters:
563 *
564 *
565 * Return value:
566 *
567 *
568 * note:
569 * 无
570 *
571 *******************************************************************************
572 */
HidDevScan(HidDev_t * HidDev)573 static int HidDevScan(HidDev_t *HidDev)
574 {
575 struct usb_host_virt_interface *cur_alt = NULL;
576 usbHidDescriptor_t *HidDesc = NULL;
577 int ret = 0;
578 unsigned int i = 0;
579
580 if(HidDev == NULL){
581 hal_log_err("ERR: HidDevScan: input error\n");
582 return USB_ERR_BAD_ARGUMENTS;
583 }
584
585 /* initalize parameter */
586 cur_alt = HidDev->pusb_intf->cur_altsetting;
587
588 /* get device type */
589 HidDev->DevType = cur_alt->desc.bInterfaceProtocol;
590
591 /* Get Hid descriptor */
592 if (usb_get_extra_descriptor(cur_alt, USB_HID_DT_HID, &HidDesc)
593 &&(!cur_alt->desc.bNumEndpoints
594 || usb_get_extra_descriptor(&(cur_alt->endpoint[0]), USB_HID_DT_HID, &HidDesc))){
595 hal_log_err("ERR: class descriptor not present\n");
596 return USB_ERR_UNKOWN_ERROR;
597 }
598
599 /* 获得report返回的数据长度 */
600 for (i = 0; i < HidDesc->bNumDescriptors; i++){
601 if (HidDesc->desc[i].bDescriptorType == USB_HID_DT_REPORT){
602 HidDev->ReportSize = le16_to_cpu(HidDesc->desc[i].wDescriptorLength);
603 break;
604 }
605 }
606
607 if (HidDev->ReportSize == 0 || HidDev->ReportSize > USB_HID_MAX_DESCRIPTOR_SIZE) {
608 hal_log_err("ERR: weird size of report descriptor (%u)\n", HidDev->ReportSize);
609 return USB_ERR_UNKOWN_ERROR;
610 }
611
612 /* set idle request, 限制了report的频率 */
613 HidSetIlde(HidDev, HidDev->InterfaceNo, 0, 0);
614
615 /* Get Hid Report descriptor */
616 ret = HidGetClassDescriptor(HidDev,
617 HidDev->InterfaceNo,
618 USB_HID_DT_REPORT,
619 (void *)HidDev->ReportDesc,
620 HidDev->ReportSize);
621 if(ret != USB_ERR_SUCCESS){
622 hal_log_err("ERR: HidGetClassDescriptor failed\n");
623 return USB_ERR_COMMAND_EXECUTE_FAILED;
624 }
625
626 /* parse Hid Report descriptor */
627 HidParseReport(HidDev->ReportDesc, HidDev->ReportSize, HidDev);
628
629 /* Client probe */
630 switch(HidDev->DevType){
631 case USB_HID_PROTOCOL_MOUSE:
632 HidDev->ClientProbe = usbMouseProbe;
633 HidDev->ClientRemove = usbMouseRemove;
634 break;
635 /*
636 case USB_HID_PROTOCOL_KEYBOARD:
637 HidDev->ClientProbe = usbKeyBoardProbe;
638 HidDev->ClientRemove = usbKeyBoardRemove;
639 break;
640 */
641 default:
642 hal_log_err("ERR: HidDevScan: unkown hid Device Type(%x)\n", HidDev->DevType);
643 HidDev->ClientProbe = NULL;
644 HidDev->ClientRemove = NULL;
645
646 return USB_ERR_UNKOWN_DEVICE;
647 }
648
649 if(HidDev->ClientProbe){
650 if(HidDev->ClientProbe(HidDev) != USB_ERR_SUCCESS){
651 hal_log_err("ERR: ClientProbe faield\n");
652 return USB_ERR_DEVICE_PROBE_FAILED;
653 }
654 }
655
656 return USB_ERR_SUCCESS;
657 }
658
659 /*
660 *******************************************************************************
661 * HidDevAdd
662 *
663 * Description:
664 *
665 *
666 * Parameters:
667 *
668 *
669 * Return value:
670 *
671 *
672 * note:
673 * 无
674 *
675 *******************************************************************************
676 */
HidDevAdd(HidDev_t * HidDev)677 static int HidDevAdd(HidDev_t * HidDev)
678 {
679 return HidDevScan(HidDev);
680 }
681
682 /*
683 *******************************************************************************
684 * HidDevDel
685 *
686 * Description:
687 *
688 *
689 * Parameters:
690 *
691 *
692 * Return value:
693 *
694 *
695 * note:
696 * 无
697 *
698 *******************************************************************************
699 */
HidDevDel(HidDev_t * HidDev)700 static int HidDevDel(HidDev_t * HidDev)
701 {
702 if(HidDev->ClientRemove){
703 if(HidDev->ClientRemove(HidDev) != USB_ERR_SUCCESS){
704 hal_log_err("ERR: ClientProbe faield\n");
705 return USB_ERR_DEVICE_PROBE_FAILED;
706 }
707 }
708
709 HidFreeReport(HidDev);
710
711 return USB_ERR_SUCCESS;
712 }
713
714
715 /*
716 *******************************************************************************
717 * HidSentRequest
718 *
719 * Description:
720 *
721 *
722 * Parameters:
723 *
724 *
725 * Return value:
726 *
727 *
728 * note:
729 * 无
730 *
731 *******************************************************************************
732 */
HidSentRequest(HidRequest_t * HidReq)733 int HidSentRequest(HidRequest_t *HidReq)
734 {
735 HidDev_t *HidDev = NULL;
736 unsigned int cpu_sr = 0;
737 int ret = 0;
738
739 if(HidReq == NULL){
740 hal_log_err("ERR: HidSentRequest: input error\n");
741 return USB_ERR_BAD_ARGUMENTS;
742 }
743
744 HidDev = HidReq->HidDev;
745 if(HidDev == NULL){
746 hal_log_err("ERR: HidSentRequest: HidDev == NULL\n");
747 return USB_ERR_BAD_ARGUMENTS;
748 }
749
750 /* Transport */
751 ret = HidDev->Transport(HidDev, HidReq);
752
753 ENTER_CRITICAL(cpu_sr);
754 HidReq->Result = ret;
755 EXIT_CRITICAL(cpu_sr);
756
757 /* HidReq Done */
758 HidReq->Done(HidReq);
759
760 return USB_ERR_SUCCESS;
761 }
762
763 /*
764 *******************************************************************************
765 * HidDevProbe
766 *
767 * Description:
768 *
769 *
770 * Parameters:
771 *
772 *
773 * Return value:
774 *
775 *
776 * note:
777 * 无
778 *
779 *******************************************************************************
780 */
HidDevProbe(struct usb_interface * intf,const struct usb_drv_dev_match_table * table_item)781 static int32_t HidDevProbe(struct usb_interface *intf, const struct usb_drv_dev_match_table * table_item)
782 {
783 const s32 match_table_index = table_item - Hid_match_table;
784 HidDev_t *HidDev = NULL;
785 int ret = 0;
786 // unsigned char err = 0;
787
788 hal_log_info("HidDevProbe begin\n");
789
790 if(intf == NULL || table_item == NULL){
791 hal_log_err("ERR: HidDevProbe: input error\n");
792 return -1;
793 }
794
795 //----------------------------------------------------------------
796 // 创建HidDev设备
797 //----------------------------------------------------------------
798 /* 初始化一个mscDev */
799 HidDev = hal_malloc(sizeof(HidDev_t));
800 if(HidDev == NULL){
801 hal_log_err("ERR: HidDevProbe malloc failed\n");
802 goto error0;
803 }
804
805 memset(HidDev, 0, sizeof(HidDev_t));
806
807 ret = HidDevInit(HidDev, intf);
808 if(ret != USB_ERR_SUCCESS){
809 hal_log_err("ERR: HidDevProbe failed\n");
810 ret = -1;
811 goto error1;
812 }
813
814 /* 获得设备信息 */
815 HidGetDeviceInfo(HidDev, match_table_index);
816
817 /* 获得Transport */
818 ret = HidGetTransport(HidDev);
819 if(ret != USB_ERR_SUCCESS){
820 hal_log_err("ERR: HidGetTransport failed\n");
821 ret = -1;
822 goto error2;
823 }
824
825 /* 创建传输管道 */
826 ret = HidCreatePipes(HidDev);
827 if(ret != USB_ERR_SUCCESS){
828 hal_log_err("ERR: HidGetTransport failed\n");
829 ret = -1;
830 goto error3;
831 }
832
833 HidSetDeviceState(HidDev, HID_DEV_ONLINE);
834
835 //----------------------------------------------------------------
836 // 识别HidDev设备
837 //----------------------------------------------------------------
838 ret = HidDevAdd(HidDev);
839 if(ret != USB_ERR_SUCCESS){
840 hal_log_err("ERR: HidDevScan failed\n");
841 ret = -1;
842 goto error4;
843 }
844
845 return 0;
846
847 error4:
848 HidSetDeviceState(HidDev, HID_DEV_OFFLINE);
849
850 error3:
851 error2:
852 HidDevFree(HidDev);
853
854 error1:
855 hal_free(HidDev);
856
857 error0:
858
859 return -1;
860 }
861
862 /*
863 *******************************************************************************
864 * HidInit
865 *
866 * Description:
867 *
868 *
869 * Parameters:
870 *
871 *
872 * Return value:
873 * EPDK_OK / EPDK_FAIL
874 *
875 * note:
876 * 无
877 *
878 *******************************************************************************
879 */
HidDevSuspend(struct usb_interface * intf)880 static int32_t HidDevSuspend(struct usb_interface *intf)
881 {
882 hal_log_info("HidDevSuspend not support\n");
883
884 return 0;
885 }
886 /*
887 *******************************************************************************
888 * HidInit
889 *
890 * Description:
891 *
892 *
893 * Parameters:
894 *
895 *
896 * Return value:
897 * EPDK_OK / EPDK_FAIL
898 *
899 * note:
900 * 无
901 *
902 *******************************************************************************
903 */
HidDevRemove(struct usb_interface * intf)904 static void HidDevRemove(struct usb_interface *intf)
905 {
906 HidDev_t *HidDev = NULL;
907
908 if(intf == NULL){
909 hal_log_err("ERR: HidDevRemoves: input error\n");
910 return ;
911 }
912
913 HidDev = (HidDev_t *)usb_mod_usb_get_intf_priv_data(intf);
914 if(HidDev == NULL){
915 hal_log_err("ERR: HidDev = NULL\n");
916 return ;
917 }
918
919 HidSetDeviceState(HidDev, HID_DEV_OFFLINE);
920
921 HidDevDel(HidDev);
922
923 HidDevFree(HidDev);
924
925 hal_free(HidDev);
926
927 hal_log_info("HidDevRemove complete\n");
928
929 return ;
930 }
931
932 /*
933 *******************************************************************************
934 * HidInit
935 *
936 * Description:
937 *
938 *
939 * Parameters:
940 *
941 *
942 * Return value:
943 * EPDK_OK / EPDK_FAIL
944 *
945 * note:
946 * 无
947 *
948 *******************************************************************************
949 */
HidDriverInit(struct usb_host_func_drv * drv)950 static int HidDriverInit(struct usb_host_func_drv *drv)
951 {
952 if(drv == NULL){
953 hal_log_err("ERR: mscDrv_init: input error\n");
954 return -1;
955 }
956
957 USB_INIT_LIST_HEAD(&(drv->virt_dev_list));
958 drv->func_drv_name = HID_DRV_NAME;
959 drv->func_drv_auther = HID_DRV_AUTHOR;
960 drv->probe = HidDevProbe;
961 drv->disconnect = HidDevRemove;
962 drv->suspend = HidDevSuspend;
963 drv->resume = NULL;
964 drv->match_table = Hid_match_table;
965
966 return 0;
967 }
968
969 /*
970 *******************************************************************************
971 * HidInit
972 *
973 * Description:
974 *
975 *
976 * Parameters:
977 *
978 *
979 * Return value:
980 * EPDK_OK / EPDK_FAIL
981 *
982 * note:
983 * 无
984 *
985 *******************************************************************************
986 */
HidInit(void)987 int HidInit(void)
988 {
989 int ret = 0;
990
991 memset(&HidDrv, 0, sizeof(struct usb_host_func_drv));
992
993 if(HidDriverInit(&HidDrv) != 0){
994 hal_log_err("ERR: HidDriverInit failed\n");
995 return -1;
996 }
997
998 ret = usb_host_func_drv_reg(&HidDrv);
999 if(ret != 0){
1000 hal_log_err("ERR: HidInit: Reg driver %s failed\n", HidDrv.func_drv_name);
1001 return -1;
1002 }
1003
1004 return 0;
1005 }
1006
1007 /*
1008 *******************************************************************************
1009 * HidExit
1010 *
1011 * Description:
1012 *
1013 *
1014 * Parameters:
1015 *
1016 *
1017 * Return value:
1018 * EPDK_OK / EPDK_FAIL
1019 *
1020 * note:
1021 * 无
1022 *
1023 *******************************************************************************
1024 */
HidExit(void)1025 int HidExit(void)
1026 {
1027 int ret = 0;
1028
1029 ret = usb_host_func_drv_unreg(&HidDrv);
1030 if(ret != 0){
1031 hal_log_err("ERR: HidExit: UnReg driver %s failed\n", HidDrv.func_drv_name);
1032 return -1;
1033 }
1034
1035 memset(&HidDrv, 0, sizeof(struct usb_host_func_drv));
1036
1037 return 0;
1038 }
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049