1:
9:
10:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
#include "uhs_type.h"
24:
#include "uhs_stdlib.h"
25:
26:
#include "usb_hid_boot.h"
27:
#include "usb_hid_common.h"
28:
#include "usb_hid_macro.h"
29:
#include "usb_hid_osutils.h"
30:
#include "usb_hid_class_api.h"
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
#ifdef USBH_STACK_DEBUG_BUILD
64:
static const char g_filename[] = __FILE__;
65:
#endif
66:
67:
68:
69:
70:
71:
83: uhs_status_t
Usbh_Hid_GetVersion(uhs_ubit8_t* pu8MajorVersion,
84: uhs_ubit8_t* pu8MinorVersion)
85: {
86:
87:
88:
89:
if( (pu8MajorVersion == NULL) ||
90: (pu8MinorVersion == NULL) ) {
91: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
92:
return( USBHID_API_PARAM_ERROR );
93: }
94:
95:
96:
97:
98:
if( g_pHidDriver == NULL ) {
99: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_INIT );
100:
return( USBHID_API_SYS_SYSTEM_ERROR );
101: }
102:
103:
104: *pu8MajorVersion =
HID_MAJOR_VERSION;
105:
106: *pu8MinorVersion =
HID_MINOR_VERSION;
107:
108:
return( USBHID_API_SUCCESS );
109: }
110:
111:
138: uhs_status_t
Usbh_Hid_RegistCallBack(
void* pContext,
139:
hid_callback_t pUserNotifyCallback)
140: {
141:
PHID_DEVICE pHidDevice;
142: uhs_status_t nRetvalResorce;
143: uhs_ubit8_t u8CntDeviceId;
144: uhs_status_t nRetStatus;
145:
146:
147:
148:
149:
150: CIAPI_HID_REPORT_MILESTONE( USBHID_CHKPOINTS_API_REGIST );
151:
152:
153:
154:
155:
if( pContext == NULL ){
156: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
157:
return( USBHID_API_PARAM_ERROR );
158: }
159:
160:
161:
162:
163:
if( g_pHidDriver == NULL ) {
164: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_INIT );
165:
return( USBHID_API_SYS_SYSTEM_ERROR );
166: }
167:
168:
169:
170:
171:
172: nRetStatus = Usbh_Hid_CheckDeviceStatus(pContext, &pHidDevice, &u8CntDeviceId, ID_CLSREQ_DET);
173:
if(nRetStatus != USBHID_API_SUCCESS){
174: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_SYSTEM_ERROR );
175:
return(nRetStatus);
176: }
177:
178:
179:
180:
181:
if( pUserNotifyCallback == NULL ) {
182:
183:
184: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
185: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
186:
return( USBHID_API_PARAM_ERROR );
187: }
188:
189:
190:
191:
192: nRetvalResorce = HidUtils_AcquisitionSemaphore(pHidDevice->pRegistExecuteLock, WAITFOREVER);
193:
if( nRetvalResorce != TRUE ){
194:
195:
196: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
197:
198:
199: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
200:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
201: }
202:
203:
204:
205:
206:
if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_CONNECTING ) {
207: ;
208: }
209:
else if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_NO_SUPPORT ) {
210:
211:
212:
213: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pRegistExecuteLock );
214: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
215:
216: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NO_SUPPORT );
217:
return( USBHID_API_NO_SUPPORT );
218: }
219:
else {
220:
221:
222:
223: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pRegistExecuteLock );
224: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
225:
226: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_ALREADY_REGIST );
227:
return( USBHID_API_ALREADY_REGIST );
228: }
229:
230:
231: pHidDevice->nDeviceStat = HID_DEVICE_STAT_REGIST;
232:
233:
234:
235:
236: pHidDevice->pUserNotifyCallback = pUserNotifyCallback;
237:
238:
239:
240:
241:
if( (pHidDevice->pIntInBuff = (
PHID_INTIN_BUFF)HidUtils_Malloc((uhs_size_t)
sizeof(HID_INTIN_BUFF))) == NULL ) {
242:
243: pHidDevice->nDeviceStat = HID_DEVICE_STAT_CONNECTING;
244:
245: pHidDevice->pUserNotifyCallback = NULL;
246:
247:
248:
249:
250: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pRegistExecuteLock );
251: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
252:
253:
254: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
255:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
256: }
257:
258:
259:
260:
261: pHidDevice->pIntInBuff->u8WritePos = 0;
262: pHidDevice->pIntInBuff->u8ReceiveSize = 0;
263: pHidDevice->pIntInBuff->isIntINUserFlag = TRUE;
264:
265:
266:
267:
268:
if( (pHidDevice->pIntInBuff->pu8StartBuff = (uhs_ubit8_t*)HidUtils_Malloc((uhs_size_t)(USB_MAXPKT_CTRLEP))) == NULL ) {
269:
270: pHidDevice->nDeviceStat = HID_DEVICE_STAT_CONNECTING;
271:
272: pHidDevice->pUserNotifyCallback = NULL;
273:
274:
275: (
void)HidUtils_Free( pHidDevice->pIntInBuff );
276:
277:
278: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pRegistExecuteLock );
279:
280:
281: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
282:
283:
284: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
285:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
286: }
287:
288:
289:
290:
291:
if( (pHidDevice->pIntInBuff->pu8TempBuff = (uhs_ubit8_t*)HidUtils_Malloc((uhs_size_t)(pHidDevice->pIntInPipe->u32MaxPacketSize))) == NULL ) {
292:
293: pHidDevice->nDeviceStat = HID_DEVICE_STAT_CONNECTING;
294:
295: pHidDevice->pUserNotifyCallback = NULL;
296:
297:
298: (
void)HidUtils_Free( pHidDevice->pIntInBuff->pu8StartBuff );
299:
300: (
void)HidUtils_Free( pHidDevice->pIntInBuff );
301:
302:
303: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pRegistExecuteLock );
304:
305: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
306:
307:
308: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
309:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
310: }
311:
312:
313:
314:
315: nRetvalResorce = HidUtils_ReleaseSemaphore( pHidDevice->pRegistExecuteLock );
316:
if(nRetvalResorce != TRUE){
317:
318: pHidDevice->nDeviceStat = HID_DEVICE_STAT_CONNECTING;
319:
320: pHidDevice->pUserNotifyCallback = NULL;
321:
322:
323: (
void)HidUtils_Free( pHidDevice->pIntInBuff->pu8TempBuff );
324:
325: (
void)HidUtils_Free( pHidDevice->pIntInBuff->pu8StartBuff );
326:
327: (
void)HidUtils_Free( pHidDevice->pIntInBuff );
328:
329: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
330:
331:
332: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
333:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
334: }
335:
336:
337:
338:
339: nRetvalResorce = HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
340:
if(nRetvalResorce != TRUE){
341:
342: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
343:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
344: }
345:
346:
347:
348:
349: CIAPI_HID_REPORT_MILESTONE( USBHID_CHKPOINTS_API_REGIST_FINISH );
350:
351:
return( USBHID_API_SUCCESS );
352: }
353:
354:
373: uhs_status_t
Usbh_Hid_GetHIDDescriptor(
void* pContext,
PHID_DESC_INFO pstData)
374: {
375:
PHID_DEVICE pHidDevice;
376: uhs_ubit8_t u8CntDeviceId;
377: uhs_status_t nRetStatus;
378: uhs_status_t nRetvalResorce;
379: uhs_ubit8_t u8Len;
380: uhs_ubit8_t i;
381:
382:
383:
384:
385:
if( pContext == NULL ){
386: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
387:
return( USBHID_API_PARAM_ERROR );
388: }
389:
390:
391:
392:
393:
if( g_pHidDriver == NULL ) {
394: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_INIT );
395:
return( USBHID_API_SYS_SYSTEM_ERROR );
396: }
397:
398:
399:
400:
401:
402: nRetStatus = Usbh_Hid_CheckDeviceStatus(pContext, &pHidDevice, &u8CntDeviceId, ID_CLSREQ_DET);
403:
if(nRetStatus != USBHID_API_SUCCESS){
404: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_SYSTEM_ERROR );
405:
return(nRetStatus);
406: }
407:
408:
409:
410:
411:
if( (pstData == NULL) ||
412: (pstData->pu8Buff == NULL) ||
413: (pstData->u16Length == 0) ) {
414:
415:
416: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
417: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
418:
return( USBHID_API_PARAM_ERROR );
419: }
420:
421:
422:
423:
424:
if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_CONNECTING ) {
425:
426:
427: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
428: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_USE );
429:
return( USBHID_API_NOT_READY );
430: }
431:
else if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_NO_SUPPORT ) {
432:
433:
434: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
435: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NO_SUPPORT );
436:
return( USBHID_API_NO_SUPPORT );
437: }
438:
else {
439: ;
440: }
441:
442:
443:
444:
445: u8Len = pstData->u16Length >= pHidDevice->hid_desc.data[0] ? pHidDevice->hid_desc.data[0] : pstData->u16Length;
446:
for(i = 0; i < u8Len; i++) {
447: pstData->pu8Buff[i] = pHidDevice->hid_desc.data[i];
448: }
449:
450:
451:
452:
453: nRetvalResorce = HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
454:
if(nRetvalResorce != TRUE){
455:
456: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
457:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
458: }
459:
460:
return( USBHID_API_SUCCESS );
461: }
462:
463:
482: uhs_status_t
Usbh_Hid_GetReportDescriptor(
void* pContext,
PHID_DESC_INFO pstData)
483: {
484:
PHID_DEVICE pHidDevice;
485: usb_device_request_t* pRequest;
486: HID_FUNC_STATUS nRetval;
487: uhs_ubit8_t u8CntDeviceId;
488: uhs_ubit16_t u16WLength;
489: uhs_status_t nRetStatus;
490: uhs_status_t nRetvalResorce;
491:
492:
493:
494:
495:
496:
if( pContext == NULL ){
497: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
498:
return( USBHID_API_PARAM_ERROR );
499: }
500:
501:
502:
503:
504:
if( g_pHidDriver == NULL ) {
505: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_INIT );
506:
return( USBHID_API_SYS_SYSTEM_ERROR );
507: }
508:
509:
510:
511:
512:
513: nRetStatus = Usbh_Hid_CheckDeviceStatus(pContext, &pHidDevice, &u8CntDeviceId, ID_CLSREQ_DET);
514:
if(nRetStatus != USBHID_API_SUCCESS){
515: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_SYSTEM_ERROR );
516:
return(nRetStatus);
517: }
518:
519:
520:
521:
522:
if( (pstData == NULL) ||
523: (pstData->pu8Buff == NULL) ||
524: (pstData->u16Length == 0) ) {
525:
526:
527: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
528: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
529:
return( USBHID_API_PARAM_ERROR );
530: }
531:
532:
533:
534:
535:
if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_CONNECTING ) {
536:
537:
538: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
539: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_USE );
540:
return( USBHID_API_NOT_READY );
541: }
542:
else if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_NO_SUPPORT ) {
543:
544:
545: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
546: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NO_SUPPORT );
547:
return( USBHID_API_NO_SUPPORT );
548: }
549:
else {
550: ;
551: }
552:
553:
554:
555:
556: pRequest = HidUtils_Malloc(
sizeof(usb_device_request_t));
557:
if(pRequest == NULL) {
558: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
559: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
560:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
561: }
562:
563:
564:
565: u16WLength = (pstData->u16Length + 64);
566:
567:
568:
569:
570: pRequest->bmRequestType = 0x81;
571: pRequest->bRequest = 0x06;
572: pRequest->wValue0 = 0x00;
573: pRequest->wValue1 = UNPACK16_LITTLE_ENDIAN_LSB( (uhs_ubit16_t)
USB_DESC_TYPE_REPORT );
574: pRequest->wIndex0 = UNPACK16_LITTLE_ENDIAN_LSB( pHidDevice->u16Intf_num );
575: pRequest->wIndex1 = UNPACK16_LITTLE_ENDIAN_MSB( pHidDevice->u16Intf_num );
576: pRequest->wLength0 = UNPACK16_LITTLE_ENDIAN_LSB( u16WLength );
577: pRequest->wLength1 = UNPACK16_LITTLE_ENDIAN_MSB( u16WLength );
578:
579:
580:
581:
582: nRetval = Usbh_Hid_ForCommand(pHidDevice, pRequest, pstData->pu8Buff, NULL);
583:
if(nRetval != HID_FUNC_STATUS_SUCCESS){
584: HidUtils_Free(pRequest);
585:
586:
587: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
588: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_FAILED_CLSREQ );
589:
return( USBHID_API_TRANS_CLSREQ_FAILED );
590: }
591:
592:
593:
594:
595: HidUtils_Free(pRequest);
596:
597:
598:
599:
600: nRetvalResorce = HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
601:
if(nRetvalResorce != TRUE){
602:
603: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
604:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
605: }
606:
607:
return( USBHID_API_SUCCESS );
608: }
609:
610:
631: uhs_status_t
Usbh_Hid_GetReport(
void* pContext,
PHID_REPORT_INFO pstData)
632: {
633:
PHID_DEVICE pHidDevice;
634: usb_device_request_t* pRequest;
635: HID_FUNC_STATUS nRetval;
636: uhs_ubit8_t u8CntDeviceId;
637: uhs_status_t nRetStatus;
638: uhs_status_t nRetvalResorce;
639:
640:
641:
642:
643:
if( pContext == NULL ){
644: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
645:
return( USBHID_API_PARAM_ERROR );
646: }
647:
648:
649:
650:
651:
if( g_pHidDriver == NULL ) {
652: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_INIT );
653:
return( USBHID_API_SYS_SYSTEM_ERROR );
654: }
655:
656:
657:
658:
659:
660: nRetStatus = Usbh_Hid_CheckDeviceStatus(pContext, &pHidDevice, &u8CntDeviceId, ID_CLSREQ_DET);
661:
if(nRetStatus != USBHID_API_SUCCESS){
662: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_SYSTEM_ERROR );
663:
return(nRetStatus);
664: }
665:
666:
667:
668:
669:
if( (pstData == NULL) ||
670: (pstData->pu8Buff == NULL) ||
671: (pstData->u16Length == 0) ) {
672:
673:
674: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
675: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
676:
return( USBHID_API_PARAM_ERROR );
677: }
678:
679:
680:
681:
682:
if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_CONNECTING ) {
683:
684:
685: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
686: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_USE );
687:
return( USBHID_API_NOT_READY );
688: }
689:
else if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_NO_SUPPORT ) {
690:
691:
692: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
693: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NO_SUPPORT );
694:
return( USBHID_API_NO_SUPPORT );
695: }
696:
else {
697: ;
698: }
699:
700:
701:
702:
703: pRequest = HidUtils_Malloc(
sizeof(usb_device_request_t));
704:
if(pRequest == NULL) {
705: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
706: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
707:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
708: }
709:
710:
711:
712:
713: pRequest->bmRequestType = 0xA1;
714: pRequest->bRequest = 0x01;
715: pRequest->wValue0 = UNPACK16_LITTLE_ENDIAN_LSB( (pstData->ReportTypeSelector << 8) | pstData->u8Id );
716: pRequest->wValue1 = UNPACK16_LITTLE_ENDIAN_MSB( (pstData->ReportTypeSelector << 8) | pstData->u8Id );
717: pRequest->wIndex0 = UNPACK16_LITTLE_ENDIAN_LSB( pHidDevice->u16Intf_num );
718: pRequest->wIndex1 = UNPACK16_LITTLE_ENDIAN_MSB( pHidDevice->u16Intf_num );
719: pRequest->wLength0 = UNPACK16_LITTLE_ENDIAN_LSB( pstData->u16Length );
720: pRequest->wLength1 = UNPACK16_LITTLE_ENDIAN_MSB( pstData->u16Length );
721:
722:
723:
724:
725: nRetval = Usbh_Hid_ForCommand(pHidDevice, pRequest, pstData->pu8Buff, NULL);
726:
if(nRetval != HID_FUNC_STATUS_SUCCESS){
727: HidUtils_Free(pRequest);
728:
729:
730: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
731: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_FAILED_CLSREQ );
732:
return( USBHID_API_TRANS_CLSREQ_FAILED );
733: }
734:
735:
736:
737:
738: HidUtils_Free(pRequest);
739:
740:
741:
742:
743: nRetvalResorce = HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
744:
if(nRetvalResorce != TRUE){
745:
746: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
747:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
748: }
749:
750:
return( USBHID_API_SUCCESS );
751: }
752:
753:
772: uhs_status_t
Usbh_Hid_GetProtocol(
void* pContext,
PHID_PROTOCOL pstData)
773: {
774:
PHID_DEVICE pHidDevice;
775: usb_device_request_t* pRequest;
776: HID_FUNC_STATUS nRetval;
777: uhs_ubit8_t u8CntDeviceId;
778: uhs_ubit8_t *pu8GetBuff;
779: uhs_status_t nRetStatus;
780: uhs_status_t nRetvalResorce;
781:
782:
783:
784:
785:
if( pContext == NULL ){
786: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
787:
return( USBHID_API_PARAM_ERROR );
788: }
789:
790:
791:
792:
793:
if( g_pHidDriver == NULL ) {
794: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_INIT );
795:
return( USBHID_API_SYS_SYSTEM_ERROR );
796: }
797:
798:
799:
800:
801:
802: nRetStatus = Usbh_Hid_CheckDeviceStatus(pContext, &pHidDevice, &u8CntDeviceId, ID_CLSREQ_DET);
803:
if(nRetStatus != USBHID_API_SUCCESS){
804: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_SYSTEM_ERROR );
805:
return(nRetStatus);
806: }
807:
808:
809:
810:
811:
if(pstData == NULL) {
812:
813:
814: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
815: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
816:
return( USBHID_API_PARAM_ERROR );
817: }
818:
819:
820:
821:
822:
if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_CONNECTING ) {
823:
824:
825: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
826: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_USE );
827:
return( USBHID_API_NOT_READY );
828: }
829:
else if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_NO_SUPPORT ) {
830:
831:
832: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
833: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NO_SUPPORT );
834:
return( USBHID_API_NO_SUPPORT );
835: }
836:
else {
837: ;
838: }
839:
840:
841:
842:
843: pRequest = HidUtils_Malloc(
sizeof(usb_device_request_t));
844:
if(pRequest == NULL) {
845: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
846: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
847:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
848: }
849:
850:
851:
852:
853: pu8GetBuff = HidUtils_Malloc(1);
854:
if(pu8GetBuff == NULL) {
855: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
856: HidUtils_Free(pRequest);
857: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
858: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
859:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
860: }
861:
862:
863:
864:
865: pRequest->bmRequestType = 0xA1;
866: pRequest->bRequest = 0x03;
867: pRequest->wValue0 = 0;
868: pRequest->wValue1 = 0;
869: pRequest->wIndex0 = UNPACK16_LITTLE_ENDIAN_LSB( pHidDevice->u16Intf_num );
870: pRequest->wIndex1 = UNPACK16_LITTLE_ENDIAN_MSB( pHidDevice->u16Intf_num );
871: pRequest->wLength0 = UNPACK16_LITTLE_ENDIAN_LSB( 1 );
872: pRequest->wLength1 = UNPACK16_LITTLE_ENDIAN_MSB( 1 );
873:
874:
875:
876:
877: nRetval = Usbh_Hid_ForCommand(pHidDevice, pRequest, pu8GetBuff, NULL);
878:
if(nRetval != HID_FUNC_STATUS_SUCCESS){
879: HidUtils_Free(pRequest);
880: HidUtils_Free(pu8GetBuff);
881:
882:
883: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
884: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_FAILED_CLSREQ );
885:
return( USBHID_API_TRANS_CLSREQ_FAILED );
886: }
887:
888:
889:
890:
891: pstData->u8Data = pu8GetBuff[0];
892:
893:
894:
895:
896: HidUtils_Free(pu8GetBuff);
897:
898:
899:
900:
901: HidUtils_Free(pRequest);
902:
903:
904:
905:
906: nRetvalResorce = HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
907:
if(nRetvalResorce != TRUE){
908:
909: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
910:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
911: }
912:
913:
return( USBHID_API_SUCCESS );
914: }
915:
916:
936: uhs_status_t
Usbh_Hid_SetIdle(
void* pContext,
PHID_IDLE pstData)
937: {
938:
PHID_DEVICE pHidDevice;
939: usb_device_request_t* pRequest;
940: HID_FUNC_STATUS nRetval;
941: uhs_ubit8_t u8CntDeviceId;
942: uhs_status_t nRetStatus;
943: uhs_status_t nRetvalResorce;
944:
945:
946:
947:
948:
if( pContext == NULL ){
949: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
950:
return( USBHID_API_PARAM_ERROR );
951: }
952:
953:
954:
955:
956:
if( g_pHidDriver == NULL ) {
957: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_INIT );
958:
return( USBHID_API_SYS_SYSTEM_ERROR );
959: }
960:
961:
962:
963:
964:
965: nRetStatus = Usbh_Hid_CheckDeviceStatus(pContext, &pHidDevice, &u8CntDeviceId, ID_CLSREQ_DET);
966:
if(nRetStatus != USBHID_API_SUCCESS){
967: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_SYSTEM_ERROR );
968:
return(nRetStatus);
969: }
970:
971:
972:
973:
974:
if(pstData == NULL) {
975:
976:
977: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
978: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
979:
return( USBHID_API_PARAM_ERROR );
980: }
981:
if( pstData->u8Id > 3 ) {
982:
983:
984: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
985: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
986:
return( USBHID_API_PARAM_ERROR );
987: }
988:
989:
990:
991:
992:
if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_CONNECTING ) {
993:
994:
995: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
996: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_USE );
997:
return( USBHID_API_NOT_READY );
998: }
999:
else if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_NO_SUPPORT ) {
1000:
1001:
1002: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
1003: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NO_SUPPORT );
1004:
return( USBHID_API_NO_SUPPORT );
1005: }
1006:
else {
1007: ;
1008: }
1009:
1010:
1011:
1012:
1013: pRequest = HidUtils_Malloc(
sizeof(usb_device_request_t));
1014:
if(pRequest == NULL) {
1015: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
1016: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
1017:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
1018: }
1019:
1020:
1021:
1022:
1023: pRequest->bmRequestType = 0x21;
1024: pRequest->bRequest = 0x0A;
1025: pRequest->wValue0 = UNPACK16_LITTLE_ENDIAN_LSB( (pstData->u8Duration << 8) | pstData->u8Id );
1026: pRequest->wValue1 = UNPACK16_LITTLE_ENDIAN_MSB( (pstData->u8Duration << 8) | pstData->u8Id );
1027: pRequest->wIndex0 = UNPACK16_LITTLE_ENDIAN_LSB( pHidDevice->u16Intf_num );
1028: pRequest->wIndex1 = UNPACK16_LITTLE_ENDIAN_MSB( pHidDevice->u16Intf_num );
1029: pRequest->wLength0 = 0;
1030: pRequest->wLength1 = 0;
1031:
1032:
1033:
1034:
1035: nRetval = Usbh_Hid_ForCommand(pHidDevice, pRequest, NULL, NULL);
1036:
if(nRetval != HID_FUNC_STATUS_SUCCESS){
1037: HidUtils_Free(pRequest);
1038:
1039:
1040: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
1041: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_FAILED_CLSREQ );
1042:
return( USBHID_API_TRANS_CLSREQ_FAILED );
1043: }
1044:
1045:
1046:
1047:
1048: HidUtils_Free(pRequest);
1049:
1050:
1051:
1052:
1053: nRetvalResorce = HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
1054:
if(nRetvalResorce != TRUE){
1055:
1056: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
1057:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
1058: }
1059:
1060:
return( USBHID_API_SUCCESS );
1061: }
1062:
1063:
1082: uhs_status_t
Usbh_Hid_SetProtocol(
void* pContext,
PHID_PROTOCOL pstData)
1083: {
1084:
PHID_DEVICE pHidDevice;
1085: usb_device_request_t* pRequest;
1086: HID_FUNC_STATUS nRetval;
1087: uhs_ubit8_t u8CntDeviceId;
1088: uhs_status_t nRetStatus;
1089: uhs_status_t nRetvalResorce;
1090:
1091:
1092:
1093:
1094:
if( pContext == NULL ){
1095: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
1096:
return( USBHID_API_PARAM_ERROR );
1097: }
1098:
1099:
1100:
1101:
1102:
if( g_pHidDriver == NULL ) {
1103: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_INIT );
1104:
return( USBHID_API_SYS_SYSTEM_ERROR );
1105: }
1106:
1107:
1108:
1109:
1110:
1111: nRetStatus = Usbh_Hid_CheckDeviceStatus(pContext, &pHidDevice, &u8CntDeviceId, ID_CLSREQ_DET);
1112:
if(nRetStatus != USBHID_API_SUCCESS){
1113: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_SYSTEM_ERROR );
1114:
return(nRetStatus);
1115: }
1116:
1117:
1118:
1119:
1120:
if(pstData == NULL) {
1121:
1122:
1123: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
1124: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
1125:
return( USBHID_API_PARAM_ERROR );
1126: }
1127:
if( pstData->u8Data > 1 ) {
1128:
1129:
1130: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
1131: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
1132:
return( USBHID_API_PARAM_ERROR );
1133: }
1134:
1135:
1136:
1137:
1138:
if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_CONNECTING ) {
1139:
1140:
1141: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
1142: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_USE );
1143:
return( USBHID_API_NOT_READY );
1144: }
1145:
else if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_NO_SUPPORT ) {
1146:
1147:
1148: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
1149: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NO_SUPPORT );
1150:
return( USBHID_API_NO_SUPPORT );
1151: }
1152:
else {
1153: ;
1154: }
1155:
1156:
1157:
1158:
1159: pRequest = HidUtils_Malloc(
sizeof(usb_device_request_t));
1160:
if(pRequest == NULL) {
1161: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
1162: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
1163:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
1164: }
1165:
1166:
1167:
1168:
1169: pRequest->bmRequestType = 0x21;
1170: pRequest->bRequest = 0x0B;
1171: pRequest->wValue0 = pstData->u8Data;
1172: pRequest->wValue1 = 0;
1173: pRequest->wIndex0 = UNPACK16_LITTLE_ENDIAN_LSB( pHidDevice->u16Intf_num );
1174: pRequest->wIndex1 = UNPACK16_LITTLE_ENDIAN_MSB( pHidDevice->u16Intf_num );
1175: pRequest->wLength0 = 0;
1176: pRequest->wLength1 = 0;
1177:
1178:
1179:
1180:
1181: nRetval = Usbh_Hid_ForCommand(pHidDevice, pRequest, NULL, NULL);
1182:
if(nRetval != HID_FUNC_STATUS_SUCCESS){
1183: HidUtils_Free(pRequest);
1184:
1185:
1186: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
1187: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_FAILED_CLSREQ );
1188:
return( USBHID_API_TRANS_CLSREQ_FAILED );
1189: }
1190:
1191:
1192:
1193:
1194: HidUtils_Free(pRequest);
1195:
1196:
1197:
1198:
1199: nRetvalResorce = HidUtils_ReleaseSemaphore( g_pHidDriver->pClsReqDetAccessLock[u8CntDeviceId] );
1200:
if(nRetvalResorce != TRUE){
1201:
1202: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
1203:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
1204: }
1205:
1206:
return( USBHID_API_SUCCESS );
1207: }
1208:
1209:
1228: uhs_status_t
Usbh_Hid_RestartIntIN(
void* pContext)
1229: {
1230:
PHID_DEVICE pHidDevice;
1231: uhs_status_t nRetvalResorce;
1232: HID_FUNC_STATUS nRetval;
1233: uhs_ubit8_t u8CntDeviceId;
1234: uhs_status_t nRetStatus;
1235:
1236:
1237:
1238:
1239:
if( pContext == NULL ) {
1240: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
1241:
return( USBHID_API_PARAM_ERROR );
1242: }
1243:
1244:
1245:
1246:
1247:
if( g_pHidDriver == NULL ) {
1248: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_INIT );
1249:
return( USBHID_API_SYS_SYSTEM_ERROR );
1250: }
1251:
1252:
1253:
1254:
1255:
1256: nRetStatus = Usbh_Hid_CheckDeviceStatus(pContext, &pHidDevice, &u8CntDeviceId, ID_API_DET);
1257:
if(nRetStatus != USBHID_API_SUCCESS){
1258: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_SYSTEM_ERROR );
1259:
return(nRetStatus);
1260: }
1261:
1262:
1263:
1264:
1265: nRetvalResorce = HidUtils_AcquisitionSemaphore(pHidDevice->pIntInExecuteLock, WAITFOREVER);
1266:
if( nRetvalResorce != TRUE ){
1267:
1268:
1269:
1270: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1271: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
1272:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
1273: }
1274:
1275:
1276:
1277:
1278:
if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_CONNECTING ) {
1279:
1280:
1281: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pIntInExecuteLock );
1282: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1283: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_USE );
1284:
return( USBHID_API_NOT_READY );
1285: }
1286:
else if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_NO_SUPPORT ) {
1287:
1288:
1289: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pIntInExecuteLock );
1290: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1291: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NO_SUPPORT );
1292:
return( USBHID_API_NO_SUPPORT );
1293: }
1294:
else {
1295: ;
1296: }
1297:
1298:
1299:
if( pHidDevice->pIntInBuff->isIntINUserFlag == TRUE ) {
1300:
1301:
1302: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pIntInExecuteLock );
1303:
1304:
1305:
1306: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1307:
1308:
1309: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_ALREADY_START_INTIN );
1310:
return( USBHID_API_ALREADY_START_INTIN );
1311: }
1312:
1313:
1314:
1315:
1316: nRetval = Usbh_Hid_IssueIntInMsg(pHidDevice);
1317:
if(nRetval != HID_FUNC_STATUS_SUCCESS ) {
1318:
1319:
1320: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pIntInExecuteLock );
1321:
1322:
1323:
1324: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1325:
1326:
1327: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_FAILED_INTERRUPT );
1328:
return( USBHID_API_TRANS_INT_FAILED );
1329: }
1330:
1331:
1332:
1333:
1334: pHidDevice->pIntInBuff->isIntINUserFlag = TRUE;
1335:
1336:
1337:
1338:
1339: nRetvalResorce = HidUtils_ReleaseSemaphore( pHidDevice->pIntInExecuteLock );
1340:
if(nRetvalResorce != TRUE){
1341:
1342:
1343: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1344:
1345:
1346: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
1347:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
1348: }
1349:
1350:
1351:
1352:
1353: nRetvalResorce = HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1354:
if(nRetvalResorce != TRUE){
1355:
1356: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
1357:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
1358: }
1359:
1360:
return( USBHID_API_SUCCESS );
1361: }
1362:
1363:
1384: uhs_status_t
Usbh_Hid_StopIntIN(
void* pContext)
1385: {
1386:
PHID_DEVICE pHidDevice;
1387: uhs_status_t nRetvalResorce;
1388: HID_FUNC_STATUS nRetval;
1389: uhs_ubit8_t u8CntDeviceId;
1390: uhs_status_t nRetStatus;
1391:
1392:
1393:
1394:
1395:
if( pContext == NULL ) {
1396: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_PARAM_ERROR );
1397:
return( USBHID_API_PARAM_ERROR );
1398: }
1399:
1400:
1401:
1402:
1403:
if( g_pHidDriver == NULL ) {
1404: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_INIT );
1405:
return( USBHID_API_SYS_SYSTEM_ERROR );
1406: }
1407:
1408:
1409:
1410:
1411:
1412:
1413: nRetStatus = Usbh_Hid_CheckDeviceStatus(pContext, &pHidDevice, &u8CntDeviceId, ID_API_DET);
1414:
if(nRetStatus != USBHID_API_SUCCESS){
1415: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_SYSTEM_ERROR );
1416:
return(nRetStatus);
1417: }
1418:
1419:
1420:
1421:
1422: nRetvalResorce = HidUtils_AcquisitionSemaphore(pHidDevice->pIntInExecuteLock, WAITFOREVER);
1423:
if( nRetvalResorce != TRUE ){
1424:
1425:
1426:
1427: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1428:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
1429: }
1430:
1431:
1432:
1433:
1434:
if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_CONNECTING ) {
1435:
1436:
1437: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pIntInExecuteLock );
1438: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1439: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NOT_USE );
1440:
return( USBHID_API_NOT_READY );
1441: }
1442:
else if( pHidDevice->nDeviceStat == HID_DEVICE_STAT_NO_SUPPORT ) {
1443:
1444:
1445: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pIntInExecuteLock );
1446: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1447: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_NO_SUPPORT );
1448:
return( USBHID_API_NO_SUPPORT );
1449: }
1450:
else {
1451: ;
1452: }
1453:
1454:
1455:
if( pHidDevice->pIntInBuff->isIntINUserFlag == FALSE ) {
1456:
1457:
1458: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pIntInExecuteLock );
1459:
1460:
1461:
1462: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1463:
1464:
1465: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_ALREADY_STOP_INTIN );
1466:
return( USBHID_API_ALREADY_STOP_INTIN );
1467: }
1468:
1469:
1470:
1471:
1472: nRetval = Usbh_Hid_StopIntINMsg(pHidDevice);
1473:
if(nRetval != HID_FUNC_STATUS_SUCCESS ) {
1474:
1475:
1476: (
void)HidUtils_ReleaseSemaphore( pHidDevice->pIntInExecuteLock );
1477:
1478:
1479:
1480: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1481:
1482:
1483: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_FAILED_INTERRUPT );
1484:
return( USBHID_API_TRANS_INT_FAILED );
1485: }
1486:
1487:
1488:
1489:
1490: pHidDevice->pIntInBuff->isIntINUserFlag = FALSE;
1491:
1492:
1493:
1494:
1495: nRetvalResorce = HidUtils_ReleaseSemaphore( pHidDevice->pIntInExecuteLock );
1496:
if(nRetvalResorce != TRUE){
1497:
1498:
1499: (
void)HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1500:
1501:
1502: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
1503:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
1504: }
1505:
1506:
1507:
1508:
1509: nRetvalResorce = HidUtils_ReleaseSemaphore( g_pHidDriver->pApiDetAccessLock[u8CntDeviceId] );
1510:
if(nRetvalResorce != TRUE){
1511:
1512: CIAPI_HID_REPORT_SUMMARY( USBHID_LOG_SYS_OUT_OF_RESOURCE );
1513:
return( USBHID_API_SYS_OUT_OF_RESOURCE );
1514: }
1515:
1516:
return( USBHID_API_SUCCESS );
1517: }
1518: