diff -r c1f20ce4abcf -r 3e88ff8f41d5 kernel/eka/drivers/usbc/d_usbc.cpp --- a/kernel/eka/drivers/usbc/d_usbc.cpp Tue Aug 31 16:34:26 2010 +0300 +++ b/kernel/eka/drivers/usbc/d_usbc.cpp Wed Sep 01 12:34:56 2010 +0100 @@ -1,4 +1,4 @@ -// Copyright (c) 2000-2010 Nokia Corporation and/or its subsidiary(-ies). +// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies). // All rights reserved. // This component and the accompanying materials are made available // under the terms of the License "Eclipse Public License v1.0" @@ -23,11 +23,6 @@ */ #include -#include "OstTraceDefinitions.h" -#ifdef OST_TRACE_COMPILER_IN_USE -#include "d_usbcTraces.h" -#endif - _LIT(KUsbLddName, "Usbc"); @@ -100,9 +95,7 @@ // Only proceed if we have the Controller underneath us if (!DUsbClientController::UsbcControllerPointer()) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DUSBCLOGDEVICE_INSTALL, - "LDD Install: USB Controller Not Present" ); - + __KTRACE_OPT(KPANIC, Kern::Printf("LDD Install: USB Controller Not Present")); return KErrGeneral; } return SetName(&KUsbLddName); @@ -141,9 +134,7 @@ iDeviceStatusNeeded(EFalse), iChannelClosing(EFalse) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FLOW, DLDDUSBCCHANNEL_DLDDUSBCCHANNEL_CONS, - "*** DLddUsbcChannel::DLddUsbcChannel CTOR" ); - + __KTRACE_OPT(KUSB, Kern::Printf("*** DLddUsbcChannel::DLddUsbcChannel CTOR")); iClient = &Kern::CurrentThread(); iClient->Open(); for (TInt i = 1; i <= KMaxEndpointsPerClient; i++) @@ -159,9 +150,7 @@ DLddUsbcChannel::~DLddUsbcChannel() { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FLOW, DLDDUSBCCHANNEL_DLDDUSBCCHANNEL_DES, - "DLddUsbcChannel::~DLddUsbcChannel()" ); - + __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::~DLddUsbcChannel()")); if (iController) { iController->DeRegisterClient(this); @@ -207,9 +196,8 @@ // TInt DLddUsbcChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer) { - OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCREATE, - "LDD DoCreateL 1 Ver = %02d %02d %02d", aVer.iMajor, aVer.iMinor, aVer.iBuild ); - + __KTRACE_OPT(KUSB, Kern::Printf("LDD DoCreateL 1 Ver = %02d %02d %02d", + aVer.iMajor, aVer.iMinor, aVer.iBuild)); if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD, __PLATSEC_DIAGNOSTIC_STRING("Checked by USBC.LDD (USB Driver)"))) { @@ -439,8 +427,7 @@ // TInt DLddUsbcChannel::RequestUserHandle(DThread* aThread, TOwnerType /*aType*/) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_REQUESTUSERHANDLE, - "DLddUsbcChannel::RequestUserHandle" ); + __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::RequestUserHandle")); // The USB client LDD is not designed for a channel to be shared between // threads. It saves a pointer to the current thread when it is opened, and // uses this to complete any asynchronous requests. @@ -463,8 +450,7 @@ void DLddUsbcChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2) { // Check on request status - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOREQUEST, - "DoRequest 0x%08x", aReqNo ); + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest 0x%08x", aReqNo)); TInt r = KErrNone; if (iRequestStatus[aReqNo] != NULL) { @@ -533,8 +519,7 @@ { case RDevUsbcClient::ERequestAlternateDeviceStatusNotify: { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOOTHERASYNCREQ, - "EControlReqDeviceStatusNotify" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlReqDeviceStatusNotify")); if (a1 != NULL) { iDeviceStatusNeeded = ETrue; @@ -547,16 +532,14 @@ } case RDevUsbcClient::ERequestReEnumerate: { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOOTHERASYNCREQ_DUP1, - "ERequestReEnumerate" ); + __KTRACE_OPT(KUSB, Kern::Printf("ERequestReEnumerate")); // If successful, this will complete via the status notification. r = iController->ReEnumerate(); break; } case RDevUsbcClient::ERequestEndpointStatusNotify: { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOOTHERASYNCREQ_DUP2, - "ERequestEndpointStatusNotify" ); + __KTRACE_OPT(KUSB, Kern::Printf("ERequestEndpointStatusNotify")); if (a1 != NULL) { iEndpointStatusChangePtr = a1; @@ -567,8 +550,7 @@ } case RDevUsbcClient::ERequestOtgFeaturesNotify: { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOOTHERASYNCREQ_DUP3, - "ERequestOtgFeaturesNotify" ); + __KTRACE_OPT(KUSB, Kern::Printf("ERequestOtgFeaturesNotify")); if (a1 != NULL) { iOtgFeatureChangePtr = a1; @@ -607,8 +589,7 @@ // ep0 requests if (!(iValidInterface || iOwnsDeviceControl)) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ, - "DoRequest rejected: not configured (Ep0)" ); + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest rejected: not configured (Ep0)")); r = KErrUsbInterfaceNotReady; goto exit; } @@ -620,8 +601,7 @@ iDeviceState == EUsbcDeviceStateSuspended)) ) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP1, - "DoRequest rejected not configured (Ep %d)", aEndpointNum ); + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest rejected not configured (Ep %d)", aEndpointNum)); r = KErrUsbInterfaceNotReady; goto exit; } @@ -629,8 +609,7 @@ if (!ValidEndpoint(aEndpointNum)) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP2, - " Error: DoRequest Read: in error complete" ); + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Read: in error complete")); r = KErrUsbEpNotInInterface; goto exit; } @@ -650,15 +629,13 @@ pEndpoint = iEndpoint[aEndpointNum]; if (!pEndpoint) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP3, - " Error: DoRequest Read: in error complete" ); + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Read: in error complete")); r = KErrUsbEpNotInInterface; goto exit; } pEndpointInfo = pEndpoint->EndpointInfo(); - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP4, - "DoRequest %d", aEndpointNum ); + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest %d", aEndpointNum)); switch (pTfr->iTransferType) { @@ -668,25 +645,21 @@ case ETransferTypeReadUntilShort: case ETransferTypeReadOneOrMore: { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP5, - "DoRequest Read" ); + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read")); if (pEndpoint->iDmaBuffers->RxIsActive()) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP6, - "**** ReadReq ep%d RxActive", aEndpointNum ); + __KTRACE_OPT(KUSB, Kern::Printf("**** ReadReq ep%d RxActive", aEndpointNum)); } else { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP7, - "**** ReadReq ep%d RxInActive", aEndpointNum ); + __KTRACE_OPT(KUSB, Kern::Printf("**** ReadReq ep%d RxInActive", aEndpointNum)); } if (pEndpointInfo->iDir != KUsbEpDirOut && pEndpointInfo->iDir != KUsbEpDirBidirect) { // Trying to do the wrong thing - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP8, - " Error: DoRequest Read: in error complete" ); + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Read: in error complete")); r = KErrUsbEpBadDirection; break; } @@ -704,8 +677,7 @@ { if (pTfr->iTransferType == ETransferTypeReadPacket) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP9, - "DoRequest Read packet: data available complete" ); + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read packet: data available complete")); r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer); aNeedsCompletion = ETrue; break; @@ -714,8 +686,7 @@ { if (pTfr->iTransferSize <= pEndpoint->RxBytesAvailable()) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP10, - "DoRequest Read data: data available complete"); + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read data: data available complete")); r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer); aNeedsCompletion = ETrue; break; @@ -729,8 +700,7 @@ { if (pEndpoint->RxBytesAvailable() > 0) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP11, - "DoRequest Read data: data available complete" ); + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read data: data available complete")); r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer); aNeedsCompletion = ETrue; break; @@ -748,9 +718,7 @@ (nRx < maxPacketSize) || pEndpoint->iDmaBuffers->ShortPacketExists()) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP12, - "DoRequest Read data: data available complete" ); - + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read data: data available complete")); r = pEndpoint->CopyToClient(iClient,iClientAsynchNotify[aEndpointNum]->iClientBuffer); aNeedsCompletion = ETrue; } @@ -763,9 +731,7 @@ r = pEndpoint->TryToStartRead(EFalse); if (r != KErrNone) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP13, - "DoRequest Read: couldn't start read" ); - + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Read: couldn't start read")); r = KErrNone; // Reader full isn't a userside error; } break; @@ -773,48 +739,42 @@ case ETransferTypeWrite: { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP14, - "DoRequest Write 1" ); + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Write 1")); if (pEndpointInfo->iDir != KUsbEpDirIn && pEndpointInfo->iDir != KUsbEpDirBidirect) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP15, - " Error: DoRequest Write: wrong direction complete" ); + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Write: wrong direction complete")); r = KErrUsbEpBadDirection; break; } - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP16, - "DoRequest Write 2" ); + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Write 2")); TInt desLength=iClientAsynchNotify[aEndpointNum]->iClientBuffer->Length(); if (desLength < pTfr->iTransferSize) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP17, - " Error: DoRequest Write: user buffer too short" ); + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Write: user buffer too short")); r = KErrUsbTransferSize; break; } - OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP18, - "DoRequest Write 3 length=%d maxlength=%d", pTfr->iTransferSize, desLength); + __KTRACE_OPT(KUSB, Kern::Printf("DoRequest Write 3 length=%d maxlength=%d", + pTfr->iTransferSize, desLength)); // Zero length writes are acceptable pEndpoint->SetClientWritePending(ETrue); r = pEndpoint->TryToStartWrite(pTfr); if (r != KErrNone) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP19, - " Error: DoRequest Write: couldn't start write" ); + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoRequest Write: couldn't start write")); pEndpoint->SetClientWritePending(EFalse); } break; } default: - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOTRANSFERASYNCREQ_DUP20, - " Error: DoTransferAsyncReq: pTfr->iTransferType = %d not supported", pTfr->iTransferType); - + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: DoTransferAsyncReq: pTfr->iTransferType = %d not supported", + pTfr->iTransferType)); r = KErrNotSupported; break; } @@ -830,20 +790,15 @@ TInt DLddUsbcChannel::DoCancel(TInt aReqNo) { TInt r = KErrNone; - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL, - "DoCancel: 0x%x", aReqNo ); + __KTRACE_OPT(KUSB, Kern::Printf("DoCancel: 0x%x", aReqNo)); if (aReqNo <= iNumberOfEndpoints) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL_DUP1, - "DoCancel endpoint: 0x%x", aReqNo ); - + __KTRACE_OPT(KUSB, Kern::Printf("DoCancel endpoint: 0x%x", aReqNo)); iEndpoint[aReqNo]->CancelTransfer(iClient,iClientAsynchNotify[aReqNo]->iClientBuffer); } else if (aReqNo == RDevUsbcClient::ERequestAlternateDeviceStatusNotify) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL_DUP2, - "DoCancel: ERequestAlternateDeviceStatusNotify 0x%x", aReqNo ); - + __KTRACE_OPT(KUSB, Kern::Printf("DoCancel: ERequestAlternateDeviceStatusNotify 0x%x", aReqNo)); iDeviceStatusNeeded = EFalse; iStatusFifo->FlushQueue(); if (iStatusChangePtr) @@ -861,15 +816,11 @@ } else if (aReqNo == RDevUsbcClient::ERequestReEnumerate) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL_DUP3, - "DoCancel ERequestReEnumerate: 0x%x", aReqNo ); - + __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestReEnumerate: 0x%x", aReqNo)); } else if (aReqNo == RDevUsbcClient::ERequestEndpointStatusNotify) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL_DUP4, - "DoCancel ERequestEndpointStatusNotify: 0x%x", aReqNo ); - + __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestEndpointStatusNotify: 0x%x", aReqNo)); CancelNotifyEndpointStatus(); if (iEndpointStatusChangeReq->IsReady()) { @@ -880,9 +831,7 @@ } else if (aReqNo == RDevUsbcClient::ERequestOtgFeaturesNotify) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL_DUP5, - "DoCancel ERequestOtgFeaturesNotify: 0x%x", aReqNo ); - + __KTRACE_OPT(KUSB, Kern::Printf("DoCancel ERequestOtgFeaturesNotify: 0x%x", aReqNo)); CancelNotifyOtgFeatures(); if (iOtgFeatureChangeReq->IsReady()) { @@ -892,9 +841,7 @@ } else { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCANCEL_DUP6, - "DoCancel Unknown! 0x%x", aReqNo ); - + __KTRACE_OPT(KUSB, Kern::Printf("DoCancel Unknown! 0x%x", aReqNo)); } if (r == KErrNone) @@ -1171,8 +1118,7 @@ TInt DLddUsbcChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL, - "DoControl: %d", aFunction ); + __KTRACE_OPT(KUSB, Kern::Printf("DoControl: %d", aFunction)); TInt r = KErrNone; TInt ep; @@ -1187,9 +1133,7 @@ switch (aFunction) { case RDevUsbcClient::EControlEndpointZeroRequestError: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP1, - "EControlEndpointZeroRequestError" ); - + __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointZeroRequestError")); r = KErrNone; if (iOwnsDeviceControl || (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured)) { @@ -1205,9 +1149,7 @@ break; case RDevUsbcClient::EControlGetAlternateSetting: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP2, - "EControlGetAlternateSetting" ); - + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetAlternateSetting")); if (iValidInterface && iDeviceState == EUsbcDeviceStateConfigured) { r = iController->GetInterfaceNumber(this, *(TInt*)a1); @@ -1222,16 +1164,12 @@ break; case RDevUsbcClient::EControlDeviceStatus: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP3, - "EControlDeviceStatus" ); - + __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceStatus")); *(TInt*)a1 = iController->GetDeviceStatus(); break; case RDevUsbcClient::EControlEndpointStatus: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP4, - "EControlEndpointStatus" ); - + __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointStatus")); if (iValidInterface && ValidEndpoint((TInt) a1)) { pEndpoint = iEndpoint[(TInt)a1]; @@ -1252,9 +1190,7 @@ break; case RDevUsbcClient::EControlQueryReceiveBuffer: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP5, - "EControlQueryReceiveBuffer" ); - + __KTRACE_OPT(KUSB, Kern::Printf("EControlQueryReceiveBuffer")); if (iValidInterface && ValidEndpoint((TInt) a1)) { pEndpoint=iEndpoint[(TInt) a1]; @@ -1262,8 +1198,7 @@ r = KErrNotSupported; else if (pEndpoint->EndpointInfo()->iDir != KUsbEpDirIn) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP6, - " bytes = %d", pEndpoint->RxBytesAvailable()); + __KTRACE_OPT(KUSB, Kern::Printf(" bytes = %d", pEndpoint->RxBytesAvailable())); *(TInt*)a2 = pEndpoint->RxBytesAvailable(); } } @@ -1277,8 +1212,7 @@ break; case RDevUsbcClient::EControlEndpointCaps: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP7, - "EControlEndpointCaps" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointCaps")); r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient); if (r != KErrNone) PanicClientThread(r); @@ -1286,8 +1220,7 @@ break; case RDevUsbcClient::EControlDeviceCaps: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP8, - "EControlDeviceCaps" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceCaps")); r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient); if (r != KErrNone) PanicClientThread(r); @@ -1295,14 +1228,12 @@ break; case RDevUsbcClient::EControlSendEp0StatusPacket: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP9, - "EControlSendEp0StatusPacket" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSendEp0StatusPacket")); iController->SendEp0StatusPacket(this); break; case RDevUsbcClient::EControlHaltEndpoint: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP10, - "EControlHaltEndpoint" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlHaltEndpoint")); if (iValidInterface && ValidEndpoint((TInt) a1)) { r = iController->HaltEndpoint(this, iEndpoint[(TInt)a1]->RealEpNumber()); @@ -1317,8 +1248,7 @@ break; case RDevUsbcClient::EControlClearHaltEndpoint: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP11, - "EControlClearHaltEndpoint" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlClearHaltEndpoint")); if (iValidInterface && ValidEndpoint((TInt) a1)) { r = iController->ClearHaltEndpoint(this, iEndpoint[(TInt)a1]->RealEpNumber()); @@ -1333,39 +1263,33 @@ break; case RDevUsbcClient::EControlDumpRegisters: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP12, - "EControlDumpRegisters" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlDumpRegisters")); iController->DumpRegisters(); break; case RDevUsbcClient::EControlReleaseDeviceControl: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP13, - "EControlReleaseDeviceControl" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlReleaseDeviceControl")); iController->ReleaseDeviceControl(this); iOwnsDeviceControl = EFalse; break; case RDevUsbcClient::EControlEndpointZeroMaxPacketSizes: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP14, - "EControlEndpointZeroMaxPacketSizes" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlEndpointZeroMaxPacketSizes")); r = iController->EndpointZeroMaxPacketSizes(); break; case RDevUsbcClient::EControlSetEndpointZeroMaxPacketSize: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP15, - "EControlSetEndpointZeroMaxPacketSize" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetEndpointZeroMaxPacketSize")); r = iController->SetEndpointZeroMaxPacketSize(reinterpret_cast(a1)); break; case RDevUsbcClient::EControlGetEndpointZeroMaxPacketSize: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP16, - "EControlGetEndpointZeroMaxPacketSize" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetEndpointZeroMaxPacketSize")); r = iController->Ep0PacketSize(); break; case RDevUsbcClient::EControlGetDeviceDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP17, - "EControlGetDeviceDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetDeviceDescriptor")); r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient); if (r != KErrNone) PanicClientThread(r); @@ -1373,8 +1297,7 @@ break; case RDevUsbcClient::EControlSetDeviceDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP18, - "EControlSetDeviceDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceDescriptor")); if (a1 != NULL) r = iController->SetDeviceDescriptor(iClient, *((TDes8*) a1)); else @@ -1382,8 +1305,7 @@ break; case RDevUsbcClient::EControlGetDeviceDescriptorSize: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP19, - "EControlGetDeviceDescriptorSize" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetDeviceDescriptorSize")); if (a1 != NULL) r = iController->GetDeviceDescriptorSize(iClient, *((TDes8*) a1)); else @@ -1391,8 +1313,7 @@ break; case RDevUsbcClient::EControlGetConfigurationDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP20, - "EControlGetConfigurationDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetConfigurationDescriptor")); r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0 , 0, iClient); if (r != KErrNone) PanicClientThread(r); @@ -1400,8 +1321,7 @@ break; case RDevUsbcClient::EControlGetConfigurationDescriptorSize: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP21, - "EControlGetConfigurationDescriptorSize" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetConfigurationDescriptorSize")); if (a1 != NULL) { r = iController->GetConfigurationDescriptorSize(iClient, *((TDes8*) a1)); @@ -1411,32 +1331,27 @@ break; case RDevUsbcClient::EControlSetConfigurationDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP22, - "EControlSetConfigurationDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetConfigurationDescriptor")); r = iController->SetConfigurationDescriptor(iClient, *((TDes8*) a1)); break; case RDevUsbcClient::EControlGetInterfaceDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP23, - "EControlGetInterfaceDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetInterfaceDescriptor")); r = iController->GetInterfaceDescriptor(iClient, this, (TInt) a1, *((TDes8*) a2)); break; case RDevUsbcClient::EControlGetInterfaceDescriptorSize: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP24, - "EControlGetInterfaceDescriptorSize" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetInterfaceDescriptorSize")); r = iController->GetInterfaceDescriptorSize(iClient, this, (TInt) a1, *(TDes8*) a2); break; case RDevUsbcClient::EControlSetInterfaceDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP25, - "EControlSetInterfaceDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetInterfaceDescriptor")); r = iController->SetInterfaceDescriptor(iClient, this, (TInt) a1, *((TDes8*) a2)); break; case RDevUsbcClient::EControlGetEndpointDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP26, - "EControlGetEndpointDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetEndpointDescriptor")); r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); if (r != KErrNone) PanicClientThread(r); @@ -1446,8 +1361,7 @@ break; case RDevUsbcClient::EControlGetEndpointDescriptorSize: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP27, - "EControlGetEndpointDescriptorSize" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetEndpointDescriptorSize")); r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); if (r != KErrNone) PanicClientThread(r); @@ -1457,8 +1371,7 @@ break; case RDevUsbcClient::EControlSetEndpointDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP28, - "EControlSetEndpointDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetEndpointDescriptor")); r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); if (r != KErrNone) PanicClientThread(r); @@ -1468,8 +1381,7 @@ break; case RDevUsbcClient::EControlGetDeviceQualifierDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP29, - "EControlGetDeviceQualifierDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetDeviceQualifierDescriptor")); r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0, 0, iClient); if (r != KErrNone) PanicClientThread(r); @@ -1477,8 +1389,7 @@ break; case RDevUsbcClient::EControlSetDeviceQualifierDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP30, - "EControlSetDeviceQualifierDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceQualifierDescriptor")); if (a1 != NULL) r = iController->SetDeviceQualifierDescriptor(iClient, *((TDes8*) a1)); else @@ -1486,8 +1397,7 @@ break; case RDevUsbcClient::EControlGetOtherSpeedConfigurationDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP31, - "EControlGetOtherSpeedConfigurationDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetOtherSpeedConfigurationDescriptor")); r = Kern::ThreadDesWrite(iClient, a1, pZeroDesc, 0 , 0, iClient); if (r != KErrNone) PanicClientThread(r); @@ -1495,27 +1405,23 @@ break; case RDevUsbcClient::EControlSetOtherSpeedConfigurationDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP32, - "EControlSetOtherSpeedConfigurationDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetOtherSpeedConfigurationDescriptor")); r = iController->SetOtherSpeedConfigurationDescriptor(iClient, *((TDes8*) a1)); break; case RDevUsbcClient::EControlGetCSInterfaceDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP33, - "EControlGetCSInterfaceDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSInterfaceDescriptor")); r = iController->GetCSInterfaceDescriptorBlock(iClient, this, (TInt) a1, *((TDes8*) a2)); break; case RDevUsbcClient::EControlGetCSInterfaceDescriptorSize: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP34, - "EControlGetCSInterfaceDescriptorSize" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSInterfaceDescriptorSize")); r = iController->GetCSInterfaceDescriptorBlockSize(iClient, this, (TInt) a1, *(TDes8*) a2); break; case RDevUsbcClient::EControlGetCSEndpointDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP35, - "EControlGetCSEndpointDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSEndpointDescriptor")); r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); if (r != KErrNone) PanicClientThread(r); @@ -1525,8 +1431,7 @@ break; case RDevUsbcClient::EControlGetCSEndpointDescriptorSize: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP36, - "EControlGetCSEndpointDescriptorSize" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetCSEndpointDescriptorSize")); r = Kern::ThreadRawRead(iClient, a1, &epInfo, sizeof(epInfo)); if (r != KErrNone) PanicClientThread(r); @@ -1536,46 +1441,38 @@ break; case RDevUsbcClient::EControlSignalRemoteWakeup: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP37, - "EControlSignalRemoteWakeup" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSignalRemoteWakeup")); r = iController->SignalRemoteWakeup(); break; case RDevUsbcClient::EControlDeviceDisconnectFromHost: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP38, - "EControlDeviceDisconnectFromHost" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceDisconnectFromHost")); r = iController->UsbDisconnect(); break; case RDevUsbcClient::EControlDeviceConnectToHost: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP39, - "EControlDeviceConnectToHost" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlDeviceConnectToHost")); r = iController->UsbConnect(); break; case RDevUsbcClient::EControlDevicePowerUpUdc: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP40, - "EControlDevicePowerUpUdc" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlDevicePowerUpUdc")); r = iController->PowerUpUdc(); break; case RDevUsbcClient::EControlSetDeviceControl: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP41, - "EControlSetDeviceControl" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceControl")); r = iController->SetDeviceControl(this); if (r == KErrNone) { iOwnsDeviceControl = ETrue; if (iEndpoint[0] == NULL) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP42, - "EControlSetDeviceControl 11" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetDeviceControl 11")); r = SetupEp0(); if (r != KErrNone) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOCONTROL_DUP43, - " Error: SetupEp0() failed" ); - + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: SetupEp0() failed")); iController->ReleaseDeviceControl(this); DestroyEp0(); iOwnsDeviceControl = EFalse; @@ -1588,14 +1485,12 @@ break; case RDevUsbcClient::EControlCurrentlyUsingHighSpeed: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP44, - "EControlCurrentlyUsingHighSpeed" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlCurrentlyUsingHighSpeed")); r = iController->CurrentlyUsingHighSpeed(); break; case RDevUsbcClient::EControlSetInterface: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP45, - "EControlSetInterface" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetInterface")); r = Kern::ThreadRawRead(iClient, a2, &ifcInfo, sizeof(ifcInfo)); if (r != KErrNone) PanicClientThread(r); @@ -1621,8 +1516,7 @@ break; case RDevUsbcClient::EControlReleaseInterface: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP46, - "EControlReleaseInterface" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlReleaseInterface")); r = iController->ReleaseInterface(this, (TInt) a1); if (r == KErrNone) { @@ -1630,14 +1524,12 @@ } else { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_DOCONTROL_DUP47, - " Error in PIL: LDD interface won't be released." ); + __KTRACE_OPT(KPANIC, Kern::Printf(" Error in PIL: LDD interface won't be released.")); } break; case RDevUsbcClient::EControlSetCSInterfaceDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP48, - "EControlSetCSInterfaceDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetCSInterfaceDescriptor")); r = Kern::ThreadRawRead(iClient, a1, &desInfo, sizeof(desInfo)); if (r != KErrNone) PanicClientThread(r); @@ -1647,8 +1539,7 @@ break; case RDevUsbcClient::EControlSetCSEndpointDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP49, - "EControlSetCSEndpointDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetCSEndpointDescriptor")); r = Kern::ThreadRawRead(iClient, a1, &desInfo, sizeof(desInfo)); if (r != KErrNone) PanicClientThread(r); @@ -1659,104 +1550,87 @@ break; case RDevUsbcClient::EControlGetStringDescriptorLangId: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP50, - "EControlGetStringDescriptorLangId" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetStringDescriptorLangId")); r = iController->GetStringDescriptorLangId(iClient, *((TDes8*) a1)); break; case RDevUsbcClient::EControlSetStringDescriptorLangId: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP51, - "EControlSetStringDescriptorLangId" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetStringDescriptorLangId")); r = iController->SetStringDescriptorLangId(reinterpret_cast(a1)); break; case RDevUsbcClient::EControlGetManufacturerStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP52, - "EControlGetManufacturerStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetManufacturerStringDescriptor")); r = iController->GetManufacturerStringDescriptor(iClient, *((TPtr8*) a1)); break; case RDevUsbcClient::EControlSetManufacturerStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP53, - "EControlSetManufacturerStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetManufacturerStringDescriptor")); r = iController->SetManufacturerStringDescriptor(iClient, *((TPtr8*) a1)); break; case RDevUsbcClient::EControlRemoveManufacturerStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP54, - "EControlRemoveManufacturerStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveManufacturerStringDescriptor")); r = iController->RemoveManufacturerStringDescriptor(); break; case RDevUsbcClient::EControlGetProductStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP55, - "EControlGetProductStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetProductStringDescriptor")); r = iController->GetProductStringDescriptor(iClient, *((TPtr8*) a1)); break; case RDevUsbcClient::EControlSetProductStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP56, - "EControlSetProductStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetProductStringDescriptor")); r = iController->SetProductStringDescriptor(iClient, *((TPtr8*) a1)); break; case RDevUsbcClient::EControlRemoveProductStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP57, - "EControlRemoveProductStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveProductStringDescriptor")); r = iController->RemoveProductStringDescriptor(); break; case RDevUsbcClient::EControlGetSerialNumberStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP58, - "EControlGetSerialNumberStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetSerialNumberStringDescriptor")); r = iController->GetSerialNumberStringDescriptor(iClient, *((TPtr8*) a1)); break; case RDevUsbcClient::EControlSetSerialNumberStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP59, - "EControlSetSerialNumberStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetSerialNumberStringDescriptor")); r = iController->SetSerialNumberStringDescriptor(iClient, *((TPtr8*) a1)); break; case RDevUsbcClient::EControlRemoveSerialNumberStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP60, - "EControlRemoveSerialNumberStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveSerialNumberStringDescriptor")); r = iController->RemoveSerialNumberStringDescriptor(); break; case RDevUsbcClient::EControlGetConfigurationStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP61, - "EControlGetConfigurationStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetConfigurationStringDescriptor")); r = iController->GetConfigurationStringDescriptor(iClient, *((TPtr8*) a1)); break; case RDevUsbcClient::EControlSetConfigurationStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP62, - "EControlSetConfigurationStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetConfigurationStringDescriptor")); r = iController->SetConfigurationStringDescriptor(iClient, *((TPtr8*) a1)); break; case RDevUsbcClient::EControlRemoveConfigurationStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP63, - "EControlRemoveConfigurationStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveConfigurationStringDescriptor")); r = iController->RemoveConfigurationStringDescriptor(); break; case RDevUsbcClient::EControlGetStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP64, - "EControlGetStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlGetStringDescriptor")); r = iController->GetStringDescriptor(iClient, (TUint8) (TInt) a1, *((TPtr8*) a2)); break; case RDevUsbcClient::EControlSetStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP65, - "EControlSetStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlSetStringDescriptor")); r = iController->SetStringDescriptor(iClient, (TUint8) (TInt) a1, *((TPtr8*) a2)); break; case RDevUsbcClient::EControlRemoveStringDescriptor: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP66, - "EControlRemoveStringDescriptor" ); + __KTRACE_OPT(KUSB, Kern::Printf("EControlRemoveStringDescriptor")); r = iController->RemoveStringDescriptor((TUint8) (TInt) a1); break; @@ -1815,8 +1689,7 @@ break; default: - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOCONTROL_DUP67, - "Function code not supported" ); + __KTRACE_OPT(KUSB, Kern::Printf("Function code not supported")); r = KErrNotSupported; } @@ -1831,16 +1704,14 @@ const TInt srcLen = Kern::ThreadGetDesLength(iClient, ifc_info_buf_ptr); if (srcLen < ifc_info_buf.Length()) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE, - "SetInterface can't copy" ); + __KTRACE_OPT(KUSB, Kern::Printf("SetInterface can't copy")); PanicClientThread(EDesOverflow); } TInt r = Kern::ThreadDesRead(iClient, ifc_info_buf_ptr, ifc_info_buf, 0, KChunkShiftBy0); if (r != KErrNone) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP1, - "SetInterface Copy failed reason=%d", r ); + __KTRACE_OPT(KUSB, Kern::Printf("SetInterface Copy failed reason=%d", r)); PanicClientThread(r); } @@ -1849,8 +1720,7 @@ // If an alternate interface is being asked for then do nothing, // just pass it down to the Controller. const TInt num_endpoints = ifc_info_buf().iTotalEndpointsUsed; - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP2, - "SetInterface num_endpoints=%d", num_endpoints ); + __KTRACE_OPT(KUSB, Kern::Printf("SetInterface num_endpoints=%d", num_endpoints)); // [The next 4 variables have to be initialized here because of the goto's that follow.] // Both IN and OUT buffers will be fully cached: @@ -1861,8 +1731,7 @@ TInt real_ep_numbers[6] = {-1, -1, -1, -1, -1, -1}; // See if PIL will accept this interface - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP3, - "SetInterface Calling controller" ); + __KTRACE_OPT(KUSB, Kern::Printf("SetInterface Calling controller")); r = iController->SetInterface(this, iClient, aInterfaceNumber, @@ -1873,12 +1742,10 @@ &real_ep_numbers, ifc_info_buf().iFeatureWord); - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP4, - "SetInterface controller returned %d", r ); + __KTRACE_OPT(KUSB, Kern::Printf("SetInterface controller returned %d", r)); if (r != KErrNone) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP5, - "SetInterface failed reason=%d", r ); + __KTRACE_OPT(KPANIC, Kern::Printf("SetInterface failed reason=%d", r)); return r; } @@ -1888,13 +1755,11 @@ // ep0 if (iEndpoint[0] == NULL) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP6, - "SetInterface 11" ); + __KTRACE_OPT(KUSB, Kern::Printf("SetInterface 11")); r = SetupEp0(); if (r != KErrNone) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP7, - " Error: SetupEp0() failed" ); + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: SetupEp0() failed")); DestroyEp0(); goto F1; } @@ -1907,15 +1772,13 @@ goto F1; } - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP8, - "DLddUsbcChannel::SetInterface num_endpoints=%d", num_endpoints ); + __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::SetInterface num_endpoints=%d", num_endpoints)); // other endpoints // calculate the total buffer size for (TInt i = 1; i <= num_endpoints; i++, pEndpointData++) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP9, - "SetInterface for ep=%d", i ); + __KTRACE_OPT(KUSB, Kern::Printf("SetInterface for ep=%d", i)); if (!ValidateEndpoint(pEndpointData)) { r = KErrUsbBadEndpoint; @@ -1935,9 +1798,8 @@ goto F2; } - OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP10, - "SetInterface for ep=%d rec=0x%08x ep==0x%08x", i, - reinterpret_cast(alternateSettingListRec), reinterpret_cast(ep) ); + __KTRACE_OPT(KUSB, Kern::Printf("SetInterface for ep=%d rec=0x%08x ep==0x%08x", + i, alternateSettingListRec, ep)); } // buf size of each endpoint @@ -1957,8 +1819,7 @@ bufSizes[i] = alternateSettingListRec->iEndpoint[i]->BufferSize(); } - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP11, - "Sort the endpoints:" ); + __KTRACE_OPT(KUSB, Kern::Printf("Sort the endpoints:")); // sort the endpoint number by the bufsize decreasely for( TInt i=1;iiEpNumDeOrderedByBufSize[i] = epNum[i]; - OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP12, - " %d:%d", epNum[i], bufSizes[i] ); + __KTRACE_OPT(KUSB, Kern::Printf(" %d:%d", epNum[i], bufSizes[i])); } alternateSettingListRec->iEpNumDeOrderedByBufSize[num_endpoints] = epNum[num_endpoints]; - OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP13, - " %d:%d", epNum[num_endpoints], bufSizes[num_endpoints] ); - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP14, "\n" ); + __KTRACE_OPT(KUSB, Kern::Printf(" %d:%d", epNum[num_endpoints], bufSizes[num_endpoints])); + __KTRACE_OPT(KUSB, Kern::Printf("\n")); // chain in this alternate setting alternateSettingListRec->iNext = iAlternateSettingList; @@ -2005,23 +1864,20 @@ r = SetupInterfaceMemory(iHwChunks, cacheAttribs ); if( r==KErrNone ) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP15, - "SetInterface ready to exit" ); + __KTRACE_OPT(KUSB, Kern::Printf("SetInterface ready to exit")); if (aInterfaceNumber == 0) { // make sure we're ready to go with the main interface iValidInterface = ETrue; - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP16, - "SetInterface SelectAlternateSetting" ); + __KTRACE_OPT(KUSB, Kern::Printf("SetInterface SelectAlternateSetting")); SelectAlternateSetting(0); } return KErrNone; } else { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP17, - "Destroying all interfaces" ); + __KTRACE_OPT(KUSB, Kern::Printf("Destroying all interfaces")); DestroyAllInterfaces(); DestroyEp0(); return r; @@ -2033,13 +1889,8 @@ F1: #if _DEBUG -#ifdef OST_TRACE_COMPILER_IN_USE TInt r1 = iController->ReleaseInterface(this, aInterfaceNumber); -#else - (void) iController->ReleaseInterface(this, aInterfaceNumber); -#endif - OstTraceDef1( OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, DLDDUSBCCHANNEL_SETINTERFACE_DUP18, - "Release Interface controller returned %d", r1 ); + __KTRACE_OPT(KUSB, Kern::Printf("Release Interface controller returned %d", r1)); #else (void) iController->ReleaseInterface(this, aInterfaceNumber); #endif @@ -2058,15 +1909,13 @@ // 1, collect all bufs' sizes for the current interface // to realloc all the chunks - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY, - "Collect all buffer sizes:" ); + __KTRACE_OPT(KUSB, Kern::Printf("Collect all buffer sizes:")); RArray bufSizes; for(TInt i=1;i<=numOfEp;i++) { TInt nextEp = asRec->iEpNumDeOrderedByBufSize[i]; TInt epBufCount = asRec->iEndpoint[nextEp]->BufferNumber(); - OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP1, - " ep %d, buf count %d", nextEp, epBufCount ); + __KTRACE_OPT(KUSB, Kern::Printf(" ep %d, buf count %d", nextEp, epBufCount )); for(TInt k=0;kiEndpoint[nextEp]->BufferSize(); @@ -2077,20 +1926,17 @@ bufSizes.Close(); return r; } - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP2, - " %d", epBufSize ); + __KTRACE_OPT(KUSB,Kern::Printf(" %d", epBufSize )); } - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP3, "\n" ); + __KTRACE_OPT(KUSB, Kern::Printf("\n")); } // 2, alloc the buffer decreasely, biggest-->smallest // 2.1 check the existing chunks TInt bufCount = bufSizes.Count(); - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP4, - " ep buf number needed %d", bufCount ); - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP5, - " chunks available %d", aHwChunks.Count() ); + __KTRACE_OPT(KUSB, Kern::Printf(" ep buf number needed %d", bufCount )); + __KTRACE_OPT(KUSB, Kern::Printf(" chunks available %d", aHwChunks.Count() )); TInt chunkInd = 0; while( (chunkIndDeRegisterClient(this); @@ -2113,9 +1958,7 @@ { // Parcel out the memory between endpoints TUint8* newAddr = reinterpret_cast(chunk->LinearAddress()); - OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP7, - "SetupInterfaceMemory alloc new chunk=0x%x, size=%d", - reinterpret_cast(newAddr), bufSizes[chunkInd] ); + __KTRACE_OPT(KUSB, Kern::Printf("SetupInterfaceMemory alloc new chunk=0x%x, size=%d", newAddr,bufSizes[chunkInd])); // The check is important to avoid chunkChanged to be corrupted. // This code change is to fix the problem that one chunk is used by multiple interfaces. if(!chunkChanged) @@ -2134,8 +1977,7 @@ chunk = Allocate( bufSizes[chunkInd], aCacheAttribs); if (chunk == NULL) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP8, - "Failed to alloc chunk, size %d!", bufSizes[chunkInd] ); + __KTRACE_OPT(KUSB, Kern::Printf("Failed to alloc chunk, size %d!", bufSizes[chunkInd])); // lost all interfaces: // Tell Controller to release Interface and h/w resources associated with this iController->DeRegisterClient(this); @@ -2145,10 +1987,8 @@ else { // Parcel out the memory between endpoints - OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP9, - "SetupInterfaceMemory alloc new chunk=0x%x, size=%d", - static_cast(chunk->LinearAddress()), bufSizes[chunkInd]); - + __KTRACE_OPT(KUSB, Kern::Printf("SetupInterfaceMemory alloc new chunk=0x%x, size=%d", + reinterpret_cast(chunk->LinearAddress()), bufSizes[chunkInd])); TInt r = aHwChunks.Append(chunk); if(r!=KErrNone) { @@ -2167,14 +2007,12 @@ if(chunkChanged) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP10, - "SetupInterfaceMemory readdressing." ); + __KTRACE_OPT(KUSB, Kern::Printf("SetupInterfaceMemory readdressing.")); asRec = asRec->iNext; while (asRec) { // Interfaces are not concurrent so they can all start at the same logical address - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPINTERFACEMEMORY_DUP11, - "SetupInterfaceMemory readdressing setting=%d", asRec->iSetting ); + __KTRACE_OPT(KUSB, Kern::Printf("SetupInterfaceMemory readdressing setting=%d", asRec->iSetting)); ReSetInterfaceMemory(asRec, aHwChunks); asRec = asRec->iNext; } @@ -2184,8 +2022,7 @@ TInt DLddUsbcChannel::SetupEp0() { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPEP0, - "SetupEp0 entry %x", this ); + __KTRACE_OPT(KUSB, Kern::Printf("SetupEp0 entry %x", this)); TInt ep0Size = iController->Ep0PacketSize(); TUsbcEndpointInfo ep0Info = TUsbcEndpointInfo(KUsbEpTypeControl, KUsbEpDirBidirect, ep0Size); TUsbcEndpoint* ep0 = new TUsbcEndpoint(this, iController, &ep0Info, 0, 0); @@ -2221,10 +2058,8 @@ TUint8 * buf; buf = (TUint8*) chunk->LinearAddress(); ep0->SetBufferAddr( i, buf); - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPEP0_DUP1, - "SetupEp0 60 buffer number %d", i ); - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_SETUPEP0_DUP2, - "SetupEp0 60 buffer size %d", bufferSize ); + __KTRACE_OPT(KUSB, Kern::Printf("SetupEp0 60 buffer number %d", i)); + __KTRACE_OPT(KUSB, Kern::Printf("SetupEp0 60 buffer size %d", bufferSize)); } ep0->SetRealEpNumber(0); @@ -2254,17 +2089,11 @@ TUint8* pBuf = NULL; pBuf = reinterpret_cast(aHwChunks[chunkInd]->LinearAddress()); ep->SetBufferAddr( k, pBuf); - OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_RESETINTERFACEMEMORY, - " ep %d, buf %d, addr 0x%x", nextEp, k, reinterpret_cast(pBuf) ); + __KTRACE_OPT(KUSB, Kern::Printf(" ep %d, buf %d, addr 0x%x", nextEp, k, pBuf )); chunkInd++; -#ifdef _DEBUG - if (chunkInd > aHwChunks.Count()) - { - OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, DLDDUSBCCHANNEL_RESETINTERFACEMEMORY_DUP1, - " Error: available chunks %d, run out at epInd%d, bufInd%d", - aHwChunks.Count(), i, k ); - } -#endif + __ASSERT_DEBUG(chunkInd<=aHwChunks.Count(), + Kern::Printf(" Error: available chunks %d, run out at epInd%d, bufInd%d", + aHwChunks.Count(), i, k)); __ASSERT_DEBUG(chunkInd<=aHwChunks.Count(), Kern::Fault("usbc.ldd", __LINE__)); } @@ -2360,8 +2189,7 @@ void DLddUsbcChannel::EndpointStatusChangeCallback(TAny* aDLddUsbcChannel) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_ENDPOINTSTATUSCHANGECALLBACK, - "EndpointStatusChangeCallback" ); + __KTRACE_OPT(KUSB, Kern::Printf("EndpointStatusChangeCallback")); DLddUsbcChannel* dUsbc = (DLddUsbcChannel*) aDLddUsbcChannel; if (dUsbc->iChannelClosing) return; @@ -2369,8 +2197,7 @@ const TInt reqNo = (TInt) RDevUsbcClient::ERequestEndpointStatusNotify; if (dUsbc->iRequestStatus[reqNo]) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_ENDPOINTSTATUSCHANGECALLBACK_DUP1, - "EndpointStatusChangeCallback Notify status" ); + __KTRACE_OPT(KUSB, Kern::Printf("EndpointStatusChangeCallback Notify status")); DThread* client = dUsbc->iClient; dUsbc->iEndpointStatusChangeReq->Data() = endpointState; @@ -2393,8 +2220,7 @@ (i < KUsbcDeviceStateRequests) && ((deviceState = dUsbc->iStatusCallbackInfo.State(i)) != EUsbcNoState); ++i) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_STATUSCHANGECALLBACK, - "StatusChangeCallBack status=%d", static_cast(deviceState) ); + __KTRACE_OPT(KUSB, Kern::Printf("StatusChangeCallBack status=%d", deviceState)); if (deviceState & KUsbAlternateSetting) { dUsbc->ProcessAlternateSetting(deviceState); @@ -2424,8 +2250,7 @@ void DLddUsbcChannel::OtgFeatureChangeCallback(TAny* aDLddUsbcChannel) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_OTGFEATURECHANGECALLBACK, - "OtgFeatureChangeCallback" ); + __KTRACE_OPT(KUSB, Kern::Printf("OtgFeatureChangeCallback")); DLddUsbcChannel* dUsbc = (DLddUsbcChannel*) aDLddUsbcChannel; if (dUsbc->iChannelClosing) return; @@ -2437,8 +2262,7 @@ const TInt reqNo = (TInt) RDevUsbcClient::ERequestOtgFeaturesNotify; if (dUsbc->iRequestStatus[reqNo]) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_OTGFEATURECHANGECALLBACK_DUP1, - "OtgFeatureChangeCallback Notify status" ); + __KTRACE_OPT(KUSB, Kern::Printf("OtgFeatureChangeCallback Notify status")); dUsbc->iOtgFeatureChangeReq->Data()=features; dUsbc->iRequestStatus[reqNo] = NULL; Kern::QueueRequestComplete(dUsbc->iClient,dUsbc->iOtgFeatureChangeReq,KErrNone); @@ -2489,15 +2313,14 @@ } else { - OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_EPFROMALTERNATESETTING, - " Error: aEndpoint %d wrong for aAlternateSetting %d", aEndpoint, aAlternateSetting ); + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: aEndpoint %d wrong for aAlternateSetting %d", + aEndpoint, aAlternateSetting)); return -1; } } alternateSettingListRec = alternateSettingListRec->iNext; } - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_EPFROMALTERNATESETTING_DUP1, - " Error: no aAlternateSetting %d found", aAlternateSetting ); + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: no aAlternateSetting %d found", aAlternateSetting)); return -1; } @@ -2505,12 +2328,9 @@ TInt DLddUsbcChannel::ProcessAlternateSetting(TUint aAlternateSetting) { ResetInterface(KErrUsbInterfaceChange); // kill any outstanding transfers - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSALTERNATESETTING, - "ProcessAlternateSetting 0x%08x", aAlternateSetting ); + __KTRACE_OPT(KUSB, Kern::Printf("ProcessAlternateSetting 0x%08x", aAlternateSetting)); TUint newSetting = aAlternateSetting&(~KUsbAlternateSetting); - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSALTERNATESETTING_DUP1, - "ProcessAlternateSetting selecting alternate setting 0x%08x", newSetting ); - + __KTRACE_OPT(KUSB, Kern::Printf("ProcessAlternateSetting selecting alternate setting 0x%08x", newSetting)); TInt r = SelectAlternateSetting(newSetting); if (r != KErrNone) return r; @@ -2522,23 +2342,19 @@ TInt DLddUsbcChannel::ProcessDeviceState(TUsbcDeviceState aDeviceState) { - OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSDEVICESTATE, - "ProcessDeviceState(%d -> %d)", iDeviceState, aDeviceState ); + __KTRACE_OPT(KUSB, Kern::Printf("ProcessDeviceState(%d -> %d)", iDeviceState, aDeviceState)); if (iDeviceState == aDeviceState) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSDEVICESTATE_DUP1, - " No state change => nothing to be done." ); + __KTRACE_OPT(KUSB, Kern::Printf(" No state change => nothing to be done.")); return KErrNone; } if (iDeviceState == EUsbcDeviceStateSuspended) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSDEVICESTATE_DUP2, - " Coming out of Suspend: old state = %d", iOldDeviceState ); + __KTRACE_OPT(KUSB, Kern::Printf(" Coming out of Suspend: old state = %d", iOldDeviceState)); iDeviceState = iOldDeviceState; if (iDeviceState == aDeviceState) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSDEVICESTATE_DUP3, - " New state same as before Suspend => nothing to be done." ); + __KTRACE_OPT(KUSB, Kern::Printf(" New state same as before Suspend => nothing to be done.")); return KErrNone; } } @@ -2547,8 +2363,7 @@ TInt cancellationCode = KErrNone; if (aDeviceState == EUsbcDeviceStateSuspended) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSDEVICESTATE_DUP4, - " Suspending..." ); + __KTRACE_OPT(KUSB, Kern::Printf(" Suspending...")); iOldDeviceState = iDeviceState; // Put PSL into low power mode here } @@ -2568,8 +2383,7 @@ cancellationCode = KErrUsbDeviceNotConfigured; } } - OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_PROCESSDEVICESTATE_DUP5, - " %d --> %d", iDeviceState, aDeviceState ); + __KTRACE_OPT(KUSB, Kern::Printf(" %d --> %d", iDeviceState, aDeviceState)); iDeviceState = aDeviceState; if (iValidInterface || iOwnsDeviceControl) { @@ -2612,24 +2426,17 @@ const TInt size = iController->EndpointPacketSize(this, iEndpoint[i]->RealEpNumber()); if (size < 0) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_FATAL, DLDDUSBCCHANNEL_UPDATEENDPOINTSIZES, - " Error: Packet size < 0 for ep %d", i ); + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: Packet size < 0 for ep %d", i)); continue; } iEndpoint[i]->SetMaxPacketSize(size); } -#ifdef _DEBUG - if (i != iNumberOfEndpoints + 1) - { - OstTraceDef1( OST_TRACE_CATEGORY_DEBUG, TRACE_FATAL, DLDDUSBCCHANNEL_UPDATEENDPOINTSIZES_DUP1, - " Error: iNumberOfEndpoints wrong (%d)", iNumberOfEndpoints ); - - } -#endif + __ASSERT_DEBUG(i == iNumberOfEndpoints + 1, + Kern::Printf(" Error: iNumberOfEndpoints wrong (%d)", iNumberOfEndpoints)); } -DPlatChunkHw* DLddUsbcChannel::ReAllocate(TInt aBuffersize, DPlatChunkHw* aHwChunk,TUint32 aCacheAttribs) +DPlatChunkHw* DLddUsbcChannel::ReAllocate(TInt aBuffersize, DPlatChunkHw* aHwChunk, TUint32 aCacheAttribs) { DPlatChunkHw* chunk = aHwChunk; if ((!chunk) || (chunk->iSize < aBuffersize)) @@ -2638,8 +2445,7 @@ { ClosePhysicalChunk(chunk); } - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_REALLOCATE, - "ReAllocate need to get new chunk" ); + __KTRACE_OPT(KUSB, Kern::Printf("ReAllocate need to get new chunk")); chunk = Allocate(aBuffersize, aCacheAttribs); } return chunk; @@ -2705,8 +2511,7 @@ { // Device state waiting to be sent userside completeNow = ETrue; - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_ALTERNATEDEVICESTATETESTCOMPLETE, - "StatusChangeCallback Notify status" ); + __KTRACE_OPT(KUSB, Kern::Printf("StatusChangeCallback Notify status")); iStatusChangeReq->Data()=deviceState; iStatusChangePtr = NULL; } @@ -2723,8 +2528,7 @@ void DLddUsbcChannel::DeConfigure(TInt aErrorCode) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DECONFIGURE, - "DLddUsbcChannel::DeConfigure()" ); + __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::DeConfigure()")); // Called after deconfiguration. Cancels transfers on all endpoints. ResetInterface(aErrorCode); // Cancel the endpoint status notify request if it is outstanding. @@ -2762,8 +2566,7 @@ // Reset each endpoint except ep0 for (TInt i = 1; i <= iNumberOfEndpoints; i++) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_RESETINTERFACE, - "Cancelling transfer ep=%d", i ); + __KTRACE_OPT(KUSB, Kern::Printf("Cancelling transfer ep=%d", i)); iEndpoint[i]->CancelTransfer(iClient,iClientAsynchNotify[i]->iClientBuffer); // Copies data userside iEndpoint[i]->AbortTransfer(); // kills any ldd->pil outstanding transfers iEndpoint[i]->iDmaBuffers->Flush(); @@ -2808,16 +2611,14 @@ TInt DLddUsbcChannel::DoEmergencyComplete() { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOEMERGENCYCOMPLETE, - "TUsbcEndpoint::DoEmergencyComplete" ); + __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::DoEmergencyComplete")); // cancel any pending DFCs // complete all client requests for (TInt i = 0; i < KUsbcMaxRequests; i++) { if (iRequestStatus[i]) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, DLDDUSBCCHANNEL_DOEMERGENCYCOMPLETE_DUP1, - "Complete request 0x%x", iRequestStatus[i] ); + __KTRACE_OPT(KUSB, Kern::Printf("Complete request 0x%x", iRequestStatus[i])); if (i == RDevUsbcClient::ERequestAlternateDeviceStatusNotify) { @@ -2923,8 +2724,7 @@ iBandwidthPriority(aBandwidthPriority) { ResetTransferInfo(); - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FLOW, TUSBCENDPOINT_TUSBCENDPOINT_CONS, - "TUsbcEndpoint::TUsbcEndpoint 2" ); + __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::TUsbcEndpoint 2")); } @@ -2956,8 +2756,7 @@ TUsbcEndpoint::~TUsbcEndpoint() { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_FLOW, TUSBCENDPOINT_TUSBCENDPOINT_DES, - "TUsbcEndpoint::~TUsbcEndpoint(%d)", iEndpointNumber ); + __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::~TUsbcEndpoint(%d)", iEndpointNumber)); AbortTransfer(); delete iRequestCallbackInfo; delete iDmaBuffers; @@ -2966,8 +2765,7 @@ void TUsbcEndpoint::RequestCallback(TAny* aTUsbcEndpoint) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_REQUESTCALLBACK, - "TUsbcEndpoint::RequestCallback" ); + __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::RequestCallback")); ((TUsbcEndpoint*) aTUsbcEndpoint)->EndpointComplete(); } @@ -2981,13 +2779,12 @@ TInt TUsbcEndpoint::EndpointComplete() { - OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ENDPOINTCOMPLETE, - "TUsbcEndpoint::EndpointComplete ep=%d %d", iEndpointNumber, iRequestCallbackInfo->iEndpointNum ); + __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::EndpointComplete ep=%d %d", + iEndpointNumber, iRequestCallbackInfo->iEndpointNum)); if (iLdd->ChannelClosing()) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ENDPOINTCOMPLETE_DUP1, - "We're going home -> completions no longer accepted" ); + __KTRACE_OPT(KUSB, Kern::Printf("We're going home -> completions no longer accepted")); return KErrNone; } @@ -2999,12 +2796,10 @@ case EControllerWrite: { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ENDPOINTCOMPLETE_DUP2, - "TUsbcEndpoint::EndpointComplete Write 2" ); + __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::EndpointComplete Write 2")); if (!iDmaBuffers->TxIsActive()) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ENDPOINTCOMPLETE_DUP3, - " TX completion but !iDmaBuffers->TxIsActive()" ); + __KTRACE_OPT(KUSB, Kern::Printf(" TX completion but !iDmaBuffers->TxIsActive()")); break; } @@ -3060,10 +2855,8 @@ if (iClientReadPending) { //Complete outstanding read - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ENDPOINTCOMPLETE_DUP4, - "TUsbcEndpoint::EndpointComplete Read 3 (bytes available=%d)", - iDmaBuffers->RxBytesAvailable()); - + __KTRACE_OPT(KUSB, Kern::Printf("TUsbcEndpoint::EndpointComplete Read 3 (bytes " + "available=%d)", iDmaBuffers->RxBytesAvailable())); TInt bytesReqd = iTransferInfo.iTransferSize - iBytesTransferred; TBool completeNow = EFalse; @@ -3164,8 +2957,7 @@ const TBool KReadData = EFalse; const TBool KReadUntilShort = ETrue; - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_COPYTOCLIENT, - "CopyToClient: length = %d", length ); + __KTRACE_OPT(KUSB, Kern::Printf("CopyToClient: length = %d", length)); if (iTransferInfo.iTransferType == ETransferTypeReadPacket) { @@ -3201,15 +2993,13 @@ TInt TUsbcEndpoint::TryToStartRead(TBool aReEntrant) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTREAD, - "TryToStartRead 1 ep=%d", iEndpointNumber ); + __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead 1 ep=%d", iEndpointNumber)); TInt r = KErrNone; if (iEndpointInfo.iDir != KUsbEpDirOut && iEndpointInfo.iDir != KUsbEpDirBidirect) { // Verify ep direction - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTREAD_DUP1, - "TryToStartRead wrong direction ep=%d", iEndpointNumber ); + __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead wrong direction ep=%d", iEndpointNumber)); return KErrUsbEpBadDirection; } @@ -3218,15 +3008,12 @@ // Can't issue an Ep0 read if reader or writer is active if (iDmaBuffers->TxIsActive()) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTREAD_DUP2, - "TryToStartRead ep0 Tx already active FATAL" ); - + __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead ep0 Tx already active FATAL")); return KErrUsbEpNotReady; } if (iDmaBuffers->RxIsActive()) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTREAD_DUP3, - "TryToStartRead ep0 Rx already active non-FATAL" ); + __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead ep0 Rx already active non-FATAL")); } } @@ -3242,15 +3029,14 @@ { iDmaBuffers->RxSetActive(); iRequestCallbackInfo->SetRxBufferInfo(bufferAddr, physAddr, indexArray, sizeArray, length); - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTREAD_DUP4, - "TryToStartRead 2 bufferAddr=0x%08x", bufferAddr ); + + __KTRACE_OPT(KUSB, Kern::Printf("TryToStartRead 2 bufferAddr=0x%08x", bufferAddr)); r = iController->SetupReadBuffer(*iRequestCallbackInfo); if (r != KErrNone) { iDmaBuffers->RxSetInActive(); - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTREAD_DUP5, - " Error: TryToStartRead controller rejects read" ); + __KTRACE_OPT(KPANIC, Kern::Printf(" Error: TryToStartRead controller rejects read")); } } else @@ -3276,8 +3062,7 @@ TInt TUsbcEndpoint::TryToStartWrite(TEndpointTransferInfo* pTfr) { - OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_TRYTOSTARTWRITE, - "TryToStartWrite 1 ep=%d", iEndpointNumber ); + __KTRACE_OPT(KUSB, Kern::Printf("TryToStartWrite 1 ep=%d", iEndpointNumber)); if (iEndpointInfo.iDir != KUsbEpDirIn && iEndpointInfo.iDir != KUsbEpDirBidirect) { @@ -3306,16 +3091,14 @@ TInt TUsbcEndpoint::ContinueWrite() { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_CONTINUEWRITE, "ContinueWrite 2" ); + __KTRACE_OPT(KUSB, Kern::Printf("ContinueWrite 2")); TUint8* bufferAddr; TPhysAddr physAddr; TInt bufferLength; TInt r = iDmaBuffers->TxGetNextXfer(bufferAddr, bufferLength, physAddr); if (r != KErrNone) // probably already active return r; - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_CONTINUEWRITE_DUP1, - "ContinueWrite 3" ); - + __KTRACE_OPT(KUSB, Kern::Printf("ContinueWrite 3")); iDmaBuffers->TxSetActive(); TBool zlpReqd = EFalse; TUint32 transferSize = iTransferInfo.iTransferSize; @@ -3334,9 +3117,7 @@ #if 0 for (TInt i = 0; i < iRequestCallbackInfo->iLength; i++) { - OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_CONTINUEWRITE_DUP2, - "Buffer[%d] = 0x%02x", i, iRequestCallbackInfo->iBufferStart[i] ); - + __KTRACE_OPT(KUSB, Kern::Printf("Buffer[%d] = 0x%02x", i, iRequestCallbackInfo->iBufferStart[i])); } #endif r = iController->SetupWriteBuffer(*iRequestCallbackInfo); @@ -3346,21 +3127,19 @@ void TUsbcEndpoint::CancelTransfer(DThread* aThread, TClientBuffer *aTcb) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_CANCELTRANSFER, "CancelTransfer" ); + __KTRACE_OPT(KUSB, Kern::Printf("CancelTransfer")); if (iDmaBuffers != NULL) { if (iClientWritePending) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_CANCELTRANSFER_DUP1, - " (iClientWritePending)" ); + __KTRACE_OPT(KUSB, Kern::Printf(" (iClientWritePending)")); iClientWritePending = EFalse; iController->CancelWriteBuffer(iLdd, iRealEpNumber); iDmaBuffers->TxSetInActive(); } if (iClientReadPending) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_CANCELTRANSFER_DUP2, - " (iClientReadPending)" ); + __KTRACE_OPT(KUSB, Kern::Printf(" (iClientReadPending)")); iClientReadPending = EFalse; CopyToClient(aThread,aTcb); } @@ -3370,20 +3149,18 @@ void TUsbcEndpoint::AbortTransfer() { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ABORTTRANSFER, "Abort Transfer" ); + __KTRACE_OPT(KUSB, Kern::Printf("Abort Transfer")); if (iDmaBuffers != NULL) { if (iDmaBuffers->TxIsActive()) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ABORTTRANSFER_DUP1, - " (iClientWritePending)" ); + __KTRACE_OPT(KUSB, Kern::Printf(" (iClientWritePending)")); iController->CancelWriteBuffer(iLdd, iRealEpNumber); iDmaBuffers->TxSetInActive(); } if (iDmaBuffers->RxIsActive()) { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_NORMAL, TUSBCENDPOINT_ABORTTRANSFER_DUP2, - " (iClientReadPending)" ); + __KTRACE_OPT(KUSB, Kern::Printf(" (iClientReadPending)")); iController->CancelReadBuffer(iLdd, iRealEpNumber); iDmaBuffers->RxSetInActive(); } @@ -3407,8 +3184,7 @@ TUsbcAlternateSettingList::~TUsbcAlternateSettingList() { - OstTraceDef0( OST_TRACE_CATEGORY_RND, TRACE_FLOW, TUSBCALTERNATESETTINGLIST_TUSBCALTERNATESETTINGLIST_DES, - "TUsbcAlternateSettingList::~TUsbcAlternateSettingList()" ); + __KTRACE_OPT(KUSB, Kern::Printf("TUsbcAlternateSettingList::~TUsbcAlternateSettingList()")); for (TInt i = 0; i <= KMaxEndpointsPerClient; i++) { delete iEndpoint[i];