189
|
1 |
/*
|
253
|
2 |
* Copyright (c) 1997-2010 Nokia Corporation and/or its subsidiary(-ies).
|
189
|
3 |
* All rights reserved.
|
|
4 |
* This component and the accompanying materials are made available
|
|
5 |
* under the terms of "Eclipse Public License v1.0"
|
|
6 |
* which accompanies this distribution, and is available
|
|
7 |
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
8 |
*
|
|
9 |
* Initial Contributors:
|
|
10 |
* Nokia Corporation - initial contribution.
|
|
11 |
*
|
|
12 |
* Contributors:
|
|
13 |
*
|
|
14 |
*
|
|
15 |
*/
|
|
16 |
|
|
17 |
/**
|
|
18 |
@file
|
|
19 |
*/
|
|
20 |
|
|
21 |
#include <e32svr.h>
|
|
22 |
#include "transferserver.h"
|
|
23 |
#include "transfersession.h"
|
|
24 |
#include "transfersrv.h"
|
|
25 |
#include "transferserversecuritypolicy.h"
|
|
26 |
#include "transferhandle.h"
|
|
27 |
#include "tranhandlesrv.h"
|
253
|
28 |
#include "OstTraceDefinitions.h"
|
|
29 |
#ifdef OST_TRACE_COMPILER_IN_USE
|
|
30 |
#include "transferserverTraces.h"
|
|
31 |
#endif
|
189
|
32 |
|
|
33 |
|
|
34 |
|
|
35 |
TBool gVerbose = ETrue;
|
|
36 |
extern RTest test;
|
|
37 |
|
|
38 |
|
|
39 |
CTransferServer* CTransferServer::NewLC()
|
|
40 |
{
|
253
|
41 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_NEWLC, "CTransferServer::NewLC");
|
189
|
42 |
CTransferServer* self = new(ELeave) CTransferServer;
|
|
43 |
CleanupStack::PushL(self);
|
|
44 |
self->StartL(KTransferServerName);
|
|
45 |
self->ConstructL();
|
|
46 |
return self;
|
|
47 |
}
|
|
48 |
|
|
49 |
CTransferServer::~CTransferServer()
|
|
50 |
{
|
253
|
51 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_DCTRANSFERSERVER, "CTransferServer::~CTransferServer");
|
189
|
52 |
while (iLddPtr->iIFPtr)
|
|
53 |
{
|
|
54 |
IFConfigPtr* ifPtrPtr = & iLddPtr->iIFPtr;
|
|
55 |
while ((*ifPtrPtr)->iPtrNext)
|
|
56 |
{
|
|
57 |
ifPtrPtr = &(*ifPtrPtr)->iPtrNext;
|
|
58 |
}
|
|
59 |
delete (*ifPtrPtr)->iInfoPtr->iString;
|
|
60 |
delete (*ifPtrPtr)->iInfoPtr;
|
|
61 |
delete (*ifPtrPtr);
|
|
62 |
* ifPtrPtr = NULL;
|
|
63 |
}
|
|
64 |
|
|
65 |
while (iLddPtr)
|
|
66 |
{
|
|
67 |
LDDConfigPtr* lddPtrPtr = &iLddPtr;
|
|
68 |
while ((*lddPtrPtr)->iPtrNext)
|
|
69 |
{
|
|
70 |
lddPtrPtr = &(*lddPtrPtr)->iPtrNext;
|
|
71 |
}
|
|
72 |
delete (*lddPtrPtr)->iManufacturer;
|
|
73 |
delete (*lddPtrPtr)->iProduct;
|
|
74 |
delete (*lddPtrPtr)->iSerialNumber;
|
|
75 |
delete (*lddPtrPtr);
|
|
76 |
* lddPtrPtr = NULL;
|
|
77 |
}
|
|
78 |
|
|
79 |
delete iShutdownTimer;
|
|
80 |
delete iTransferHandle;
|
253
|
81 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_DCTRANSFERSERVER_DUP01, "<<<CTransferServer::~CTransferServer");
|
189
|
82 |
}
|
|
83 |
|
|
84 |
|
|
85 |
CTransferServer::CTransferServer()
|
|
86 |
: CPolicyServer(EPriorityHigh,KTransferServerPolicy)
|
|
87 |
{
|
|
88 |
}
|
|
89 |
|
|
90 |
void CTransferServer::ConstructL()
|
|
91 |
{
|
|
92 |
iShutdownTimer = new(ELeave) CShutdownTimer;
|
|
93 |
iShutdownTimer->ConstructL();
|
|
94 |
|
|
95 |
iTransferHandle = CTransferHandle::NewL(*this);
|
253
|
96 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_CONSTRUCTL, "CTransferServer::ConstructL");
|
189
|
97 |
}
|
|
98 |
|
|
99 |
|
|
100 |
CSession2* CTransferServer::NewSessionL(const TVersion &aVersion, const RMessage2& aMessage) const
|
|
101 |
{
|
|
102 |
(void)aMessage;//Remove compiler warning
|
|
103 |
(void)aVersion;//Remove compiler warning
|
|
104 |
|
|
105 |
CTransferServer* ncThis = const_cast<CTransferServer*>(this);
|
|
106 |
|
|
107 |
CTransferSession* sess = CTransferSession::NewL(ncThis);
|
|
108 |
|
|
109 |
return sess;
|
|
110 |
}
|
|
111 |
|
|
112 |
|
|
113 |
void CTransferServer::Error(TInt aError)
|
|
114 |
{
|
253
|
115 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_ERROR, "CTransferServer::Error");
|
189
|
116 |
Message().Complete(aError);
|
|
117 |
ReStart();
|
|
118 |
}
|
|
119 |
|
|
120 |
void CTransferServer::IncrementSessionCount()
|
|
121 |
{
|
253
|
122 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_INCREMENTSESSIONCOUNT, "CTransferServer::IncrementSessionCount");
|
189
|
123 |
|
|
124 |
++iSessionCount;
|
|
125 |
iShutdownTimer->Cancel();
|
|
126 |
|
|
127 |
}
|
|
128 |
|
|
129 |
void CTransferServer::DecrementSessionCount()
|
|
130 |
{
|
|
131 |
--iSessionCount;
|
253
|
132 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_DECREMENTSESSIONCOUNT, "CTransferServer::DecrementSessionCount");
|
189
|
133 |
if (iSessionCount == 0)
|
|
134 |
{
|
|
135 |
iShutdownTimer->After(KShutdownDelay);
|
253
|
136 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_DECREMENTSESSIONCOUNT_DUP01, "CTransferServer::DecrementSessionCount1");
|
189
|
137 |
}
|
|
138 |
}
|
|
139 |
|
|
140 |
void CTransferServer::LaunchShutdownTimerIfNoSessions()
|
|
141 |
{
|
|
142 |
if (iSessionCount == 0)
|
|
143 |
iShutdownTimer->After(KShutdownDelay);
|
|
144 |
}
|
|
145 |
|
|
146 |
CTransferServer::CShutdownTimer::CShutdownTimer()
|
|
147 |
: CTimer(EPriorityStandard)
|
|
148 |
{
|
|
149 |
CActiveScheduler::Add(this);
|
|
150 |
}
|
|
151 |
|
|
152 |
|
|
153 |
void CTransferServer::CShutdownTimer::ConstructL()
|
|
154 |
{
|
253
|
155 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_LAUNCHSHUTDOWNTIMERIFNOSESSIONS, "CTransferServer::CShutdownTimer::ConstructL");
|
189
|
156 |
CTimer::ConstructL();
|
|
157 |
}
|
|
158 |
|
|
159 |
|
|
160 |
void CTransferServer::CShutdownTimer::RunL()
|
|
161 |
{
|
253
|
162 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_LAUNCHSHUTDOWNTIMERIFNOSESSIONS_DUP01, "CShutdownTimer::RunL");
|
189
|
163 |
CActiveScheduler::Stop();
|
|
164 |
}
|
|
165 |
|
|
166 |
|
|
167 |
void CTransferServer::TransferHandleL()
|
|
168 |
{
|
|
169 |
RTranHandleSrv aServer;
|
|
170 |
RChunk* commChunk = NULL;
|
|
171 |
User::LeaveIfError(aServer.Connect());
|
|
172 |
User::LeaveIfError(iPort[0].GetDataTransferChunk(commChunk));
|
|
173 |
User::LeaveIfError(aServer.TransferHandle(iPort[0], *commChunk));
|
|
174 |
aServer.Close();
|
|
175 |
commChunk->Close();
|
|
176 |
iPort[0].Close();
|
|
177 |
}
|
|
178 |
|
|
179 |
void CTransferServer::FillEndpointsResourceAllocation(IFConfigPtr aIfCfg)
|
|
180 |
{
|
|
181 |
|
|
182 |
#ifdef USB_SC
|
|
183 |
TUsbcScInterfaceInfo* iInfoPtr = aIfCfg->iInfoPtr;
|
|
184 |
#else
|
|
185 |
TUsbcInterfaceInfo* iInfoPtr = aIfCfg->iInfoPtr;
|
|
186 |
#endif
|
|
187 |
|
|
188 |
// fill resource allocation info in the endpoint info with resource allocation v2
|
|
189 |
for (TUint8 i = 1; i <= iInfoPtr->iTotalEndpointsUsed; i++)
|
|
190 |
{
|
|
191 |
if (aIfCfg->iEpDMA[i-1])
|
|
192 |
{
|
|
193 |
iInfoPtr->iEndpointData[i-1].iFeatureWord1 |= KUsbcEndpointInfoFeatureWord1_DMA;
|
|
194 |
}
|
|
195 |
else
|
|
196 |
{
|
|
197 |
iInfoPtr->iEndpointData[i-1].iFeatureWord1 &= (~KUsbcEndpointInfoFeatureWord1_DMA);
|
|
198 |
}
|
|
199 |
#ifndef USB_SC
|
|
200 |
if (aIfCfg->iEpDoubleBuff[i-1])
|
|
201 |
{
|
|
202 |
iInfoPtr->iEndpointData[i-1].iFeatureWord1 |= KUsbcEndpointInfoFeatureWord1_DoubleBuffering;
|
|
203 |
}
|
|
204 |
else
|
|
205 |
{
|
|
206 |
iInfoPtr->iEndpointData[i-1].iFeatureWord1 &= (~KUsbcEndpointInfoFeatureWord1_DoubleBuffering);
|
|
207 |
}
|
|
208 |
#endif
|
|
209 |
}
|
|
210 |
}
|
|
211 |
|
|
212 |
|
|
213 |
void CTransferServer::PopulateInterfaceResourceAllocation(IFConfigPtr aFirstIfCfg, TInt aPortNumber)
|
|
214 |
{
|
|
215 |
FillEndpointsResourceAllocation(aFirstIfCfg);
|
|
216 |
|
|
217 |
IFConfigPtr ifCfgPtr = aFirstIfCfg->iPtrNext;
|
|
218 |
while (ifCfgPtr != NULL)
|
|
219 |
{
|
|
220 |
if (ifCfgPtr->iAlternateSetting)
|
|
221 |
{
|
|
222 |
FillEndpointsResourceAllocation(ifCfgPtr);
|
|
223 |
ifCfgPtr = ifCfgPtr->iPtrNext;
|
|
224 |
}
|
|
225 |
else
|
|
226 |
{
|
|
227 |
ifCfgPtr = NULL;
|
|
228 |
}
|
|
229 |
}
|
|
230 |
}
|
|
231 |
|
|
232 |
void CTransferServer::SetupInterface(IFConfigPtr* aIfPtr, TInt aPortNumber)
|
|
233 |
{
|
|
234 |
test.Start (_L("Setup Interface"));
|
|
235 |
|
|
236 |
// first of all set the default interface
|
|
237 |
TUSB_PRINT2 ("Set Default Interface with %d endpoints bandwidth 0x%x",(*aIfPtr)->iInfoPtr->iTotalEndpointsUsed,(*aIfPtr)->iBandwidthIn | (*aIfPtr)->iBandwidthOut);
|
253
|
238 |
OstTraceExt2 (TRACE_NORMAL, CTRANSFERSERVER_SETUPINTERFACE, "Set Default Interface with %d endpoints bandwidth 0x%x",(*aIfPtr)->iInfoPtr->iTotalEndpointsUsed,(*aIfPtr)->iBandwidthIn | (*aIfPtr)->iBandwidthOut);
|
189
|
239 |
#ifdef USB_SC
|
|
240 |
TUsbcScInterfaceInfoBuf ifc = *((*aIfPtr)->iInfoPtr);
|
|
241 |
TInt r = iPort[aPortNumber].SetInterface(0, ifc);
|
|
242 |
#else
|
|
243 |
TUsbcInterfaceInfoBuf ifc = *((*aIfPtr)->iInfoPtr);
|
|
244 |
TInt r = iPort[aPortNumber].SetInterface(0, ifc, (*aIfPtr)->iBandwidthIn | (*aIfPtr)->iBandwidthOut);
|
|
245 |
#endif
|
|
246 |
test_KErrNone(r);
|
|
247 |
|
|
248 |
TBuf8<KUsbDescSize_Interface> ifDescriptor;
|
|
249 |
r = iPort[aPortNumber].GetInterfaceDescriptor(0, ifDescriptor);
|
|
250 |
test_KErrNone(r);
|
|
251 |
|
|
252 |
// Check the interface descriptor
|
|
253 |
test(ifDescriptor[KIfcDesc_SettingOffset] == 0 && ifDescriptor[KIfcDesc_NumEndpointsOffset] == (*aIfPtr)->iInfoPtr->iTotalEndpointsUsed &&
|
|
254 |
ifDescriptor[KIfcDesc_ClassOffset] == (*aIfPtr)->iInfoPtr->iClass.iClassNum &&
|
|
255 |
ifDescriptor[KIfcDesc_SubClassOffset] == (*aIfPtr)->iInfoPtr->iClass.iSubClassNum &&
|
|
256 |
ifDescriptor[KIfcDesc_ProtocolOffset] == (*aIfPtr)->iInfoPtr->iClass.iProtocolNum);
|
|
257 |
|
|
258 |
if ((*aIfPtr)->iNumber != 0 && ifDescriptor[KIfcDesc_NumberOffset] != (*aIfPtr)->iNumber)
|
|
259 |
{
|
|
260 |
ifDescriptor[KIfcDesc_NumberOffset] = (*aIfPtr)->iNumber;
|
|
261 |
r = iPort[aPortNumber].SetInterfaceDescriptor(0, ifDescriptor);
|
|
262 |
test_KErrNone(r);
|
|
263 |
}
|
|
264 |
else
|
|
265 |
{
|
|
266 |
(*aIfPtr)->iNumber = ifDescriptor[KIfcDesc_NumberOffset];
|
|
267 |
}
|
|
268 |
TUint8 interfaceNumber = (*aIfPtr)->iNumber;
|
|
269 |
TUSB_PRINT1 ("Interface Number %d",interfaceNumber);
|
253
|
270 |
OstTrace1 (TRACE_NORMAL, CTRANSFERSERVER_SETUPINTERFACE_DUP01, "Interface Number %d",interfaceNumber);
|
189
|
271 |
test.End();
|
|
272 |
}
|
|
273 |
|
|
274 |
|
|
275 |
TInt CTransferServer::SetupLdds(TDes& aFileName)
|
|
276 |
{
|
|
277 |
TInt r;
|
|
278 |
User::LeaveIfError(iFs.Connect());
|
|
279 |
|
253
|
280 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_SETUPLDDS, "Configuration");
|
189
|
281 |
|
253
|
282 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_SETUPLDDS_DUP01, "Open configuration file");
|
189
|
283 |
// set the session path to use the ROM if no drive specified
|
|
284 |
r=iFs.SetSessionPath(_L("Z:\\test\\"));
|
|
285 |
test_KErrNone(r);
|
|
286 |
|
|
287 |
r = iConfigFile.Open(iFs, aFileName, EFileShareReadersOnly | EFileStreamText | EFileRead);
|
|
288 |
test_KErrNone(r);
|
253
|
289 |
OstTraceExt1(TRACE_NORMAL, CTRANSFERSERVER_SETUPLDDS_DUP02, "Configuration file %S Opened successfully", aFileName);
|
189
|
290 |
|
253
|
291 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_SETUPLDDS_DUP03, "Process configuration file");
|
189
|
292 |
test(ProcessConfigFile (iConfigFile,NULL,&iLddPtr));
|
|
293 |
|
|
294 |
iConfigFile.Close();
|
|
295 |
iFs.Close();
|
|
296 |
|
253
|
297 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_SETUPLDDS_DUP04, "LDD in configuration file");
|
189
|
298 |
test_NotNull(iLddPtr);
|
|
299 |
|
|
300 |
LDDConfigPtr lddPtr = iLddPtr;
|
|
301 |
TInt nextPort = 0;
|
|
302 |
while (lddPtr != NULL)
|
|
303 |
{
|
|
304 |
// Load logical driver (LDD)
|
|
305 |
// (There's no physical driver (PDD) with USB: it's a kernel extension DLL which
|
|
306 |
// was already loaded at boot time.)
|
253
|
307 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_SETUPLDDS_DUP05, "Loading USB LDD");
|
189
|
308 |
TUSB_PRINT1("Loading USB LDD ",lddPtr->iName.PtrZ());
|
253
|
309 |
OstTraceExt1(TRACE_NORMAL, CTRANSFERSERVER_SETUPLDDS_DUP06, "Loading USB LDD %s",lddPtr->iName);
|
189
|
310 |
r = User::LoadLogicalDevice(lddPtr->iName);
|
|
311 |
test(r == KErrNone || r == KErrAlreadyExists);
|
|
312 |
|
|
313 |
IFConfigPtr ifPtr = lddPtr->iIFPtr;
|
|
314 |
|
253
|
315 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_SETUPLDDS_DUP07, "Opening Channels");
|
189
|
316 |
for (TInt portNumber = nextPort; portNumber < nextPort+lddPtr->iNumChannels; portNumber++)
|
|
317 |
{
|
|
318 |
test_Compare(lddPtr->iNumChannels,>,0);
|
|
319 |
test_Compare(lddPtr->iNumChannels,==,1);
|
|
320 |
|
|
321 |
// Open USB channel
|
|
322 |
r = iPort[portNumber].Open(0);
|
|
323 |
test_KErrNone(r);
|
|
324 |
TUSB_PRINT("Successfully opened USB port");
|
253
|
325 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_SETUPLDDS_DUP08, "Successfully opened USB port");
|
189
|
326 |
|
|
327 |
// Query the USB device/Setup the USB interface
|
|
328 |
if (portNumber == nextPort)
|
|
329 |
{
|
|
330 |
// Change some descriptors to contain suitable values
|
|
331 |
//SetupDescriptors(lddPtr, &iPort[portNumber]);
|
|
332 |
}
|
|
333 |
|
|
334 |
|
|
335 |
test_NotNull(ifPtr);
|
|
336 |
|
|
337 |
if (iSupportResourceAllocationV2)
|
|
338 |
{
|
|
339 |
PopulateInterfaceResourceAllocation(ifPtr, portNumber);
|
|
340 |
}
|
|
341 |
|
|
342 |
SetupInterface(&ifPtr,portNumber);
|
|
343 |
|
|
344 |
#ifdef USB_SC
|
|
345 |
// RChunk *tChunk = &gChunk;
|
|
346 |
test_KErrNone(iPort[portNumber].FinalizeInterface());
|
|
347 |
#endif
|
|
348 |
|
|
349 |
}
|
|
350 |
|
|
351 |
iTotalChannels += lddPtr->iNumChannels;
|
|
352 |
nextPort += lddPtr->iNumChannels;
|
|
353 |
lddPtr = lddPtr->iPtrNext;
|
|
354 |
}
|
|
355 |
|
|
356 |
TUSB_PRINT("All Interfaces and Alternate Settings successfully set up");
|
253
|
357 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_SETUPLDDS_DUP09, "All Interfaces and Alternate Settings successfully set up");
|
189
|
358 |
|
|
359 |
iTransferHandle->StartTimer();
|
|
360 |
|
|
361 |
return KErrNone;
|
|
362 |
}
|
|
363 |
|
|
364 |
void CTransferServer::QueryUsbClientL(LDDConfigPtr aLddPtr, RDEVCLIENT* aPort)
|
|
365 |
{
|
|
366 |
test.Start(_L("Query device and Endpoint Capabilities"));
|
|
367 |
|
|
368 |
|
|
369 |
TUsbDeviceCaps d_caps;
|
|
370 |
TInt r = aPort->DeviceCaps(d_caps);
|
|
371 |
test_KErrNone(r);
|
|
372 |
|
|
373 |
const TInt n = d_caps().iTotalEndpoints;
|
|
374 |
|
|
375 |
TUSB_PRINT("### USB device capabilities:");
|
253
|
376 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_QUERYUSBCLIENTL, "### USB device capabilities:");
|
189
|
377 |
TUSB_PRINT1("Number of endpoints: %d", n);
|
253
|
378 |
OstTrace1(TRACE_NORMAL, CTRANSFERSERVER_QUERYUSBCLIENTL_DUP01, "Number of endpoints: %d", n);
|
189
|
379 |
TUSB_PRINT1("Supports Software-Connect: %s",
|
|
380 |
d_caps().iConnect ? _S("yes") : _S("no"));
|
253
|
381 |
OstTraceExt1(TRACE_NORMAL, CTRANSFERSERVER_QUERYUSBCLIENTL_DUP02, "Supports Software-Connect: %s",
|
|
382 |
d_caps().iConnect ? _L("yes") : _L("no"));
|
189
|
383 |
TUSB_PRINT1("Device is Self-Powered: %s",
|
253
|
384 |
d_caps().iConnect ? _S("yes") : _S("no"));
|
|
385 |
OstTraceExt1(TRACE_NORMAL, CTRANSFERSERVER_QUERYUSBCLIENTL_DUP03, "Device is Self-Powered: %s",
|
|
386 |
d_caps().iSelfPowered ? _L("yes") : _L("no"));
|
189
|
387 |
TUSB_PRINT1("Supports Remote-Wakeup: %s",
|
253
|
388 |
d_caps().iConnect ? _S("yes") : _S("no"));
|
|
389 |
OstTraceExt1(TRACE_NORMAL, CTRANSFERSERVER_QUERYUSBCLIENTL_DUP04, "Supports Remote-Wakeup: %s",
|
|
390 |
d_caps().iRemoteWakeup ? _L("yes") : _L("no"));
|
189
|
391 |
TUSB_PRINT1("Supports High-speed: %s",
|
253
|
392 |
d_caps().iConnect ? _S("yes") : _S("no"));
|
|
393 |
OstTraceExt1(TRACE_NORMAL, CTRANSFERSERVER_QUERYUSBCLIENTL_DUP05, "Supports High-speed: %s",
|
|
394 |
d_caps().iHighSpeed ? _L("yes") : _L("no"));
|
189
|
395 |
TUSB_PRINT1("Supports unpowered cable detection: %s\n",
|
253
|
396 |
d_caps().iConnect ? _S("yes") : _S("no"));
|
|
397 |
OstTraceExt1(TRACE_NORMAL, CTRANSFERSERVER_QUERYUSBCLIENTL_DUP06, "Supports unpowered cable detection: %s\n",
|
189
|
398 |
(d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_CableDetectWithoutPower) ?
|
253
|
399 |
_L("yes") : _L("no"));
|
189
|
400 |
TUSB_PRINT1("Supports endpoint resource allocation v2 scheme: %s\n",
|
253
|
401 |
d_caps().iConnect ? _S("yes") : _S("no"));
|
|
402 |
OstTraceExt1(TRACE_NORMAL, CTRANSFERSERVER_QUERYUSBCLIENTL_DUP07, "Supports endpoint resource allocation v2 scheme: %s\n",
|
189
|
403 |
(d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_EndpointResourceAllocV2) ?
|
253
|
404 |
_L("yes") : _L("no"));
|
189
|
405 |
TUSB_PRINT("");
|
253
|
406 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_QUERYUSBCLIENTL_DUP08, "");
|
189
|
407 |
|
|
408 |
iSoftwareConnect = d_caps().iConnect; // we need to remember this
|
|
409 |
test_Equal(aLddPtr->iSoftConnect,iSoftwareConnect);
|
|
410 |
|
|
411 |
iSupportResourceAllocationV2 = ((d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_EndpointResourceAllocV2) != 0);
|
|
412 |
|
|
413 |
// only check capabilities if set; therefore allowing them to be disabled
|
|
414 |
if (aLddPtr->iSelfPower)
|
|
415 |
{
|
|
416 |
test(d_caps().iSelfPowered);
|
|
417 |
}
|
|
418 |
|
|
419 |
// only check capabilities if set; therefore allowing them to be disabled
|
|
420 |
if (aLddPtr->iRemoteWakeup)
|
|
421 |
{
|
|
422 |
test(d_caps().iRemoteWakeup);
|
|
423 |
}
|
|
424 |
|
|
425 |
test_Equal(d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_CableDetectWithoutPower,aLddPtr->iFeatures);
|
|
426 |
|
|
427 |
// only check capability if set; therefore allowing it to be disabled
|
|
428 |
if (aLddPtr->iHighSpeed)
|
|
429 |
{
|
|
430 |
test(d_caps().iHighSpeed);
|
|
431 |
}
|
|
432 |
|
|
433 |
test_Equal(aLddPtr->iNumEndpoints,n);
|
|
434 |
|
|
435 |
// Endpoints
|
|
436 |
TUsbcEndpointData data[KUsbcMaxEndpoints];
|
|
437 |
TPtr8 dataptr(reinterpret_cast<TUint8*>(data), sizeof(data), sizeof(data));
|
|
438 |
r = aPort->EndpointCaps(dataptr);
|
|
439 |
test_KErrNone(r);
|
|
440 |
|
|
441 |
TUSB_PRINT("### USB device endpoint capabilities:");
|
253
|
442 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_QUERYUSBCLIENTL_DUP09, "### USB device endpoint capabilities:");
|
189
|
443 |
for (TInt i = 0; i < n; i++)
|
|
444 |
{
|
|
445 |
const TUsbcEndpointCaps* caps = &data[i].iCaps;
|
|
446 |
|
|
447 |
|
|
448 |
TBuf<40> sizeStr(_S("unknown"));
|
|
449 |
if (caps->iSizes == KUsbEpNotAvailable)
|
|
450 |
{
|
|
451 |
sizeStr = _S("Not Available");
|
|
452 |
}
|
|
453 |
else
|
|
454 |
{
|
|
455 |
sizeStr.SetLength(0);
|
|
456 |
if (caps->iSizes & KUsbEpSizeCont)
|
|
457 |
sizeStr.Append(_S(" Continuous"),11);
|
|
458 |
if (caps->iSizes & KUsbEpSize8)
|
|
459 |
sizeStr.Append(_S(" 8"),2);
|
|
460 |
if (caps->iSizes & KUsbEpSize16)
|
|
461 |
sizeStr.Append(_S(" 16"),3);
|
|
462 |
if (caps->iSizes & KUsbEpSize32)
|
|
463 |
sizeStr.Append(_S(" 32"),3);
|
|
464 |
if (caps->iSizes & KUsbEpSize64)
|
|
465 |
sizeStr.Append(_S(" 64"),3);
|
|
466 |
if (caps->iSizes & KUsbEpSize128)
|
|
467 |
sizeStr.Append(_S(" 128"),4);
|
|
468 |
if (caps->iSizes & KUsbEpSize256)
|
|
469 |
sizeStr.Append(_S(" 256"),4);
|
|
470 |
if (caps->iSizes & KUsbEpSize512)
|
|
471 |
sizeStr.Append(_S(" 512"),4);
|
|
472 |
if (caps->iSizes & KUsbEpSize1023)
|
|
473 |
sizeStr.Append(_S(" 1023"),5);
|
|
474 |
if (caps->iSizes & KUsbEpSize1024)
|
|
475 |
sizeStr.Append(_S(" 1024"),5);
|
|
476 |
}
|
|
477 |
|
|
478 |
TBuf<40> typeStr(_S("unknown"));
|
|
479 |
if (caps->iTypesAndDir == KUsbEpNotAvailable)
|
|
480 |
typeStr = _S("Not Available");
|
|
481 |
if (caps->iTypesAndDir & (KUsbEpTypeControl | KUsbEpTypeBulk | KUsbEpTypeInterrupt | KUsbEpTypeIsochronous))
|
|
482 |
{
|
|
483 |
typeStr.SetLength(0);
|
|
484 |
if (caps->iTypesAndDir & KUsbEpTypeBulk)
|
|
485 |
typeStr.Append(_S("Control "),8);
|
|
486 |
if (caps->iTypesAndDir & KUsbEpTypeBulk)
|
|
487 |
typeStr.Append(_S("Bulk "),5);
|
|
488 |
if (caps->iTypesAndDir & KUsbEpTypeInterrupt)
|
|
489 |
typeStr.Append(_S("Interrupt "),10);
|
|
490 |
if (caps->iTypesAndDir & KUsbEpTypeIsochronous)
|
|
491 |
typeStr.Append(_S("Isochronous"),11);
|
|
492 |
}
|
|
493 |
|
|
494 |
TBuf<20> directionStr(_S("unknown"));
|
|
495 |
|
|
496 |
if (caps->iTypesAndDir & KUsbEpDirIn)
|
|
497 |
directionStr = _S("In");
|
|
498 |
if (caps->iTypesAndDir & KUsbEpDirOut)
|
|
499 |
directionStr = _S("Out");
|
|
500 |
if (caps->iTypesAndDir & KUsbEpDirBidirect)
|
|
501 |
directionStr = _S("Both");
|
|
502 |
|
|
503 |
TUSB_PRINT4("Endpoint:%d Sizes =%s Type = %s - %s",
|
253
|
504 |
i+1,sizeStr.PtrZ(), typeStr.PtrZ(), directionStr.PtrZ());
|
|
505 |
OstTraceExt4(TRACE_NORMAL, CTRANSFERSERVER_QUERYUSBCLIENTL_DUP10, "Endpoint:%d Sizes =%S Type = %S - %S",
|
|
506 |
i+1,sizeStr, typeStr, directionStr);
|
189
|
507 |
}
|
|
508 |
TUSB_PRINT("");
|
253
|
509 |
OstTrace0(TRACE_NORMAL, CTRANSFERSERVER_QUERYUSBCLIENTL_DUP11, "");
|
189
|
510 |
|
|
511 |
test.End();
|
|
512 |
|
|
513 |
}
|
|
514 |
|