FCL/sf/os/kernelhwsrv: comparison kernel/eka/drivers/dma/dma2

equal deleted inserted replaced

-:a5496987b1da
+:189ece41fa29
 #include <drivers/dma_hai.h>
 #include <kernel/kern_priv.h>
-// Symbian Min() & Max() are broken, so we have to define them ourselves
+// Symbian _Min() & _Max() are broken, so we have to define them ourselves
-inline TUint Min(TUint aLeft, TUint aRight)
+inline TUint _Min(TUint aLeft, TUint aRight)
 	{return(aLeft < aRight ? aLeft : aRight);}
-inline TUint Max(TUint aLeft, TUint aRight)
+inline TUint _Max(TUint aLeft, TUint aRight)
 	{return(aLeft > aRight ? aLeft : aRight);}
-// Uncomment the following #define only when freezing the DMA2 export library.
+// The following section is used only when freezing the DMA2 export library
-//#define __FREEZE_DMA2_LIB
+/*
-#ifdef __FREEZE_DMA2_LIB
 TInt DmaChannelMgr::StaticExtension(TInt, TAny*) {return 0;}
 TDmaChannel* DmaChannelMgr::Open(TUint32, TBool, TUint) {return 0;}
 void DmaChannelMgr::Close(TDmaChannel*) {}
 EXPORT_C const TDmaTestInfo& DmaTestInfo() {static TDmaTestInfo a; return a;}
 EXPORT_C const TDmaV2TestInfo& DmaTestInfoV2() {static TDmaV2TestInfo a; return a;}
-#endif	// #ifdef __FREEZE_DMA2_LIB
+*/
 static const char KDmaPanicCat[] = "DMA " __FILE__;
 //////////////////////////////////////////////////////////////////////
 // DmaChannelMgr
 void TDmac::Transfer(const TDmaChannel& /*aChannel*/, const SDmaDesHdr& /*aHdr*/)
 	{
 	// TDmac needs to override this function if it has reported the channel
 	// type for which the PIL calls it.
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	}
 void TDmac::Transfer(const TDmaChannel& /*aChannel*/, const SDmaDesHdr& /*aSrcHdr*/,
 					 const SDmaDesHdr& /*aDstHdr*/)
 	{
 	// TDmac needs to override this function if it has reported the channel
 	// type for which the PIL calls it.
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	}
 TInt TDmac::PauseTransfer(const TDmaChannel& /*aChannel*/)
 	{
 			}
 #endif
 		}
 	else
 		{
-		iDesPool = new TDmaTransferArgs[iMaxDesCount];
+		iDesPool = Kern::Alloc(iMaxDesCount * sizeof(TDmaTransferArgs));
 		r = iDesPool ? KErrNone : KErrNoMemory;
 		}
 	return r;
 	}
 TInt TDmac::InitHwDes(const SDmaDesHdr& /*aHdr*/, const TDmaTransferArgs& /*aTransferArgs*/)
 	{
 	// concrete controller must override if SDmacCaps::iHwDescriptors set
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	return KErrGeneral;
 	}
 TInt TDmac::InitSrcHwDes(const SDmaDesHdr& /*aHdr*/, const TDmaTransferArgs& /*aTransferArgs*/)
 	{
 	// concrete controller must override if SDmacCaps::iAsymHwDescriptors set
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	return KErrGeneral;
 	}
 TInt TDmac::InitDstHwDes(const SDmaDesHdr& /*aHdr*/, const TDmaTransferArgs& /*aTransferArgs*/)
 	{
 	// concrete controller must override if SDmacCaps::iAsymHwDescriptors set
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	return KErrGeneral;
 	}
 TInt TDmac::UpdateDes(const SDmaDesHdr& aHdr, TUint32 aSrcAddr, TUint32 aDstAddr,
 TInt TDmac::UpdateHwDes(const SDmaDesHdr& /*aHdr*/, TUint32 /*aSrcAddr*/, TUint32 /*aDstAddr*/,
 						TUint /*aTransferCount*/, TUint32 /*aPslRequestInfo*/)
 	{
 	// concrete controller must override if SDmacCaps::iHwDescriptors set
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	return KErrGeneral;
 	}
 TInt TDmac::UpdateSrcHwDes(const SDmaDesHdr& /*aHdr*/, TUint32 /*aSrcAddr*/,
 						   TUint /*aTransferCount*/, TUint32 /*aPslRequestInfo*/)
 	{
 	// concrete controller must override if SDmacCaps::iAsymHwDescriptors set
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	return KErrGeneral;
 	}
 TInt TDmac::UpdateDstHwDes(const SDmaDesHdr& /*aHdr*/, TUint32 /*aDstAddr*/,
 						   TUint /*aTransferCount*/, TUint32 /*aPslRequestInfo*/)
 	{
 	// concrete controller must override if SDmacCaps::iAsymHwDescriptors set
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	return KErrGeneral;
 	}
 void TDmac::ChainHwDes(const SDmaDesHdr& /*aHdr*/, const SDmaDesHdr& /*aNextHdr*/)
 	{
 	// concrete controller must override if SDmacCaps::iHwDescriptors set
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	}
 void TDmac::AppendHwDes(const TDmaChannel& /*aChannel*/, const SDmaDesHdr& /*aLastHdr*/,
 						const SDmaDesHdr& /*aNewHdr*/)
 	{
 	// concrete controller must override if SDmacCaps::iHwDescriptors set
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	}
 void TDmac::AppendHwDes(const TDmaChannel& /*aChannel*/,
 						const SDmaDesHdr& /*aSrcLastHdr*/, const SDmaDesHdr& /*aSrcNewHdr*/,
 						const SDmaDesHdr& /*aDstLastHdr*/, const SDmaDesHdr& /*aDstNewHdr*/)
 	{
 	// concrete controller must override if SDmacCaps::iAsymHwDescriptors set
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	}
 void TDmac::UnlinkHwDes(const TDmaChannel& /*aChannel*/, SDmaDesHdr& /*aHdr*/)
 	{
 	// concrete controller must override if SDmacCaps::iHwDescriptors set
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	}
 void TDmac::ClearHwDes(const SDmaDesHdr& /*aHdr*/)
 	{
 TUint32 TDmac::HwDesNumDstElementsTransferred(const SDmaDesHdr& /*aHdr*/)
 	{
 	// Concrete controller must override if SDmacCaps::iHwDescriptors set.
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	return 0;
 	}
 TUint32 TDmac::HwDesNumSrcElementsTransferred(const SDmaDesHdr& /*aHdr*/)
 	{
 	// Concrete controller must override if SDmacCaps::iHwDescriptors set.
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	return 0;
 	}
 #ifdef _DEBUG
 		}
 	return KErrNone;
 	}
-TInt DDmaRequest::CheckMemFlags(const TDmaTransferConfig& aTarget, TUint aCount) const
+TInt DDmaRequest::CheckMemFlags(const TDmaTransferConfig& aTarget) const
 	{
 	__KTRACE_OPT(KDMA, Kern::Printf("DDmaRequest::CheckMemFlags"));
 	const TBool mem_target = (aTarget.iFlags & KDmaMemAddr);
 									aFragSize, aElementSize, aFrameSize));
 	TUint rem = 0;
 	TInt r = KErrNone;
-	while (1)
+	FOREVER
 		{
 		// If an element size is defined, make sure the fragment size is
 		// greater or equal.
 		if (aElementSize)
 			{
 	// Set the channel cookie for the PSL
 	aTransferArgs.iChannelCookie = iChannel.PslId();
 	// Client shouldn't specify contradictory or invalid things
-	TInt r = CheckMemFlags(aTransferArgs.iSrcConfig, count);
+	TInt r = CheckMemFlags(aTransferArgs.iSrcConfig);
 	if (r != KErrNone)
 		{
 		__KTRACE_OPT(KPANIC, Kern::Printf("Error: CheckMemFlags(src)"));
 		return r;
 		}
-	r =  CheckMemFlags(aTransferArgs.iDstConfig, count);
+	r =  CheckMemFlags(aTransferArgs.iDstConfig);
 	if (r != KErrNone)
 		{
 		__KTRACE_OPT(KPANIC, Kern::Printf("Error: CheckMemFlags(dst)"));
 		return r;
 		}
 	__DMA_ASSERTD(!mem_dst || ((dst.iAddr & align_mask_dst) == 0));
 	// Max aligned length is used to make sure the beginnings of subtransfers
 	// (i.e. fragments) are correctly aligned.
 	const TUint max_aligned_len = (aMaxTransferLen &
-								   ~(Max(align_mask_src, align_mask_dst)));
+								   ~(_Max(align_mask_src, align_mask_dst)));
 	__KTRACE_OPT(KDMA, Kern::Printf("max_aligned_len: %d", max_aligned_len));
 	// Client and PSL sane?
 	__DMA_ASSERTD(max_aligned_len > 0);
 	if (mem_src && mem_dst &&
 		if (r != KErrNone)
 			{
 			break;
 			}
 		// Compute fragment size
-		TUint c = Min(aMaxTransferLen, aCount);
+		TUint c = _Min(aMaxTransferLen, aCount);
-		__KTRACE_OPT(KDMA, Kern::Printf("c = Min(aMaxTransferLen, aCount) = %d", c));
+		__KTRACE_OPT(KDMA, Kern::Printf("c = _Min(aMaxTransferLen, aCount) = %d", c));
 		// SRC
 		if (mem_src && !(src.iFlags & KDmaMemIsContiguous))
 			{
 			c = MaxPhysSize(src.iAddr, c);
 		if (r != KErrNone)
 			{
 			break;
 			}
 		// Compute fragment size
-		TUint c = Min(aMaxTransferLen, aCount);
+		TUint c = _Min(aMaxTransferLen, aCount);
-		__KTRACE_OPT(KDMA, Kern::Printf("c = Min(aMaxTransferLen, aCount) = %d", c));
+		__KTRACE_OPT(KDMA, Kern::Printf("c = _Min(aMaxTransferLen, aCount) = %d", c));
 		if (mem_src && !(src.iFlags & KDmaMemIsContiguous))
 			{
 			c = MaxPhysSize(src.iAddr, c);
 			__KTRACE_OPT(KDMA, Kern::Printf("c = MaxPhysSize(src.iAddr, c) = %d", c));
 		if (r != KErrNone)
 			{
 			break;
 			}
 		// Compute fragment size
-		TUint c = Min(aMaxTransferLen, aCount);
+		TUint c = _Min(aMaxTransferLen, aCount);
-		__KTRACE_OPT(KDMA, Kern::Printf("c = Min(aMaxTransferLen, aCount) = %d", c));
+		__KTRACE_OPT(KDMA, Kern::Printf("c = _Min(aMaxTransferLen, aCount) = %d", c));
 		if (mem_dst && !(dst.iFlags & KDmaMemIsContiguous))
 			{
 			c = MaxPhysSize(dst.iAddr, c);
 			__KTRACE_OPT(KDMA, Kern::Printf("c = MaxPhysSize(dst.iAddr, c) = %d", c));
 	__DMA_ASSERTD(!mem_dst || ((dst.iAddr & align_mask_dst) == 0));
 	// Max aligned length is used to make sure the beginnings of subtransfers
 	// (i.e. fragments) are correctly aligned.
 	const TUint max_aligned_len = (aMaxTransferLen &
-								   ~(Max(align_mask_src, align_mask_dst)));
+								   ~(_Max(align_mask_src, align_mask_dst)));
 	__KTRACE_OPT(KDMA, Kern::Printf("max_aligned_len: %d", max_aligned_len));
 	// Client and PSL sane?
 	__DMA_ASSERTD(max_aligned_len > 0);
 	if (mem_src && mem_dst &&
 			{
 			break;
 			}
 		__DMA_ASSERTD(iSrcDesCount == iDstDesCount);
 		// Compute fragment size
-		TUint c = Min(aMaxTransferLen, aCount);
+		TUint c = _Min(aMaxTransferLen, aCount);
-		__KTRACE_OPT(KDMA, Kern::Printf("c = Min(aMaxTransferLen, aCount) = %d", c));
+		__KTRACE_OPT(KDMA, Kern::Printf("c = _Min(aMaxTransferLen, aCount) = %d", c));
 		// SRC
 		if (mem_src && !(src.iFlags & KDmaMemIsContiguous))
 			{
 			c = MaxPhysSize(src.iAddr, c);
 void TDmaChannel::DoQueue(const DDmaRequest& /*aReq*/)
 	{
 	// Must be overridden
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	}
 //
 // Unlink the last item of a LLI chain from the next chain.
 void TDmaChannel::DoDfc(const DDmaRequest& /*aCurReq*/, SDmaDesHdr*& /*aCompletedHdr*/)
 	{
 	// To make sure this version of the function isn't called for channels for
 	// which it isn't appropriate (and which therefore don't override it) we
 	// put this check in here.
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	}
 void TDmaChannel::DoDfc(const DDmaRequest& /*aCurReq*/, SDmaDesHdr*& /*aSrcCompletedHdr*/,
 						SDmaDesHdr*& /*aDstCompletedHdr*/)
 	{
 	// To make sure this version of the function isn't called for channels for
 	// which it isn't appropriate (and which therefore don't override it) we
 	// put this check in here.
-	__DMA_CANT_HAPPEN();
+	__DMA_UNREACHABLE_DEFAULT();
 	}
 /** PSL may override */
 void TDmaChannel::QueuedRequestCountChanged()

changeset 199	189ece41fa29
parent 189	a5496987b1da
child 231	75252ea6123b