diff -r 613028a7da24 -r eaaed528d5fd usbdrv/peripheral/ldd/perildd/src/d_usbc.cpp
--- a/usbdrv/peripheral/ldd/perildd/src/d_usbc.cpp	Thu Sep 02 22:23:37 2010 +0300
+++ b/usbdrv/peripheral/ldd/perildd/src/d_usbc.cpp	Fri Sep 17 08:40:15 2010 +0300
@@ -127,6 +127,8 @@
                                   KUsbRequestCallbackPriority),
       iOtgFeatureChangePtr(NULL),
       iOtgFeatureCallbackInfo(this, DLddUsbcChannel::OtgFeatureChangeCallback, KUsbRequestCallbackPriority),
+      iChargerTypeChangePtr(NULL),
+      iChargerTypeCallbackInfo(this, DLddUsbcChannel::ChargerTypeChangeCallback, KUsbRequestCallbackPriority),
       iNumberOfEndpoints(0),
       iDeviceState(UsbShai::EUsbPeripheralStateUndefined),
       iOwnsDeviceControl(EFalse),
@@ -157,6 +159,7 @@
         iStatusCallbackInfo.Cancel();
         iEndpointStatusCallbackInfo.Cancel();
         iOtgFeatureCallbackInfo.Cancel();
+        iChargerTypeCallbackInfo.Cancel();
         iCompleteAllCallbackInfo.Cancel();
         AbortInterface();
         DestroyAllInterfaces();
@@ -170,7 +173,7 @@
         Kern::DestroyClientRequest(iStatusChangeReq);
         Kern::DestroyClientRequest(iEndpointStatusChangeReq);
         Kern::DestroyClientRequest(iOtgFeatureChangeReq);
-
+        Kern::DestroyClientRequest(iChargerTypeChangeReq);
         Kern::DestroyVirtualPinObject(iPinObj1);
         Kern::DestroyVirtualPinObject(iPinObj2);
         Kern::DestroyVirtualPinObject(iPinObj3);
@@ -231,29 +234,36 @@
     iStatusCallbackInfo.SetDfcQ(iDfcQ);                        // use the channel's dfcq for this dfc
     iEndpointStatusCallbackInfo.SetDfcQ(iDfcQ);                // use the channel's dfcq for this dfc
     iOtgFeatureCallbackInfo.SetDfcQ(iDfcQ);
-    iMsgQ.Receive();                                        //start up the message q
-    TInt r = iController->RegisterClientCallback(iCompleteAllCallbackInfo);
-    if (r != KErrNone)
-        return r;
-    r = iController->RegisterForStatusChange(iStatusCallbackInfo);
-    if (r != KErrNone)
-        return r;
-    r = iController->RegisterForEndpointStatusChange(iEndpointStatusCallbackInfo);
-    if (r != KErrNone)
-        return r;
-    r = iController->RegisterForOtgFeatureChange(iOtgFeatureCallbackInfo);
+    iChargerTypeCallbackInfo.SetDfcQ(iDfcQ);
+	iMsgQ.Receive();										//start up the message q
+	TInt r = iController->RegisterClientCallback(iCompleteAllCallbackInfo);
+	if (r != KErrNone)
+		return r;
+	r = iController->RegisterForStatusChange(iStatusCallbackInfo);
+	if (r != KErrNone)
+		return r;
+	r = iController->RegisterForEndpointStatusChange(iEndpointStatusCallbackInfo);
+	if (r != KErrNone)
+		return r;
+	r = iController->RegisterForOtgFeatureChange(iOtgFeatureCallbackInfo);
+	if (r != KErrNone)
+		return r;	
+    r = iController->RegisterChargingPortTypeNotify(iChargerTypeCallbackInfo);
     if (r != KErrNone)
-        return r;
-
-    r = Kern::CreateClientDataRequest(iStatusChangeReq);
+        return r;	
+	
+	r = Kern::CreateClientDataRequest(iStatusChangeReq);
+	if (r != KErrNone)
+		return r;
+	r = Kern::CreateClientDataRequest(iEndpointStatusChangeReq);
+	if (r != KErrNone)
+		return r;
+	r = Kern::CreateClientDataRequest(iOtgFeatureChangeReq);
+	if (r != KErrNone)
+		return r;
+    r = Kern::CreateClientDataRequest(iChargerTypeChangeReq);
     if (r != KErrNone)
-        return r;
-    r = Kern::CreateClientDataRequest(iEndpointStatusChangeReq);
-    if (r != KErrNone)
-        return r;
-    r = Kern::CreateClientDataRequest(iOtgFeatureChangeReq);
-    if (r != KErrNone)
-        return r;
+        return r;	
     
     Kern::CreateVirtualPinObject(iPinObj1);
     Kern::CreateVirtualPinObject(iPinObj2);
@@ -344,6 +354,11 @@
                 iOtgFeatureChangeReq->SetStatus(aStatus);
                 iOtgFeatureChangeReq->SetDestPtr(a1);
             break;
+            case RDevUsbcClient::ERequestChargingPortTypeNotify:
+                iChargerTypeChangeReq->Reset();
+                iChargerTypeChangeReq->SetStatus(aStatus);
+                iChargerTypeChangeReq->SetDestPtr(a1);
+            break;	
             case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:
                 iStatusChangeReq->Reset();
                 iStatusChangeReq->SetStatus(aStatus);
@@ -477,6 +492,10 @@
                             iRequestStatus[aReqNo]=NULL;
                             Kern::QueueRequestComplete(iClient,iOtgFeatureChangeReq,r);
                         break;
+                        case RDevUsbcClient::ERequestChargingPortTypeNotify:
+                            iRequestStatus[aReqNo]=NULL;
+                            Kern::QueueRequestComplete(iClient,iChargerTypeChangeReq,r);
+                        break;
                         case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:
                             iRequestStatus[aReqNo]=NULL;
                             Kern::QueueRequestComplete(iClient,iStatusChangeReq,r);
@@ -559,6 +578,24 @@
             r = KErrArgument;
         break;
         }
+    case RDevUsbcClient::ERequestChargingPortTypeNotify:
+        {
+        __KTRACE_OPT(KUSB, Kern::Printf("ERequestChargingPortTypeNotify"));
+        if (a1 != NULL)
+            {
+            iChargerTypeChangePtr = a1;         
+            aNeedsCompletion = iChargerTypeCallbackInfo.PendingNotify();
+            if(aNeedsCompletion)
+                {
+                iChargerTypeChangeReq->Data()= iChargerTypeCallbackInfo.ChargerType();
+                iChargerTypeChangePtr = NULL;
+                iChargerTypeCallbackInfo.SetPendingNotify(EFalse);
+                }
+            }
+        else
+            r = KErrArgument;
+        break;
+        }
     default:
         r = KErrNotSupported;
         }
@@ -839,6 +876,16 @@
             Kern::QueueRequestComplete(iClient, iOtgFeatureChangeReq, KErrCancel);
             }
         }
+    else if (aReqNo == RDevUsbcClient::ERequestChargingPortTypeNotify)
+        {
+        __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestChargingPortTypeNotify: 0x%x", aReqNo));
+        CancelNotifyChargerType();
+        if (iChargerTypeChangeReq->IsReady())
+            {
+            iRequestStatus[aReqNo] = NULL;
+            Kern::QueueRequestComplete(iClient, iChargerTypeChangeReq, KErrCancel);
+            }
+        }
     else
         {
         __KTRACE_OPT(KUSB, Kern::Printf("DoCancel Unknown! 0x%x", aReqNo));
@@ -881,6 +928,18 @@
         }
     }
 
+void DLddUsbcChannel::CancelNotifyChargerType()
+    {
+    if (iChargerTypeChangePtr)
+        {
+        TUint chargerType;
+        chargerType = iChargerTypeCallbackInfo.ChargerType();
+        iChargerTypeChangeReq->Data()=chargerType;
+        iChargerTypeChangePtr = NULL;
+        iChargerTypeCallbackInfo.SetPendingNotify(EFalse);
+        }
+    }
+
 TInt DLddUsbcChannel::PinMemory(TDesC8 *aDes, TVirtualPinObject *aPinObj)
     {
     TInt r = KErrNone;
@@ -940,6 +999,7 @@
     case RDevUsbcClient::EControlSetOtgDescriptor:
     case RDevUsbcClient::EControlGetOtgDescriptor:
     case RDevUsbcClient::EControlGetOtgFeatures:
+    case RDevUsbcClient::EControlGetChargerDetectorCaps:
         r=PinMemory((TDesC8 *) a1, iPinObj1);
         if(r!=KErrNone)
             {
@@ -1070,6 +1130,7 @@
     case RDevUsbcClient::EControlSetOtgDescriptor:
     case RDevUsbcClient::EControlGetOtgDescriptor:
     case RDevUsbcClient::EControlGetOtgFeatures:
+    case RDevUsbcClient::EControlGetChargerDetectorCaps:		
         if(a1!=NULL)
             {
             Kern::UnpinVirtualMemory(iPinObj1);
@@ -1128,6 +1189,7 @@
     TUsbcIfcInfo ifcInfo;
     TCSDescriptorInfo desInfo;
     TUsbcEndpointResource epRes;
+	TUsbcChargerDetectorProperties chargingPro;	
     TInt bandwidthPriority;
 
     switch (aFunction)
@@ -1514,6 +1576,17 @@
             }
             
         break;
+		
+
+    case RDevUsbcClient::EControlGetChargerDetectorCaps:
+        __KTRACE_OPT(KUSB, Kern::Printf("EControlGetChargerDetectorCaps"));
+		iController->ChargerDetectorCaps(chargingPro);          		
+        r = Kern::ThreadRawWrite(iClient, a1, &chargingPro, sizeof(chargingPro), iClient);
+        if (r != KErrNone)
+        	{
+            PanicClientThread(r);
+            }
+        break;		
 
     case RDevUsbcClient::EControlReleaseInterface:
         __KTRACE_OPT(KUSB, Kern::Printf("EControlReleaseInterface"));
@@ -2246,6 +2319,32 @@
         }
     }
 
+void DLddUsbcChannel::ChargerTypeChangeCallback(TAny* aDLddUsbcChannel)
+    {
+    __KTRACE_OPT(KUSB, Kern::Printf("ChargerTypeChangeCallback"));
+    DLddUsbcChannel* dUsbc = (DLddUsbcChannel*) aDLddUsbcChannel;
+    if (dUsbc->iChannelClosing)
+        return;   
+    const TInt reqNo = (TInt) RDevUsbcClient::ERequestChargingPortTypeNotify;
+    if (dUsbc->iRequestStatus[reqNo])
+        {
+        __KTRACE_OPT(KUSB, Kern::Printf("ChargerTypeChangeCallback Notify status"));        
+        Kern::Printf("ChargerTypeChangeCallback Notify status");        
+        TUint chargerType;
+        chargerType = dUsbc->iChargerTypeCallbackInfo.ChargerType();
+        dUsbc->iChargerTypeChangeReq->Data()=chargerType;
+        dUsbc->iRequestStatus[reqNo] = NULL;
+        Kern::QueueRequestComplete(dUsbc->iClient,dUsbc->iChargerTypeChangeReq,KErrNone);
+        dUsbc->iChargerTypeChangePtr = NULL;
+        dUsbc->iChargerTypeCallbackInfo.SetPendingNotify(EFalse);
+        }    
+    else
+        {
+        Kern::Printf("ChargerTypeChangeCallback Set pending notify");
+        __KTRACE_OPT(KUSB, Kern::Printf("ChargerTypeChangeCallback Set pending notify"));
+        dUsbc->iChargerTypeCallbackInfo.SetPendingNotify(ETrue);
+        }
+    }
 
 TInt DLddUsbcChannel::SelectAlternateSetting(TUint aAlternateSetting)
     {
@@ -2660,6 +2759,25 @@
                     }
 
                 }
+	        else if (i == RDevUsbcClient::ERequestChargingPortTypeNotify)
+	                {
+	                    
+	                if (iChargerTypeChangePtr)
+	                    {
+				        TUint chargerType;
+				        chargerType = iChargerTypeCallbackInfo.ChargerType();
+				        iChargerTypeChangeReq->Data()=chargerType;
+						iChargerTypeChangePtr = NULL;
+	                    }
+	                    
+	                if (iChargerTypeChangeReq->IsReady())
+	                    {
+	                    iRequestStatus[i] = NULL;
+	                    Kern::QueueRequestComplete(iClient, iChargerTypeChangeReq,
+	                            KErrDisconnected);
+	                    }
+
+	                }			
             else
                 {
                 CompleteBufferRequest(iClient, i, KErrDisconnected);
@@ -2671,8 +2789,9 @@
     iStatusCallbackInfo.Cancel();
     iEndpointStatusCallbackInfo.Cancel();
     iOtgFeatureCallbackInfo.Cancel();
-    return KErrNone;
-    }
+    iChargerTypeCallbackInfo.Cancel();
+	return KErrNone;
+	}
 
 
 void DLddUsbcChannel::PanicClientThread(TInt aReason)