| changeset 253 | d37db4dcc88d |
| parent 90 | 947f0dc9f7a8 |
| 252:0a40b8675b23 | 253:d37db4dcc88d |
|---|---|
1 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies). |
1 // Copyright (c) 2000-2010 Nokia Corporation and/or its subsidiary(-ies). |
2 // All rights reserved. |
2 // All rights reserved. |
3 // This component and the accompanying materials are made available |
3 // This component and the accompanying materials are made available |
4 // under the terms of the License "Eclipse Public License v1.0" |
4 // under the terms of the License "Eclipse Public License v1.0" |
5 // which accompanies this distribution, and is available |
5 // which accompanies this distribution, and is available |
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
21 @file d_usbc.cpp |
21 @file d_usbc.cpp |
22 @internalTechnology |
22 @internalTechnology |
23 */ |
23 */ |
24 |
24 |
25 #include <drivers/usbc.h> |
25 #include <drivers/usbc.h> |
26 #include "OstTraceDefinitions.h" |
|
27 #ifdef OST_TRACE_COMPILER_IN_USE |
|
28 #include "d_usbcTraces.h" |
|
29 #endif |
|
30 |
|
26 |
31 |
27 |
32 |
28 _LIT(KUsbLddName, "Usbc"); |
33 _LIT(KUsbLddName, "Usbc"); |
29 |
34 |
30 static const TInt KUsbRequestCallbackPriority = 2; |
35 static const TInt KUsbRequestCallbackPriority = 2; |
93 TInt DUsbcLogDevice::Install() |
98 TInt DUsbcLogDevice::Install() |
94 { |
99 { |
95 // Only proceed if we have the Controller underneath us |
100 // Only proceed if we have the Controller underneath us |
96 if (!DUsbClientController::UsbcControllerPointer()) |
101 if (!DUsbClientController::UsbcControllerPointer()) |
97 { |
102 { |
98 __KTRACE_OPT(KPANIC, Kern::Printf("LDD Install: USB Controller Not Present")); |
103 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DUSBCLOGDEVICE_INSTALL, |
104 "LDD Install: USB Controller Not Present" ); |
|
105 |
|
99 return KErrGeneral; |
106 return KErrGeneral; |
100 } |
107 } |
101 return SetName(&KUsbLddName); |
108 return SetName(&KUsbLddName); |
102 } |
109 } |
103 |
110 |
132 iOwnsDeviceControl(EFalse), |
139 iOwnsDeviceControl(EFalse), |
133 iAlternateSetting(0), |
140 iAlternateSetting(0), |
134 iDeviceStatusNeeded(EFalse), |
141 iDeviceStatusNeeded(EFalse), |
135 iChannelClosing(EFalse) |
142 iChannelClosing(EFalse) |
136 { |
143 { |
137 __KTRACE_OPT(KUSB, Kern::Printf("*** DLddUsbcChannel::DLddUsbcChannel CTOR")); |
144 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FLOW, DLDDUSBCCHANNEL_DLDDUSBCCHANNEL_CONS, |
145 "*** DLddUsbcChannel::DLddUsbcChannel CTOR" ); |
|
146 |
|
138 iClient = &Kern::CurrentThread(); |
147 iClient = &Kern::CurrentThread(); |
139 iClient->Open(); |
148 iClient->Open(); |
140 for (TInt i = 1; i <= KMaxEndpointsPerClient; i++) |
149 for (TInt i = 1; i <= KMaxEndpointsPerClient; i++) |
141 { |
150 { |
142 iEndpoint[i] = NULL; |
151 iEndpoint[i] = NULL; |
148 } |
157 } |
149 |
158 |
150 |
159 |
151 DLddUsbcChannel::~DLddUsbcChannel() |
160 DLddUsbcChannel::~DLddUsbcChannel() |
152 { |
161 { |
153 __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::~DLddUsbcChannel()")); |
162 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FLOW, DLDDUSBCCHANNEL_DLDDUSBCCHANNEL_DES, |
163 "DLddUsbcChannel::~DLddUsbcChannel()" ); |
|
164 |
|
154 if (iController) |
165 if (iController) |
155 { |
166 { |
156 iController->DeRegisterClient(this); |
167 iController->DeRegisterClient(this); |
157 iStatusCallbackInfo.Cancel(); |
168 iStatusCallbackInfo.Cancel(); |
158 iEndpointStatusCallbackInfo.Cancel(); |
169 iEndpointStatusCallbackInfo.Cancel(); |
194 // |
205 // |
195 // Create channel |
206 // Create channel |
196 // |
207 // |
197 TInt DLddUsbcChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer) |
208 TInt DLddUsbcChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer) |
198 { |
209 { |
199 __KTRACE_OPT(KUSB, Kern::Printf("LDD DoCreateL 1 Ver = %02d %02d %02d", |
210 OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCREATE, |
200 aVer.iMajor, aVer.iMinor, aVer.iBuild)); |
211 "LDD DoCreateL 1 Ver = %02d %02d %02d", aVer.iMajor, aVer.iMinor, aVer.iBuild ); |
212 |
|
201 if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD, |
213 if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD, |
202 __PLATSEC_DIAGNOSTIC_STRING("Checked by USBC.LDD (USB Driver)"))) |
214 __PLATSEC_DIAGNOSTIC_STRING("Checked by USBC.LDD (USB Driver)"))) |
203 { |
215 { |
204 return KErrPermissionDenied; |
216 return KErrPermissionDenied; |
205 } |
217 } |
425 // |
437 // |
426 // Overriding DObject virtual |
438 // Overriding DObject virtual |
427 // |
439 // |
428 TInt DLddUsbcChannel::RequestUserHandle(DThread* aThread, TOwnerType /*aType*/) |
440 TInt DLddUsbcChannel::RequestUserHandle(DThread* aThread, TOwnerType /*aType*/) |
429 { |
441 { |
430 __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::RequestUserHandle")); |
442 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_REQUESTUSERHANDLE, |
443 "DLddUsbcChannel::RequestUserHandle" ); |
|
431 // The USB client LDD is not designed for a channel to be shared between |
444 // The USB client LDD is not designed for a channel to be shared between |
432 // threads. It saves a pointer to the current thread when it is opened, and |
445 // threads. It saves a pointer to the current thread when it is opened, and |
433 // uses this to complete any asynchronous requests. |
446 // uses this to complete any asynchronous requests. |
434 // It is therefore not acceptable for the handle to be duplicated and used |
447 // It is therefore not acceptable for the handle to be duplicated and used |
435 // by another thread: |
448 // by another thread: |
448 // Asynchronous requests - overriding pure virtual |
461 // Asynchronous requests - overriding pure virtual |
449 // |
462 // |
450 void DLddUsbcChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2) |
463 void DLddUsbcChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2) |
451 { |
464 { |
452 // Check on request status |
465 // Check on request status |
453 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest 0x%08x", aReqNo)); |
466 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOREQUEST, |
467 "DoRequest 0x%08x", aReqNo ); |
|
454 TInt r = KErrNone; |
468 TInt r = KErrNone; |
455 if (iRequestStatus[aReqNo] != NULL) |
469 if (iRequestStatus[aReqNo] != NULL) |
456 { |
470 { |
457 DestroyAllInterfaces(); |
471 DestroyAllInterfaces(); |
458 PanicClientThread(ERequestAlreadyPending); |
472 PanicClientThread(ERequestAlreadyPending); |
517 |
531 |
518 switch (aReqNo) |
532 switch (aReqNo) |
519 { |
533 { |
520 case RDevUsbcClient::ERequestAlternateDeviceStatusNotify: |
534 case RDevUsbcClient::ERequestAlternateDeviceStatusNotify: |
521 { |
535 { |
522 __KTRACE_OPT(KUSB, Kern::Printf("EControlReqDeviceStatusNotify")); |
536 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOOTHERASYNCREQ, |
537 "EControlReqDeviceStatusNotify" ); |
|
523 if (a1 != NULL) |
538 if (a1 != NULL) |
524 { |
539 { |
525 iDeviceStatusNeeded = ETrue; |
540 iDeviceStatusNeeded = ETrue; |
526 iStatusChangePtr = a1; |
541 iStatusChangePtr = a1; |
527 aNeedsCompletion = AlternateDeviceStateTestComplete(); |
542 aNeedsCompletion = AlternateDeviceStateTestComplete(); |
530 r = KErrArgument; |
545 r = KErrArgument; |
531 break; |
546 break; |
532 } |
547 } |
533 case RDevUsbcClient::ERequestReEnumerate: |
548 case RDevUsbcClient::ERequestReEnumerate: |
534 { |
549 { |
535 __KTRACE_OPT(KUSB, Kern::Printf("ERequestReEnumerate")); |
550 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOOTHERASYNCREQ_DUP1, |
551 "ERequestReEnumerate" ); |
|
536 // If successful, this will complete via the status notification. |
552 // If successful, this will complete via the status notification. |
537 r = iController->ReEnumerate(); |
553 r = iController->ReEnumerate(); |
538 break; |
554 break; |
539 } |
555 } |
540 case RDevUsbcClient::ERequestEndpointStatusNotify: |
556 case RDevUsbcClient::ERequestEndpointStatusNotify: |
541 { |
557 { |
542 __KTRACE_OPT(KUSB, Kern::Printf("ERequestEndpointStatusNotify")); |
558 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOOTHERASYNCREQ_DUP2, |
559 "ERequestEndpointStatusNotify" ); |
|
543 if (a1 != NULL) |
560 if (a1 != NULL) |
544 { |
561 { |
545 iEndpointStatusChangePtr = a1; |
562 iEndpointStatusChangePtr = a1; |
546 } |
563 } |
547 else |
564 else |
548 r = KErrArgument; |
565 r = KErrArgument; |
549 break; |
566 break; |
550 } |
567 } |
551 case RDevUsbcClient::ERequestOtgFeaturesNotify: |
568 case RDevUsbcClient::ERequestOtgFeaturesNotify: |
552 { |
569 { |
553 __KTRACE_OPT(KUSB, Kern::Printf("ERequestOtgFeaturesNotify")); |
570 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOOTHERASYNCREQ_DUP3, |
571 "ERequestOtgFeaturesNotify" ); |
|
554 if (a1 != NULL) |
572 if (a1 != NULL) |
555 { |
573 { |
556 iOtgFeatureChangePtr = a1; |
574 iOtgFeatureChangePtr = a1; |
557 } |
575 } |
558 else |
576 else |
587 if (aEndpointNum == 0) |
605 if (aEndpointNum == 0) |
588 { |
606 { |
589 // ep0 requests |
607 // ep0 requests |
590 if (!(iValidInterface || iOwnsDeviceControl)) |
608 if (!(iValidInterface || iOwnsDeviceControl)) |
591 { |
609 { |
592 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest rejected: not configured (Ep0)")); |
610 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ, |
611 "DoRequest rejected: not configured (Ep0)" ); |
|
593 r = KErrUsbInterfaceNotReady; |
612 r = KErrUsbInterfaceNotReady; |
594 goto exit; |
613 goto exit; |
595 } |
614 } |
596 } |
615 } |
597 else |
616 else |
599 // other eps |
618 // other eps |
600 if (!(iValidInterface && (iDeviceState == EUsbcDeviceStateConfigured || |
619 if (!(iValidInterface && (iDeviceState == EUsbcDeviceStateConfigured || |
601 iDeviceState == EUsbcDeviceStateSuspended)) |
620 iDeviceState == EUsbcDeviceStateSuspended)) |
602 ) |
621 ) |
603 { |
622 { |
604 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest rejected not configured (Ep %d)", aEndpointNum)); |
623 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP1, |
624 "DoRequest rejected not configured (Ep %d)", aEndpointNum ); |
|
605 r = KErrUsbInterfaceNotReady; |
625 r = KErrUsbInterfaceNotReady; |
606 goto exit; |
626 goto exit; |
607 } |
627 } |
608 } |
628 } |
609 |
629 |
610 if (!ValidEndpoint(aEndpointNum)) |
630 if (!ValidEndpoint(aEndpointNum)) |
611 { |
631 { |
612 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Read: in error complete")); |
632 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP2, |
633 " Error: DoRequest Read: in error complete" ); |
|
613 r = KErrUsbEpNotInInterface; |
634 r = KErrUsbEpNotInInterface; |
614 goto exit; |
635 goto exit; |
615 } |
636 } |
616 |
637 |
617 if (a1 == NULL) |
638 if (a1 == NULL) |
627 goto exit; |
648 goto exit; |
628 } |
649 } |
629 pEndpoint = iEndpoint[aEndpointNum]; |
650 pEndpoint = iEndpoint[aEndpointNum]; |
630 if (!pEndpoint) |
651 if (!pEndpoint) |
631 { |
652 { |
632 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Read: in error complete")); |
653 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP3, |
654 " Error: DoRequest Read: in error complete" ); |
|
633 r = KErrUsbEpNotInInterface; |
655 r = KErrUsbEpNotInInterface; |
634 goto exit; |
656 goto exit; |
635 } |
657 } |
636 |
658 |
637 pEndpointInfo = pEndpoint->EndpointInfo(); |
659 pEndpointInfo = pEndpoint->EndpointInfo(); |
638 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest %d", aEndpointNum)); |
660 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP4, |
661 "DoRequest %d", aEndpointNum ); |
|
639 |
662 |
640 switch (pTfr->iTransferType) |
663 switch (pTfr->iTransferType) |
641 { |
664 { |
642 |
665 |
643 case ETransferTypeReadData: |
666 case ETransferTypeReadData: |
644 case ETransferTypeReadPacket: |
667 case ETransferTypeReadPacket: |
645 case ETransferTypeReadUntilShort: |
668 case ETransferTypeReadUntilShort: |
646 case ETransferTypeReadOneOrMore: |
669 case ETransferTypeReadOneOrMore: |
647 { |
670 { |
648 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read")); |
671 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP5, |
672 "DoRequest Read" ); |
|
649 if (pEndpoint->iDmaBuffers->RxIsActive()) |
673 if (pEndpoint->iDmaBuffers->RxIsActive()) |
650 { |
674 { |
651 __KTRACE_OPT(KUSB, Kern::Printf("**** ReadReq ep%d RxActive", aEndpointNum)); |
675 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP6, |
676 "**** ReadReq ep%d RxActive", aEndpointNum ); |
|
652 } |
677 } |
653 else |
678 else |
654 { |
679 { |
655 __KTRACE_OPT(KUSB, Kern::Printf("**** ReadReq ep%d RxInActive", aEndpointNum)); |
680 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP7, |
681 "**** ReadReq ep%d RxInActive", aEndpointNum ); |
|
656 } |
682 } |
657 |
683 |
658 if (pEndpointInfo->iDir != KUsbEpDirOut && |
684 if (pEndpointInfo->iDir != KUsbEpDirOut && |
659 pEndpointInfo->iDir != KUsbEpDirBidirect) |
685 pEndpointInfo->iDir != KUsbEpDirBidirect) |
660 { |
686 { |
661 // Trying to do the wrong thing |
687 // Trying to do the wrong thing |
662 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Read: in error complete")); |
688 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP8, |
689 " Error: DoRequest Read: in error complete" ); |
|
663 r = KErrUsbEpBadDirection; |
690 r = KErrUsbEpBadDirection; |
664 break; |
691 break; |
665 } |
692 } |
666 // Set the length of data to zero now to catch all cases |
693 // Set the length of data to zero now to catch all cases |
667 TPtrC8 pZeroDesc(NULL, 0); |
694 TPtrC8 pZeroDesc(NULL, 0); |
675 } |
702 } |
676 else |
703 else |
677 { |
704 { |
678 if (pTfr->iTransferType == ETransferTypeReadPacket) |
705 if (pTfr->iTransferType == ETransferTypeReadPacket) |
679 { |
706 { |
680 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read packet: data available complete")); |
707 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP9, |
708 "DoRequest Read packet: data available complete" ); |
|
681 r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer); |
709 r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer); |
682 aNeedsCompletion = ETrue; |
710 aNeedsCompletion = ETrue; |
683 break; |
711 break; |
684 } |
712 } |
685 else if (pTfr->iTransferType == ETransferTypeReadData) |
713 else if (pTfr->iTransferType == ETransferTypeReadData) |
686 { |
714 { |
687 if (pTfr->iTransferSize <= pEndpoint->RxBytesAvailable()) |
715 if (pTfr->iTransferSize <= pEndpoint->RxBytesAvailable()) |
688 { |
716 { |
689 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read data: data available complete")); |
717 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP10, |
718 "DoRequest Read data: data available complete"); |
|
690 r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer); |
719 r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer); |
691 aNeedsCompletion = ETrue; |
720 aNeedsCompletion = ETrue; |
692 break; |
721 break; |
693 } |
722 } |
694 else |
723 else |
698 } |
727 } |
699 else if (pTfr->iTransferType == ETransferTypeReadOneOrMore) |
728 else if (pTfr->iTransferType == ETransferTypeReadOneOrMore) |
700 { |
729 { |
701 if (pEndpoint->RxBytesAvailable() > 0) |
730 if (pEndpoint->RxBytesAvailable() > 0) |
702 { |
731 { |
703 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read data: data available complete")); |
732 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP11, |
733 "DoRequest Read data: data available complete" ); |
|
704 r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer); |
734 r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer); |
705 aNeedsCompletion = ETrue; |
735 aNeedsCompletion = ETrue; |
706 break; |
736 break; |
707 } |
737 } |
708 else |
738 else |
716 TInt maxPacketSize = pEndpoint->EndpointInfo()->iSize; |
746 TInt maxPacketSize = pEndpoint->EndpointInfo()->iSize; |
717 if( (pTfr->iTransferSize <= nRx) || |
747 if( (pTfr->iTransferSize <= nRx) || |
718 (nRx < maxPacketSize) || |
748 (nRx < maxPacketSize) || |
719 pEndpoint->iDmaBuffers->ShortPacketExists()) |
749 pEndpoint->iDmaBuffers->ShortPacketExists()) |
720 { |
750 { |
721 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read data: data available complete")); |
751 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP12, |
752 "DoRequest Read data: data available complete" ); |
|
753 |
|
722 r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer); |
754 r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer); |
723 aNeedsCompletion = ETrue; |
755 aNeedsCompletion = ETrue; |
724 } |
756 } |
725 else |
757 else |
726 { |
758 { |
729 } |
761 } |
730 } |
762 } |
731 r = pEndpoint->TryToStartRead(EFalse); |
763 r = pEndpoint->TryToStartRead(EFalse); |
732 if (r != KErrNone) |
764 if (r != KErrNone) |
733 { |
765 { |
734 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read: couldn't start read")); |
766 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP13, |
767 "DoRequest Read: couldn't start read" ); |
|
768 |
|
735 r = KErrNone; // Reader full isn't a userside error; |
769 r = KErrNone; // Reader full isn't a userside error; |
736 } |
770 } |
737 break; |
771 break; |
738 } |
772 } |
739 |
773 |
740 case ETransferTypeWrite: |
774 case ETransferTypeWrite: |
741 { |
775 { |
742 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Write 1")); |
776 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP14, |
777 "DoRequest Write 1" ); |
|
743 if (pEndpointInfo->iDir != KUsbEpDirIn && |
778 if (pEndpointInfo->iDir != KUsbEpDirIn && |
744 pEndpointInfo->iDir != KUsbEpDirBidirect) |
779 pEndpointInfo->iDir != KUsbEpDirBidirect) |
745 { |
780 { |
746 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Write: wrong direction complete")); |
781 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP15, |
782 " Error: DoRequest Write: wrong direction complete" ); |
|
747 r = KErrUsbEpBadDirection; |
783 r = KErrUsbEpBadDirection; |
748 break; |
784 break; |
749 } |
785 } |
750 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Write 2")); |
786 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP16, |
787 "DoRequest Write 2" ); |
|
751 |
788 |
752 |
789 |
753 TInt desLength=iClientAsynchNotify[aEndpointNum]->iClientBuffer->Length(); |
790 TInt desLength=iClientAsynchNotify[aEndpointNum]->iClientBuffer->Length(); |
754 |
791 |
755 if (desLength < pTfr->iTransferSize) |
792 if (desLength < pTfr->iTransferSize) |
756 { |
793 { |
757 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Write: user buffer too short")); |
794 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP17, |
795 " Error: DoRequest Write: user buffer too short" ); |
|
758 r = KErrUsbTransferSize; |
796 r = KErrUsbTransferSize; |
759 break; |
797 break; |
760 } |
798 } |
761 |
799 |
762 __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Write 3 length=%d maxlength=%d", |
800 OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP18, |
763 pTfr->iTransferSize, desLength)); |
801 "DoRequest Write 3 length=%d maxlength=%d", pTfr->iTransferSize, desLength); |
764 // Zero length writes are acceptable |
802 // Zero length writes are acceptable |
765 pEndpoint->SetClientWritePending(ETrue); |
803 pEndpoint->SetClientWritePending(ETrue); |
766 r = pEndpoint->TryToStartWrite(pTfr); |
804 r = pEndpoint->TryToStartWrite(pTfr); |
767 if (r != KErrNone) |
805 if (r != KErrNone) |
768 { |
806 { |
769 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Write: couldn't start write")); |
807 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP19, |
808 " Error: DoRequest Write: couldn't start write" ); |
|
770 pEndpoint->SetClientWritePending(EFalse); |
809 pEndpoint->SetClientWritePending(EFalse); |
771 } |
810 } |
772 break; |
811 break; |
773 } |
812 } |
774 |
813 |
775 default: |
814 default: |
776 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoTransferAsyncReq: pTfr->iTransferType = %d not supported", |
815 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP20, |
777 pTfr->iTransferType)); |
816 " Error: DoTransferAsyncReq: pTfr->iTransferType = %d not supported", pTfr->iTransferType); |
817 |
|
778 r = KErrNotSupported; |
818 r = KErrNotSupported; |
779 break; |
819 break; |
780 } |
820 } |
781 exit: |
821 exit: |
782 aNeedsCompletion = aNeedsCompletion || (r != KErrNone); |
822 aNeedsCompletion = aNeedsCompletion || (r != KErrNone); |
788 // Cancel an outstanding request - overriding pure virtual |
828 // Cancel an outstanding request - overriding pure virtual |
789 // |
829 // |
790 TInt DLddUsbcChannel::DoCancel(TInt aReqNo) |
830 TInt DLddUsbcChannel::DoCancel(TInt aReqNo) |
791 { |
831 { |
792 TInt r = KErrNone; |
832 TInt r = KErrNone; |
793 __KTRACE_OPT(KUSB, Kern::Printf("DoCancel: 0x%x", aReqNo)); |
833 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL, |
834 "DoCancel: 0x%x", aReqNo ); |
|
794 if (aReqNo <= iNumberOfEndpoints) |
835 if (aReqNo <= iNumberOfEndpoints) |
795 { |
836 { |
796 __KTRACE_OPT(KUSB, Kern::Printf("DoCancel endpoint: 0x%x", aReqNo)); |
837 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL_DUP1, |
838 "DoCancel endpoint: 0x%x", aReqNo ); |
|
839 |
|
797 iEndpoint[aReqNo]->CancelTransfer(iClient,iClientAsynchNotify[aReqNo]->iClientBuffer); |
840 iEndpoint[aReqNo]->CancelTransfer(iClient,iClientAsynchNotify[aReqNo]->iClientBuffer); |
798 } |
841 } |
799 else if (aReqNo == RDevUsbcClient::ERequestAlternateDeviceStatusNotify) |
842 else if (aReqNo == RDevUsbcClient::ERequestAlternateDeviceStatusNotify) |
800 { |
843 { |
801 __KTRACE_OPT(KUSB, Kern::Printf("DoCancel: ERequestAlternateDeviceStatusNotify 0x%x", aReqNo)); |
844 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL_DUP2, |
845 "DoCancel: ERequestAlternateDeviceStatusNotify 0x%x", aReqNo ); |
|
846 |
|
802 iDeviceStatusNeeded = EFalse; |
847 iDeviceStatusNeeded = EFalse; |
803 iStatusFifo->FlushQueue(); |
848 iStatusFifo->FlushQueue(); |
804 if (iStatusChangePtr) |
849 if (iStatusChangePtr) |
805 { |
850 { |
806 iStatusChangeReq->Data()=iController->GetDeviceStatus(); |
851 iStatusChangeReq->Data()=iController->GetDeviceStatus(); |
814 return KErrNone; |
859 return KErrNone; |
815 } |
860 } |
816 } |
861 } |
817 else if (aReqNo == RDevUsbcClient::ERequestReEnumerate) |
862 else if (aReqNo == RDevUsbcClient::ERequestReEnumerate) |
818 { |
863 { |
819 __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestReEnumerate: 0x%x", aReqNo)); |
864 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL_DUP3, |
865 "DoCancel ERequestReEnumerate: 0x%x", aReqNo ); |
|
866 |
|
820 } |
867 } |
821 else if (aReqNo == RDevUsbcClient::ERequestEndpointStatusNotify) |
868 else if (aReqNo == RDevUsbcClient::ERequestEndpointStatusNotify) |
822 { |
869 { |
823 __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestEndpointStatusNotify: 0x%x", aReqNo)); |
870 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL_DUP4, |
871 "DoCancel ERequestEndpointStatusNotify: 0x%x", aReqNo ); |
|
872 |
|
824 CancelNotifyEndpointStatus(); |
873 CancelNotifyEndpointStatus(); |
825 if (iEndpointStatusChangeReq->IsReady()) |
874 if (iEndpointStatusChangeReq->IsReady()) |
826 { |
875 { |
827 iRequestStatus[aReqNo] = NULL; |
876 iRequestStatus[aReqNo] = NULL; |
828 Kern::QueueRequestComplete(iClient, iEndpointStatusChangeReq, KErrCancel); |
877 Kern::QueueRequestComplete(iClient, iEndpointStatusChangeReq, KErrCancel); |
829 } |
878 } |
830 return KErrNone; |
879 return KErrNone; |
831 } |
880 } |
832 else if (aReqNo == RDevUsbcClient::ERequestOtgFeaturesNotify) |
881 else if (aReqNo == RDevUsbcClient::ERequestOtgFeaturesNotify) |
833 { |
882 { |
834 __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestOtgFeaturesNotify: 0x%x", aReqNo)); |
883 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL_DUP5, |
884 "DoCancel ERequestOtgFeaturesNotify: 0x%x", aReqNo ); |
|
885 |
|
835 CancelNotifyOtgFeatures(); |
886 CancelNotifyOtgFeatures(); |
836 if (iOtgFeatureChangeReq->IsReady()) |
887 if (iOtgFeatureChangeReq->IsReady()) |
837 { |
888 { |
838 iRequestStatus[aReqNo] = NULL; |
889 iRequestStatus[aReqNo] = NULL; |
839 Kern::QueueRequestComplete(iClient, iOtgFeatureChangeReq, KErrCancel); |
890 Kern::QueueRequestComplete(iClient, iOtgFeatureChangeReq, KErrCancel); |
840 } |
891 } |
841 } |
892 } |
842 else |
893 else |
843 { |
894 { |
844 __KTRACE_OPT(KUSB, Kern::Printf("DoCancel Unknown! 0x%x", aReqNo)); |
895 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL_DUP6, |
896 "DoCancel Unknown! 0x%x", aReqNo ); |
|
897 |
|
845 } |
898 } |
846 |
899 |
847 if (r == KErrNone) |
900 if (r == KErrNone) |
848 r = KErrCancel; |
901 r = KErrCancel; |
849 |
902 |
1116 } |
1169 } |
1117 |
1170 |
1118 |
1171 |
1119 TInt DLddUsbcChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2) |
1172 TInt DLddUsbcChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2) |
1120 { |
1173 { |
1121 __KTRACE_OPT(KUSB, Kern::Printf("DoControl: %d", aFunction)); |
1174 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL, |
1175 "DoControl: %d", aFunction ); |
|
1122 |
1176 |
1123 TInt r = KErrNone; |
1177 TInt r = KErrNone; |
1124 TInt ep; |
1178 TInt ep; |
1125 TUsbcEndpoint* pEndpoint; |
1179 TUsbcEndpoint* pEndpoint; |
1126 TPtrC8 pZeroDesc(NULL, 0); |
1180 TPtrC8 pZeroDesc(NULL, 0); |
1131 TInt bandwidthPriority; |
1185 TInt bandwidthPriority; |
1132 |
1186 |
1133 switch (aFunction) |
1187 switch (aFunction) |
1134 { |
1188 { |
1135 case RDevUsbcClient::EControlEndpointZeroRequestError: |
1189 case RDevUsbcClient::EControlEndpointZeroRequestError: |
1136 __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointZeroRequestError")); |
1190 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP1, |
1191 "EControlEndpointZeroRequestError" ); |
|
1192 |
|
1137 r = KErrNone; |
1193 r = KErrNone; |
1138 if (iOwnsDeviceControl || (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured)) |
1194 if (iOwnsDeviceControl || (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured)) |
1139 { |
1195 { |
1140 iController->Ep0Stall(this); |
1196 iController->Ep0Stall(this); |
1141 } |
1197 } |
1147 r = KErrUsbInterfaceNotReady; |
1203 r = KErrUsbInterfaceNotReady; |
1148 } |
1204 } |
1149 break; |
1205 break; |
1150 |
1206 |
1151 case RDevUsbcClient::EControlGetAlternateSetting: |
1207 case RDevUsbcClient::EControlGetAlternateSetting: |
1152 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetAlternateSetting")); |
1208 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP2, |
1209 "EControlGetAlternateSetting" ); |
|
1210 |
|
1153 if (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured) |
1211 if (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured) |
1154 { |
1212 { |
1155 r = iController->GetInterfaceNumber(this, *(TInt*)a1); |
1213 r = iController->GetInterfaceNumber(this, *(TInt*)a1); |
1156 } |
1214 } |
1157 else |
1215 else |
1162 r = KErrUsbInterfaceNotReady; |
1220 r = KErrUsbInterfaceNotReady; |
1163 } |
1221 } |
1164 break; |
1222 break; |
1165 |
1223 |
1166 case RDevUsbcClient::EControlDeviceStatus: |
1224 case RDevUsbcClient::EControlDeviceStatus: |
1167 __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceStatus")); |
1225 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP3, |
1226 "EControlDeviceStatus" ); |
|
1227 |
|
1168 *(TInt*)a1 = iController->GetDeviceStatus(); |
1228 *(TInt*)a1 = iController->GetDeviceStatus(); |
1169 break; |
1229 break; |
1170 |
1230 |
1171 case RDevUsbcClient::EControlEndpointStatus: |
1231 case RDevUsbcClient::EControlEndpointStatus: |
1172 __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointStatus")); |
1232 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP4, |
1233 "EControlEndpointStatus" ); |
|
1234 |
|
1173 if (iValidInterface && ValidEndpoint((TInt) a1)) |
1235 if (iValidInterface && ValidEndpoint((TInt) a1)) |
1174 { |
1236 { |
1175 pEndpoint = iEndpoint[(TInt)a1]; |
1237 pEndpoint = iEndpoint[(TInt)a1]; |
1176 if (pEndpoint == NULL) |
1238 if (pEndpoint == NULL) |
1177 r = KErrNotSupported; |
1239 r = KErrNotSupported; |
1188 r = KErrUsbInterfaceNotReady; |
1250 r = KErrUsbInterfaceNotReady; |
1189 } |
1251 } |
1190 break; |
1252 break; |
1191 |
1253 |
1192 case RDevUsbcClient::EControlQueryReceiveBuffer: |
1254 case RDevUsbcClient::EControlQueryReceiveBuffer: |
1193 __KTRACE_OPT(KUSB, Kern::Printf("EControlQueryReceiveBuffer")); |
1255 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP5, |
1256 "EControlQueryReceiveBuffer" ); |
|
1257 |
|
1194 if (iValidInterface && ValidEndpoint((TInt) a1)) |
1258 if (iValidInterface && ValidEndpoint((TInt) a1)) |
1195 { |
1259 { |
1196 pEndpoint=iEndpoint[(TInt) a1]; |
1260 pEndpoint=iEndpoint[(TInt) a1]; |
1197 if (pEndpoint == NULL) |
1261 if (pEndpoint == NULL) |
1198 r = KErrNotSupported; |
1262 r = KErrNotSupported; |
1199 else if (pEndpoint->EndpointInfo()->iDir != KUsbEpDirIn) |
1263 else if (pEndpoint->EndpointInfo()->iDir != KUsbEpDirIn) |
1200 { |
1264 { |
1201 __KTRACE_OPT(KUSB, Kern::Printf(" bytes = %d", pEndpoint->RxBytesAvailable())); |
1265 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP6, |
1266 " bytes = %d", pEndpoint->RxBytesAvailable()); |
|
1202 *(TInt*)a2 = pEndpoint->RxBytesAvailable(); |
1267 *(TInt*)a2 = pEndpoint->RxBytesAvailable(); |
1203 } |
1268 } |
1204 } |
1269 } |
1205 else |
1270 else |
1206 { |
1271 { |
1210 r = KErrUsbInterfaceNotReady; |
1275 r = KErrUsbInterfaceNotReady; |
1211 } |
1276 } |
1212 break; |
1277 break; |
1213 |
1278 |
1214 case RDevUsbcClient::EControlEndpointCaps: |
1279 case RDevUsbcClient::EControlEndpointCaps: |
1215 __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointCaps")); |
1280 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP7, |
1281 "EControlEndpointCaps" ); |
|
1216 r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient); |
1282 r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient); |
1217 if (r != KErrNone) |
1283 if (r != KErrNone) |
1218 PanicClientThread(r); |
1284 PanicClientThread(r); |
1219 iController->EndpointCaps(this, *((TDes8*) a1)); |
1285 iController->EndpointCaps(this, *((TDes8*) a1)); |
1220 break; |
1286 break; |
1221 |
1287 |
1222 case RDevUsbcClient::EControlDeviceCaps: |
1288 case RDevUsbcClient::EControlDeviceCaps: |
1223 __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceCaps")); |
1289 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP8, |
1290 "EControlDeviceCaps" ); |
|
1224 r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient); |
1291 r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient); |
1225 if (r != KErrNone) |
1292 if (r != KErrNone) |
1226 PanicClientThread(r); |
1293 PanicClientThread(r); |
1227 iController->DeviceCaps(this, *((TDes8*) a1)); |
1294 iController->DeviceCaps(this, *((TDes8*) a1)); |
1228 break; |
1295 break; |
1229 |
1296 |
1230 case RDevUsbcClient::EControlSendEp0StatusPacket: |
1297 case RDevUsbcClient::EControlSendEp0StatusPacket: |
1231 __KTRACE_OPT(KUSB, Kern::Printf("EControlSendEp0StatusPacket")); |
1298 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP9, |
1299 "EControlSendEp0StatusPacket" ); |
|
1232 iController->SendEp0StatusPacket(this); |
1300 iController->SendEp0StatusPacket(this); |
1233 break; |
1301 break; |
1234 |
1302 |
1235 case RDevUsbcClient::EControlHaltEndpoint: |
1303 case RDevUsbcClient::EControlHaltEndpoint: |
1236 __KTRACE_OPT(KUSB, Kern::Printf("EControlHaltEndpoint")); |
1304 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP10, |
1305 "EControlHaltEndpoint" ); |
|
1237 if (iValidInterface && ValidEndpoint((TInt) a1)) |
1306 if (iValidInterface && ValidEndpoint((TInt) a1)) |
1238 { |
1307 { |
1239 r = iController->HaltEndpoint(this, iEndpoint[(TInt)a1]->RealEpNumber()); |
1308 r = iController->HaltEndpoint(this, iEndpoint[(TInt)a1]->RealEpNumber()); |
1240 } |
1309 } |
1241 else |
1310 else |
1246 r = KErrUsbInterfaceNotReady; |
1315 r = KErrUsbInterfaceNotReady; |
1247 } |
1316 } |
1248 break; |
1317 break; |
1249 |
1318 |
1250 case RDevUsbcClient::EControlClearHaltEndpoint: |
1319 case RDevUsbcClient::EControlClearHaltEndpoint: |
1251 __KTRACE_OPT(KUSB, Kern::Printf("EControlClearHaltEndpoint")); |
1320 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP11, |
1321 "EControlClearHaltEndpoint" ); |
|
1252 if (iValidInterface && ValidEndpoint((TInt) a1)) |
1322 if (iValidInterface && ValidEndpoint((TInt) a1)) |
1253 { |
1323 { |
1254 r = iController->ClearHaltEndpoint(this, iEndpoint[(TInt)a1]->RealEpNumber()); |
1324 r = iController->ClearHaltEndpoint(this, iEndpoint[(TInt)a1]->RealEpNumber()); |
1255 } |
1325 } |
1256 else |
1326 else |
1261 r = KErrUsbInterfaceNotReady; |
1331 r = KErrUsbInterfaceNotReady; |
1262 } |
1332 } |
1263 break; |
1333 break; |
1264 |
1334 |
1265 case RDevUsbcClient::EControlDumpRegisters: |
1335 case RDevUsbcClient::EControlDumpRegisters: |
1266 __KTRACE_OPT(KUSB, Kern::Printf("EControlDumpRegisters")); |
1336 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP12, |
1337 "EControlDumpRegisters" ); |
|
1267 iController->DumpRegisters(); |
1338 iController->DumpRegisters(); |
1268 break; |
1339 break; |
1269 |
1340 |
1270 case RDevUsbcClient::EControlReleaseDeviceControl: |
1341 case RDevUsbcClient::EControlReleaseDeviceControl: |
1271 __KTRACE_OPT(KUSB, Kern::Printf("EControlReleaseDeviceControl")); |
1342 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP13, |
1343 "EControlReleaseDeviceControl" ); |
|
1272 iController->ReleaseDeviceControl(this); |
1344 iController->ReleaseDeviceControl(this); |
1273 iOwnsDeviceControl = EFalse; |
1345 iOwnsDeviceControl = EFalse; |
1274 break; |
1346 break; |
1275 |
1347 |
1276 case RDevUsbcClient::EControlEndpointZeroMaxPacketSizes: |
1348 case RDevUsbcClient::EControlEndpointZeroMaxPacketSizes: |
1277 __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointZeroMaxPacketSizes")); |
1349 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP14, |
1350 "EControlEndpointZeroMaxPacketSizes" ); |
|
1278 r = iController->EndpointZeroMaxPacketSizes(); |
1351 r = iController->EndpointZeroMaxPacketSizes(); |
1279 break; |
1352 break; |
1280 |
1353 |
1281 case RDevUsbcClient::EControlSetEndpointZeroMaxPacketSize: |
1354 case RDevUsbcClient::EControlSetEndpointZeroMaxPacketSize: |
1282 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetEndpointZeroMaxPacketSize")); |
1355 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP15, |
1356 "EControlSetEndpointZeroMaxPacketSize" ); |
|
1283 r = iController->SetEndpointZeroMaxPacketSize(reinterpret_cast<TInt>(a1)); |
1357 r = iController->SetEndpointZeroMaxPacketSize(reinterpret_cast<TInt>(a1)); |
1284 break; |
1358 break; |
1285 |
1359 |
1286 case RDevUsbcClient::EControlGetEndpointZeroMaxPacketSize: |
1360 case RDevUsbcClient::EControlGetEndpointZeroMaxPacketSize: |
1287 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetEndpointZeroMaxPacketSize")); |
1361 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP16, |
1362 "EControlGetEndpointZeroMaxPacketSize" ); |
|
1288 r = iController->Ep0PacketSize(); |
1363 r = iController->Ep0PacketSize(); |
1289 break; |
1364 break; |
1290 |
1365 |
1291 case RDevUsbcClient::EControlGetDeviceDescriptor: |
1366 case RDevUsbcClient::EControlGetDeviceDescriptor: |
1292 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetDeviceDescriptor")); |
1367 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP17, |
1368 "EControlGetDeviceDescriptor" ); |
|
1293 r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient); |
1369 r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient); |
1294 if (r != KErrNone) |
1370 if (r != KErrNone) |
1295 PanicClientThread(r); |
1371 PanicClientThread(r); |
1296 r = iController->GetDeviceDescriptor(iClient, *((TDes8*) a1)); |
1372 r = iController->GetDeviceDescriptor(iClient, *((TDes8*) a1)); |
1297 break; |
1373 break; |
1298 |
1374 |
1299 case RDevUsbcClient::EControlSetDeviceDescriptor: |
1375 case RDevUsbcClient::EControlSetDeviceDescriptor: |
1300 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceDescriptor")); |
1376 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP18, |
1377 "EControlSetDeviceDescriptor" ); |
|
1301 if (a1 != NULL) |
1378 if (a1 != NULL) |
1302 r = iController->SetDeviceDescriptor(iClient, *((TDes8*) a1)); |
1379 r = iController->SetDeviceDescriptor(iClient, *((TDes8*) a1)); |
1303 else |
1380 else |
1304 r = KErrArgument; |
1381 r = KErrArgument; |
1305 break; |
1382 break; |
1306 |
1383 |
1307 case RDevUsbcClient::EControlGetDeviceDescriptorSize: |
1384 case RDevUsbcClient::EControlGetDeviceDescriptorSize: |
1308 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetDeviceDescriptorSize")); |
1385 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP19, |
1386 "EControlGetDeviceDescriptorSize" ); |
|
1309 if (a1 != NULL) |
1387 if (a1 != NULL) |
1310 r = iController->GetDeviceDescriptorSize(iClient, *((TDes8*) a1)); |
1388 r = iController->GetDeviceDescriptorSize(iClient, *((TDes8*) a1)); |
1311 else |
1389 else |
1312 r = KErrArgument; |
1390 r = KErrArgument; |
1313 break; |
1391 break; |
1314 |
1392 |
1315 case RDevUsbcClient::EControlGetConfigurationDescriptor: |
1393 case RDevUsbcClient::EControlGetConfigurationDescriptor: |
1316 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetConfigurationDescriptor")); |
1394 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP20, |
1395 "EControlGetConfigurationDescriptor" ); |
|
1317 r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0 , 0, iClient); |
1396 r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0 , 0, iClient); |
1318 if (r != KErrNone) |
1397 if (r != KErrNone) |
1319 PanicClientThread(r); |
1398 PanicClientThread(r); |
1320 r = iController->GetConfigurationDescriptor(iClient, *((TDes8*) a1)); |
1399 r = iController->GetConfigurationDescriptor(iClient, *((TDes8*) a1)); |
1321 break; |
1400 break; |
1322 |
1401 |
1323 case RDevUsbcClient::EControlGetConfigurationDescriptorSize: |
1402 case RDevUsbcClient::EControlGetConfigurationDescriptorSize: |
1324 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetConfigurationDescriptorSize")); |
1403 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP21, |
1404 "EControlGetConfigurationDescriptorSize" ); |
|
1325 if (a1 != NULL) |
1405 if (a1 != NULL) |
1326 { |
1406 { |
1327 r = iController->GetConfigurationDescriptorSize(iClient, *((TDes8*) a1)); |
1407 r = iController->GetConfigurationDescriptorSize(iClient, *((TDes8*) a1)); |
1328 } |
1408 } |
1329 else |
1409 else |
1330 r = KErrArgument; |
1410 r = KErrArgument; |
1331 break; |
1411 break; |
1332 |
1412 |
1333 case RDevUsbcClient::EControlSetConfigurationDescriptor: |
1413 case RDevUsbcClient::EControlSetConfigurationDescriptor: |
1334 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetConfigurationDescriptor")); |
1414 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP22, |
1415 "EControlSetConfigurationDescriptor" ); |
|
1335 r = iController->SetConfigurationDescriptor(iClient, *((TDes8*) a1)); |
1416 r = iController->SetConfigurationDescriptor(iClient, *((TDes8*) a1)); |
1336 break; |
1417 break; |
1337 |
1418 |
1338 case RDevUsbcClient::EControlGetInterfaceDescriptor: |
1419 case RDevUsbcClient::EControlGetInterfaceDescriptor: |
1339 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetInterfaceDescriptor")); |
1420 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP23, |
1421 "EControlGetInterfaceDescriptor" ); |
|
1340 r = iController->GetInterfaceDescriptor(iClient, this, (TInt) a1, *((TDes8*) a2)); |
1422 r = iController->GetInterfaceDescriptor(iClient, this, (TInt) a1, *((TDes8*) a2)); |
1341 break; |
1423 break; |
1342 |
1424 |
1343 case RDevUsbcClient::EControlGetInterfaceDescriptorSize: |
1425 case RDevUsbcClient::EControlGetInterfaceDescriptorSize: |
1344 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetInterfaceDescriptorSize")); |
1426 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP24, |
1427 "EControlGetInterfaceDescriptorSize" ); |
|
1345 r = iController->GetInterfaceDescriptorSize(iClient, this, (TInt) a1, *(TDes8*) a2); |
1428 r = iController->GetInterfaceDescriptorSize(iClient, this, (TInt) a1, *(TDes8*) a2); |
1346 break; |
1429 break; |
1347 |
1430 |
1348 case RDevUsbcClient::EControlSetInterfaceDescriptor: |
1431 case RDevUsbcClient::EControlSetInterfaceDescriptor: |
1349 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetInterfaceDescriptor")); |
1432 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP25, |
1433 "EControlSetInterfaceDescriptor" ); |
|
1350 r = iController->SetInterfaceDescriptor(iClient, this, (TInt) a1, *((TDes8*) a2)); |
1434 r = iController->SetInterfaceDescriptor(iClient, this, (TInt) a1, *((TDes8*) a2)); |
1351 break; |
1435 break; |
1352 |
1436 |
1353 case RDevUsbcClient::EControlGetEndpointDescriptor: |
1437 case RDevUsbcClient::EControlGetEndpointDescriptor: |
1354 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetEndpointDescriptor")); |
1438 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP26, |
1439 "EControlGetEndpointDescriptor" ); |
|
1355 r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); |
1440 r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); |
1356 if (r != KErrNone) |
1441 if (r != KErrNone) |
1357 PanicClientThread(r); |
1442 PanicClientThread(r); |
1358 ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint); |
1443 ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint); |
1359 r = iController->GetEndpointDescriptor(iClient, this, epInfo.iSetting, |
1444 r = iController->GetEndpointDescriptor(iClient, this, epInfo.iSetting, |
1360 ep, *(TDes8*) epInfo.iArg); |
1445 ep, *(TDes8*) epInfo.iArg); |
1361 break; |
1446 break; |
1362 |
1447 |
1363 case RDevUsbcClient::EControlGetEndpointDescriptorSize: |
1448 case RDevUsbcClient::EControlGetEndpointDescriptorSize: |
1364 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetEndpointDescriptorSize")); |
1449 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP27, |
1450 "EControlGetEndpointDescriptorSize" ); |
|
1365 r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); |
1451 r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); |
1366 if (r != KErrNone) |
1452 if (r != KErrNone) |
1367 PanicClientThread(r); |
1453 PanicClientThread(r); |
1368 ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint); |
1454 ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint); |
1369 r = iController->GetEndpointDescriptorSize(iClient, this, epInfo.iSetting, |
1455 r = iController->GetEndpointDescriptorSize(iClient, this, epInfo.iSetting, |
1370 ep, *(TDes8*) epInfo.iArg); |
1456 ep, *(TDes8*) epInfo.iArg); |
1371 break; |
1457 break; |
1372 |
1458 |
1373 case RDevUsbcClient::EControlSetEndpointDescriptor: |
1459 case RDevUsbcClient::EControlSetEndpointDescriptor: |
1374 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetEndpointDescriptor")); |
1460 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP28, |
1461 "EControlSetEndpointDescriptor" ); |
|
1375 r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); |
1462 r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); |
1376 if (r != KErrNone) |
1463 if (r != KErrNone) |
1377 PanicClientThread(r); |
1464 PanicClientThread(r); |
1378 ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint); |
1465 ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint); |
1379 r = iController->SetEndpointDescriptor(iClient, this, epInfo.iSetting, |
1466 r = iController->SetEndpointDescriptor(iClient, this, epInfo.iSetting, |
1380 ep, *(TDes8*)epInfo.iArg); |
1467 ep, *(TDes8*)epInfo.iArg); |
1381 break; |
1468 break; |
1382 |
1469 |
1383 case RDevUsbcClient::EControlGetDeviceQualifierDescriptor: |
1470 case RDevUsbcClient::EControlGetDeviceQualifierDescriptor: |
1384 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetDeviceQualifierDescriptor")); |
1471 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP29, |
1472 "EControlGetDeviceQualifierDescriptor" ); |
|
1385 r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient); |
1473 r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient); |
1386 if (r != KErrNone) |
1474 if (r != KErrNone) |
1387 PanicClientThread(r); |
1475 PanicClientThread(r); |
1388 r = iController->GetDeviceQualifierDescriptor(iClient, *((TDes8*) a1)); |
1476 r = iController->GetDeviceQualifierDescriptor(iClient, *((TDes8*) a1)); |
1389 break; |
1477 break; |
1390 |
1478 |
1391 case RDevUsbcClient::EControlSetDeviceQualifierDescriptor: |
1479 case RDevUsbcClient::EControlSetDeviceQualifierDescriptor: |
1392 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceQualifierDescriptor")); |
1480 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP30, |
1481 "EControlSetDeviceQualifierDescriptor" ); |
|
1393 if (a1 != NULL) |
1482 if (a1 != NULL) |
1394 r = iController->SetDeviceQualifierDescriptor(iClient, *((TDes8*) a1)); |
1483 r = iController->SetDeviceQualifierDescriptor(iClient, *((TDes8*) a1)); |
1395 else |
1484 else |
1396 r = KErrArgument; |
1485 r = KErrArgument; |
1397 break; |
1486 break; |
1398 |
1487 |
1399 case RDevUsbcClient::EControlGetOtherSpeedConfigurationDescriptor: |
1488 case RDevUsbcClient::EControlGetOtherSpeedConfigurationDescriptor: |
1400 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetOtherSpeedConfigurationDescriptor")); |
1489 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP31, |
1490 "EControlGetOtherSpeedConfigurationDescriptor" ); |
|
1401 r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0 , 0, iClient); |
1491 r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0 , 0, iClient); |
1402 if (r != KErrNone) |
1492 if (r != KErrNone) |
1403 PanicClientThread(r); |
1493 PanicClientThread(r); |
1404 r = iController->GetOtherSpeedConfigurationDescriptor(iClient, *((TDes8*) a1)); |
1494 r = iController->GetOtherSpeedConfigurationDescriptor(iClient, *((TDes8*) a1)); |
1405 break; |
1495 break; |
1406 |
1496 |
1407 case RDevUsbcClient::EControlSetOtherSpeedConfigurationDescriptor: |
1497 case RDevUsbcClient::EControlSetOtherSpeedConfigurationDescriptor: |
1408 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetOtherSpeedConfigurationDescriptor")); |
1498 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP32, |
1499 "EControlSetOtherSpeedConfigurationDescriptor" ); |
|
1409 r = iController->SetOtherSpeedConfigurationDescriptor(iClient, *((TDes8*) a1)); |
1500 r = iController->SetOtherSpeedConfigurationDescriptor(iClient, *((TDes8*) a1)); |
1410 break; |
1501 break; |
1411 |
1502 |
1412 |
1503 |
1413 case RDevUsbcClient::EControlGetCSInterfaceDescriptor: |
1504 case RDevUsbcClient::EControlGetCSInterfaceDescriptor: |
1414 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSInterfaceDescriptor")); |
1505 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP33, |
1506 "EControlGetCSInterfaceDescriptor" ); |
|
1415 r = iController->GetCSInterfaceDescriptorBlock(iClient, this, (TInt) a1, *((TDes8*) a2)); |
1507 r = iController->GetCSInterfaceDescriptorBlock(iClient, this, (TInt) a1, *((TDes8*) a2)); |
1416 break; |
1508 break; |
1417 |
1509 |
1418 case RDevUsbcClient::EControlGetCSInterfaceDescriptorSize: |
1510 case RDevUsbcClient::EControlGetCSInterfaceDescriptorSize: |
1419 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSInterfaceDescriptorSize")); |
1511 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP34, |
1512 "EControlGetCSInterfaceDescriptorSize" ); |
|
1420 r = iController->GetCSInterfaceDescriptorBlockSize(iClient, this, (TInt) a1, *(TDes8*) a2); |
1513 r = iController->GetCSInterfaceDescriptorBlockSize(iClient, this, (TInt) a1, *(TDes8*) a2); |
1421 break; |
1514 break; |
1422 |
1515 |
1423 case RDevUsbcClient::EControlGetCSEndpointDescriptor: |
1516 case RDevUsbcClient::EControlGetCSEndpointDescriptor: |
1424 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSEndpointDescriptor")); |
1517 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP35, |
1518 "EControlGetCSEndpointDescriptor" ); |
|
1425 r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); |
1519 r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); |
1426 if (r != KErrNone) |
1520 if (r != KErrNone) |
1427 PanicClientThread(r); |
1521 PanicClientThread(r); |
1428 ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint); |
1522 ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint); |
1429 r = iController->GetCSEndpointDescriptorBlock(iClient, this, epInfo.iSetting, |
1523 r = iController->GetCSEndpointDescriptorBlock(iClient, this, epInfo.iSetting, |
1430 ep, *(TDes8*) epInfo.iArg); |
1524 ep, *(TDes8*) epInfo.iArg); |
1431 break; |
1525 break; |
1432 |
1526 |
1433 case RDevUsbcClient::EControlGetCSEndpointDescriptorSize: |
1527 case RDevUsbcClient::EControlGetCSEndpointDescriptorSize: |
1434 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSEndpointDescriptorSize")); |
1528 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP36, |
1529 "EControlGetCSEndpointDescriptorSize" ); |
|
1435 r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); |
1530 r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); |
1436 if (r != KErrNone) |
1531 if (r != KErrNone) |
1437 PanicClientThread(r); |
1532 PanicClientThread(r); |
1438 ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint); |
1533 ep = EpFromAlternateSetting(epInfo.iSetting, epInfo.iEndpoint); |
1439 r = iController->GetCSEndpointDescriptorBlockSize(iClient, this, epInfo.iSetting, |
1534 r = iController->GetCSEndpointDescriptorBlockSize(iClient, this, epInfo.iSetting, |
1440 ep, *(TDes8*) epInfo.iArg); |
1535 ep, *(TDes8*) epInfo.iArg); |
1441 break; |
1536 break; |
1442 |
1537 |
1443 case RDevUsbcClient::EControlSignalRemoteWakeup: |
1538 case RDevUsbcClient::EControlSignalRemoteWakeup: |
1444 __KTRACE_OPT(KUSB, Kern::Printf("EControlSignalRemoteWakeup")); |
1539 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP37, |
1540 "EControlSignalRemoteWakeup" ); |
|
1445 r = iController->SignalRemoteWakeup(); |
1541 r = iController->SignalRemoteWakeup(); |
1446 break; |
1542 break; |
1447 |
1543 |
1448 case RDevUsbcClient::EControlDeviceDisconnectFromHost: |
1544 case RDevUsbcClient::EControlDeviceDisconnectFromHost: |
1449 __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceDisconnectFromHost")); |
1545 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP38, |
1546 "EControlDeviceDisconnectFromHost" ); |
|
1450 r = iController->UsbDisconnect(); |
1547 r = iController->UsbDisconnect(); |
1451 break; |
1548 break; |
1452 |
1549 |
1453 case RDevUsbcClient::EControlDeviceConnectToHost: |
1550 case RDevUsbcClient::EControlDeviceConnectToHost: |
1454 __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceConnectToHost")); |
1551 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP39, |
1552 "EControlDeviceConnectToHost" ); |
|
1455 r = iController->UsbConnect(); |
1553 r = iController->UsbConnect(); |
1456 break; |
1554 break; |
1457 |
1555 |
1458 case RDevUsbcClient::EControlDevicePowerUpUdc: |
1556 case RDevUsbcClient::EControlDevicePowerUpUdc: |
1459 __KTRACE_OPT(KUSB, Kern::Printf("EControlDevicePowerUpUdc")); |
1557 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP40, |
1558 "EControlDevicePowerUpUdc" ); |
|
1460 r = iController->PowerUpUdc(); |
1559 r = iController->PowerUpUdc(); |
1461 break; |
1560 break; |
1462 |
1561 |
1463 case RDevUsbcClient::EControlSetDeviceControl: |
1562 case RDevUsbcClient::EControlSetDeviceControl: |
1464 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceControl")); |
1563 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP41, |
1564 "EControlSetDeviceControl" ); |
|
1465 r = iController->SetDeviceControl(this); |
1565 r = iController->SetDeviceControl(this); |
1466 if (r == KErrNone) |
1566 if (r == KErrNone) |
1467 { |
1567 { |
1468 iOwnsDeviceControl = ETrue; |
1568 iOwnsDeviceControl = ETrue; |
1469 if (iEndpoint[0] == NULL) |
1569 if (iEndpoint[0] == NULL) |
1470 { |
1570 { |
1471 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceControl 11")); |
1571 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP42, |
1572 "EControlSetDeviceControl 11" ); |
|
1472 r = SetupEp0(); |
1573 r = SetupEp0(); |
1473 if (r != KErrNone) |
1574 if (r != KErrNone) |
1474 { |
1575 { |
1475 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: SetupEp0() failed")); |
1576 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOCONTROL_DUP43, |
1577 " Error: SetupEp0() failed" ); |
|
1578 |
|
1476 iController->ReleaseDeviceControl(this); |
1579 iController->ReleaseDeviceControl(this); |
1477 DestroyEp0(); |
1580 DestroyEp0(); |
1478 iOwnsDeviceControl = EFalse; |
1581 iOwnsDeviceControl = EFalse; |
1479 } |
1582 } |
1480 iEndpoint[0]->TryToStartRead(EFalse); |
1583 iEndpoint[0]->TryToStartRead(EFalse); |
1483 else |
1586 else |
1484 r = KErrInUse; |
1587 r = KErrInUse; |
1485 break; |
1588 break; |
1486 |
1589 |
1487 case RDevUsbcClient::EControlCurrentlyUsingHighSpeed: |
1590 case RDevUsbcClient::EControlCurrentlyUsingHighSpeed: |
1488 __KTRACE_OPT(KUSB, Kern::Printf("EControlCurrentlyUsingHighSpeed")); |
1591 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP44, |
1592 "EControlCurrentlyUsingHighSpeed" ); |
|
1489 r = iController->CurrentlyUsingHighSpeed(); |
1593 r = iController->CurrentlyUsingHighSpeed(); |
1490 break; |
1594 break; |
1491 |
1595 |
1492 case RDevUsbcClient::EControlSetInterface: |
1596 case RDevUsbcClient::EControlSetInterface: |
1493 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetInterface")); |
1597 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP45, |
1598 "EControlSetInterface" ); |
|
1494 r = Kern::ThreadRawRead(iClient, a2, &ifcInfo, sizeof(ifcInfo)); |
1599 r = Kern::ThreadRawRead(iClient, a2, &ifcInfo, sizeof(ifcInfo)); |
1495 if (r != KErrNone) |
1600 if (r != KErrNone) |
1496 PanicClientThread(r); |
1601 PanicClientThread(r); |
1497 if (iValidInterface && (iDeviceState == EUsbcDeviceStateConfigured)) |
1602 if (iValidInterface && (iDeviceState == EUsbcDeviceStateConfigured)) |
1498 { |
1603 { |
1514 } |
1619 } |
1515 |
1620 |
1516 break; |
1621 break; |
1517 |
1622 |
1518 case RDevUsbcClient::EControlReleaseInterface: |
1623 case RDevUsbcClient::EControlReleaseInterface: |
1519 __KTRACE_OPT(KUSB, Kern::Printf("EControlReleaseInterface")); |
1624 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP46, |
1625 "EControlReleaseInterface" ); |
|
1520 r = iController->ReleaseInterface(this, (TInt) a1); |
1626 r = iController->ReleaseInterface(this, (TInt) a1); |
1521 if (r == KErrNone) |
1627 if (r == KErrNone) |
1522 { |
1628 { |
1523 DestroyInterface((TUint) a1); |
1629 DestroyInterface((TUint) a1); |
1524 } |
1630 } |
1525 else |
1631 else |
1526 { |
1632 { |
1527 __KTRACE_OPT(KPANIC, Kern::Printf(" Error in PIL: LDD interface won't be released.")); |
1633 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOCONTROL_DUP47, |
1634 " Error in PIL: LDD interface won't be released." ); |
|
1528 } |
1635 } |
1529 break; |
1636 break; |
1530 |
1637 |
1531 case RDevUsbcClient::EControlSetCSInterfaceDescriptor: |
1638 case RDevUsbcClient::EControlSetCSInterfaceDescriptor: |
1532 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetCSInterfaceDescriptor")); |
1639 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP48, |
1640 "EControlSetCSInterfaceDescriptor" ); |
|
1533 r = Kern::ThreadRawRead(iClient, a1, &desInfo, sizeof(desInfo)); |
1641 r = Kern::ThreadRawRead(iClient, a1, &desInfo, sizeof(desInfo)); |
1534 if (r != KErrNone) |
1642 if (r != KErrNone) |
1535 PanicClientThread(r); |
1643 PanicClientThread(r); |
1536 r = iController->SetCSInterfaceDescriptorBlock(iClient, this, desInfo.iSetting, |
1644 r = iController->SetCSInterfaceDescriptorBlock(iClient, this, desInfo.iSetting, |
1537 *reinterpret_cast<const TDes8*>(desInfo.iArg), |
1645 *reinterpret_cast<const TDes8*>(desInfo.iArg), |
1538 desInfo.iSize); |
1646 desInfo.iSize); |
1539 break; |
1647 break; |
1540 |
1648 |
1541 case RDevUsbcClient::EControlSetCSEndpointDescriptor: |
1649 case RDevUsbcClient::EControlSetCSEndpointDescriptor: |
1542 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetCSEndpointDescriptor")); |
1650 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP49, |
1651 "EControlSetCSEndpointDescriptor" ); |
|
1543 r = Kern::ThreadRawRead(iClient, a1, &desInfo, sizeof(desInfo)); |
1652 r = Kern::ThreadRawRead(iClient, a1, &desInfo, sizeof(desInfo)); |
1544 if (r != KErrNone) |
1653 if (r != KErrNone) |
1545 PanicClientThread(r); |
1654 PanicClientThread(r); |
1546 ep = EpFromAlternateSetting(desInfo.iSetting, desInfo.iEndpoint); |
1655 ep = EpFromAlternateSetting(desInfo.iSetting, desInfo.iEndpoint); |
1547 r = iController->SetCSEndpointDescriptorBlock(iClient, this, desInfo.iSetting, ep, |
1656 r = iController->SetCSEndpointDescriptorBlock(iClient, this, desInfo.iSetting, ep, |
1548 *reinterpret_cast<const TDes8*>(desInfo.iArg), |
1657 *reinterpret_cast<const TDes8*>(desInfo.iArg), |
1549 desInfo.iSize); |
1658 desInfo.iSize); |
1550 break; |
1659 break; |
1551 |
1660 |
1552 case RDevUsbcClient::EControlGetStringDescriptorLangId: |
1661 case RDevUsbcClient::EControlGetStringDescriptorLangId: |
1553 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetStringDescriptorLangId")); |
1662 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP50, |
1663 "EControlGetStringDescriptorLangId" ); |
|
1554 r = iController->GetStringDescriptorLangId(iClient, *((TDes8*) a1)); |
1664 r = iController->GetStringDescriptorLangId(iClient, *((TDes8*) a1)); |
1555 break; |
1665 break; |
1556 |
1666 |
1557 case RDevUsbcClient::EControlSetStringDescriptorLangId: |
1667 case RDevUsbcClient::EControlSetStringDescriptorLangId: |
1558 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetStringDescriptorLangId")); |
1668 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP51, |
1669 "EControlSetStringDescriptorLangId" ); |
|
1559 r = iController->SetStringDescriptorLangId(reinterpret_cast<TUint>(a1)); |
1670 r = iController->SetStringDescriptorLangId(reinterpret_cast<TUint>(a1)); |
1560 break; |
1671 break; |
1561 |
1672 |
1562 case RDevUsbcClient::EControlGetManufacturerStringDescriptor: |
1673 case RDevUsbcClient::EControlGetManufacturerStringDescriptor: |
1563 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetManufacturerStringDescriptor")); |
1674 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP52, |
1675 "EControlGetManufacturerStringDescriptor" ); |
|
1564 r = iController->GetManufacturerStringDescriptor(iClient, *((TPtr8*) a1)); |
1676 r = iController->GetManufacturerStringDescriptor(iClient, *((TPtr8*) a1)); |
1565 break; |
1677 break; |
1566 |
1678 |
1567 case RDevUsbcClient::EControlSetManufacturerStringDescriptor: |
1679 case RDevUsbcClient::EControlSetManufacturerStringDescriptor: |
1568 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetManufacturerStringDescriptor")); |
1680 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP53, |
1681 "EControlSetManufacturerStringDescriptor" ); |
|
1569 r = iController->SetManufacturerStringDescriptor(iClient, *((TPtr8*) a1)); |
1682 r = iController->SetManufacturerStringDescriptor(iClient, *((TPtr8*) a1)); |
1570 break; |
1683 break; |
1571 |
1684 |
1572 case RDevUsbcClient::EControlRemoveManufacturerStringDescriptor: |
1685 case RDevUsbcClient::EControlRemoveManufacturerStringDescriptor: |
1573 __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveManufacturerStringDescriptor")); |
1686 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP54, |
1687 "EControlRemoveManufacturerStringDescriptor" ); |
|
1574 r = iController->RemoveManufacturerStringDescriptor(); |
1688 r = iController->RemoveManufacturerStringDescriptor(); |
1575 break; |
1689 break; |
1576 |
1690 |
1577 case RDevUsbcClient::EControlGetProductStringDescriptor: |
1691 case RDevUsbcClient::EControlGetProductStringDescriptor: |
1578 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetProductStringDescriptor")); |
1692 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP55, |
1693 "EControlGetProductStringDescriptor" ); |
|
1579 r = iController->GetProductStringDescriptor(iClient, *((TPtr8*) a1)); |
1694 r = iController->GetProductStringDescriptor(iClient, *((TPtr8*) a1)); |
1580 break; |
1695 break; |
1581 |
1696 |
1582 case RDevUsbcClient::EControlSetProductStringDescriptor: |
1697 case RDevUsbcClient::EControlSetProductStringDescriptor: |
1583 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetProductStringDescriptor")); |
1698 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP56, |
1699 "EControlSetProductStringDescriptor" ); |
|
1584 r = iController->SetProductStringDescriptor(iClient, *((TPtr8*) a1)); |
1700 r = iController->SetProductStringDescriptor(iClient, *((TPtr8*) a1)); |
1585 break; |
1701 break; |
1586 |
1702 |
1587 case RDevUsbcClient::EControlRemoveProductStringDescriptor: |
1703 case RDevUsbcClient::EControlRemoveProductStringDescriptor: |
1588 __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveProductStringDescriptor")); |
1704 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP57, |
1705 "EControlRemoveProductStringDescriptor" ); |
|
1589 r = iController->RemoveProductStringDescriptor(); |
1706 r = iController->RemoveProductStringDescriptor(); |
1590 break; |
1707 break; |
1591 |
1708 |
1592 case RDevUsbcClient::EControlGetSerialNumberStringDescriptor: |
1709 case RDevUsbcClient::EControlGetSerialNumberStringDescriptor: |
1593 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetSerialNumberStringDescriptor")); |
1710 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP58, |
1711 "EControlGetSerialNumberStringDescriptor" ); |
|
1594 r = iController->GetSerialNumberStringDescriptor(iClient, *((TPtr8*) a1)); |
1712 r = iController->GetSerialNumberStringDescriptor(iClient, *((TPtr8*) a1)); |
1595 break; |
1713 break; |
1596 |
1714 |
1597 case RDevUsbcClient::EControlSetSerialNumberStringDescriptor: |
1715 case RDevUsbcClient::EControlSetSerialNumberStringDescriptor: |
1598 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetSerialNumberStringDescriptor")); |
1716 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP59, |
1717 "EControlSetSerialNumberStringDescriptor" ); |
|
1599 r = iController->SetSerialNumberStringDescriptor(iClient, *((TPtr8*) a1)); |
1718 r = iController->SetSerialNumberStringDescriptor(iClient, *((TPtr8*) a1)); |
1600 break; |
1719 break; |
1601 |
1720 |
1602 case RDevUsbcClient::EControlRemoveSerialNumberStringDescriptor: |
1721 case RDevUsbcClient::EControlRemoveSerialNumberStringDescriptor: |
1603 __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveSerialNumberStringDescriptor")); |
1722 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP60, |
1723 "EControlRemoveSerialNumberStringDescriptor" ); |
|
1604 r = iController->RemoveSerialNumberStringDescriptor(); |
1724 r = iController->RemoveSerialNumberStringDescriptor(); |
1605 break; |
1725 break; |
1606 |
1726 |
1607 case RDevUsbcClient::EControlGetConfigurationStringDescriptor: |
1727 case RDevUsbcClient::EControlGetConfigurationStringDescriptor: |
1608 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetConfigurationStringDescriptor")); |
1728 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP61, |
1729 "EControlGetConfigurationStringDescriptor" ); |
|
1609 r = iController->GetConfigurationStringDescriptor(iClient, *((TPtr8*) a1)); |
1730 r = iController->GetConfigurationStringDescriptor(iClient, *((TPtr8*) a1)); |
1610 break; |
1731 break; |
1611 |
1732 |
1612 case RDevUsbcClient::EControlSetConfigurationStringDescriptor: |
1733 case RDevUsbcClient::EControlSetConfigurationStringDescriptor: |
1613 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetConfigurationStringDescriptor")); |
1734 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP62, |
1735 "EControlSetConfigurationStringDescriptor" ); |
|
1614 r = iController->SetConfigurationStringDescriptor(iClient, *((TPtr8*) a1)); |
1736 r = iController->SetConfigurationStringDescriptor(iClient, *((TPtr8*) a1)); |
1615 break; |
1737 break; |
1616 |
1738 |
1617 case RDevUsbcClient::EControlRemoveConfigurationStringDescriptor: |
1739 case RDevUsbcClient::EControlRemoveConfigurationStringDescriptor: |
1618 __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveConfigurationStringDescriptor")); |
1740 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP63, |
1741 "EControlRemoveConfigurationStringDescriptor" ); |
|
1619 r = iController->RemoveConfigurationStringDescriptor(); |
1742 r = iController->RemoveConfigurationStringDescriptor(); |
1620 break; |
1743 break; |
1621 |
1744 |
1622 case RDevUsbcClient::EControlGetStringDescriptor: |
1745 case RDevUsbcClient::EControlGetStringDescriptor: |
1623 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetStringDescriptor")); |
1746 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP64, |
1747 "EControlGetStringDescriptor" ); |
|
1624 r = iController->GetStringDescriptor(iClient, (TUint8) (TInt) a1, *((TPtr8*) a2)); |
1748 r = iController->GetStringDescriptor(iClient, (TUint8) (TInt) a1, *((TPtr8*) a2)); |
1625 break; |
1749 break; |
1626 |
1750 |
1627 case RDevUsbcClient::EControlSetStringDescriptor: |
1751 case RDevUsbcClient::EControlSetStringDescriptor: |
1628 __KTRACE_OPT(KUSB, Kern::Printf("EControlSetStringDescriptor")); |
1752 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP65, |
1753 "EControlSetStringDescriptor" ); |
|
1629 r = iController->SetStringDescriptor(iClient, (TUint8) (TInt) a1, *((TPtr8*) a2)); |
1754 r = iController->SetStringDescriptor(iClient, (TUint8) (TInt) a1, *((TPtr8*) a2)); |
1630 break; |
1755 break; |
1631 |
1756 |
1632 case RDevUsbcClient::EControlRemoveStringDescriptor: |
1757 case RDevUsbcClient::EControlRemoveStringDescriptor: |
1633 __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveStringDescriptor")); |
1758 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP66, |
1759 "EControlRemoveStringDescriptor" ); |
|
1634 r = iController->RemoveStringDescriptor((TUint8) (TInt) a1); |
1760 r = iController->RemoveStringDescriptor((TUint8) (TInt) a1); |
1635 break; |
1761 break; |
1636 |
1762 |
1637 case RDevUsbcClient::EControlAllocateEndpointResource: |
1763 case RDevUsbcClient::EControlAllocateEndpointResource: |
1638 epRes = (TUsbcEndpointResource)((TInt) a2); |
1764 epRes = (TUsbcEndpointResource)((TInt) a2); |
1687 r = iController->GetOtgFeatures(iClient, *((TDes8*)a1)); |
1813 r = iController->GetOtgFeatures(iClient, *((TDes8*)a1)); |
1688 } |
1814 } |
1689 break; |
1815 break; |
1690 |
1816 |
1691 default: |
1817 default: |
1692 __KTRACE_OPT(KUSB, Kern::Printf("Function code not supported")); |
1818 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP67, |
1819 "Function code not supported" ); |
|
1693 r = KErrNotSupported; |
1820 r = KErrNotSupported; |
1694 } |
1821 } |
1695 |
1822 |
1696 return r; |
1823 return r; |
1697 } |
1824 } |
1702 TUsbcInterfaceInfoBuf ifc_info_buf; |
1829 TUsbcInterfaceInfoBuf ifc_info_buf; |
1703 TUsbcInterfaceInfoBuf* const ifc_info_buf_ptr = aInfoBuf->iInterfaceData; |
1830 TUsbcInterfaceInfoBuf* const ifc_info_buf_ptr = aInfoBuf->iInterfaceData; |
1704 const TInt srcLen = Kern::ThreadGetDesLength(iClient, ifc_info_buf_ptr); |
1831 const TInt srcLen = Kern::ThreadGetDesLength(iClient, ifc_info_buf_ptr); |
1705 if (srcLen < ifc_info_buf.Length()) |
1832 if (srcLen < ifc_info_buf.Length()) |
1706 { |
1833 { |
1707 __KTRACE_OPT(KUSB, Kern::Printf("SetInterface can't copy")); |
1834 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE, |
1835 "SetInterface can't copy" ); |
|
1708 PanicClientThread(EDesOverflow); |
1836 PanicClientThread(EDesOverflow); |
1709 } |
1837 } |
1710 |
1838 |
1711 TInt r = Kern::ThreadDesRead(iClient, ifc_info_buf_ptr, ifc_info_buf, 0, KChunkShiftBy0); |
1839 TInt r = Kern::ThreadDesRead(iClient, ifc_info_buf_ptr, ifc_info_buf, 0, KChunkShiftBy0); |
1712 if (r != KErrNone) |
1840 if (r != KErrNone) |
1713 { |
1841 { |
1714 __KTRACE_OPT(KUSB, Kern::Printf("SetInterface Copy failed reason=%d", r)); |
1842 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP1, |
1843 "SetInterface Copy failed reason=%d", r ); |
|
1715 PanicClientThread(r); |
1844 PanicClientThread(r); |
1716 } |
1845 } |
1717 |
1846 |
1718 TUsbcEndpointInfo* pEndpointData = ifc_info_buf().iEndpointData; |
1847 TUsbcEndpointInfo* pEndpointData = ifc_info_buf().iEndpointData; |
1719 |
1848 |
1720 // If an alternate interface is being asked for then do nothing, |
1849 // If an alternate interface is being asked for then do nothing, |
1721 // just pass it down to the Controller. |
1850 // just pass it down to the Controller. |
1722 const TInt num_endpoints = ifc_info_buf().iTotalEndpointsUsed; |
1851 const TInt num_endpoints = ifc_info_buf().iTotalEndpointsUsed; |
1723 __KTRACE_OPT(KUSB, Kern::Printf("SetInterface num_endpoints=%d", num_endpoints)); |
1852 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP2, |
1853 "SetInterface num_endpoints=%d", num_endpoints ); |
|
1724 |
1854 |
1725 // [The next 4 variables have to be initialized here because of the goto's that follow.] |
1855 // [The next 4 variables have to be initialized here because of the goto's that follow.] |
1726 // Both IN and OUT buffers will be fully cached: |
1856 // Both IN and OUT buffers will be fully cached: |
1727 const TUint32 cacheAttribs = EMapAttrSupRw | EMapAttrCachedMax; |
1857 const TUint32 cacheAttribs = EMapAttrSupRw | EMapAttrCachedMax; |
1728 const TUint32 bandwidthPriority = aInfoBuf->iBandwidthPriority; |
1858 const TUint32 bandwidthPriority = aInfoBuf->iBandwidthPriority; |
1729 |
1859 |
1730 // Supports ep0+5 endpoints |
1860 // Supports ep0+5 endpoints |
1731 TInt real_ep_numbers[6] = {-1, -1, -1, -1, -1, -1}; |
1861 TInt real_ep_numbers[6] = {-1, -1, -1, -1, -1, -1}; |
1732 |
1862 |
1733 // See if PIL will accept this interface |
1863 // See if PIL will accept this interface |
1734 __KTRACE_OPT(KUSB, Kern::Printf("SetInterface Calling controller")); |
1864 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP3, |
1865 "SetInterface Calling controller" ); |
|
1735 r = iController->SetInterface(this, |
1866 r = iController->SetInterface(this, |
1736 iClient, |
1867 iClient, |
1737 aInterfaceNumber, |
1868 aInterfaceNumber, |
1738 ifc_info_buf().iClass, |
1869 ifc_info_buf().iClass, |
1739 aInfoBuf->iString, |
1870 aInfoBuf->iString, |
1740 ifc_info_buf().iTotalEndpointsUsed, |
1871 ifc_info_buf().iTotalEndpointsUsed, |
1741 ifc_info_buf().iEndpointData, |
1872 ifc_info_buf().iEndpointData, |
1742 &real_ep_numbers, |
1873 &real_ep_numbers, |
1743 ifc_info_buf().iFeatureWord); |
1874 ifc_info_buf().iFeatureWord); |
1744 |
1875 |
1745 __KTRACE_OPT(KUSB, Kern::Printf("SetInterface controller returned %d", r)); |
1876 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP4, |
1877 "SetInterface controller returned %d", r ); |
|
1746 if (r != KErrNone) |
1878 if (r != KErrNone) |
1747 { |
1879 { |
1748 __KTRACE_OPT(KPANIC, Kern::Printf("SetInterface failed reason=%d", r)); |
1880 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP5, |
1881 "SetInterface failed reason=%d", r ); |
|
1749 return r; |
1882 return r; |
1750 } |
1883 } |
1751 |
1884 |
1752 // [The next variable has to be initialized here because of the goto's that follow.] |
1885 // [The next variable has to be initialized here because of the goto's that follow.] |
1753 TUsbcAlternateSettingList* alternateSettingListRec; |
1886 TUsbcAlternateSettingList* alternateSettingListRec; |
1754 |
1887 |
1755 // ep0 |
1888 // ep0 |
1756 if (iEndpoint[0] == NULL) |
1889 if (iEndpoint[0] == NULL) |
1757 { |
1890 { |
1758 __KTRACE_OPT(KUSB, Kern::Printf("SetInterface 11")); |
1891 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP6, |
1892 "SetInterface 11" ); |
|
1759 r = SetupEp0(); |
1893 r = SetupEp0(); |
1760 if (r != KErrNone) |
1894 if (r != KErrNone) |
1761 { |
1895 { |
1762 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: SetupEp0() failed")); |
1896 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP7, |
1897 " Error: SetupEp0() failed" ); |
|
1763 DestroyEp0(); |
1898 DestroyEp0(); |
1764 goto F1; |
1899 goto F1; |
1765 } |
1900 } |
1766 } |
1901 } |
1767 |
1902 |
1770 { |
1905 { |
1771 r = KErrNoMemory; |
1906 r = KErrNoMemory; |
1772 goto F1; |
1907 goto F1; |
1773 } |
1908 } |
1774 |
1909 |
1775 __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::SetInterface num_endpoints=%d", num_endpoints)); |
1910 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP8, |
1911 "DLddUsbcChannel::SetInterface num_endpoints=%d", num_endpoints ); |
|
1776 |
1912 |
1777 // other endpoints |
1913 // other endpoints |
1778 // calculate the total buffer size |
1914 // calculate the total buffer size |
1779 for (TInt i = 1; i <= num_endpoints; i++, pEndpointData++) |
1915 for (TInt i = 1; i <= num_endpoints; i++, pEndpointData++) |
1780 { |
1916 { |
1781 __KTRACE_OPT(KUSB, Kern::Printf("SetInterface for ep=%d", i)); |
1917 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP9, |
1918 "SetInterface for ep=%d", i ); |
|
1782 if (!ValidateEndpoint(pEndpointData)) |
1919 if (!ValidateEndpoint(pEndpointData)) |
1783 { |
1920 { |
1784 r = KErrUsbBadEndpoint; |
1921 r = KErrUsbBadEndpoint; |
1785 goto F2; |
1922 goto F2; |
1786 } |
1923 } |
1796 { |
1933 { |
1797 r = KErrNoMemory; |
1934 r = KErrNoMemory; |
1798 goto F2; |
1935 goto F2; |
1799 } |
1936 } |
1800 |
1937 |
1801 __KTRACE_OPT(KUSB, Kern::Printf("SetInterface for ep=%d rec=0x%08x ep==0x%08x", |
1938 OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP10, |
1802 i, alternateSettingListRec, ep)); |
1939 "SetInterface for ep=%d rec=0x%08x ep==0x%08x", i, |
1940 reinterpret_cast<TUint>(alternateSettingListRec), reinterpret_cast<TUint>(ep) ); |
|
1803 } |
1941 } |
1804 |
1942 |
1805 // buf size of each endpoint |
1943 // buf size of each endpoint |
1806 TInt bufSizes[KMaxEndpointsPerClient + 1]; |
1944 TInt bufSizes[KMaxEndpointsPerClient + 1]; |
1807 TInt epNum[KMaxEndpointsPerClient + 1]; |
1945 TInt epNum[KMaxEndpointsPerClient + 1]; |
1817 for( TInt i=1;i<=num_endpoints;i++ ) |
1955 for( TInt i=1;i<=num_endpoints;i++ ) |
1818 { |
1956 { |
1819 bufSizes[i] = alternateSettingListRec->iEndpoint[i]->BufferSize(); |
1957 bufSizes[i] = alternateSettingListRec->iEndpoint[i]->BufferSize(); |
1820 } |
1958 } |
1821 |
1959 |
1822 __KTRACE_OPT(KUSB, Kern::Printf("Sort the endpoints:")); |
1960 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP11, |
1961 "Sort the endpoints:" ); |
|
1823 |
1962 |
1824 // sort the endpoint number by the bufsize decreasely |
1963 // sort the endpoint number by the bufsize decreasely |
1825 for( TInt i=1;i<num_endpoints;i++ ) |
1964 for( TInt i=1;i<num_endpoints;i++ ) |
1826 { |
1965 { |
1827 TInt epMaxBuf = i; |
1966 TInt epMaxBuf = i; |
1840 epNum[i] = epNum[epMaxBuf]; |
1979 epNum[i] = epNum[epMaxBuf]; |
1841 epNum[epMaxBuf] = temp; |
1980 epNum[epMaxBuf] = temp; |
1842 |
1981 |
1843 alternateSettingListRec->iEpNumDeOrderedByBufSize[i] = epNum[i]; |
1982 alternateSettingListRec->iEpNumDeOrderedByBufSize[i] = epNum[i]; |
1844 |
1983 |
1845 __KTRACE_OPT(KUSB, Kern::Printf(" %d:%d", epNum[i], bufSizes[i])); |
1984 OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP12, |
1985 " %d:%d", epNum[i], bufSizes[i] ); |
|
1846 } |
1986 } |
1847 alternateSettingListRec->iEpNumDeOrderedByBufSize[num_endpoints] = epNum[num_endpoints]; |
1987 alternateSettingListRec->iEpNumDeOrderedByBufSize[num_endpoints] = epNum[num_endpoints]; |
1848 __KTRACE_OPT(KUSB, Kern::Printf(" %d:%d", epNum[num_endpoints], bufSizes[num_endpoints])); |
1988 OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP13, |
1849 __KTRACE_OPT(KUSB, Kern::Printf("\n")); |
1989 " %d:%d", epNum[num_endpoints], bufSizes[num_endpoints] ); |
1990 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP14, "\n" ); |
|
1850 |
1991 |
1851 // chain in this alternate setting |
1992 // chain in this alternate setting |
1852 alternateSettingListRec->iNext = iAlternateSettingList; |
1993 alternateSettingListRec->iNext = iAlternateSettingList; |
1853 iAlternateSettingList = alternateSettingListRec; |
1994 iAlternateSettingList = alternateSettingListRec; |
1854 alternateSettingListRec->iSetting = aInterfaceNumber; |
1995 alternateSettingListRec->iSetting = aInterfaceNumber; |
1862 } |
2003 } |
1863 |
2004 |
1864 r = SetupInterfaceMemory(iHwChunks, cacheAttribs ); |
2005 r = SetupInterfaceMemory(iHwChunks, cacheAttribs ); |
1865 if( r==KErrNone ) |
2006 if( r==KErrNone ) |
1866 { |
2007 { |
1867 __KTRACE_OPT(KUSB, Kern::Printf("SetInterface ready to exit")); |
2008 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP15, |
2009 "SetInterface ready to exit" ); |
|
1868 |
2010 |
1869 if (aInterfaceNumber == 0) |
2011 if (aInterfaceNumber == 0) |
1870 { |
2012 { |
1871 // make sure we're ready to go with the main interface |
2013 // make sure we're ready to go with the main interface |
1872 iValidInterface = ETrue; |
2014 iValidInterface = ETrue; |
1873 __KTRACE_OPT(KUSB, Kern::Printf("SetInterface SelectAlternateSetting")); |
2015 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP16, |
2016 "SetInterface SelectAlternateSetting" ); |
|
1874 SelectAlternateSetting(0); |
2017 SelectAlternateSetting(0); |
1875 } |
2018 } |
1876 return KErrNone; |
2019 return KErrNone; |
1877 } |
2020 } |
1878 else |
2021 else |
1879 { |
2022 { |
1880 __KTRACE_OPT(KUSB, Kern::Printf("Destroying all interfaces")); |
2023 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP17, |
2024 "Destroying all interfaces" ); |
|
1881 DestroyAllInterfaces(); |
2025 DestroyAllInterfaces(); |
1882 DestroyEp0(); |
2026 DestroyEp0(); |
1883 return r; |
2027 return r; |
1884 } |
2028 } |
1885 |
2029 |
1887 delete alternateSettingListRec; |
2031 delete alternateSettingListRec; |
1888 //Fall through |
2032 //Fall through |
1889 |
2033 |
1890 F1: |
2034 F1: |
1891 #if _DEBUG |
2035 #if _DEBUG |
2036 #ifdef OST_TRACE_COMPILER_IN_USE |
|
1892 TInt r1 = iController->ReleaseInterface(this, aInterfaceNumber); |
2037 TInt r1 = iController->ReleaseInterface(this, aInterfaceNumber); |
1893 __KTRACE_OPT(KUSB, Kern::Printf("Release Interface controller returned %d", r1)); |
2038 #else |
2039 (void) iController->ReleaseInterface(this, aInterfaceNumber); |
|
2040 #endif |
|
2041 OstTraceDef1( OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP18, |
|
2042 "Release Interface controller returned %d", r1 ); |
|
1894 #else |
2043 #else |
1895 (void) iController->ReleaseInterface(this, aInterfaceNumber); |
2044 (void) iController->ReleaseInterface(this, aInterfaceNumber); |
1896 #endif |
2045 #endif |
1897 return r; |
2046 return r; |
1898 } |
2047 } |
1907 TBool chunkChanged = EFalse; |
2056 TBool chunkChanged = EFalse; |
1908 TInt numOfEp = asRec->iNumberOfEndpoints; |
2057 TInt numOfEp = asRec->iNumberOfEndpoints; |
1909 |
2058 |
1910 // 1, collect all bufs' sizes for the current interface |
2059 // 1, collect all bufs' sizes for the current interface |
1911 // to realloc all the chunks |
2060 // to realloc all the chunks |
1912 __KTRACE_OPT(KUSB, Kern::Printf("Collect all buffer sizes:")); |
2061 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY, |
2062 "Collect all buffer sizes:" ); |
|
1913 RArray<TInt> bufSizes; |
2063 RArray<TInt> bufSizes; |
1914 for(TInt i=1;i<=numOfEp;i++) |
2064 for(TInt i=1;i<=numOfEp;i++) |
1915 { |
2065 { |
1916 TInt nextEp = asRec->iEpNumDeOrderedByBufSize[i]; |
2066 TInt nextEp = asRec->iEpNumDeOrderedByBufSize[i]; |
1917 TInt epBufCount = asRec->iEndpoint[nextEp]->BufferNumber(); |
2067 TInt epBufCount = asRec->iEndpoint[nextEp]->BufferNumber(); |
1918 __KTRACE_OPT(KUSB, Kern::Printf(" ep %d, buf count %d", nextEp, epBufCount )); |
2068 OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP1, |
2069 " ep %d, buf count %d", nextEp, epBufCount ); |
|
1919 for(TInt k=0;k<epBufCount;k++) |
2070 for(TInt k=0;k<epBufCount;k++) |
1920 { |
2071 { |
1921 TInt epBufSize = asRec->iEndpoint[nextEp]->BufferSize(); |
2072 TInt epBufSize = asRec->iEndpoint[nextEp]->BufferSize(); |
1922 TInt r = bufSizes.Append(epBufSize); |
2073 TInt r = bufSizes.Append(epBufSize); |
1923 if(r!=KErrNone) |
2074 if(r!=KErrNone) |
1924 { |
2075 { |
1925 iController->DeRegisterClient(this); |
2076 iController->DeRegisterClient(this); |
1926 bufSizes.Close(); |
2077 bufSizes.Close(); |
1927 return r; |
2078 return r; |
1928 } |
2079 } |
1929 __KTRACE_OPT(KUSB,Kern::Printf(" %d", epBufSize )); |
2080 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP2, |
2081 " %d", epBufSize ); |
|
1930 } |
2082 } |
1931 __KTRACE_OPT(KUSB, Kern::Printf("\n")); |
2083 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP3, "\n" ); |
1932 |
2084 |
1933 } |
2085 } |
1934 |
2086 |
1935 // 2, alloc the buffer decreasely, biggest-->smallest |
2087 // 2, alloc the buffer decreasely, biggest-->smallest |
1936 // 2.1 check the existing chunks |
2088 // 2.1 check the existing chunks |
1937 TInt bufCount = bufSizes.Count(); |
2089 TInt bufCount = bufSizes.Count(); |
1938 __KTRACE_OPT(KUSB, Kern::Printf(" ep buf number needed %d", bufCount )); |
2090 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP4, |
1939 __KTRACE_OPT(KUSB, Kern::Printf(" chunks available %d", aHwChunks.Count() )); |
2091 " ep buf number needed %d", bufCount ); |
2092 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP5, |
|
2093 " chunks available %d", aHwChunks.Count() ); |
|
1940 |
2094 |
1941 TInt chunkInd = 0; |
2095 TInt chunkInd = 0; |
1942 while( (chunkInd<aHwChunks.Count())&& (chunkInd<bufCount)) |
2096 while( (chunkInd<aHwChunks.Count())&& (chunkInd<bufCount)) |
1943 { |
2097 { |
1944 TUint8* oldAddr = NULL; |
2098 TUint8* oldAddr = NULL; |
1945 oldAddr = reinterpret_cast<TUint8*>(aHwChunks[chunkInd]->LinearAddress()); |
2099 oldAddr = reinterpret_cast<TUint8*>(aHwChunks[chunkInd]->LinearAddress()); |
1946 |
2100 |
1947 DPlatChunkHw* chunk = ReAllocate(bufSizes[chunkInd], aHwChunks[chunkInd], aCacheAttribs); |
2101 DPlatChunkHw* chunk = ReAllocate(bufSizes[chunkInd], aHwChunks[chunkInd], aCacheAttribs); |
1948 if (chunk == NULL) |
2102 if (chunk == NULL) |
1949 { |
2103 { |
1950 __KTRACE_OPT(KUSB, Kern::Printf("Failed to alloc chunks size %d!", bufSizes[chunkInd])); |
2104 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP6, |
2105 "Failed to alloc chunks size %d!", bufSizes[chunkInd] ); |
|
1951 // lost all interfaces: |
2106 // lost all interfaces: |
1952 // Tell Controller to release Interface and h/w resources associated with this |
2107 // Tell Controller to release Interface and h/w resources associated with this |
1953 iController->DeRegisterClient(this); |
2108 iController->DeRegisterClient(this); |
1954 bufSizes.Close(); |
2109 bufSizes.Close(); |
1955 return KErrNoMemory; |
2110 return KErrNoMemory; |
1956 } |
2111 } |
1957 else |
2112 else |
1958 { |
2113 { |
1959 // Parcel out the memory between endpoints |
2114 // Parcel out the memory between endpoints |
1960 TUint8* newAddr = reinterpret_cast<TUint8*>(chunk->LinearAddress()); |
2115 TUint8* newAddr = reinterpret_cast<TUint8*>(chunk->LinearAddress()); |
1961 __KTRACE_OPT(KUSB, Kern::Printf("SetupInterfaceMemory alloc new chunk=0x%x, size=%d", newAddr,bufSizes[chunkInd])); |
2116 OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP7, |
2117 "SetupInterfaceMemory alloc new chunk=0x%x, size=%d", |
|
2118 reinterpret_cast<TUint>(newAddr), bufSizes[chunkInd] ); |
|
1962 // The check is important to avoid chunkChanged to be corrupted. |
2119 // The check is important to avoid chunkChanged to be corrupted. |
1963 // This code change is to fix the problem that one chunk is used by multiple interfaces. |
2120 // This code change is to fix the problem that one chunk is used by multiple interfaces. |
1964 if(!chunkChanged) |
2121 if(!chunkChanged) |
1965 { |
2122 { |
1966 chunkChanged = (newAddr != oldAddr); |
2123 chunkChanged = (newAddr != oldAddr); |
1975 { |
2132 { |
1976 DPlatChunkHw* chunk = NULL; |
2133 DPlatChunkHw* chunk = NULL; |
1977 chunk = Allocate( bufSizes[chunkInd], aCacheAttribs); |
2134 chunk = Allocate( bufSizes[chunkInd], aCacheAttribs); |
1978 if (chunk == NULL) |
2135 if (chunk == NULL) |
1979 { |
2136 { |
1980 __KTRACE_OPT(KUSB, Kern::Printf("Failed to alloc chunk, size %d!", bufSizes[chunkInd])); |
2137 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP8, |
2138 "Failed to alloc chunk, size %d!", bufSizes[chunkInd] ); |
|
1981 // lost all interfaces: |
2139 // lost all interfaces: |
1982 // Tell Controller to release Interface and h/w resources associated with this |
2140 // Tell Controller to release Interface and h/w resources associated with this |
1983 iController->DeRegisterClient(this); |
2141 iController->DeRegisterClient(this); |
1984 bufSizes.Close(); |
2142 bufSizes.Close(); |
1985 return KErrNoMemory; |
2143 return KErrNoMemory; |
1986 } |
2144 } |
1987 else |
2145 else |
1988 { |
2146 { |
1989 // Parcel out the memory between endpoints |
2147 // Parcel out the memory between endpoints |
1990 __KTRACE_OPT(KUSB, Kern::Printf("SetupInterfaceMemory alloc new chunk=0x%x, size=%d", |
2148 OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP9, |
1991 reinterpret_cast<TUint8*>(chunk->LinearAddress()), bufSizes[chunkInd])); |
2149 "SetupInterfaceMemory alloc new chunk=0x%x, size=%d", |
2150 static_cast<TUint>(chunk->LinearAddress()), bufSizes[chunkInd]); |
|
2151 |
|
1992 TInt r = aHwChunks.Append(chunk); |
2152 TInt r = aHwChunks.Append(chunk); |
1993 if(r!=KErrNone) |
2153 if(r!=KErrNone) |
1994 { |
2154 { |
1995 ClosePhysicalChunk(chunk); |
2155 ClosePhysicalChunk(chunk); |
1996 iController->DeRegisterClient(this); |
2156 iController->DeRegisterClient(this); |
2005 |
2165 |
2006 ReSetInterfaceMemory(asRec, aHwChunks); |
2166 ReSetInterfaceMemory(asRec, aHwChunks); |
2007 |
2167 |
2008 if(chunkChanged) |
2168 if(chunkChanged) |
2009 { |
2169 { |
2010 __KTRACE_OPT(KUSB, Kern::Printf("SetupInterfaceMemory readdressing.")); |
2170 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP10, |
2171 "SetupInterfaceMemory readdressing." ); |
|
2011 asRec = asRec->iNext; |
2172 asRec = asRec->iNext; |
2012 while (asRec) |
2173 while (asRec) |
2013 { |
2174 { |
2014 // Interfaces are not concurrent so they can all start at the same logical address |
2175 // Interfaces are not concurrent so they can all start at the same logical address |
2015 __KTRACE_OPT(KUSB, Kern::Printf("SetupInterfaceMemory readdressing setting=%d", asRec->iSetting)); |
2176 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP11, |
2177 "SetupInterfaceMemory readdressing setting=%d", asRec->iSetting ); |
|
2016 ReSetInterfaceMemory(asRec, aHwChunks); |
2178 ReSetInterfaceMemory(asRec, aHwChunks); |
2017 asRec = asRec->iNext; |
2179 asRec = asRec->iNext; |
2018 } |
2180 } |
2019 } |
2181 } |
2020 return KErrNone; |
2182 return KErrNone; |
2021 } |
2183 } |
2022 |
2184 |
2023 TInt DLddUsbcChannel::SetupEp0() |
2185 TInt DLddUsbcChannel::SetupEp0() |
2024 { |
2186 { |
2025 __KTRACE_OPT(KUSB, Kern::Printf("SetupEp0 entry %x", this)); |
2187 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPEP0, |
2188 "SetupEp0 entry %x", this ); |
|
2026 TInt ep0Size = iController->Ep0PacketSize(); |
2189 TInt ep0Size = iController->Ep0PacketSize(); |
2027 TUsbcEndpointInfo ep0Info = TUsbcEndpointInfo(KUsbEpTypeControl, KUsbEpDirBidirect, ep0Size); |
2190 TUsbcEndpointInfo ep0Info = TUsbcEndpointInfo(KUsbEpTypeControl, KUsbEpDirBidirect, ep0Size); |
2028 TUsbcEndpoint* ep0 = new TUsbcEndpoint(this, iController, &ep0Info, 0, 0); |
2191 TUsbcEndpoint* ep0 = new TUsbcEndpoint(this, iController, &ep0Info, 0, 0); |
2029 if (ep0 == NULL) |
2192 if (ep0 == NULL) |
2030 { |
2193 { |
2056 return r; |
2219 return r; |
2057 } |
2220 } |
2058 TUint8 * buf; |
2221 TUint8 * buf; |
2059 buf = (TUint8*) chunk->LinearAddress(); |
2222 buf = (TUint8*) chunk->LinearAddress(); |
2060 ep0->SetBufferAddr( i, buf); |
2223 ep0->SetBufferAddr( i, buf); |
2061 __KTRACE_OPT(KUSB, Kern::Printf("SetupEp0 60 buffer number %d", i)); |
2224 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPEP0_DUP1, |
2062 __KTRACE_OPT(KUSB, Kern::Printf("SetupEp0 60 buffer size %d", bufferSize)); |
2225 "SetupEp0 60 buffer number %d", i ); |
2226 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPEP0_DUP2, |
|
2227 "SetupEp0 60 buffer size %d", bufferSize ); |
|
2063 } |
2228 } |
2064 |
2229 |
2065 ep0->SetRealEpNumber(0); |
2230 ep0->SetRealEpNumber(0); |
2066 return KErrNone; |
2231 return KErrNone; |
2067 } |
2232 } |
2087 if (ep != NULL ) |
2252 if (ep != NULL ) |
2088 { |
2253 { |
2089 TUint8* pBuf = NULL; |
2254 TUint8* pBuf = NULL; |
2090 pBuf = reinterpret_cast<TUint8*>(aHwChunks[chunkInd]->LinearAddress()); |
2255 pBuf = reinterpret_cast<TUint8*>(aHwChunks[chunkInd]->LinearAddress()); |
2091 ep->SetBufferAddr( k, pBuf); |
2256 ep->SetBufferAddr( k, pBuf); |
2092 __KTRACE_OPT(KUSB, Kern::Printf(" ep %d, buf %d, addr 0x%x", nextEp, k, pBuf )); |
2257 OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_RESETINTERFACEMEMORY, |
2258 " ep %d, buf %d, addr 0x%x", nextEp, k, reinterpret_cast<TUint>(pBuf) ); |
|
2093 chunkInd++; |
2259 chunkInd++; |
2094 __ASSERT_DEBUG(chunkInd<=aHwChunks.Count(), |
2260 #ifdef _DEBUG |
2095 Kern::Printf(" Error: available chunks %d, run out at epInd%d, bufInd%d", |
2261 if (chunkInd > aHwChunks.Count()) |
2096 aHwChunks.Count(), i, k)); |
2262 { |
2263 OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, DLDDUSBCCHANNEL_RESETINTERFACEMEMORY_DUP1, |
|
2264 " Error: available chunks %d, run out at epInd%d, bufInd%d", |
|
2265 aHwChunks.Count(), i, k ); |
|
2266 } |
|
2267 #endif |
|
2097 __ASSERT_DEBUG(chunkInd<=aHwChunks.Count(), |
2268 __ASSERT_DEBUG(chunkInd<=aHwChunks.Count(), |
2098 Kern::Fault("usbc.ldd", __LINE__)); |
2269 Kern::Fault("usbc.ldd", __LINE__)); |
2099 } |
2270 } |
2100 } |
2271 } |
2101 } |
2272 } |
2187 } |
2358 } |
2188 |
2359 |
2189 |
2360 |
2190 void DLddUsbcChannel::EndpointStatusChangeCallback(TAny* aDLddUsbcChannel) |
2361 void DLddUsbcChannel::EndpointStatusChangeCallback(TAny* aDLddUsbcChannel) |
2191 { |
2362 { |
2192 __KTRACE_OPT(KUSB, Kern::Printf("EndpointStatusChangeCallback")); |
2363 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_ENDPOINTSTATUSCHANGECALLBACK, |
2364 "EndpointStatusChangeCallback" ); |
|
2193 DLddUsbcChannel* dUsbc = (DLddUsbcChannel*) aDLddUsbcChannel; |
2365 DLddUsbcChannel* dUsbc = (DLddUsbcChannel*) aDLddUsbcChannel; |
2194 if (dUsbc->iChannelClosing) |
2366 if (dUsbc->iChannelClosing) |
2195 return; |
2367 return; |
2196 TUint endpointState = dUsbc->iEndpointStatusCallbackInfo.State(); |
2368 TUint endpointState = dUsbc->iEndpointStatusCallbackInfo.State(); |
2197 const TInt reqNo = (TInt) RDevUsbcClient::ERequestEndpointStatusNotify; |
2369 const TInt reqNo = (TInt) RDevUsbcClient::ERequestEndpointStatusNotify; |
2198 if (dUsbc->iRequestStatus[reqNo]) |
2370 if (dUsbc->iRequestStatus[reqNo]) |
2199 { |
2371 { |
2200 __KTRACE_OPT(KUSB, Kern::Printf("EndpointStatusChangeCallback Notify status")); |
2372 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_ENDPOINTSTATUSCHANGECALLBACK_DUP1, |
2373 "EndpointStatusChangeCallback Notify status" ); |
|
2201 DThread* client = dUsbc->iClient; |
2374 DThread* client = dUsbc->iClient; |
2202 |
2375 |
2203 dUsbc->iEndpointStatusChangeReq->Data() = endpointState; |
2376 dUsbc->iEndpointStatusChangeReq->Data() = endpointState; |
2204 dUsbc->iRequestStatus[reqNo] = NULL; |
2377 dUsbc->iRequestStatus[reqNo] = NULL; |
2205 Kern::QueueRequestComplete(client,dUsbc->iEndpointStatusChangeReq,KErrNone); |
2378 Kern::QueueRequestComplete(client,dUsbc->iEndpointStatusChangeReq,KErrNone); |
2218 TInt i; |
2391 TInt i; |
2219 for (i = 0; |
2392 for (i = 0; |
2220 (i < KUsbcDeviceStateRequests) && ((deviceState = dUsbc->iStatusCallbackInfo.State(i)) != EUsbcNoState); |
2393 (i < KUsbcDeviceStateRequests) && ((deviceState = dUsbc->iStatusCallbackInfo.State(i)) != EUsbcNoState); |
2221 ++i) |
2394 ++i) |
2222 { |
2395 { |
2223 __KTRACE_OPT(KUSB, Kern::Printf("StatusChangeCallBack status=%d", deviceState)); |
2396 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_STATUSCHANGECALLBACK, |
2397 "StatusChangeCallBack status=%d", static_cast<TInt>(deviceState) ); |
|
2224 if (deviceState & KUsbAlternateSetting) |
2398 if (deviceState & KUsbAlternateSetting) |
2225 { |
2399 { |
2226 dUsbc->ProcessAlternateSetting(deviceState); |
2400 dUsbc->ProcessAlternateSetting(deviceState); |
2227 } |
2401 } |
2228 else |
2402 else |
2248 } |
2422 } |
2249 |
2423 |
2250 |
2424 |
2251 void DLddUsbcChannel::OtgFeatureChangeCallback(TAny* aDLddUsbcChannel) |
2425 void DLddUsbcChannel::OtgFeatureChangeCallback(TAny* aDLddUsbcChannel) |
2252 { |
2426 { |
2253 __KTRACE_OPT(KUSB, Kern::Printf("OtgFeatureChangeCallback")); |
2427 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_OTGFEATURECHANGECALLBACK, |
2428 "OtgFeatureChangeCallback" ); |
|
2254 DLddUsbcChannel* dUsbc = (DLddUsbcChannel*) aDLddUsbcChannel; |
2429 DLddUsbcChannel* dUsbc = (DLddUsbcChannel*) aDLddUsbcChannel; |
2255 if (dUsbc->iChannelClosing) |
2430 if (dUsbc->iChannelClosing) |
2256 return; |
2431 return; |
2257 |
2432 |
2258 TUint8 features; |
2433 TUint8 features; |
2260 dUsbc->iController->GetCurrentOtgFeatures(features); |
2435 dUsbc->iController->GetCurrentOtgFeatures(features); |
2261 |
2436 |
2262 const TInt reqNo = (TInt) RDevUsbcClient::ERequestOtgFeaturesNotify; |
2437 const TInt reqNo = (TInt) RDevUsbcClient::ERequestOtgFeaturesNotify; |
2263 if (dUsbc->iRequestStatus[reqNo]) |
2438 if (dUsbc->iRequestStatus[reqNo]) |
2264 { |
2439 { |
2265 __KTRACE_OPT(KUSB, Kern::Printf("OtgFeatureChangeCallback Notify status")); |
2440 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_OTGFEATURECHANGECALLBACK_DUP1, |
2441 "OtgFeatureChangeCallback Notify status" ); |
|
2266 dUsbc->iOtgFeatureChangeReq->Data()=features; |
2442 dUsbc->iOtgFeatureChangeReq->Data()=features; |
2267 dUsbc->iRequestStatus[reqNo] = NULL; |
2443 dUsbc->iRequestStatus[reqNo] = NULL; |
2268 Kern::QueueRequestComplete(dUsbc->iClient,dUsbc->iOtgFeatureChangeReq,KErrNone); |
2444 Kern::QueueRequestComplete(dUsbc->iClient,dUsbc->iOtgFeatureChangeReq,KErrNone); |
2269 dUsbc->iOtgFeatureChangePtr = NULL; |
2445 dUsbc->iOtgFeatureChangePtr = NULL; |
2270 } |
2446 } |
2311 { |
2487 { |
2312 return alternateSettingListRec->iEndpoint[aEndpoint]->RealEpNumber(); |
2488 return alternateSettingListRec->iEndpoint[aEndpoint]->RealEpNumber(); |
2313 } |
2489 } |
2314 else |
2490 else |
2315 { |
2491 { |
2316 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: aEndpoint %d wrong for aAlternateSetting %d", |
2492 OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_EPFROMALTERNATESETTING, |
2317 aEndpoint, aAlternateSetting)); |
2493 " Error: aEndpoint %d wrong for aAlternateSetting %d", aEndpoint, aAlternateSetting ); |
2318 return -1; |
2494 return -1; |
2319 } |
2495 } |
2320 } |
2496 } |
2321 alternateSettingListRec = alternateSettingListRec->iNext; |
2497 alternateSettingListRec = alternateSettingListRec->iNext; |
2322 } |
2498 } |
2323 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: no aAlternateSetting %d found", aAlternateSetting)); |
2499 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_EPFROMALTERNATESETTING_DUP1, |
2500 " Error: no aAlternateSetting %d found", aAlternateSetting ); |
|
2324 return -1; |
2501 return -1; |
2325 } |
2502 } |
2326 |
2503 |
2327 |
2504 |
2328 TInt DLddUsbcChannel::ProcessAlternateSetting(TUint aAlternateSetting) |
2505 TInt DLddUsbcChannel::ProcessAlternateSetting(TUint aAlternateSetting) |
2329 { |
2506 { |
2330 ResetInterface(KErrUsbInterfaceChange); // kill any outstanding transfers |
2507 ResetInterface(KErrUsbInterfaceChange); // kill any outstanding transfers |
2331 __KTRACE_OPT(KUSB, Kern::Printf("ProcessAlternateSetting 0x%08x", aAlternateSetting)); |
2508 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSALTERNATESETTING, |
2509 "ProcessAlternateSetting 0x%08x", aAlternateSetting ); |
|
2332 TUint newSetting = aAlternateSetting&(~KUsbAlternateSetting); |
2510 TUint newSetting = aAlternateSetting&(~KUsbAlternateSetting); |
2333 __KTRACE_OPT(KUSB, Kern::Printf("ProcessAlternateSetting selecting alternate setting 0x%08x", newSetting)); |
2511 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSALTERNATESETTING_DUP1, |
2512 "ProcessAlternateSetting selecting alternate setting 0x%08x", newSetting ); |
|
2513 |
|
2334 TInt r = SelectAlternateSetting(newSetting); |
2514 TInt r = SelectAlternateSetting(newSetting); |
2335 if (r != KErrNone) |
2515 if (r != KErrNone) |
2336 return r; |
2516 return r; |
2337 StartEpReads(); |
2517 StartEpReads(); |
2338 iAlternateSetting = newSetting; |
2518 iAlternateSetting = newSetting; |
2340 } |
2520 } |
2341 |
2521 |
2342 |
2522 |
2343 TInt DLddUsbcChannel::ProcessDeviceState(TUsbcDeviceState aDeviceState) |
2523 TInt DLddUsbcChannel::ProcessDeviceState(TUsbcDeviceState aDeviceState) |
2344 { |
2524 { |
2345 __KTRACE_OPT(KUSB, Kern::Printf("ProcessDeviceState(%d -> %d)", iDeviceState, aDeviceState)); |
2525 OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSDEVICESTATE, |
2526 "ProcessDeviceState(%d -> %d)", iDeviceState, aDeviceState ); |
|
2346 if (iDeviceState == aDeviceState) |
2527 if (iDeviceState == aDeviceState) |
2347 { |
2528 { |
2348 __KTRACE_OPT(KUSB, Kern::Printf(" No state change => nothing to be done.")); |
2529 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSDEVICESTATE_DUP1, |
2530 " No state change => nothing to be done." ); |
|
2349 return KErrNone; |
2531 return KErrNone; |
2350 } |
2532 } |
2351 if (iDeviceState == EUsbcDeviceStateSuspended) |
2533 if (iDeviceState == EUsbcDeviceStateSuspended) |
2352 { |
2534 { |
2353 __KTRACE_OPT(KUSB, Kern::Printf(" Coming out of Suspend: old state = %d", iOldDeviceState)); |
2535 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSDEVICESTATE_DUP2, |
2536 " Coming out of Suspend: old state = %d", iOldDeviceState ); |
|
2354 iDeviceState = iOldDeviceState; |
2537 iDeviceState = iOldDeviceState; |
2355 if (iDeviceState == aDeviceState) |
2538 if (iDeviceState == aDeviceState) |
2356 { |
2539 { |
2357 __KTRACE_OPT(KUSB, Kern::Printf(" New state same as before Suspend => nothing to be done.")); |
2540 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSDEVICESTATE_DUP3, |
2541 " New state same as before Suspend => nothing to be done." ); |
|
2358 return KErrNone; |
2542 return KErrNone; |
2359 } |
2543 } |
2360 } |
2544 } |
2361 TBool renumerateState = (aDeviceState == EUsbcDeviceStateConfigured); |
2545 TBool renumerateState = (aDeviceState == EUsbcDeviceStateConfigured); |
2362 TBool deconfigured = EFalse; |
2546 TBool deconfigured = EFalse; |
2363 TInt cancellationCode = KErrNone; |
2547 TInt cancellationCode = KErrNone; |
2364 if (aDeviceState == EUsbcDeviceStateSuspended) |
2548 if (aDeviceState == EUsbcDeviceStateSuspended) |
2365 { |
2549 { |
2366 __KTRACE_OPT(KUSB, Kern::Printf(" Suspending...")); |
2550 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSDEVICESTATE_DUP4, |
2551 " Suspending..." ); |
|
2367 iOldDeviceState = iDeviceState; |
2552 iOldDeviceState = iDeviceState; |
2368 // Put PSL into low power mode here |
2553 // Put PSL into low power mode here |
2369 } |
2554 } |
2370 else |
2555 else |
2371 { |
2556 { |
2381 cancellationCode = KErrUsbDeviceBusReset; |
2566 cancellationCode = KErrUsbDeviceBusReset; |
2382 else |
2567 else |
2383 cancellationCode = KErrUsbDeviceNotConfigured; |
2568 cancellationCode = KErrUsbDeviceNotConfigured; |
2384 } |
2569 } |
2385 } |
2570 } |
2386 __KTRACE_OPT(KUSB, Kern::Printf(" %d --> %d", iDeviceState, aDeviceState)); |
2571 OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSDEVICESTATE_DUP5, |
2572 " %d --> %d", iDeviceState, aDeviceState ); |
|
2387 iDeviceState = aDeviceState; |
2573 iDeviceState = aDeviceState; |
2388 if (iValidInterface || iOwnsDeviceControl) |
2574 if (iValidInterface || iOwnsDeviceControl) |
2389 { |
2575 { |
2390 // This LDD may not own an interface. It could be some manager reenumerating |
2576 // This LDD may not own an interface. It could be some manager reenumerating |
2391 // after its subordinate LDDs have setup their interfaces. |
2577 // after its subordinate LDDs have setup their interfaces. |
2424 while ((++i <= KMaxEndpointsPerClient) && iEndpoint[i]) |
2610 while ((++i <= KMaxEndpointsPerClient) && iEndpoint[i]) |
2425 { |
2611 { |
2426 const TInt size = iController->EndpointPacketSize(this, iEndpoint[i]->RealEpNumber()); |
2612 const TInt size = iController->EndpointPacketSize(this, iEndpoint[i]->RealEpNumber()); |
2427 if (size < 0) |
2613 if (size < 0) |
2428 { |
2614 { |
2429 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: Packet size < 0 for ep %d", i)); |
2615 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_UPDATEENDPOINTSIZES, |
2616 " Error: Packet size < 0 for ep %d", i ); |
|
2430 continue; |
2617 continue; |
2431 } |
2618 } |
2432 iEndpoint[i]->SetMaxPacketSize(size); |
2619 iEndpoint[i]->SetMaxPacketSize(size); |
2433 } |
2620 } |
2434 __ASSERT_DEBUG(i == iNumberOfEndpoints + 1, |
2621 #ifdef _DEBUG |
2435 Kern::Printf(" Error: iNumberOfEndpoints wrong (%d)", iNumberOfEndpoints)); |
2622 if (i != iNumberOfEndpoints + 1) |
2436 } |
2623 { |
2437 |
2624 OstTraceDef1( OST_TRACE_CATEGORY_DEBUG, TRACE_FATAL, DLDDUSBCCHANNEL_UPDATEENDPOINTSIZES_DUP1, |
2438 |
2625 " Error: iNumberOfEndpoints wrong (%d)", iNumberOfEndpoints ); |
2439 DPlatChunkHw* DLddUsbcChannel::ReAllocate(TInt aBuffersize, DPlatChunkHw* aHwChunk, TUint32 aCacheAttribs) |
2626 |
2627 } |
|
2628 #endif |
|
2629 } |
|
2630 |
|
2631 |
|
2632 DPlatChunkHw* DLddUsbcChannel::ReAllocate(TInt aBuffersize, DPlatChunkHw* aHwChunk,TUint32 aCacheAttribs) |
|
2440 { |
2633 { |
2441 DPlatChunkHw* chunk = aHwChunk; |
2634 DPlatChunkHw* chunk = aHwChunk; |
2442 if ((!chunk) || (chunk->iSize < aBuffersize)) |
2635 if ((!chunk) || (chunk->iSize < aBuffersize)) |
2443 { |
2636 { |
2444 if (chunk) |
2637 if (chunk) |
2445 { |
2638 { |
2446 ClosePhysicalChunk(chunk); |
2639 ClosePhysicalChunk(chunk); |
2447 } |
2640 } |
2448 __KTRACE_OPT(KUSB, Kern::Printf("ReAllocate need to get new chunk")); |
2641 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_REALLOCATE, |
2642 "ReAllocate need to get new chunk" ); |
|
2449 chunk = Allocate(aBuffersize, aCacheAttribs); |
2643 chunk = Allocate(aBuffersize, aCacheAttribs); |
2450 } |
2644 } |
2451 return chunk; |
2645 return chunk; |
2452 } |
2646 } |
2453 |
2647 |
2509 TUint32 deviceState; |
2703 TUint32 deviceState; |
2510 if (iStatusFifo->GetDeviceQueuedStatus(deviceState) == KErrNone) |
2704 if (iStatusFifo->GetDeviceQueuedStatus(deviceState) == KErrNone) |
2511 { |
2705 { |
2512 // Device state waiting to be sent userside |
2706 // Device state waiting to be sent userside |
2513 completeNow = ETrue; |
2707 completeNow = ETrue; |
2514 __KTRACE_OPT(KUSB, Kern::Printf("StatusChangeCallback Notify status")); |
2708 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_ALTERNATEDEVICESTATETESTCOMPLETE, |
2709 "StatusChangeCallback Notify status" ); |
|
2515 iStatusChangeReq->Data()=deviceState; |
2710 iStatusChangeReq->Data()=deviceState; |
2516 iStatusChangePtr = NULL; |
2711 iStatusChangePtr = NULL; |
2517 } |
2712 } |
2518 } |
2713 } |
2519 return completeNow; |
2714 return completeNow; |
2526 } |
2721 } |
2527 |
2722 |
2528 |
2723 |
2529 void DLddUsbcChannel::DeConfigure(TInt aErrorCode) |
2724 void DLddUsbcChannel::DeConfigure(TInt aErrorCode) |
2530 { |
2725 { |
2531 __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::DeConfigure()")); |
2726 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DECONFIGURE, |
2727 "DLddUsbcChannel::DeConfigure()" ); |
|
2532 // Called after deconfiguration. Cancels transfers on all endpoints. |
2728 // Called after deconfiguration. Cancels transfers on all endpoints. |
2533 ResetInterface(aErrorCode); |
2729 ResetInterface(aErrorCode); |
2534 // Cancel the endpoint status notify request if it is outstanding. |
2730 // Cancel the endpoint status notify request if it is outstanding. |
2535 const TInt KEpNotReq = RDevUsbcClient::ERequestEndpointStatusNotify; |
2731 const TInt KEpNotReq = RDevUsbcClient::ERequestEndpointStatusNotify; |
2536 if (iRequestStatus[KEpNotReq]) |
2732 if (iRequestStatus[KEpNotReq]) |
2564 if (iValidInterface || iOwnsDeviceControl) |
2760 if (iValidInterface || iOwnsDeviceControl) |
2565 { |
2761 { |
2566 // Reset each endpoint except ep0 |
2762 // Reset each endpoint except ep0 |
2567 for (TInt i = 1; i <= iNumberOfEndpoints; i++) |
2763 for (TInt i = 1; i <= iNumberOfEndpoints; i++) |
2568 { |
2764 { |
2569 __KTRACE_OPT(KUSB, Kern::Printf("Cancelling transfer ep=%d", i)); |
2765 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_RESETINTERFACE, |
2766 "Cancelling transfer ep=%d", i ); |
|
2570 iEndpoint[i]->CancelTransfer(iClient,iClientAsynchNotify[i]->iClientBuffer); // Copies data userside |
2767 iEndpoint[i]->CancelTransfer(iClient,iClientAsynchNotify[i]->iClientBuffer); // Copies data userside |
2571 iEndpoint[i]->AbortTransfer(); // kills any ldd->pil outstanding transfers |
2768 iEndpoint[i]->AbortTransfer(); // kills any ldd->pil outstanding transfers |
2572 iEndpoint[i]->iDmaBuffers->Flush(); |
2769 iEndpoint[i]->iDmaBuffers->Flush(); |
2573 if (iRequestStatus[i] != NULL) |
2770 if (iRequestStatus[i] != NULL) |
2574 CompleteBufferRequest(iClient, i, aErrorCode); |
2771 CompleteBufferRequest(iClient, i, aErrorCode); |
2609 } |
2806 } |
2610 |
2807 |
2611 |
2808 |
2612 TInt DLddUsbcChannel::DoEmergencyComplete() |
2809 TInt DLddUsbcChannel::DoEmergencyComplete() |
2613 { |
2810 { |
2614 __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::DoEmergencyComplete")); |
2811 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOEMERGENCYCOMPLETE, |
2812 "TUsbcEndpoint::DoEmergencyComplete" ); |
|
2615 // cancel any pending DFCs |
2813 // cancel any pending DFCs |
2616 // complete all client requests |
2814 // complete all client requests |
2617 for (TInt i = 0; i < KUsbcMaxRequests; i++) |
2815 for (TInt i = 0; i < KUsbcMaxRequests; i++) |
2618 { |
2816 { |
2619 if (iRequestStatus[i]) |
2817 if (iRequestStatus[i]) |
2620 { |
2818 { |
2621 __KTRACE_OPT(KUSB, Kern::Printf("Complete request 0x%x", iRequestStatus[i])); |
2819 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOEMERGENCYCOMPLETE_DUP1, |
2820 "Complete request 0x%x", iRequestStatus[i] ); |
|
2622 |
2821 |
2623 if (i == RDevUsbcClient::ERequestAlternateDeviceStatusNotify) |
2822 if (i == RDevUsbcClient::ERequestAlternateDeviceStatusNotify) |
2624 { |
2823 { |
2625 |
2824 |
2626 iDeviceStatusNeeded = EFalse; |
2825 iDeviceStatusNeeded = EFalse; |
2722 iRequestCallbackInfo(NULL), |
2921 iRequestCallbackInfo(NULL), |
2723 iBytesTransferred(0), |
2922 iBytesTransferred(0), |
2724 iBandwidthPriority(aBandwidthPriority) |
2923 iBandwidthPriority(aBandwidthPriority) |
2725 { |
2924 { |
2726 ResetTransferInfo(); |
2925 ResetTransferInfo(); |
2727 __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::TUsbcEndpoint 2")); |
2926 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FLOW, TUSBCENDPOINT_TUSBCENDPOINT_CONS, |
2927 "TUsbcEndpoint::TUsbcEndpoint 2" ); |
|
2728 } |
2928 } |
2729 |
2929 |
2730 |
2930 |
2731 TInt TUsbcEndpoint::Construct() |
2931 TInt TUsbcEndpoint::Construct() |
2732 { |
2932 { |
2754 } |
2954 } |
2755 |
2955 |
2756 |
2956 |
2757 TUsbcEndpoint::~TUsbcEndpoint() |
2957 TUsbcEndpoint::~TUsbcEndpoint() |
2758 { |
2958 { |
2759 __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::~TUsbcEndpoint(%d)", iEndpointNumber)); |
2959 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_FLOW, TUSBCENDPOINT_TUSBCENDPOINT_DES, |
2960 "TUsbcEndpoint::~TUsbcEndpoint(%d)", iEndpointNumber ); |
|
2760 AbortTransfer(); |
2961 AbortTransfer(); |
2761 delete iRequestCallbackInfo; |
2962 delete iRequestCallbackInfo; |
2762 delete iDmaBuffers; |
2963 delete iDmaBuffers; |
2763 } |
2964 } |
2764 |
2965 |
2765 |
2966 |
2766 void TUsbcEndpoint::RequestCallback(TAny* aTUsbcEndpoint) |
2967 void TUsbcEndpoint::RequestCallback(TAny* aTUsbcEndpoint) |
2767 { |
2968 { |
2768 __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::RequestCallback")); |
2969 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_REQUESTCALLBACK, |
2970 "TUsbcEndpoint::RequestCallback" ); |
|
2769 ((TUsbcEndpoint*) aTUsbcEndpoint)->EndpointComplete(); |
2971 ((TUsbcEndpoint*) aTUsbcEndpoint)->EndpointComplete(); |
2770 } |
2972 } |
2771 |
2973 |
2772 |
2974 |
2773 void TUsbcEndpoint::SetMaxPacketSize(TInt aSize) |
2975 void TUsbcEndpoint::SetMaxPacketSize(TInt aSize) |
2777 } |
2979 } |
2778 |
2980 |
2779 |
2981 |
2780 TInt TUsbcEndpoint::EndpointComplete() |
2982 TInt TUsbcEndpoint::EndpointComplete() |
2781 { |
2983 { |
2782 __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::EndpointComplete ep=%d %d", |
2984 OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ENDPOINTCOMPLETE, |
2783 iEndpointNumber, iRequestCallbackInfo->iEndpointNum)); |
2985 "TUsbcEndpoint::EndpointComplete ep=%d %d", iEndpointNumber, iRequestCallbackInfo->iEndpointNum ); |
2784 |
2986 |
2785 if (iLdd->ChannelClosing()) |
2987 if (iLdd->ChannelClosing()) |
2786 { |
2988 { |
2787 __KTRACE_OPT(KUSB, Kern::Printf("We're going home -> completions no longer accepted")); |
2989 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ENDPOINTCOMPLETE_DUP1, |
2990 "We're going home -> completions no longer accepted" ); |
|
2788 return KErrNone; |
2991 return KErrNone; |
2789 } |
2992 } |
2790 |
2993 |
2791 TTransferDirection transferDir = iRequestCallbackInfo->iTransferDir; |
2994 TTransferDirection transferDir = iRequestCallbackInfo->iTransferDir; |
2792 TInt error = iRequestCallbackInfo->iError; |
2995 TInt error = iRequestCallbackInfo->iError; |
2794 switch (transferDir) |
2997 switch (transferDir) |
2795 { |
2998 { |
2796 |
2999 |
2797 case EControllerWrite: |
3000 case EControllerWrite: |
2798 { |
3001 { |
2799 __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::EndpointComplete Write 2")); |
3002 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ENDPOINTCOMPLETE_DUP2, |
3003 "TUsbcEndpoint::EndpointComplete Write 2" ); |
|
2800 if (!iDmaBuffers->TxIsActive()) |
3004 if (!iDmaBuffers->TxIsActive()) |
2801 { |
3005 { |
2802 __KTRACE_OPT(KUSB, Kern::Printf(" TX completion but !iDmaBuffers->TxIsActive()")); |
3006 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ENDPOINTCOMPLETE_DUP3, |
3007 " TX completion but !iDmaBuffers->TxIsActive()" ); |
|
2803 break; |
3008 break; |
2804 } |
3009 } |
2805 |
3010 |
2806 iDmaBuffers->TxSetInActive(); |
3011 iDmaBuffers->TxSetInActive(); |
2807 TBool completeNow = EFalse; |
3012 TBool completeNow = EFalse; |
2853 // We queue the dfc if we can complete the read, i.e. if we are reading a packet, |
3058 // We queue the dfc if we can complete the read, i.e. if we are reading a packet, |
2854 // or if we have enough data to satisfy a read data request. |
3059 // or if we have enough data to satisfy a read data request. |
2855 if (iClientReadPending) |
3060 if (iClientReadPending) |
2856 { |
3061 { |
2857 //Complete outstanding read |
3062 //Complete outstanding read |
2858 __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::EndpointComplete Read 3 (bytes " |
3063 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ENDPOINTCOMPLETE_DUP4, |
2859 "available=%d)", iDmaBuffers->RxBytesAvailable())); |
3064 "TUsbcEndpoint::EndpointComplete Read 3 (bytes available=%d)", |
3065 iDmaBuffers->RxBytesAvailable()); |
|
3066 |
|
2860 TInt bytesReqd = iTransferInfo.iTransferSize - iBytesTransferred; |
3067 TInt bytesReqd = iTransferInfo.iTransferSize - iBytesTransferred; |
2861 TBool completeNow = EFalse; |
3068 TBool completeNow = EFalse; |
2862 |
3069 |
2863 if (iTransferInfo.iTransferType == ETransferTypeReadPacket || |
3070 if (iTransferInfo.iTransferType == ETransferTypeReadPacket || |
2864 iTransferInfo.iTransferType == ETransferTypeReadOneOrMore) |
3071 iTransferInfo.iTransferType == ETransferTypeReadOneOrMore) |
2955 TInt err; |
3162 TInt err; |
2956 const TInt length = iTransferInfo.iTransferSize; |
3163 const TInt length = iTransferInfo.iTransferSize; |
2957 const TBool KReadData = EFalse; |
3164 const TBool KReadData = EFalse; |
2958 const TBool KReadUntilShort = ETrue; |
3165 const TBool KReadUntilShort = ETrue; |
2959 |
3166 |
2960 __KTRACE_OPT(KUSB, Kern::Printf("CopyToClient: length = %d", length)); |
3167 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_COPYTOCLIENT, |
3168 "CopyToClient: length = %d", length ); |
|
2961 |
3169 |
2962 if (iTransferInfo.iTransferType == ETransferTypeReadPacket) |
3170 if (iTransferInfo.iTransferType == ETransferTypeReadPacket) |
2963 { |
3171 { |
2964 err = iDmaBuffers->RxCopyPacketToClient(aClient, aTcb, length); |
3172 err = iDmaBuffers->RxCopyPacketToClient(aClient, aTcb, length); |
2965 aCompleteNow = ETrue; |
3173 aCompleteNow = ETrue; |
2991 } |
3199 } |
2992 |
3200 |
2993 |
3201 |
2994 TInt TUsbcEndpoint::TryToStartRead(TBool aReEntrant) |
3202 TInt TUsbcEndpoint::TryToStartRead(TBool aReEntrant) |
2995 { |
3203 { |
2996 __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead 1 ep=%d", iEndpointNumber)); |
3204 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTREAD, |
3205 "TryToStartRead 1 ep=%d", iEndpointNumber ); |
|
2997 TInt r = KErrNone; |
3206 TInt r = KErrNone; |
2998 if (iEndpointInfo.iDir != KUsbEpDirOut && |
3207 if (iEndpointInfo.iDir != KUsbEpDirOut && |
2999 iEndpointInfo.iDir != KUsbEpDirBidirect) |
3208 iEndpointInfo.iDir != KUsbEpDirBidirect) |
3000 { |
3209 { |
3001 // Verify ep direction |
3210 // Verify ep direction |
3002 __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead wrong direction ep=%d", iEndpointNumber)); |
3211 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTREAD_DUP1, |
3212 "TryToStartRead wrong direction ep=%d", iEndpointNumber ); |
|
3003 return KErrUsbEpBadDirection; |
3213 return KErrUsbEpBadDirection; |
3004 } |
3214 } |
3005 |
3215 |
3006 if (iEndpointNumber == 0) |
3216 if (iEndpointNumber == 0) |
3007 { |
3217 { |
3008 // Can't issue an Ep0 read if reader or writer is active |
3218 // Can't issue an Ep0 read if reader or writer is active |
3009 if (iDmaBuffers->TxIsActive()) |
3219 if (iDmaBuffers->TxIsActive()) |
3010 { |
3220 { |
3011 __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead ep0 Tx already active FATAL")); |
3221 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTREAD_DUP2, |
3222 "TryToStartRead ep0 Tx already active FATAL" ); |
|
3223 |
|
3012 return KErrUsbEpNotReady; |
3224 return KErrUsbEpNotReady; |
3013 } |
3225 } |
3014 if (iDmaBuffers->RxIsActive()) |
3226 if (iDmaBuffers->RxIsActive()) |
3015 { |
3227 { |
3016 __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead ep0 Rx already active non-FATAL")); |
3228 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTREAD_DUP3, |
3229 "TryToStartRead ep0 Rx already active non-FATAL" ); |
|
3017 } |
3230 } |
3018 } |
3231 } |
3019 |
3232 |
3020 if (!(iDmaBuffers->RxIsActive())) |
3233 if (!(iDmaBuffers->RxIsActive())) |
3021 { |
3234 { |
3027 r = iDmaBuffers->RxGetNextXfer(bufferAddr, indexArray, sizeArray, length, physAddr); |
3240 r = iDmaBuffers->RxGetNextXfer(bufferAddr, indexArray, sizeArray, length, physAddr); |
3028 if (r == KErrNone) |
3241 if (r == KErrNone) |
3029 { |
3242 { |
3030 iDmaBuffers->RxSetActive(); |
3243 iDmaBuffers->RxSetActive(); |
3031 iRequestCallbackInfo->SetRxBufferInfo(bufferAddr, physAddr, indexArray, sizeArray, length); |
3244 iRequestCallbackInfo->SetRxBufferInfo(bufferAddr, physAddr, indexArray, sizeArray, length); |
3032 |
3245 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTREAD_DUP4, |
3033 __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead 2 bufferAddr=0x%08x", bufferAddr)); |
3246 "TryToStartRead 2 bufferAddr=0x%08x", bufferAddr ); |
3034 |
3247 |
3035 r = iController->SetupReadBuffer(*iRequestCallbackInfo); |
3248 r = iController->SetupReadBuffer(*iRequestCallbackInfo); |
3036 if (r != KErrNone) |
3249 if (r != KErrNone) |
3037 { |
3250 { |
3038 iDmaBuffers->RxSetInActive(); |
3251 iDmaBuffers->RxSetInActive(); |
3039 __KTRACE_OPT(KPANIC, Kern::Printf(" Error: TryToStartRead controller rejects read")); |
3252 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTREAD_DUP5, |
3253 " Error: TryToStartRead controller rejects read" ); |
|
3040 } |
3254 } |
3041 } |
3255 } |
3042 else |
3256 else |
3043 { |
3257 { |
3044 if (iClientReadPending) |
3258 if (iClientReadPending) |
3060 } |
3274 } |
3061 |
3275 |
3062 |
3276 |
3063 TInt TUsbcEndpoint::TryToStartWrite(TEndpointTransferInfo* pTfr) |
3277 TInt TUsbcEndpoint::TryToStartWrite(TEndpointTransferInfo* pTfr) |
3064 { |
3278 { |
3065 __KTRACE_OPT(KUSB, Kern::Printf("TryToStartWrite 1 ep=%d", iEndpointNumber)); |
3279 OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTWRITE, |
3280 "TryToStartWrite 1 ep=%d", iEndpointNumber ); |
|
3066 if (iEndpointInfo.iDir != KUsbEpDirIn && |
3281 if (iEndpointInfo.iDir != KUsbEpDirIn && |
3067 iEndpointInfo.iDir != KUsbEpDirBidirect) |
3282 iEndpointInfo.iDir != KUsbEpDirBidirect) |
3068 { |
3283 { |
3069 // Verify ep direction |
3284 // Verify ep direction |
3070 return KErrUsbEpBadDirection; |
3285 return KErrUsbEpBadDirection; |
3089 } |
3304 } |
3090 |
3305 |
3091 |
3306 |
3092 TInt TUsbcEndpoint::ContinueWrite() |
3307 TInt TUsbcEndpoint::ContinueWrite() |
3093 { |
3308 { |
3094 __KTRACE_OPT(KUSB, Kern::Printf("ContinueWrite 2")); |
3309 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_CONTINUEWRITE, "ContinueWrite 2" ); |
3095 TUint8* bufferAddr; |
3310 TUint8* bufferAddr; |
3096 TPhysAddr physAddr; |
3311 TPhysAddr physAddr; |
3097 TInt bufferLength; |
3312 TInt bufferLength; |
3098 TInt r = iDmaBuffers->TxGetNextXfer(bufferAddr, bufferLength, physAddr); |
3313 TInt r = iDmaBuffers->TxGetNextXfer(bufferAddr, bufferLength, physAddr); |
3099 if (r != KErrNone) // probably already active |
3314 if (r != KErrNone) // probably already active |
3100 return r; |
3315 return r; |
3101 __KTRACE_OPT(KUSB, Kern::Printf("ContinueWrite 3")); |
3316 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_CONTINUEWRITE_DUP1, |
3317 "ContinueWrite 3" ); |
|
3318 |
|
3102 iDmaBuffers->TxSetActive(); |
3319 iDmaBuffers->TxSetActive(); |
3103 TBool zlpReqd = EFalse; |
3320 TBool zlpReqd = EFalse; |
3104 TUint32 transferSize = iTransferInfo.iTransferSize; |
3321 TUint32 transferSize = iTransferInfo.iTransferSize; |
3105 TInt length = Min(transferSize - iBytesTransferred, (TUint32) bufferLength); |
3322 TInt length = Min(transferSize - iBytesTransferred, (TUint32) bufferLength); |
3106 if (iBytesTransferred+length>=transferSize) |
3323 if (iBytesTransferred+length>=transferSize) |
3115 iRequestCallbackInfo->SetTxBufferInfo(bufferAddr, physAddr, length); |
3332 iRequestCallbackInfo->SetTxBufferInfo(bufferAddr, physAddr, length); |
3116 iRequestCallbackInfo->iZlpReqd = zlpReqd; |
3333 iRequestCallbackInfo->iZlpReqd = zlpReqd; |
3117 #if 0 |
3334 #if 0 |
3118 for (TInt i = 0; i < iRequestCallbackInfo->iLength; i++) |
3335 for (TInt i = 0; i < iRequestCallbackInfo->iLength; i++) |
3119 { |
3336 { |
3120 __KTRACE_OPT(KUSB, Kern::Printf("Buffer[%d] = 0x%02x", i, iRequestCallbackInfo->iBufferStart[i])); |
3337 OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_CONTINUEWRITE_DUP2, |
3338 "Buffer[%d] = 0x%02x", i, iRequestCallbackInfo->iBufferStart[i] ); |
|
3339 |
|
3121 } |
3340 } |
3122 #endif |
3341 #endif |
3123 r = iController->SetupWriteBuffer(*iRequestCallbackInfo); |
3342 r = iController->SetupWriteBuffer(*iRequestCallbackInfo); |
3124 return r; |
3343 return r; |
3125 } |
3344 } |
3126 |
3345 |
3127 |
3346 |
3128 void TUsbcEndpoint::CancelTransfer(DThread* aThread, TClientBuffer *aTcb) |
3347 void TUsbcEndpoint::CancelTransfer(DThread* aThread, TClientBuffer *aTcb) |
3129 { |
3348 { |
3130 __KTRACE_OPT(KUSB, Kern::Printf("CancelTransfer")); |
3349 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_CANCELTRANSFER, "CancelTransfer" ); |
3131 if (iDmaBuffers != NULL) |
3350 if (iDmaBuffers != NULL) |
3132 { |
3351 { |
3133 if (iClientWritePending) |
3352 if (iClientWritePending) |
3134 { |
3353 { |
3135 __KTRACE_OPT(KUSB, Kern::Printf(" (iClientWritePending)")); |
3354 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_CANCELTRANSFER_DUP1, |
3355 " (iClientWritePending)" ); |
|
3136 iClientWritePending = EFalse; |
3356 iClientWritePending = EFalse; |
3137 iController->CancelWriteBuffer(iLdd, iRealEpNumber); |
3357 iController->CancelWriteBuffer(iLdd, iRealEpNumber); |
3138 iDmaBuffers->TxSetInActive(); |
3358 iDmaBuffers->TxSetInActive(); |
3139 } |
3359 } |
3140 if (iClientReadPending) |
3360 if (iClientReadPending) |
3141 { |
3361 { |
3142 __KTRACE_OPT(KUSB, Kern::Printf(" (iClientReadPending)")); |
3362 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_CANCELTRANSFER_DUP2, |
3363 " (iClientReadPending)" ); |
|
3143 iClientReadPending = EFalse; |
3364 iClientReadPending = EFalse; |
3144 CopyToClient(aThread,aTcb); |
3365 CopyToClient(aThread,aTcb); |
3145 } |
3366 } |
3146 } |
3367 } |
3147 } |
3368 } |
3148 |
3369 |
3149 |
3370 |
3150 void TUsbcEndpoint::AbortTransfer() |
3371 void TUsbcEndpoint::AbortTransfer() |
3151 { |
3372 { |
3152 __KTRACE_OPT(KUSB, Kern::Printf("Abort Transfer")); |
3373 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ABORTTRANSFER, "Abort Transfer" ); |
3153 if (iDmaBuffers != NULL) |
3374 if (iDmaBuffers != NULL) |
3154 { |
3375 { |
3155 if (iDmaBuffers->TxIsActive()) |
3376 if (iDmaBuffers->TxIsActive()) |
3156 { |
3377 { |
3157 __KTRACE_OPT(KUSB, Kern::Printf(" (iClientWritePending)")); |
3378 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ABORTTRANSFER_DUP1, |
3379 " (iClientWritePending)" ); |
|
3158 iController->CancelWriteBuffer(iLdd, iRealEpNumber); |
3380 iController->CancelWriteBuffer(iLdd, iRealEpNumber); |
3159 iDmaBuffers->TxSetInActive(); |
3381 iDmaBuffers->TxSetInActive(); |
3160 } |
3382 } |
3161 if (iDmaBuffers->RxIsActive()) |
3383 if (iDmaBuffers->RxIsActive()) |
3162 { |
3384 { |
3163 __KTRACE_OPT(KUSB, Kern::Printf(" (iClientReadPending)")); |
3385 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ABORTTRANSFER_DUP2, |
3386 " (iClientReadPending)" ); |
|
3164 iController->CancelReadBuffer(iLdd, iRealEpNumber); |
3387 iController->CancelReadBuffer(iLdd, iRealEpNumber); |
3165 iDmaBuffers->RxSetInActive(); |
3388 iDmaBuffers->RxSetInActive(); |
3166 } |
3389 } |
3167 iRequestCallbackInfo->iDfc.Cancel(); |
3390 iRequestCallbackInfo->iDfc.Cancel(); |
3168 } |
3391 } |
3182 } |
3405 } |
3183 |
3406 |
3184 |
3407 |
3185 TUsbcAlternateSettingList::~TUsbcAlternateSettingList() |
3408 TUsbcAlternateSettingList::~TUsbcAlternateSettingList() |
3186 { |
3409 { |
3187 __KTRACE_OPT(KUSB, Kern::Printf("TUsbcAlternateSettingList::~TUsbcAlternateSettingList()")); |
3410 OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FLOW, TUSBCALTERNATESETTINGLIST_TUSBCALTERNATESETTINGLIST_DES, |
3411 "TUsbcAlternateSettingList::~TUsbcAlternateSettingList()" ); |
|
3188 for (TInt i = 0; i <= KMaxEndpointsPerClient; i++) |
3412 for (TInt i = 0; i <= KMaxEndpointsPerClient; i++) |
3189 { |
3413 { |
3190 delete iEndpoint[i]; |
3414 delete iEndpoint[i]; |
3191 } |
3415 } |
3192 } |
3416 } |