125 iEndpointStatusChangePtr(NULL), |
125 iEndpointStatusChangePtr(NULL), |
126 iEndpointStatusCallbackInfo(this, DLddUsbcChannel::EndpointStatusChangeCallback, |
126 iEndpointStatusCallbackInfo(this, DLddUsbcChannel::EndpointStatusChangeCallback, |
127 KUsbRequestCallbackPriority), |
127 KUsbRequestCallbackPriority), |
128 iOtgFeatureChangePtr(NULL), |
128 iOtgFeatureChangePtr(NULL), |
129 iOtgFeatureCallbackInfo(this, DLddUsbcChannel::OtgFeatureChangeCallback, KUsbRequestCallbackPriority), |
129 iOtgFeatureCallbackInfo(this, DLddUsbcChannel::OtgFeatureChangeCallback, KUsbRequestCallbackPriority), |
|
130 iChargerTypeChangePtr(NULL), |
|
131 iChargerTypeCallbackInfo(this, DLddUsbcChannel::ChargerTypeChangeCallback, KUsbRequestCallbackPriority), |
130 iNumberOfEndpoints(0), |
132 iNumberOfEndpoints(0), |
131 iDeviceState(UsbShai::EUsbPeripheralStateUndefined), |
133 iDeviceState(UsbShai::EUsbPeripheralStateUndefined), |
132 iOwnsDeviceControl(EFalse), |
134 iOwnsDeviceControl(EFalse), |
133 iAlternateSetting(0), |
135 iAlternateSetting(0), |
134 iDeviceStatusNeeded(EFalse), |
136 iDeviceStatusNeeded(EFalse), |
155 { |
157 { |
156 iController->DeRegisterClient(this); |
158 iController->DeRegisterClient(this); |
157 iStatusCallbackInfo.Cancel(); |
159 iStatusCallbackInfo.Cancel(); |
158 iEndpointStatusCallbackInfo.Cancel(); |
160 iEndpointStatusCallbackInfo.Cancel(); |
159 iOtgFeatureCallbackInfo.Cancel(); |
161 iOtgFeatureCallbackInfo.Cancel(); |
|
162 iChargerTypeCallbackInfo.Cancel(); |
160 iCompleteAllCallbackInfo.Cancel(); |
163 iCompleteAllCallbackInfo.Cancel(); |
161 AbortInterface(); |
164 AbortInterface(); |
162 DestroyAllInterfaces(); |
165 DestroyAllInterfaces(); |
163 if (iOwnsDeviceControl) |
166 if (iOwnsDeviceControl) |
164 { |
167 { |
168 DestroyEp0(); |
171 DestroyEp0(); |
169 delete iStatusFifo; |
172 delete iStatusFifo; |
170 Kern::DestroyClientRequest(iStatusChangeReq); |
173 Kern::DestroyClientRequest(iStatusChangeReq); |
171 Kern::DestroyClientRequest(iEndpointStatusChangeReq); |
174 Kern::DestroyClientRequest(iEndpointStatusChangeReq); |
172 Kern::DestroyClientRequest(iOtgFeatureChangeReq); |
175 Kern::DestroyClientRequest(iOtgFeatureChangeReq); |
173 |
176 Kern::DestroyClientRequest(iChargerTypeChangeReq); |
174 Kern::DestroyVirtualPinObject(iPinObj1); |
177 Kern::DestroyVirtualPinObject(iPinObj1); |
175 Kern::DestroyVirtualPinObject(iPinObj2); |
178 Kern::DestroyVirtualPinObject(iPinObj2); |
176 Kern::DestroyVirtualPinObject(iPinObj3); |
179 Kern::DestroyVirtualPinObject(iPinObj3); |
177 |
180 |
178 for (TInt i = 0; i < KUsbcMaxRequests; i++) |
181 for (TInt i = 0; i < KUsbcMaxRequests; i++) |
229 #endif |
232 #endif |
230 iCompleteAllCallbackInfo.SetDfcQ(iDfcQ); |
233 iCompleteAllCallbackInfo.SetDfcQ(iDfcQ); |
231 iStatusCallbackInfo.SetDfcQ(iDfcQ); // use the channel's dfcq for this dfc |
234 iStatusCallbackInfo.SetDfcQ(iDfcQ); // use the channel's dfcq for this dfc |
232 iEndpointStatusCallbackInfo.SetDfcQ(iDfcQ); // use the channel's dfcq for this dfc |
235 iEndpointStatusCallbackInfo.SetDfcQ(iDfcQ); // use the channel's dfcq for this dfc |
233 iOtgFeatureCallbackInfo.SetDfcQ(iDfcQ); |
236 iOtgFeatureCallbackInfo.SetDfcQ(iDfcQ); |
234 iMsgQ.Receive(); //start up the message q |
237 iChargerTypeCallbackInfo.SetDfcQ(iDfcQ); |
235 TInt r = iController->RegisterClientCallback(iCompleteAllCallbackInfo); |
238 iMsgQ.Receive(); //start up the message q |
|
239 TInt r = iController->RegisterClientCallback(iCompleteAllCallbackInfo); |
|
240 if (r != KErrNone) |
|
241 return r; |
|
242 r = iController->RegisterForStatusChange(iStatusCallbackInfo); |
|
243 if (r != KErrNone) |
|
244 return r; |
|
245 r = iController->RegisterForEndpointStatusChange(iEndpointStatusCallbackInfo); |
|
246 if (r != KErrNone) |
|
247 return r; |
|
248 r = iController->RegisterForOtgFeatureChange(iOtgFeatureCallbackInfo); |
|
249 if (r != KErrNone) |
|
250 return r; |
|
251 r = iController->RegisterChargingPortTypeNotify(iChargerTypeCallbackInfo); |
236 if (r != KErrNone) |
252 if (r != KErrNone) |
237 return r; |
253 return r; |
238 r = iController->RegisterForStatusChange(iStatusCallbackInfo); |
254 |
|
255 r = Kern::CreateClientDataRequest(iStatusChangeReq); |
|
256 if (r != KErrNone) |
|
257 return r; |
|
258 r = Kern::CreateClientDataRequest(iEndpointStatusChangeReq); |
|
259 if (r != KErrNone) |
|
260 return r; |
|
261 r = Kern::CreateClientDataRequest(iOtgFeatureChangeReq); |
|
262 if (r != KErrNone) |
|
263 return r; |
|
264 r = Kern::CreateClientDataRequest(iChargerTypeChangeReq); |
239 if (r != KErrNone) |
265 if (r != KErrNone) |
240 return r; |
266 return r; |
241 r = iController->RegisterForEndpointStatusChange(iEndpointStatusCallbackInfo); |
|
242 if (r != KErrNone) |
|
243 return r; |
|
244 r = iController->RegisterForOtgFeatureChange(iOtgFeatureCallbackInfo); |
|
245 if (r != KErrNone) |
|
246 return r; |
|
247 |
|
248 r = Kern::CreateClientDataRequest(iStatusChangeReq); |
|
249 if (r != KErrNone) |
|
250 return r; |
|
251 r = Kern::CreateClientDataRequest(iEndpointStatusChangeReq); |
|
252 if (r != KErrNone) |
|
253 return r; |
|
254 r = Kern::CreateClientDataRequest(iOtgFeatureChangeReq); |
|
255 if (r != KErrNone) |
|
256 return r; |
|
257 |
267 |
258 Kern::CreateVirtualPinObject(iPinObj1); |
268 Kern::CreateVirtualPinObject(iPinObj1); |
259 Kern::CreateVirtualPinObject(iPinObj2); |
269 Kern::CreateVirtualPinObject(iPinObj2); |
260 Kern::CreateVirtualPinObject(iPinObj3); |
270 Kern::CreateVirtualPinObject(iPinObj3); |
261 |
271 |
342 case RDevUsbcClient::ERequestOtgFeaturesNotify: |
352 case RDevUsbcClient::ERequestOtgFeaturesNotify: |
343 iOtgFeatureChangeReq->Reset(); |
353 iOtgFeatureChangeReq->Reset(); |
344 iOtgFeatureChangeReq->SetStatus(aStatus); |
354 iOtgFeatureChangeReq->SetStatus(aStatus); |
345 iOtgFeatureChangeReq->SetDestPtr(a1); |
355 iOtgFeatureChangeReq->SetDestPtr(a1); |
346 break; |
356 break; |
|
357 case RDevUsbcClient::ERequestChargingPortTypeNotify: |
|
358 iChargerTypeChangeReq->Reset(); |
|
359 iChargerTypeChangeReq->SetStatus(aStatus); |
|
360 iChargerTypeChangeReq->SetDestPtr(a1); |
|
361 break; |
347 case RDevUsbcClient::ERequestAlternateDeviceStatusNotify: |
362 case RDevUsbcClient::ERequestAlternateDeviceStatusNotify: |
348 iStatusChangeReq->Reset(); |
363 iStatusChangeReq->Reset(); |
349 iStatusChangeReq->SetStatus(aStatus); |
364 iStatusChangeReq->SetStatus(aStatus); |
350 iStatusChangeReq->SetDestPtr(a1); |
365 iStatusChangeReq->SetDestPtr(a1); |
351 break; |
366 break; |
475 break; |
490 break; |
476 case RDevUsbcClient::ERequestOtgFeaturesNotify: |
491 case RDevUsbcClient::ERequestOtgFeaturesNotify: |
477 iRequestStatus[aReqNo]=NULL; |
492 iRequestStatus[aReqNo]=NULL; |
478 Kern::QueueRequestComplete(iClient,iOtgFeatureChangeReq,r); |
493 Kern::QueueRequestComplete(iClient,iOtgFeatureChangeReq,r); |
479 break; |
494 break; |
|
495 case RDevUsbcClient::ERequestChargingPortTypeNotify: |
|
496 iRequestStatus[aReqNo]=NULL; |
|
497 Kern::QueueRequestComplete(iClient,iChargerTypeChangeReq,r); |
|
498 break; |
480 case RDevUsbcClient::ERequestAlternateDeviceStatusNotify: |
499 case RDevUsbcClient::ERequestAlternateDeviceStatusNotify: |
481 iRequestStatus[aReqNo]=NULL; |
500 iRequestStatus[aReqNo]=NULL; |
482 Kern::QueueRequestComplete(iClient,iStatusChangeReq,r); |
501 Kern::QueueRequestComplete(iClient,iStatusChangeReq,r); |
483 break; |
502 break; |
484 case RDevUsbcClient::ERequestReEnumerate: |
503 case RDevUsbcClient::ERequestReEnumerate: |
552 { |
571 { |
553 __KTRACE_OPT(KUSB, Kern::Printf("ERequestOtgFeaturesNotify")); |
572 __KTRACE_OPT(KUSB, Kern::Printf("ERequestOtgFeaturesNotify")); |
554 if (a1 != NULL) |
573 if (a1 != NULL) |
555 { |
574 { |
556 iOtgFeatureChangePtr = a1; |
575 iOtgFeatureChangePtr = a1; |
|
576 } |
|
577 else |
|
578 r = KErrArgument; |
|
579 break; |
|
580 } |
|
581 case RDevUsbcClient::ERequestChargingPortTypeNotify: |
|
582 { |
|
583 __KTRACE_OPT(KUSB, Kern::Printf("ERequestChargingPortTypeNotify")); |
|
584 if (a1 != NULL) |
|
585 { |
|
586 iChargerTypeChangePtr = a1; |
|
587 aNeedsCompletion = iChargerTypeCallbackInfo.PendingNotify(); |
|
588 if(aNeedsCompletion) |
|
589 { |
|
590 iChargerTypeChangeReq->Data()= iChargerTypeCallbackInfo.ChargerType(); |
|
591 iChargerTypeChangePtr = NULL; |
|
592 iChargerTypeCallbackInfo.SetPendingNotify(EFalse); |
|
593 } |
557 } |
594 } |
558 else |
595 else |
559 r = KErrArgument; |
596 r = KErrArgument; |
560 break; |
597 break; |
561 } |
598 } |
837 { |
874 { |
838 iRequestStatus[aReqNo] = NULL; |
875 iRequestStatus[aReqNo] = NULL; |
839 Kern::QueueRequestComplete(iClient, iOtgFeatureChangeReq, KErrCancel); |
876 Kern::QueueRequestComplete(iClient, iOtgFeatureChangeReq, KErrCancel); |
840 } |
877 } |
841 } |
878 } |
|
879 else if (aReqNo == RDevUsbcClient::ERequestChargingPortTypeNotify) |
|
880 { |
|
881 __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestChargingPortTypeNotify: 0x%x", aReqNo)); |
|
882 CancelNotifyChargerType(); |
|
883 if (iChargerTypeChangeReq->IsReady()) |
|
884 { |
|
885 iRequestStatus[aReqNo] = NULL; |
|
886 Kern::QueueRequestComplete(iClient, iChargerTypeChangeReq, KErrCancel); |
|
887 } |
|
888 } |
842 else |
889 else |
843 { |
890 { |
844 __KTRACE_OPT(KUSB, Kern::Printf("DoCancel Unknown! 0x%x", aReqNo)); |
891 __KTRACE_OPT(KUSB, Kern::Printf("DoCancel Unknown! 0x%x", aReqNo)); |
845 } |
892 } |
846 |
893 |
876 { |
923 { |
877 TUint8 features; |
924 TUint8 features; |
878 iController->GetCurrentOtgFeatures(features); |
925 iController->GetCurrentOtgFeatures(features); |
879 iOtgFeatureChangeReq->Data()=features; |
926 iOtgFeatureChangeReq->Data()=features; |
880 iOtgFeatureChangePtr = NULL; |
927 iOtgFeatureChangePtr = NULL; |
|
928 } |
|
929 } |
|
930 |
|
931 void DLddUsbcChannel::CancelNotifyChargerType() |
|
932 { |
|
933 if (iChargerTypeChangePtr) |
|
934 { |
|
935 TUint chargerType; |
|
936 chargerType = iChargerTypeCallbackInfo.ChargerType(); |
|
937 iChargerTypeChangeReq->Data()=chargerType; |
|
938 iChargerTypeChangePtr = NULL; |
|
939 iChargerTypeCallbackInfo.SetPendingNotify(EFalse); |
881 } |
940 } |
882 } |
941 } |
883 |
942 |
884 TInt DLddUsbcChannel::PinMemory(TDesC8 *aDes, TVirtualPinObject *aPinObj) |
943 TInt DLddUsbcChannel::PinMemory(TDesC8 *aDes, TVirtualPinObject *aPinObj) |
885 { |
944 { |
938 case RDevUsbcClient::EControlGetConfigurationStringDescriptor: |
997 case RDevUsbcClient::EControlGetConfigurationStringDescriptor: |
939 case RDevUsbcClient::EControlSetConfigurationStringDescriptor: |
998 case RDevUsbcClient::EControlSetConfigurationStringDescriptor: |
940 case RDevUsbcClient::EControlSetOtgDescriptor: |
999 case RDevUsbcClient::EControlSetOtgDescriptor: |
941 case RDevUsbcClient::EControlGetOtgDescriptor: |
1000 case RDevUsbcClient::EControlGetOtgDescriptor: |
942 case RDevUsbcClient::EControlGetOtgFeatures: |
1001 case RDevUsbcClient::EControlGetOtgFeatures: |
|
1002 case RDevUsbcClient::EControlGetChargerDetectorCaps: |
943 r=PinMemory((TDesC8 *) a1, iPinObj1); |
1003 r=PinMemory((TDesC8 *) a1, iPinObj1); |
944 if(r!=KErrNone) |
1004 if(r!=KErrNone) |
945 { |
1005 { |
946 PanicClientThread(r); |
1006 PanicClientThread(r); |
947 return r; |
1007 return r; |
1068 case RDevUsbcClient::EControlGetConfigurationStringDescriptor: |
1128 case RDevUsbcClient::EControlGetConfigurationStringDescriptor: |
1069 case RDevUsbcClient::EControlSetConfigurationStringDescriptor: |
1129 case RDevUsbcClient::EControlSetConfigurationStringDescriptor: |
1070 case RDevUsbcClient::EControlSetOtgDescriptor: |
1130 case RDevUsbcClient::EControlSetOtgDescriptor: |
1071 case RDevUsbcClient::EControlGetOtgDescriptor: |
1131 case RDevUsbcClient::EControlGetOtgDescriptor: |
1072 case RDevUsbcClient::EControlGetOtgFeatures: |
1132 case RDevUsbcClient::EControlGetOtgFeatures: |
|
1133 case RDevUsbcClient::EControlGetChargerDetectorCaps: |
1073 if(a1!=NULL) |
1134 if(a1!=NULL) |
1074 { |
1135 { |
1075 Kern::UnpinVirtualMemory(iPinObj1); |
1136 Kern::UnpinVirtualMemory(iPinObj1); |
1076 } |
1137 } |
1077 break; |
1138 break; |
1126 TPtrC8 pZeroDesc(NULL, 0); |
1187 TPtrC8 pZeroDesc(NULL, 0); |
1127 TEndpointDescriptorInfo epInfo; |
1188 TEndpointDescriptorInfo epInfo; |
1128 TUsbcIfcInfo ifcInfo; |
1189 TUsbcIfcInfo ifcInfo; |
1129 TCSDescriptorInfo desInfo; |
1190 TCSDescriptorInfo desInfo; |
1130 TUsbcEndpointResource epRes; |
1191 TUsbcEndpointResource epRes; |
|
1192 TUsbcChargerDetectorProperties chargingPro; |
1131 TInt bandwidthPriority; |
1193 TInt bandwidthPriority; |
1132 |
1194 |
1133 switch (aFunction) |
1195 switch (aFunction) |
1134 { |
1196 { |
1135 case RDevUsbcClient::EControlEndpointZeroRequestError: |
1197 case RDevUsbcClient::EControlEndpointZeroRequestError: |
1512 r = SetInterface((TInt) a1, &ifcInfo); |
1574 r = SetInterface((TInt) a1, &ifcInfo); |
1513 } |
1575 } |
1514 } |
1576 } |
1515 |
1577 |
1516 break; |
1578 break; |
|
1579 |
|
1580 |
|
1581 case RDevUsbcClient::EControlGetChargerDetectorCaps: |
|
1582 __KTRACE_OPT(KUSB, Kern::Printf("EControlGetChargerDetectorCaps")); |
|
1583 iController->ChargerDetectorCaps(chargingPro); |
|
1584 r = Kern::ThreadRawWrite(iClient, a1, &chargingPro, sizeof(chargingPro), iClient); |
|
1585 if (r != KErrNone) |
|
1586 { |
|
1587 PanicClientThread(r); |
|
1588 } |
|
1589 break; |
1517 |
1590 |
1518 case RDevUsbcClient::EControlReleaseInterface: |
1591 case RDevUsbcClient::EControlReleaseInterface: |
1519 __KTRACE_OPT(KUSB, Kern::Printf("EControlReleaseInterface")); |
1592 __KTRACE_OPT(KUSB, Kern::Printf("EControlReleaseInterface")); |
1520 r = iController->ReleaseInterface(this, (TInt) a1); |
1593 r = iController->ReleaseInterface(this, (TInt) a1); |
1521 if (r == KErrNone) |
1594 if (r == KErrNone) |
2244 Kern::QueueRequestComplete(dUsbc->iClient,dUsbc->iOtgFeatureChangeReq,KErrNone); |
2317 Kern::QueueRequestComplete(dUsbc->iClient,dUsbc->iOtgFeatureChangeReq,KErrNone); |
2245 dUsbc->iOtgFeatureChangePtr = NULL; |
2318 dUsbc->iOtgFeatureChangePtr = NULL; |
2246 } |
2319 } |
2247 } |
2320 } |
2248 |
2321 |
|
2322 void DLddUsbcChannel::ChargerTypeChangeCallback(TAny* aDLddUsbcChannel) |
|
2323 { |
|
2324 __KTRACE_OPT(KUSB, Kern::Printf("ChargerTypeChangeCallback")); |
|
2325 DLddUsbcChannel* dUsbc = (DLddUsbcChannel*) aDLddUsbcChannel; |
|
2326 if (dUsbc->iChannelClosing) |
|
2327 return; |
|
2328 const TInt reqNo = (TInt) RDevUsbcClient::ERequestChargingPortTypeNotify; |
|
2329 if (dUsbc->iRequestStatus[reqNo]) |
|
2330 { |
|
2331 __KTRACE_OPT(KUSB, Kern::Printf("ChargerTypeChangeCallback Notify status")); |
|
2332 Kern::Printf("ChargerTypeChangeCallback Notify status"); |
|
2333 TUint chargerType; |
|
2334 chargerType = dUsbc->iChargerTypeCallbackInfo.ChargerType(); |
|
2335 dUsbc->iChargerTypeChangeReq->Data()=chargerType; |
|
2336 dUsbc->iRequestStatus[reqNo] = NULL; |
|
2337 Kern::QueueRequestComplete(dUsbc->iClient,dUsbc->iChargerTypeChangeReq,KErrNone); |
|
2338 dUsbc->iChargerTypeChangePtr = NULL; |
|
2339 dUsbc->iChargerTypeCallbackInfo.SetPendingNotify(EFalse); |
|
2340 } |
|
2341 else |
|
2342 { |
|
2343 Kern::Printf("ChargerTypeChangeCallback Set pending notify"); |
|
2344 __KTRACE_OPT(KUSB, Kern::Printf("ChargerTypeChangeCallback Set pending notify")); |
|
2345 dUsbc->iChargerTypeCallbackInfo.SetPendingNotify(ETrue); |
|
2346 } |
|
2347 } |
2249 |
2348 |
2250 TInt DLddUsbcChannel::SelectAlternateSetting(TUint aAlternateSetting) |
2349 TInt DLddUsbcChannel::SelectAlternateSetting(TUint aAlternateSetting) |
2251 { |
2350 { |
2252 TInt r = KErrGeneral; // error code doesn't go userside |
2351 TInt r = KErrGeneral; // error code doesn't go userside |
2253 TUsbcAlternateSettingList* alternateSettingListRec = iAlternateSettingList; |
2352 TUsbcAlternateSettingList* alternateSettingListRec = iAlternateSettingList; |
2658 Kern::QueueRequestComplete(iClient, iOtgFeatureChangeReq, |
2757 Kern::QueueRequestComplete(iClient, iOtgFeatureChangeReq, |
2659 KErrDisconnected); |
2758 KErrDisconnected); |
2660 } |
2759 } |
2661 |
2760 |
2662 } |
2761 } |
|
2762 else if (i == RDevUsbcClient::ERequestChargingPortTypeNotify) |
|
2763 { |
|
2764 |
|
2765 if (iChargerTypeChangePtr) |
|
2766 { |
|
2767 TUint chargerType; |
|
2768 chargerType = iChargerTypeCallbackInfo.ChargerType(); |
|
2769 iChargerTypeChangeReq->Data()=chargerType; |
|
2770 iChargerTypeChangePtr = NULL; |
|
2771 } |
|
2772 |
|
2773 if (iChargerTypeChangeReq->IsReady()) |
|
2774 { |
|
2775 iRequestStatus[i] = NULL; |
|
2776 Kern::QueueRequestComplete(iClient, iChargerTypeChangeReq, |
|
2777 KErrDisconnected); |
|
2778 } |
|
2779 |
|
2780 } |
2663 else |
2781 else |
2664 { |
2782 { |
2665 CompleteBufferRequest(iClient, i, KErrDisconnected); |
2783 CompleteBufferRequest(iClient, i, KErrDisconnected); |
2666 } |
2784 } |
2667 |
2785 |
2669 } |
2787 } |
2670 |
2788 |
2671 iStatusCallbackInfo.Cancel(); |
2789 iStatusCallbackInfo.Cancel(); |
2672 iEndpointStatusCallbackInfo.Cancel(); |
2790 iEndpointStatusCallbackInfo.Cancel(); |
2673 iOtgFeatureCallbackInfo.Cancel(); |
2791 iOtgFeatureCallbackInfo.Cancel(); |
2674 return KErrNone; |
2792 iChargerTypeCallbackInfo.Cancel(); |
2675 } |
2793 return KErrNone; |
|
2794 } |
2676 |
2795 |
2677 |
2796 |
2678 void DLddUsbcChannel::PanicClientThread(TInt aReason) |
2797 void DLddUsbcChannel::PanicClientThread(TInt aReason) |
2679 { |
2798 { |
2680 Kern::ThreadKill(iClient, EExitPanic, aReason, KUsbLDDKillCat); |
2799 Kern::ThreadKill(iClient, EExitPanic, aReason, KUsbLDDKillCat); |