📄 dma.c
字号:
/***************************************************************************
* Copyright Motorola, Inc. 1989-2001 ALL RIGHTS RESERVED
*
* $ID:$
*
* You are hereby granted a copyright license to use, modify, and
* distribute the SOFTWARE, also know as DINK32 (Dynamic Interactive Nano
* Kernel for 32-bit processors) solely in conjunction with the development
* and marketing of your products which use and incorporate microprocessors
* which implement the PowerPC(TM) architecture manufactured by
* Motorola and provided you comply with all of the following restrictions
* i) this entire notice is retained without alteration in any
* modified and/or redistributed versions, and
* ii) that such modified versions are clearly identified as such.
* No licenses are granted by implication, estoppel or
* otherwise under any patents or trademarks of Motorola, Inc.
*
* The SOFTWARE is provided on an "AS IS" basis and without warranty. To
* the maximum extent permitted by applicable law, MOTOROLA DISCLAIMS ALL
* WARRANTIES WHETHER EXPRESS OR IMPLIED, INCLUDING IMPLIED WARRANTIES OF
* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE AND ANY WARRANTY
* AGAINST INFRINGEMENT WITH REGARD TO THE SOFTWARE
* (INCLUDING ANY MODIFIED VERSIONS THEREOF) AND ANY ACCOMPANYING
* WRITTEN MATERIALS.
*
* To the maximum extent permitted by applicable law, IN NO EVENT SHALL
* MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING WITHOUT
* LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS
* INTERRUPTION, LOSS OF BUSINESS INFORMATION,
* OR OTHER PECUNIARY LOSS) ARISING OF THE USE OR INABILITY TO USE THE
* SOFTWARE.
* Motorola assumes no responsibility for the maintenance and support of
* the SOFTWARE.
************************************************************************/
/*
* App. API
*
* App. API are the APIs Kernel provides for the application
* level program
*
************************************************************/
#include "vxWorks.h"
#include "iv.h"
#include "intLib.h"
#include "config.h"
#include "sysLib.h"
#include "dma_export.h"
#include "dma.h"
/*#include "i2o.h"*/
#include "logLib.h"
/* Define a macro to use an optional application-layer print function, if
* one was passed to the library during initialization. If there was no
* function pointer passed, this protects against referencing a NULL pointer.
* Also define The global variable that holds the passed pointer.
*/
/*#define DMADBG0*/
#define PRINT printf
#define GTPRINT(X0, X1, X2, X3, X4, X5, X6) \
_func_logMsg (X0, X1, X2, X3, X4, X5, X6);
/* Set by call to get_eumbbar during DMA_Initialize.
* This could be globally available to the library, but there is
* an advantage to passing it as a parameter: it is already in a register
* and doesn't have to be loaded from memory. Also, that is the way the
* library was already implemented and I don't want to change it without
* a more detailed analysis.
* It is being set as a global variable during initialization to hide it from
* the DINK application layer, because it is Kahlua-specific. I think that
* get_eumbbar, load_runtime_reg, and store_runtime_reg should be defined in
* a Kahlua-specific library dealing with the embedded utilities memory block.
* Right now, get_eumbbar is defined in dink32/kahlua.s. The other two are
* defined in dink32/drivers/i2c/i2c2.s, drivers/dma/dma2.s, etc.
*/
int initnum=0;
static unsigned int Global_eumbbard = 0;
extern unsigned int get_eumbbar();
extern unsigned long memSpeed;
extern unsigned long decrementer_read();
extern void decrementer_write();
extern void led12(unsigned short );
void delay(int);
UINT32 DMAdespArray [sizeof(DMA_DESP)*n0*2];
UINT32 * pDMADesp;
UINT32 DMAQueueArray [sizeof(DMA_CHAIN_QUEUE)*n0*2];
UINT32 * pDMAQueue;
SEM_ID dmaTaskSemId = NULL;
SEM_ID dmaSemId = NULL;
int dma_length = 0; /* Use this value to track the length
of the DMA transfer */
int decrementer_value = 0; /* This global is used to store
a value read from the decrementer
register */
int runled12;
extern unsigned int load_runtime_reg( unsigned int eumbbar, unsigned int reg );
#pragma Alias( load_runtime_reg, "load_runtime_reg" );
extern void store_runtime_reg( unsigned int eumbbar, unsigned int reg, unsigned int val );
#pragma Alias( store_runtime_reg, "store_runtime_reg" );
unsigned int dma_reg_tb[][14] = {
/* local DMA registers */
{
/* DMA_0_MR */ 0x00001100,
/* DMA_0_SR */ 0x00001104,
/* DMA_0_CDAR */ 0x00001108,
/* DMA_0_SAR */ 0x00001110,
/* DMA_0_DAR */ 0x00001118,
/* DMA_0_BCR */ 0x00001120,
/* DMA_0_NDAR */ 0x00001124,
/* DMA_1_MR */ 0x00001200,
/* DMA_1_SR */ 0x00001204,
/* DMA_1_CDAR */ 0x00001208,
/* DMA_1_SAR */ 0x00001210,
/* DMA_1_DAR */ 0x00001218,
/* DMA_1_BCR */ 0x00001220,
/* DMA_1_NDAR */ 0x00001224,
},
/* remote DMA registers */
{
/* DMA_0_MR */ 0x00000100,
/* DMA_0_SR */ 0x00000104,
/* DMA_0_CDAR */ 0x00000108,
/* DMA_0_SAR */ 0x00000110,
/* DMA_0_DAR */ 0x00000118,
/* DMA_0_BCR */ 0x00000120,
/* DMA_0_NDAR */ 0x00000124,
/* DMA_1_MR */ 0x00000200,
/* DMA_1_SR */ 0x00000204,
/* DMA_1_CDAR */ 0x00000208,
/* DMA_1_SAR */ 0x00000210,
/* DMA_1_DAR */ 0x00000218,
/* DMA_1_BCR */ 0x00000220,
/* DMA_1_NDAR */ 0x00000224,
},
};
/* API functions */
/* Perform the DMA transfer, chaining mode is currently implemented.
* At this point, I think it would be better to define a different
* function for chaining mode.
* Also, I'm not sure if it is appropriate to have the "generic" API
* accept snoop and int_steer parameters. The DINK user interface allows
* them, so for now I'll leave them.
*
* int_steer controls DMA interrupt steering to PCI or local processor
* type is the type of transfer: M2M, M2P, P2M, P2P
* source is the source address of the data
* dest is the destination address of the data
* len is the length of data to transfer
* channel is the DMA channel to use for the transfer
* snoop is the snoop enable control
*/
extern DMA_Status DMA_chaining_transfer( DMA_INTERRUPT_STEER int_steer,
DMA_TRANSFER_TYPE type,
unsigned int *chainsrc,
unsigned int *chaindes,
unsigned int *chainbcn,
unsigned int paranum,
DMA_CHANNEL channel,
DMA_SNOOP_MODE snoop)
{
unsigned int i,temp,stnum;
DMA_MR md;
DMA_SR status;
DMA_CDAR cdar;
DMA_NDAR ndar;
/* it's inappropriate for curr to be a struct, but I'll leave it */
/*DMA_CURR curr;*/
DMAStatus stat;
DMA_DESP cdesp;
DMA_CHAIN_QUEUE *qu;
/* The rest of this code was moved from device.c test_dma to here.
* It needs to be cleaned up and validated, but at least it is removed
* from the application and API. Most of the mode is left hard coded.
* This should be changed after the final API is defined and the user
* application has a way to control the transfer.
*
*/
/*if(dmaTaskSemId == NULL || dmaSemId == NULL )
{
return DMA_ERROR;
}*/
/*semTake(dmaTaskSemId,WAIT_FOREVER);*/
if ( DMA_Get_Mode( LOCALA, Global_eumbbard, channel, &md ) != DMASUCCESS )
{
/*semGive(dmaTaskSemId);*/
return DMA_ERROR;
}
/* Added for PCI Latency Timer eratta RGP-11/23/99 */
md.reserved0 = 4;
md.irqs = int_steer;
md.pde = 0;
md.dahts = 0;
md.sahts = 0;
md.dahe = 0;
md.sahe = 0;
md.prc = 0;
md.eie = 1/*0*/;
md.eotie = 1;
md.dl = 0;
md.ctm = 0; /* chain mode */
md.cc = 0;
if ( DMA_Get_Stat( LOCALA, Global_eumbbard, channel, &status ) != DMASUCCESS )
{
/*semGive(dmaTaskSemId);*/
return DMAINVALID;
}
qu = (DMA_CHAIN_QUEUE *)pDMAQueue;
if ( status.cb == 0 )
{
stnum = qu->r;
for(i=0;i<paranum;i++)
{
cdesp.src_addr = LONGSWAP(chainsrc[i]);
cdesp.dest_addr = LONGSWAP(chaindes[i]);
cdesp.byte_cnt = LONGSWAP(chainbcn[i]);
ndar.nda = ((UINT32)pDMADesp+((qu->r+1)%(n0+1))*32);
ndar.ndsnen = snoop;
ndar.ndeosie = 1;
ndar.ndctt = type;
if(i!=(paranum-1))
ndar.eotd = 0;
else
ndar.eotd = 1;
temp = /*(*/ ndar.nda /*& 0x7ffffff ) << 5*/;
temp |= (( ndar.ndsnen & 0x1 ) << 4 );
temp |= (( ndar.ndeosie & 0x1 ) << 3 );
temp |= (( ndar.ndctt & 0x3 ) << 1 );
temp |= ( ndar.eotd & 0x1 );
cdesp.next_desp = LONGSWAP(temp);
if(dma_chain_enq(qu,&cdesp))
{
PRINT( "dev DMA: channel %d busy.\n", channel );
return DMA_ERROR;
}
}
(void)DMA_Poke_Desp( LOCALA, Global_eumbbard, channel, &cdar );
cdar.cda = ((UINT32)pDMADesp+stnum*32);
cdar.snen = snoop;
cdar.eosie = 1;
cdar.ctt = type;
if ( ( stat = DMA_Bld_Desp( LOCALA, Global_eumbbard, channel, cdar ))
!= DMASUCCESS ||
( stat = DMA_Set_Mode( LOCALA, Global_eumbbard, channel, md ))
!= DMASUCCESS ||
( stat = DMA_Start( LOCALA, Global_eumbbard, channel, 0 ))
!= DMASUCCESS )
{
if ( stat == DMACHNBUSY )
{
PRINT( "dev DMA: invalid channel %d request.\n", channel );
}
else
{
PRINT( "dev DMA: invalid channel %d request.\n", channel );
}
/*semGive(dmaTaskSemId);*/
return DMA_ERROR;
}
/*semTake(dmaSemId,WAIT_FOREVER);*/
/* Since we are interested at the DMA performace right now,
we are going to do as less as possible to burden the
603e core.
if you have epic enabled or don't care the return from
DMA operation, you can just return SUCCESS.
if you don't have epic enabled and care the DMA result,
you can use the polling method below.
Note: I'll attempt to activate the code for handling polling.
*/
#if 0
/* if steering interrupt to local processor, let it handle results */
if ( int_steer == DMA_INT_STEER_LOCAL )
{
return DMA_SUCCESS;
}
/* polling since interrupt goes to PCI */
do
{
stat = DMA_ISR( Global_eumbbard, channel, dma_error_func,
dma_error_func, dma_error_func, dma_error_func );
}
while ( stat == DMANOEVENT );
#endif
/*semGive(dmaTaskSemId);*/
return DMA_SUCCESS;
}
else
{
if ( DMA_Get_Mode( LOCALA, Global_eumbbard, channel, &md ) != DMASUCCESS )
{
/*semGive(dmaTaskSemId);*/
return DMA_ERROR;
}
if(md.cc == 1)
{int delnum;
delnum=qu->f;
while (qu->f==delnum);
if ( DMA_Get_Mode( LOCALA, Global_eumbbard, channel, &md ) != DMASUCCESS )
{
/*semGive(dmaTaskSemId);*/
return DMA_ERROR;
}
}
if(md.cc == 0)
{
int modinum;
modinum = qu->r;
for(i=0;i<paranum;i++)
{
cdesp.src_addr = LONGSWAP(chainsrc[i]);
cdesp.dest_addr = LONGSWAP(chaindes[i]);
cdesp.byte_cnt = LONGSWAP(chainbcn[i]);
ndar.nda = (/*0x2000000*/(UINT32)pDMADesp+((qu->r+1)%(n0+1))*32);
ndar.ndsnen = snoop;
ndar.ndeosie = 1;
ndar.ndctt = type;
if(i!=(paranum-1))
ndar.eotd = 0;
else
ndar.eotd = 1;
temp = /*(*/ ndar.nda /*& 0x7ffffff ) << 5*/;
temp |= (( ndar.ndsnen & 0x1 ) << 4 );
temp |= (( ndar.ndeosie & 0x1 ) << 3 );
temp |= (( ndar.ndctt & 0x3 ) << 1 );
temp |= ( ndar.eotd & 0x1 );
cdesp.next_desp = LONGSWAP(temp);
if(dma_chain_enq(qu,&cdesp))
{
qu->r = modinum;
PRINT( "dev DMA: channel %d busy.\n", channel );
return DMA_ERROR;
}
}
(qu->q[(modinum+(n0+1)-1)%(n0+1)]).next_desp &= ~(LONGSWAP(DMA_EOTD));
if ( ( stat = DMA_ReStart( LOCALA, Global_eumbbard, channel, 0 ))
!= DMASUCCESS )
{
PRINT( "dev DMA: invalid channel%d request\n", channel );
/*semGive(dmaTaskSemId);*/
return DMA_ERROR;
}
else
return DMA_SUCCESS;
}
else
{
PRINT( "dev DMA: channel %d is error.\n", channel );
return DMA_ERROR;
}
}
}
/* Perform the DMA transfer, direct mode is currently implemented.
* At this point, I think it would be better to define a different
* function for chaining mode.
* Also, I'm not sure if it is appropriate to have the "generic" API
* accept snoop and int_steer parameters. The DINK user interface allows
* them, so for now I'll leave them.
*
* int_steer controls DMA interrupt steering to PCI or local processor
* type is the type of transfer: M2M, M2P, P2M, P2P
* source is the source address of the data
* dest is the destination address of the data
* len is the length of data to transfer
* channel is the DMA channel to use for the transfer
* snoop is the snoop enable control
*/
extern DMA_Status DMA_direct_transfer( DMA_INTERRUPT_STEER int_steer,
DMA_TRANSFER_TYPE type,
unsigned int source,
unsigned int dest,
unsigned int len,
DMA_CHANNEL channel,
DMA_SNOOP_MODE snoop)
{
DMA_MR md;
DMA_CDAR cdar;
/* it's inappropriate for curr to be a struct, but I'll leave it */
DMA_CURR curr;
DMAStatus stat;
/* The rest of this code was moved from device.c test_dma to here.
* It needs to be cleaned up and validated, but at least it is removed
* from the application and API. Most of the mode is left hard coded.
* This should be changed after the final API is defined and the user
* application has a way to control the transfer.
*
*/
if(dmaTaskSemId == NULL || dmaSemId == NULL )
{
return DMA_ERROR;
}
semTake(dmaTaskSemId,WAIT_FOREVER);
if ( DMA_Get_Mode( LOCALA, Global_eumbbard, channel, &md ) != DMASUCCESS )
{
semGive(dmaTaskSemId);
return DMA_ERROR;
}
/* Added for PCI Latency Timer eratta RGP-11/23/99 */
md.reserved0 = 4;
md.irqs = int_steer;
md.pde = 0;
md.dahts = 0;
md.sahts = 0;
md.dahe = 0;
md.sahe = 0;
md.prc = 0;
md.eie = 1/*0*/;
md.eotie = 1;
md.dl = 0;
md.ctm = 1; /* direct mode */
md.cc = 0;
/* validate the length range */
if (len > 0x3ffffff )
{
PRINT( "dev DMA: length of transfer too large: %d\n", len );
semGive(dmaTaskSemId);
return DMA_ERROR;
}
/* inappropriate to use a struct, but leave as is for now */
curr.src_addr = source;
curr.dest_addr = dest;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -