DMA Resource - Revision history

Costel Mincea: Text replacement - "" to ""

2025-01-26T19:19:31Z

Text replacement - "<syntaxhighlight>" to "<syntaxhighlight lang="C" line>"

← Older revision		Revision as of 19:19, 26 January 2025
Line 52:		Line 52:
	Three API calls make up the FslDMA API; CopyMemDMA(), CopyMemDMATagList() and CopyMemDMATags().		Three API calls make up the FslDMA API; CopyMemDMA(), CopyMemDMATagList() and CopyMemDMATags().

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	BOOL CopyMemDMA( CONST_APTR pSourceBuffer, APTR pDestBuffer, uint32 lBufferSize );		BOOL CopyMemDMA( CONST_APTR pSourceBuffer, APTR pDestBuffer, uint32 lBufferSize );
	BOOL CopyMemDMATags( CONST_APTR pSourceBuffer, APTR pDestBuffer, uint32 lBufferSize, uint32 TagItem1, ... );		BOOL CopyMemDMATags( CONST_APTR pSourceBuffer, APTR pDestBuffer, uint32 lBufferSize, uint32 TagItem1, ... );
Line 68:		Line 68:
	=== Example 1: "Blocking" mode ===		=== Example 1: "Blocking" mode ===

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	#include <stdio.h>		#include <stdio.h>
	#include <stdlib.h>		#include <stdlib.h>
Line 148:		Line 148:
	=== Example 2: "Non-Blocking" mode ===		=== Example 2: "Non-Blocking" mode ===

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	#include <stdio.h>		#include <stdio.h>
	#include <stdlib.h>		#include <stdlib.h>
Line 356:		Line 356:
	Breaking the above example down the first thing we do is include the interface header for the fsldma.resource and obtain the resource itself.		Breaking the above example down the first thing we do is include the interface header for the fsldma.resource and obtain the resource itself.

	<syntaxhighlight>		<syntaxhighlight lang="C" line>
	#include <interfaces/fsldma.h>		#include <interfaces/fsldma.h>
	struct fslDMAIFace *IfslDMA = IExec->OpenResource(FSLDMA_NAME);		struct fslDMAIFace *IfslDMA = IExec->OpenResource(FSLDMA_NAME);

Jamie Krueger: Jamie Krueger moved page DMA Engine to DMA Resource: Renaming to reflect that this page covers the fsldma.resource API and not just a discussion of the underlined DMA Engine.

2023-10-18T20:50:15Z

Jamie Krueger moved page DMA Engine to DMA Resource: Renaming to reflect that this page covers the fsldma.resource API and not just a discussion of the underlined DMA Engine.

← Older revision		Revision as of 20:50, 18 October 2023
(No difference)

Jamie Krueger at 18:09, 10 December 2021

2021-12-10T18:09:24Z

← Older revision		Revision as of 18:09, 10 December 2021
Line 2:		Line 2:

	Jamie Krueger, BITbyBIT Software Group LLC<br/>		Jamie Krueger, BITbyBIT Software Group LLC<br/>
	Copyright (c) 2019 Trevor Dickinson<br/>		Copyright (c) 2019, 2021 Trevor Dickinson<br/>
	Used by permission.		Used by permission.

Jamie Krueger at 22:18, 9 December 2019

2019-12-09T22:18:12Z

← Older revision		Revision as of 22:18, 9 December 2019
Line 387:		Line 387:

	In general, the larger the data block the better.		In general, the larger the data block the better.

			== Current fsldma.resource API release notes ==

			<pre>
			fsldma.resource 53.1 (30.9.2019) <jkrueger>

			- First release.


			fsldma.resource 53.2 (4.11.2019) <jkrueger>

			- Replaced the Busy Wait polling of the DMA Channel
			completion status with a fully event (interrupt)
			driven, multitasking task handler system.


			fsldma.resource 53.3 (22.11.2019) <jkrueger>

			- Reworked DMACopyMem() to properly handle normal
			cache-enabled virtual memory blocks using a
			combination of StartDMA()/EndDMA() and "CPU Snoop"
			mode on the DMA hardware.


			fsldma.resource 53.4 (4.12.2019) <jkrueger>

			- Major API rework and streamlining.
			Removed all other API calls save DMACopyMem().
			DMACopyMem() was renamed CopyMemDMA() and new
			TagItem based versions were added; CopyMemDMATagList()
			and CopyMemDMATags().

			Seven new Tags were added to the API for use
			with the Tags version of CopyMemDMA. They enable
			using any combination of Virtual and Physical
			memory copies and support for new "Non-Blocking"
			transactions with user Notification via three
			possible signals; "Success", "In Progress" and "Error."

			Several internal changes and improvements including
			but not limited to, streamlining internal signal
			handling between DMA Handler Tasks and user tasks
			and optimizing transactions using "Basic Chaining Mode."

			The DMA hardware's "Basic Chaining Mode" is now used
			internally to transfer larger single block sizes.
			Blocks greater than FSLDMA_OPTIMAL_BLKSIZE is size
			are transferred using "Basic Chaining Mode", while
			blocks less than or equal to FSLDMA_OPTIMAL_BLKSIZE
			are transferred using "Basic Direct Mode."

			Previously, block sizes larger than FSLDMA_OPTIMAL_BLKSIZE
			were all transfered using a CPU driven loop of
			"Basic Direct Mode" transactions. This internal CPU
			driven loop has now been replaced by programming the
			hardware to perform a series of block transactions
			in a "Chain" as a single hardware transaction.
			This also enabled bringing out "Completed Successfully",
			"In Progress" (a sub-block has transferred successfully)
			and "Error" signaling during "Non-Blocking" transactions.

			Note:
			Currently only source and destination memory
			areas of the same type, Virtual-to-Virtual or
			Physical-to-Physical are supported.

			Also, only Physical-to-Physical transactions
			support "Non-Blocking" transactions and User
			Notification signaling.

			Future releases will remove these limitations.
			</pre>

Jamie Krueger: /* Example 2: "Non-Blocking" mode */

2019-12-09T22:05:30Z

Example 2: "Non-Blocking" mode

@@ Line 359: / Line 359: @@
 #include <interfaces/fsldma.h>
 struct fslDMAIFace *IfslDMA = IExec->OpenResource(FSLDMA_NAME);
 </syntaxhighlight>

Jamie Krueger: /* Example 2: "Non-Blocking" mode */

2019-12-09T22:03:44Z

Example 2: "Non-Blocking" mode

← Older revision		Revision as of 22:03, 9 December 2019
Line 266:		Line 266:
	// Call IfslDMA->CopyMemDMATags() to perform the memory copy using the		// Call IfslDMA->CopyMemDMATags() to perform the memory copy using the
	// DMA hardware. Start off the transaction then wait on completion signals.		// DMA hardware. Start off the transaction then wait on completion signals.

	// We use full 64-Bit values to pass in the source and destination to
	// IfslDMA->CopyMemDMATags() so we need to use a "double cast" on the
	// 32-Bit pointers returned by AllocVecTags() in order to properly pass
	// in fully extended 64-Bit pointers.
	// (see <resource/fsldma.h> for more details)

	printf("Starting \"Non-Blocking\" DMA Transaction"		printf("Starting \"Non-Blocking\" DMA Transaction"
	" of %ld bytes from 0x%08lx to 0x%08lx...\n",~~lSize,pPhySrcAttr,pPhyDstAttr);~~		" of %ld bytes from 0x%08lx to 0x%08lx...\n",
			lSize,pPhySrcAttr,pPhyDstAttr);
	fflush(stdout);		fflush(stdout);

	if ( TRUE == IfslDMA->CopyMemDMATags((CONST_DMAPTR)(uint32)pPhySrcAttr,
	~~(DMAPTR)~~(~~uint32)~~pPhyDstAttr,		if ( TRUE == IfslDMA->CopyMemDMATags(pPhySrcAttr,pPhyDstAttr,lSize,
	lSize,
	FSLDMA_CM_SourceIsPhysical, TRUE,		FSLDMA_CM_SourceIsPhysical, TRUE,
	FSLDMA_CM_DestinationIsPhysical, TRUE,		FSLDMA_CM_DestinationIsPhysical, TRUE,

Jamie Krueger: /* Example 1: "Blocking" mode */

2019-12-09T22:00:18Z

Example 1: "Blocking" mode

← Older revision		Revision as of 22:00, 9 December 2019
Line 116:		Line 116:
	// Call IfslDMA->CopyMemDMA() to perform the memory copy using the		// Call IfslDMA->CopyMemDMA() to perform the memory copy using the
	// DMA hardware. Wait for the transaction to complete before continuing.		// DMA hardware. Wait for the transaction to complete before continuing.

	// We use full 64-Bit values to pass in the source and destination to
	// IfslDMA->CopyMemDMA() so we need to use a "double cast" on the
	// 32-Bit pointers returned by AllocVecTags() in order to properly pass
	// in fully extended 64-Bit pointers.
	// (see <resource/fsldma.h> for more details)

	printf("Starting \"Blocking\" DMA Transaction"		printf("Starting \"Blocking\" DMA Transaction"
	" of %ld bytes from 0x%08lx to 0x%08lx...\n",lSize,pSrc,pDest);		" of %ld bytes from 0x%08lx to 0x%08lx...\n",lSize,pSrc,pDest);
	fflush(stdout);		fflush(stdout);

	if ( TRUE == IfslDMA->CopyMemDMA(~~(CONST_DMAPTR)(uint32)~~pSrc,		if ( TRUE == IfslDMA->CopyMemDMA(pSrc,pDest,lSize) )
	(DMAPTR)(uint32)pDest,
	lSize) )
	{		{
	// Success - Do something with the copied data and quit		// Success - Do something with the copied data and quit

Jamie Krueger: /* Copy Memory Functions */

2019-12-09T21:56:34Z

Copy Memory Functions

← Older revision		Revision as of 21:56, 9 December 2019
Line 53:		Line 53:

	<syntaxhighlight>		<syntaxhighlight>
	BOOL CopyMemDMA( ~~CONST_DMAPTR~~ pSourceBuffer, ~~DMAPTR~~ pDestBuffer, uint32 lBufferSize );		BOOL CopyMemDMA( CONST_APTR pSourceBuffer, APTR pDestBuffer, uint32 lBufferSize );
	BOOL CopyMemDMATags( ~~CONST_DMAPTR~~ pSourceBuffer, ~~DMAPTR~~ pDestBuffer, uint32 lBufferSize, uint32 TagItem1, ... );		BOOL CopyMemDMATags( CONST_APTR pSourceBuffer, APTR pDestBuffer, uint32 lBufferSize, uint32 TagItem1, ... );
	BOOL CopyMemDMATagList( ~~CONST_DMAPTR~~ pSourceBuffer, ~~DMAPTR~~ pDestBuffer, uint32 lBufferSize, const struct TagItem *tags );		BOOL CopyMemDMATagList( CONST_APTR pSourceBuffer, APTR pDestBuffer, uint32 lBufferSize, const struct TagItem *tags );
	</syntaxhighlight>		</syntaxhighlight>

Line 61:		Line 61:

	In theory any ''contiguous'' block of memory from 1 Byte up to 4GB in size may be transferred using any one of these calls. In practice the DMA hardware can directly accept memory blocks up to FSLDMA_MAXBLOCK_SIZE (or 64MB - 1 Byte). Therefore any data blocks greater than FSLDMA_MAXBLOCK_SIZE will automatically be sent to the DMA hardware in a series of smaller chunks. For maximum efficiency transfer sizes should be at least 256 Bytes in size and be an even multiple of 64 Bytes. Odd sizes are handled by the hardware but will degrade performance.		In theory any ''contiguous'' block of memory from 1 Byte up to 4GB in size may be transferred using any one of these calls. In practice the DMA hardware can directly accept memory blocks up to FSLDMA_MAXBLOCK_SIZE (or 64MB - 1 Byte). Therefore any data blocks greater than FSLDMA_MAXBLOCK_SIZE will automatically be sent to the DMA hardware in a series of smaller chunks. For maximum efficiency transfer sizes should be at least 256 Bytes in size and be an even multiple of 64 Bytes. Odd sizes are handled by the hardware but will degrade performance.

	If you are transferring many large blocks of data in series and wish to manually send them to the FslDMA API's memory copy functions one block at a time, then setting your block sizes to FSLDMA_OPTIMAL_BLKSIZE (or 64 MB - 64 Bytes) will provide the fastest transfer speeds will the least amount of CPU overhead.

	==== Further reference - The fsldma.resource AutoDoc ====		==== Further reference - The fsldma.resource AutoDoc ====

Jamie Krueger: /* Example 1: "Blocking" mode */

2019-12-04T23:37:38Z

Example 1: "Blocking" mode

@@ Line 71: / Line 71: @@
 <syntaxhighlight>
+{
-  uint32     lSize = FSLDMA_OPTIMAL_BLKSIZE;
+  uint32             lSize         = 0;
-  CONST_APTR pSrc  = IExec->AllocVecTags(lSize,
+  CONST_APTR         pSrc          = NULL;
-                                         AVT_Type,           MEMF_SHARED,
+  APTR               pDest         = NULL;
-                                         AVT_ClearWithValue, 0xB3,
+  BOOL               bGotResources = FALSE;
+  {
     // (see <resource/fsldma.h> for more details)
     if ( TRUE == IfslDMA->CopyMemDMA((CONST_DMAPTR)(uint32)pSrc,
                                      (DMAPTR)(uint32)pDest,
                                      lSize) )
+    {
-      // Success - Do something with the copied data
+      // Success - Do something with the copied data and quit
+    }
+  }
+}
 </syntaxhighlight>

Jamie Krueger: /* fsldma.resource */

2019-12-04T23:27:44Z

fsldma.resource

Show changes