kerneltest/e32test/dmav2/self_test.cpp
changeset 247 d8d70de2bd36
parent 139 95f71bcdcdb7
child 293 0659d0e1a03c
equal deleted inserted replaced
201:43365a9b78a3 247:d8d70de2bd36
    29 #include <e32debug.h>
    29 #include <e32debug.h>
    30 #include <e32svr.h>
    30 #include <e32svr.h>
    31 
    31 
    32 static RTest test(_L("t_dma2 test framework tests"));
    32 static RTest test(_L("t_dma2 test framework tests"));
    33 
    33 
    34 void RDmaSession::SelfTest()
    34 void RDmaSession::SelfTest(TBool aSimulatedDmac)
    35 	{
    35 	{
    36 	test.Start(_L("Simple transfer test"));
    36 	test.Start(_L("Simple transfer test"));
    37 	test.Next(_L("Open session"));
    37 
    38 	RDmaSession session;
    38 	RDmaSession session;
    39 	TInt r = session.Open();
    39 	TInt r = KErrUnknown;
       
    40 	if (aSimulatedDmac)
       
    41 		{
       
    42 		test.Next(_L("Open session (simulated DMA)"));
       
    43 		r = session.OpenSim();
       
    44 		}
       
    45 	else
       
    46 		{
       
    47 		test.Next(_L("Open session"));
       
    48 		r = session.Open();
       
    49 		}
       
    50 
    40 	test_KErrNone(r);
    51 	test_KErrNone(r);
    41 
    52 
    42 	test.Next(_L("Get test info"));
    53 	test.Next(_L("Get test info"));
    43 	TDmaV2TestInfo testInfo;
    54 	TDmaV2TestInfo testInfo;
    44 	r = session.GetTestInfo(testInfo);
    55 	r = session.GetTestInfo(testInfo);
   132 		TUint reqCookieNewStyle=0;
   143 		TUint reqCookieNewStyle=0;
   133 		r = session.RequestCreate(channelCookie, reqCookieNewStyle);
   144 		r = session.RequestCreate(channelCookie, reqCookieNewStyle);
   134 		test.Printf(_L("cookie recived = 0x%08x\n"), reqCookieNewStyle );
   145 		test.Printf(_L("cookie recived = 0x%08x\n"), reqCookieNewStyle );
   135 		test_KErrNone(r);
   146 		test_KErrNone(r);
   136 
   147 
   137 		test.Next(_L("Fragment for ISR callback"));
   148 		if(!aSimulatedDmac)
   138 		const TInt size = 128 * KKilo;
   149 			{
   139 		TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);
   150 			test.Next(_L("Fragment for ISR callback"));
   140 		r = session.FragmentRequest(reqCookieNewStyle, transferArgs);
   151 			const TInt size = 128 * KKilo;
   141 		test_KErrNone(r);
   152 			TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr, KDmaSyncAuto, KDmaRequestCallbackFromIsr);
   142 
   153 			r = session.FragmentRequest(reqCookieNewStyle, transferArgs);
   143 		TIsrRequeArgs reque;
   154 			test_KErrNone(r);
   144 		test.Next(_L("Queue ISR callback - with default re-queue"));
   155 
   145 		r = session.QueueRequestWithRequeue(reqCookieNewStyle, &reque, 1);
   156 			TIsrRequeArgs reque;
   146 		test_KErrNone(r);
   157 			test.Next(_L("Queue ISR callback - with default re-queue"));
       
   158 			r = session.QueueRequestWithRequeue(reqCookieNewStyle, &reque, 1);
       
   159 			test_KErrNone(r);
       
   160 			}
   147 
   161 
   148 		test.Next(_L("Destroy new-style Dma request"));
   162 		test.Next(_L("Destroy new-style Dma request"));
   149 		r = session.RequestDestroy(reqCookieNewStyle);
   163 		r = session.RequestDestroy(reqCookieNewStyle);
   150 		test_KErrNone(r);
   164 		test_KErrNone(r);
   151 
   165 
   164 	test.Printf(_L("chunk size = %d\n"), chunk.Size());
   178 	test.Printf(_L("chunk size = %d\n"), chunk.Size());
   165 	}
   179 	}
   166 	test(chunk.IsWritable());
   180 	test(chunk.IsWritable());
   167 	test(chunk.IsReadable());
   181 	test(chunk.IsReadable());
   168 
   182 
   169 	test.Next(_L("Fragment(old style)"));
   183 	if(!aSimulatedDmac)
   170 	const TInt size = 128 * KKilo;
   184 		{
   171 	TInt i;
   185 		test.Next(_L("Fragment(old style)"));
   172 	for(i = 0; i<10; i++)
   186 		const TInt size = 128 * KKilo;
   173 		{
   187 		TInt i;
   174 		TUint64 time = 0;
       
   175 		TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr);
       
   176 		r = session.FragmentRequestOld(reqCookie, transferArgs, &time);
       
   177 		test_KErrNone(r);
       
   178 		if(gVerboseOutput)
       
   179 			{
       
   180 			test.Printf(_L("%lu us\n"), time);
       
   181 			}
       
   182 	}
       
   183 
       
   184 	test.Next(_L("Queue"));
       
   185 	TRequestStatus status;
       
   186 
       
   187 	for(i = 0; i<10; i++)
       
   188 		{
       
   189 		TUint64 time = 0;
       
   190 		r = session.QueueRequest(reqCookie, status, 0, &time);
       
   191 		User::WaitForRequest(status);
       
   192 		test_KErrNone(r);
       
   193 		if(gVerboseOutput)
       
   194 			{
       
   195 			test.Printf(_L("%lu us\n"), time);
       
   196 			}
       
   197 		}
       
   198 
       
   199 	if(newPil)
       
   200 		{
       
   201 		test.Next(_L("Fragment(new style)"));
       
   202 		TDmaTransferArgs transferArgs;
       
   203 		transferArgs.iSrcConfig.iAddr = 0;
       
   204 		transferArgs.iDstConfig.iAddr = size;
       
   205 		transferArgs.iSrcConfig.iFlags = KDmaMemAddr;
       
   206 		transferArgs.iDstConfig.iFlags = KDmaMemAddr;
       
   207 		transferArgs.iTransferCount = size;
       
   208 
       
   209 		for(i = 0; i<10; i++)
   188 		for(i = 0; i<10; i++)
   210 			{
   189 			{
   211 			TUint64 time = 0;
   190 			TUint64 time = 0;
   212 			r = session.FragmentRequest(reqCookie, transferArgs, &time);
   191 			TDmaTransferArgs transferArgs(0, size, size, KDmaMemAddr);
       
   192 			r = session.FragmentRequestOld(reqCookie, transferArgs, &time);
   213 			test_KErrNone(r);
   193 			test_KErrNone(r);
   214 			if(gVerboseOutput)
   194 			if(gVerboseOutput)
   215 				{
   195 				{
   216 				test.Printf(_L("%lu us\n"), time);
   196 				test.Printf(_L("%lu us\n"), time);
   217 				}
   197 				}
   218 			}
   198 			}
   219 		}
   199 
   220 
   200 		test.Next(_L("Queue"));
   221 	test.Next(_L("Queue"));
   201 		TRequestStatus status;
   222 	TCallbackRecord record;
   202 
   223 	r = session.QueueRequest(reqCookie, &record);
   203 		for(i = 0; i<10; i++)
   224 	test_KErrNone(r);
   204 			{
   225 
   205 			TUint64 time = 0;
   226 	test.Next(_L("check TCallbackRecord record"));
   206 			r = session.QueueRequest(reqCookie, status, 0, &time);
   227 	if(gVerboseOutput)
   207 			User::WaitForRequest(status);
   228 	{
   208 			test_KErrNone(r);
   229 	record.Print();
   209 			if(gVerboseOutput)
   230 	}
   210 				{
   231 	const TCallbackRecord expected(TCallbackRecord::EThread, 1);
   211 				test.Printf(_L("%lu us\n"), time);
   232 	if(!(record == expected))
   212 				}
   233 		{
   213 			}
   234 		test.Printf(_L("TCallbackRecords did not match"));
   214 
       
   215 		if(newPil)
       
   216 			{
       
   217 			test.Next(_L("Fragment(new style)"));
       
   218 			TDmaTransferArgs transferArgs;
       
   219 			transferArgs.iSrcConfig.iAddr = 0;
       
   220 			transferArgs.iDstConfig.iAddr = size;
       
   221 			transferArgs.iSrcConfig.iFlags = KDmaMemAddr;
       
   222 			transferArgs.iDstConfig.iFlags = KDmaMemAddr;
       
   223 			transferArgs.iTransferCount = size;
       
   224 
       
   225 			for(i = 0; i<10; i++)
       
   226 				{
       
   227 				TUint64 time = 0;
       
   228 				r = session.FragmentRequest(reqCookie, transferArgs, &time);
       
   229 				test_KErrNone(r);
       
   230 				if(gVerboseOutput)
       
   231 					{
       
   232 					test.Printf(_L("%lu us\n"), time);
       
   233 					}
       
   234 				}
       
   235 			}
       
   236 
       
   237 		test.Next(_L("Queue"));
       
   238 		TCallbackRecord record;
       
   239 		r = session.QueueRequest(reqCookie, &record);
       
   240 		test_KErrNone(r);
       
   241 
       
   242 		test.Next(_L("check TCallbackRecord record"));
   235 		if(gVerboseOutput)
   243 		if(gVerboseOutput)
       
   244 		{
       
   245 		record.Print();
       
   246 		}
       
   247 		const TCallbackRecord expected(TCallbackRecord::EThread, 1);
       
   248 		if(!(record == expected))
   236 			{
   249 			{
   237 			test.Printf(_L("expected:"));
   250 			test.Printf(_L("TCallbackRecords did not match"));
   238 			expected.Print();
   251 			if(gVerboseOutput)
       
   252 				{
       
   253 				test.Printf(_L("expected:"));
       
   254 				expected.Print();
       
   255 				}
       
   256 			TEST_FAULT;
   239 			}
   257 			}
   240 		TEST_FAULT;
       
   241 		}
   258 		}
   242 
   259 
   243 	test.Next(_L("Destroy Dma request"));
   260 	test.Next(_L("Destroy Dma request"));
   244 	r = session.RequestDestroy(reqCookie);
   261 	r = session.RequestDestroy(reqCookie);
   245 	test_KErrNone(r);
   262 	test_KErrNone(r);
   257 
   274 
   258 	test.Next(_L("Close session"));
   275 	test.Next(_L("Close session"));
   259 	RTest::CloseHandleAndWaitForDestruction(session);
   276 	RTest::CloseHandleAndWaitForDestruction(session);
   260 
   277 
   261 	test.End();
   278 	test.End();
   262 
       
   263 	}
   279 	}
   264 
   280 
   265 const SDmacCaps KTestCapSet =
   281 const SDmacCaps KTestCapSet =
   266 	{6,										// TInt iChannelPriorities;
   282 	{6,										// TInt iChannelPriorities;
   267 	 EFalse,								// TBool iChannelPauseAndResume;
   283 	 EFalse,								// TBool iChannelPauseAndResume;
   813 	}
   829 	}
   814 
   830 
   815 void SelfTests()
   831 void SelfTests()
   816 	{
   832 	{
   817 	test.Next(_L("Running framework unit tests"));
   833 	test.Next(_L("Running framework unit tests"));
   818 	RDmaSession::SelfTest();
   834 #ifndef __WINS__
       
   835 	// Cannot connect real driver on Emulator - only
       
   836 	// simulator
       
   837 	RDmaSession::SelfTest(EFalse);
       
   838 #endif
       
   839 	RDmaSession::SelfTest(ETrue);
   819 	TDmaCapability::SelfTest();
   840 	TDmaCapability::SelfTest();
   820 	TTestCase::SelfTest();
   841 	TTestCase::SelfTest();
   821 	TTransferIter::SelfTest();
   842 	TTransferIter::SelfTest();
   822 	TCallbackRecord::SelfTest();
   843 	TCallbackRecord::SelfTest();
   823 	CDmaBmFragmentation::SelfTest();
   844 	CDmaBmFragmentation::SelfTest();