* Code cleanup:

[people/ms/u-boot.git] / cpu / mpc824x / drivers / dma / dma1.c

/************************************************************
 *
 * copyright @ Motorola, 1999
 *
 * App. API
 *
 * App. API are the APIs Kernel provides for the application
 * level program
 *
 ************************************************************/
#include "dma_export.h"
#include "dma.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 PRINT if ( app_print ) app_print
static int (*app_print)(char *,...);

/* 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.
 */
static unsigned int Global_eumbbar = 0;
extern unsigned int get_eumbbar();


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 */

/*  Initialize DMA unit with the following:
 *  optional pointer to application layer print function
 *
 *  These parameters may be added:
 *  ???
 *  Interrupt enables, modes, etc. are set for each transfer.
 *
 *  This function must be called before DMA unit can be used.
 */
extern
DMA_Status DMA_Initialize( int (*p)(char *,...))
{
  DMAStatus status;
  /* establish the pointer, if there is one, to the application's "printf" */
  app_print = p;

  /* If this is the first call, get the embedded utilities memory block
   * base address.  I'm not sure what to do about error handling here:
   * if a non-zero value is returned, accept it.
   */
  if ( Global_eumbbar == 0)
     Global_eumbbar = get_eumbbar();
  if ( Global_eumbbar == 0)
  {
    PRINT( "DMA_Initialize: can't find EUMBBAR\n" );
    return DMA_ERROR;
  }

  return DMA_SUCCESS;
}


/* Perform the DMA transfer, only 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 ( DMA_Get_Mode( LOCAL, Global_eumbbar, channel, &md ) != DMASUCCESS )
	{
		return DMA_ERROR;
	}

	md.irqs = int_steer;
	md.pde = 0;
	md.dahts = 3; /* 8 - byte */
	md.sahts = 3; /* 8 - byte */
	md.dahe = 0;
	md.sahe = 0;
	md.prc = 0;
	/* if steering interrupts to local processor, use polling mode */
	if ( int_steer == DMA_INT_STEER_PCI )
	{
		md.eie = 1;
		md.eotie = 1;
	} else {
		md.eie = 0;
		md.eotie = 0;
	}
	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 );
		return DMA_ERROR;
	}

	/* inappropriate to use a struct, but leave as is for now */
	curr.src_addr = source;
	curr.dest_addr = dest;
	curr.byte_cnt = len;

	(void)DMA_Poke_Desp( LOCAL, Global_eumbbar, channel, &cdar );
	cdar.snen = snoop;
	cdar.ctt = type;

	if ( ( stat = DMA_Bld_Desp( LOCAL, Global_eumbbar, channel, cdar ))
			!= DMASUCCESS ||
		 ( stat = DMA_Bld_Curr( LOCAL, Global_eumbbar, channel, curr ))
			!= DMASUCCESS ||
	     ( stat = DMA_Set_Mode( LOCAL, Global_eumbbar, channel, md ))
			!= DMASUCCESS ||
		 ( stat = DMA_Start( LOCAL, Global_eumbbar, channel ))
			!= DMASUCCESS )
	{
		if ( stat == DMACHNBUSY )
		{
			PRINT( "dev DMA: channel %d busy.\n", channel );
		}
		else
		{
			PRINT( "dev DMA: invalid channel request.\n", channel );
		}

		return DMA_ERROR;
	}

/* 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_eumbbar, channel, dma_error_func,
			dma_error_func, dma_error_func, dma_error_func );
	}
	while ( stat == DMANOEVENT );
#endif

    return DMA_SUCCESS;
}

/* DMA library internal functions */

/**
 * Note:
 *
 * In all following functions, the host (KAHLUA) processor has a
 * choice of accessing on board local DMA (LOCAL),
 * or DMA on a distributed KAHLUA (REMOTE). In either case,
 * the caller shall pass the configured embedded utility memory
 * block base address relative to the DMA. If LOCAL DMA is used,
 * this parameter shall be EUMBBAR, if REMOTE is used, the
 * parameter shall be the corresponding PCSRBAR.
 **/

/**************************************************************
 * function: DMA_Get_Stat
 *
 * description: return the content of status register of
 *              the given DMA channel
 *
 *              if error, reserved0 field all 1s.
 **************************************************************/
static
DMAStatus DMA_Get_Stat( LOCATION host, unsigned int eumbbar, unsigned int channel, DMA_SR *stat )
{
    unsigned int tmp;

   if ( channel != 0 && channel != 1 || stat == 0 )
   {
       return DMAINVALID;
   }

    tmp = load_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_SR_REG] );
#ifdef DMADBG0
   PRINT( "%s(%d): %s DMA %d (0x%08x) stat = 0x%08x\n", __FILE__, __LINE__,
		  ( host == LOCAL ? "local" : "remote" ), channel, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_SR_REG], tmp );
#endif

	 stat->reserved0 = ( tmp & 0xffffff00 ) >> 8;
	 stat->lme       = ( tmp & 0x00000080 ) >> 7;
	 stat->reserved1 = ( tmp & 0x00000060 ) >> 5;
	 stat->pe        = ( tmp & 0x00000010 ) >> 4;
	 stat->reserved2 = ( tmp & 0x00000008 ) >> 3;
	 stat->cb        = ( tmp & 0x00000004 ) >> 2;
	 stat->eosi      = ( tmp & 0x00000002 ) >> 1;
	 stat->eocai     = ( tmp & 0x00000001 );

   return DMASUCCESS;
}

/**************************************************************
 * function: DMA_Get_Mode
 *
 * description: return the content of mode register of the
 *              given DMA channel
 *
 *              if error, return DMAINVALID, otherwise return
 *              DMASUCCESS
 **************************************************************/
static
DMAStatus DMA_Get_Mode( LOCATION host, unsigned eumbbar, unsigned int channel, DMA_MR *mode )
{
    unsigned int tmp;
   if ( channel != 0 && channel != 1 || mode == 0 )
   {
     return DMAINVALID;
   }

    tmp = load_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_MR_REG] );

#ifdef DMADBG0
   PRINT( "%s(%d): %s DMA %d (0x%08x) mode = 0x%08x\n", __FILE__, __LINE__,
		  ( host == LOCAL ? "local" : "remote" ), channel, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_MR_REG], tmp );
#endif

	 mode->reserved0 = (tmp & 0xfff00000) >> 20;
	 mode->irqs      = (tmp & 0x00080000) >> 19;
	 mode->pde       = (tmp & 0x00040000) >> 18;
	 mode->dahts     = (tmp & 0x00030000) >> 16;
     mode->sahts     = (tmp & 0x0000c000) >> 14;
	 mode->dahe      = (tmp & 0x00002000) >> 13;
	 mode->sahe      = (tmp & 0x00001000) >> 12;
	 mode->prc       = (tmp & 0x00000c00) >> 10;
	 mode->reserved1 = (tmp & 0x00000200) >> 9;
	 mode->eie       = (tmp & 0x00000100) >> 8;
	 mode->eotie     = (tmp & 0x00000080) >> 7;
	 mode->reserved2 = (tmp & 0x00000070) >> 4;
	 mode->dl        = (tmp & 0x00000008) >> 3;
	 mode->ctm       = (tmp & 0x00000004) >> 2;
	 mode->cc        = (tmp & 0x00000002) >> 1;
	 mode->cs        = (tmp & 0x00000001);

   return DMASUCCESS;
}

/**************************************************************
 * function: DMA_Set_Mode
 *
 * description: Set a new mode to a given DMA channel
 *
 * note: It is not a good idea of changing the DMA mode during
 *       the middle of a transaction.
 **************************************************************/
static
DMAStatus DMA_Set_Mode( LOCATION host, unsigned eumbbar, unsigned int channel, DMA_MR mode )
{
    unsigned int tmp;
   if ( channel != 0 && channel != 1 )
   {
	   return DMAINVALID;
   }

   tmp = ( mode.reserved0 & 0xfff ) << 20;
   tmp |= ( ( mode.irqs  & 0x1 ) << 19);
   tmp |= ( ( mode.pde   & 0x1 ) << 18 );
   tmp |= ( ( mode.dahts & 0x3 ) << 16 );
   tmp |= ( ( mode.sahts & 0x3 ) << 14 );
   tmp |= ( ( mode.dahe  & 0x1 ) << 13 );
   tmp |= ( ( mode.sahe  & 0x1 ) << 12 );
   tmp |= ( ( mode.prc   & 0x3 ) << 10 );
   tmp |= ( ( mode.reserved1 & 0x1 ) << 9 );
   tmp |= ( ( mode.eie   & 0x1 ) << 8 );
   tmp |= ( ( mode.eotie & 0x1 ) << 7 );
   tmp |= ( ( mode.reserved2 & 0x7 ) << 4 );
   tmp |= ( ( mode.dl    & 0x1 ) << 3 );
   tmp |= ( ( mode.ctm   & 0x1 ) << 2 );
   tmp |= ( ( mode.cc    & 0x1 ) << 1 ) ;
   tmp |= ( mode.cs    & 0x1 );

   store_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG + DMA_MR_REG], tmp );
   return DMASUCCESS;
}

/************************************************************
 * function: DMA_Start
 *
 * description: start a given DMA channel transaction
 *              return DMASUCCESS if success otherwise return
 *              DMAStatus value
 *
 * note: this function will clear DMA_MR(CC) first, then
 *       set DMA_MR(CC).
 ***********************************************************/
static
DMAStatus DMA_Start( LOCATION host, unsigned int eumbbar, unsigned int channel )
{
   DMA_SR stat;
   unsigned int mode;

   if ( channel != 0 && channel != 1 )
   {
	   return DMAINVALID;
   }

   if ( DMA_Get_Stat( host, eumbbar, channel, &stat ) != DMASUCCESS )
   {
		   return DMAINVALID;
   }

   if ( stat.cb == 1 )
   {
	   /* DMA is not free */
	   return DMACHNBUSY;
   }

   mode = load_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG + DMA_MR_REG] );
   /* clear DMA_MR(CS) */
   mode &= 0xfffffffe;
   store_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG + DMA_MR_REG], mode );

   /* set DMA_MR(CS) */
   mode |= CS;
   store_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG + DMA_MR_REG], mode );
   return DMASUCCESS;
}

/***********************************************************
 * function: DMA_Halt
 *
 * description: halt the current dma transaction on the specified
 *              channel.
 *              return DMASUCCESS if success otherwise return DMAINVALID
 *
 * note: if the specified DMA channel is idle, nothing happens
 *************************************************************/
static
DMAStatus DMA_Halt( LOCATION host, unsigned int eumbbar, unsigned int channel )
{
   unsigned int mode;
   if ( channel != 0 && channel != 1 )
   {
	   return DMAINVALID;
   }

   mode = load_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG + DMA_MR_REG]);

   /* clear DMA_MR(CS) */
   mode &= 0xfffffffe;
   store_runtime_reg(eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG + DMA_MR_REG], mode );
   return DMASUCCESS;
}

/*************************************************************
 * function: DMA_Chn_Cnt
 *
 * description: set the DMA_MR(CC) bit for a given channel
 *              that is in chaining mode.
 *              return DMASUCCESS if successfule, otherwise return
 *              DMAINVALID.
 *
 * note: if the given channel is not in chaining mode, nothing
 *       happen.
 *
 *************************************************************/
static
DMAStatus DMA_Chn_Cnt( LOCATION host, unsigned int eumbbar, unsigned int channel )
{
	DMA_MR mode;
	if ( channel != 0 && channel != 1 )
	{
		return DMAINVALID;
	}

	if ( DMA_Get_Mode( host, eumbbar, channel, &mode ) != DMASUCCESS )
	{
			return DMAINVALID;
	}

	if ( mode.ctm == 0 )
	{
		/* either illegal mode or not chaining mode */
		return DMAINVALID;
	}

	mode.cc = 1;
	return DMA_Set_Mode( host, eumbbar, channel, mode );
}

/**************************************************************
 * function: DMA_Bld_Desp
 *
 * description: set current descriptor address register
 *              according to the desp for a given channel
 *
 *              if the given channel is busy return DMACHNBUSY
 *              and no change made, otherwise return DMASUCCESS.
 *
 * note:
 **************************************************************/
static
DMAStatus DMA_Bld_Desp( LOCATION host,
						   unsigned int eumbbar,
						   unsigned int channel,
						   DMA_CDAR     desp )
{
	DMA_SR status;
	unsigned int temp;

	if ( channel != 0 && channel != 1 )
	{
		/* channel number out of range */
		return DMAINVALID;
	}

	if ( DMA_Get_Stat( host, eumbbar, channel, &status ) != DMASUCCESS )
	{
			return DMAINVALID;
	}

	if ( status.cb == 1 )
	{
		/* channel busy */
		return DMACHNBUSY;
	}

	temp = ( desp.cda & 0x7ffffff ) << 5;
	temp |= (( desp.snen & 0x1 ) << 4 );
	temp |= (( desp.eosie & 0x1 ) << 3 );
	temp |= (( desp.ctt   & 0x3 ) << 1 );
    temp |= ( desp.eotd  & 0x1 );

    store_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_CDAR_REG], temp );

#ifdef DMADBG0
   PRINT( "%s(%d): %s DMA %d (0x%08x) cdar := 0x%08x\n", __FILE__, __LINE__,
		  ( host == LOCAL ? "local" : "remote" ), channel, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_CDAR_REG], temp );
#endif

	return DMASUCCESS;
}

/**************************************************************
 * function: DMA_Poke_Desp
 *
 * description: poke the current descriptor address register
 *              for a given channel
 *
 *              return DMASUCCESS if no error
 *
 * note: Due to the undeterministic parallellism of DMA operation,
 *       the value returned by this function shall be taken as
 *       the most recently used descriptor when the last time
 *       DMA starts a chaining mode operation.
 **************************************************************/
static
DMAStatus DMA_Poke_Desp( LOCATION host,
						    unsigned int eumbbar,
						    unsigned int channel,
						    DMA_CDAR     *desp )
{
	unsigned int cdar;
	if ( channel != 0 && channel != 1 || desp == 0 )
	{
			return DMAINVALID;
	}

    cdar = load_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_CDAR_REG] );

#ifdef DMADBG0
   PRINT( "%s(%d): %s DMA %d (0x%08x) cdar : 0x%08x\n", __FILE__, __LINE__,
		  ( host == LOCAL ? "local" : "remote" ), channel, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_CDAR_REG], cdar );
#endif


	desp->cda   = ( cdar & 0xffffffe0 ) >> 5;
	desp->snen  = ( cdar & 0x00000010 ) >> 4;
	desp->eosie = ( cdar & 0x00000008 ) >> 3;
	desp->ctt   = ( cdar & 0x00000006 ) >> 1;
	desp->eotd  = ( cdar & 0x00000001 );

	return DMASUCCESS;
}

/**************************************************************
 * function: DMA_Bld_Curr
 *
 * description: set current src, dest, byte count registers
 *              according to the desp for a given channel
 *              return DMASUCCESS if no error.
 *
 * note:
 **************************************************************/
static
DMAStatus DMA_Bld_Curr( LOCATION host,
					   unsigned int eumbbar,
					   unsigned int channel,
					   DMA_CURR     desp )
{
	DMA_SR status;
	if ( channel != 0 && channel != 1 )
	{
		/* channel number out of range */
		return DMAINVALID;
	}

	if ( DMA_Get_Stat( host, eumbbar, channel, &status ) != DMASUCCESS )
	{
		 return DMAINVALID;
	}

	if ( status.cb == 1  )
	{
		/* channel busy */
		return DMACHNBUSY;
	}

	desp.byte_cnt &= 0x03ffffff; /* upper 6-bits are 0s */

    store_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_SAR_REG], desp.src_addr );
#ifdef DMADBG0
   PRINT( "%s(%d): %s DMA %d (0x%08x) src := 0x%08x\n", __FILE__, __LINE__,
		  ( host == LOCAL ? "local" : "remote" ), channel, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_CDAR_REG], desp.src_addr );
#endif

    store_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_DAR_REG], desp.dest_addr );
#ifdef DMADBG0
   PRINT( "%s(%d): %s DMA %d (0x%08x) dest := 0x%08x\n", __FILE__, __LINE__,
		  ( host == LOCAL ? "local" : "remote" ), channel, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_CDAR_REG], desp.dest_addr );
#endif

    store_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_BCR_REG], desp.byte_cnt );
#ifdef DMADBG0
   PRINT( "%s(%d): %s DMA %d (0x%08x) count := 0x%08x\n", __FILE__, __LINE__,
		  ( host == LOCAL ? "local" : "remote" ), channel, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_CDAR_REG], desp.byte_cnt );
#endif


	return DMASUCCESS;

}

/**************************************************************
 * function: DMA_Poke_Curr
 *
 * description: poke the current src, dest, byte count registers
 *              for a given channel.
 *
 *              return DMASUCCESS if no error
 *
 * note:        Due to the undeterministic parallelism, in chaining
 *              mode, the value returned by this function shall
 *              be taken as reference when the query is made rather
 *              than the absolute snapshot when the value is returned.
 **************************************************************/
static
DMAStatus DMA_Poke_Curr( LOCATION host,
					    unsigned int eumbbar,
					    unsigned int channel,
					    DMA_CURR*    desp )
{
	if ( channel != 0 && channel != 1 || desp == 0 )
	{
			return DMAINVALID;
	}

	desp->src_addr = load_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_SAR_REG] );
#ifdef DMADBG0
   PRINT( "%s(%d): %s DMA %d (0x%08x) src : 0x%08x\n", __FILE__, __LINE__,
		  ( host == LOCAL ? "local" : "remote" ), channel, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_CDAR_REG], desp->src_addr );
#endif

	desp->dest_addr = load_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_DAR_REG] );
#ifdef DMADBG0
   PRINT( "%s(%d): %s DMA %d (0x%08x) dest : 0x%08x\n", __FILE__, __LINE__,
		  ( host == LOCAL ? "local" : "remote" ), channel, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_CDAR_REG], desp->dest_addr );
#endif

    desp->byte_cnt = load_runtime_reg( eumbbar, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_BCR_REG] );
#ifdef DMADBG0
   PRINT( "%s(%d): %s DMA %d (0x%08x) count : 0x%08x\n", __FILE__, __LINE__,
		  ( host == LOCAL ? "local" : "remote" ), channel, dma_reg_tb[host][channel*NUM_DMA_REG+DMA_CDAR_REG], desp->byte_cnt );
#endif


	return DMASUCCESS;
}

/*****************************************************************
 * function: dma_error_func
 *
 * description: display the error information
 *
 * note: This seems like a highly convoluted way to handle messages,
 * but I'll leave it as it was in device.c when I moved it into the
 * DMA library source.
 ****************************************************************/
static
DMAStatus dma_error_func( unsigned int eumbbar, unsigned int chn, DMAStatus err)
{
	unsigned char *msg[] =
		{
			"Local Memory Error",
			"PCI Error",
			"Channel Busy",
			"End-of-Segment Interrupt",
			"End-of-Chain/Direct Interrupt",
		};

	   if ( err >= DMALMERROR && err <= DMAEOCAINT )
	   {
	     PRINT( "DMA Status: channel %d  %s\n", chn, msg[err-DMASUCCESS-1] );
	   }

	   return err;

}

/*************************************************************
 * function: DMA_ISR
 *
 * description: DMA interrupt service routine
 *              return DMAStatus value based on
 *              the status
 *
 *************************************************************/
static
DMAStatus DMA_ISR( unsigned int eumbbar,
				  unsigned int channel,
				  DMAStatus (*lme_func)( unsigned int, unsigned int, DMAStatus ),
				  DMAStatus (*pe_func) ( unsigned int, unsigned int, DMAStatus ),
				  DMAStatus (*eosi_func)( unsigned int, unsigned int, DMAStatus ),
				  DMAStatus (*eocai_func)(unsigned int, unsigned int, DMAStatus ))
{

	DMA_SR stat;
	DMAStatus rval = DMANOEVENT;
    unsigned int temp;

	if ( channel != 0 && channel != 1 )
	{
		return DMAINVALID;
	}

	if ( DMA_Get_Stat( LOCAL, eumbbar, channel, &stat ) != DMASUCCESS )
	{
			return DMAINVALID;
	}

	if ( stat.lme == 1 )
	{
		/* local memory error */
		rval = DMALMERROR;
		if ( lme_func != 0 )
		{
		  rval = (*lme_func)(eumbbar, channel, DMALMERROR );
	    }

	}
	else if ( stat.pe == 1 )
	{
	/* PCI error */
		rval = DMAPERROR;
		if ( pe_func != 0 )
		{
		  rval = (*pe_func)(eumbbar, channel, DMAPERROR );
	    }

	}
	else if ( stat.eosi == 1 )
	{
		/* end-of-segment interrupt */
		rval = DMAEOSINT;
		if ( eosi_func != 0 )
		{
		  rval = (*eosi_func)(eumbbar, channel, DMAEOSINT );
	    }
	}
	else
	{
		/* End-of-chain/direct interrupt */
		rval = DMAEOCAINT;
		if ( eocai_func != 0 )
		{
		  rval = (*eocai_func)(eumbbar, channel, DMAEOCAINT );
	    }
	}

    temp = ( stat.reserved0 & 0xffffff ) << 8;
	temp |= ( ( stat.lme       & 0x1 ) << 7 );  /* write one to clear */
	temp |= ( ( stat.reserved1 & 0x3 ) << 5 );
    temp |= ( ( stat.pe        & 0x1 ) << 4 );  /* write one to clear */
    temp |= ( ( stat.reserved2 & 0x1 ) << 3 );
	temp |= ( ( stat.cb        & 0x1 ) << 2 );  /* write one to clear */
    temp |= ( ( stat.eosi      & 0x1 ) << 1 );  /* write one to clear */
    temp |= ( stat.eocai & 0x1 );               /* write one to clear */

    store_runtime_reg( eumbbar, dma_reg_tb[LOCAL][channel*NUM_DMA_REG + DMA_SR_REG], temp );

#ifdef DMADBG0
	PRINT( "%s(%d): DMA channel %d SR := 0x%08x\n", __FILE__, __LINE__, channel, temp );
#endif

	return rval;
}