z85230buf.c

Curtiss-Wright Controls Embedded Computing公司的cw183板bsp源代码

  if ( frame->read == frame->size )
    {
    /* end of this frame - increment frame and try again */
    return 0;
    }

  *byte = frame->buf[ frame->read ];
  frame->read++;
  
  return 1;
  }

/***************************************************************************
 * z85230BufWriteFrameByte - write a byte to the current frame
 *
 * RETURNS
 * the number of bytes written to the frame
 */
int z85230BufWriteFrameByte( Z85230BUF_FRAMES * buffer, unsigned char byte )
  {
  Z85230BUF_FRAME * frame = &(buffer->frames[ buffer->write ]);

  if ( frame->size == frame->maxSize )
    {
    /* frame is full */
    return 0;
    }

  frame->buf[ frame->size ] = byte;
  frame->size++;

  return 1;
  }

/***************************************************************************
 * z85230BufReadFrameSize - query the number of bytes in the read frame
 *
 * RETURNS
 * the number of bytes in the read frame
 */
int z85230BufReadFrameSize( Z85230BUF_FRAMES * buffer )
  {
  return buffer->frames[ buffer->read ].size;
  }

/***************************************************************************
 * z85230BufWriteFrameSize - query the number of bytes in the write frame
 *
 * RETURNS
 * the number of bytes in the write frame
 */
int z85230BufWriteFrameSize( Z85230BUF_FRAMES * buffer )
  {
  return buffer->frames[ buffer->write ].size;
  }

/***************************************************************************
 * z85230BufFlushFrames - empty the frame currently being read from
 *
 * RETURNS
 * N/A
 */
void z85230BufFlushFrames( Z85230BUF_FRAMES * buffer )
  {
  int i ;

  buffer->read = 0 ;
  buffer->write = 0 ;
  for(i=0; i<buffer->size ; i++ )
    {
    buffer->frames[i].size = 0 ;
    buffer->frames[i].read = 0 ;
    }
  }

/***************************************************************************
 * z85230DmaSetFrameSize - set the size of this frame on completion of the 
 *                         DMA transfer.
 *
 * RETURNS
 * N/A
 */
void z85230DmaSetFrameSize( Z85230BUF_FRAMES * buffer, int size)
  {
  Z85230BUF_FRAME * frame = &(buffer->frames[ buffer->write ]);

  if( size >= frame->maxSize )
    {
    /* overflow condition */
    return  ;
    }

  frame->size = size ;
  }

/***************************************************************************
 * z85230BufCreateStream - allocate a Z85230BUF_STREAM
 *
 * RETURNS
 * Z85230_OK: success
 * anything else: failure
 */
int z85230BufCreateStream( Z85230BUF_STREAM * buffer, int size )
  {
  buffer->buf = (unsigned char *)z85230OSMalloc( size );

  if ( buffer->buf == NULL )
    {
    return Z85230_ERR_OUT_OF_MEM;
    }

  buffer->size = size;
  buffer->read = buffer->write = 0;

  return Z85230_OK;
  }

/***************************************************************************
 * z85230BufDeleteStream - delete a Z85230BUF_STREAM
 *
 * RETURNS
 * N/A
 */
void z85230BufDeleteStream( Z85230BUF_STREAM * buffer )
  {
  if ( buffer->size == 0 )
    {
    /* empty/uninitialized buffer */
    return;
    }

  z85230OSFree( buffer->buf );
  buffer->size = 0;
  buffer->read = buffer->write = 0;
  }

/***************************************************************************
 * z85230BufStreamSize - returns the number of bytes buffered in the stream
 *
 */
int z85230BufStreamSize( Z85230BUF_STREAM * buffer )
  {
  int size = buffer->write - buffer->read;

  if ( size < 0 )
    {
    size += buffer->size;
    }

  return size;
  }

/***************************************************************************
 * z85230BufStreamAvailable - returns the number of bytes free for buffering
 *                             in the stream
 */
int z85230BufStreamAvailable( Z85230BUF_STREAM * buffer )
  {
  return buffer->size - z85230BufStreamSize( buffer ) - 1;
  }

/***************************************************************************
 * z85230BufReadStream - read up to the specified number of bytes
 *
 * RETURNS
 * the number of bytes read
 */
int z85230BufReadStream( Z85230BUF_STREAM * buffer, char * bytes, 
			 int size, unsigned char mask )
  {
  int bytesCopied = 0;

  while ( (buffer->read != buffer->write) && (bytesCopied < size) )
    {
    bytes[ bytesCopied++ ] = buffer->buf[ buffer->read++ ] & mask;
    if ( buffer->read == buffer->size )
      {
      buffer->read = 0;
      }
    }

  return bytesCopied;
  }

/***************************************************************************
 * z85230BufWriteStream - write the specified number of bytes
 *
 * RETURNS
 * the number of bytes written
 */
int z85230BufWriteStream( Z85230BUF_STREAM * buffer, char * bytes, 
			  int size, unsigned char mask )
  {
  int bytesCopied = 0;

  while ( (buffer->write + 1 % buffer->size != buffer->read) &&
	  (bytesCopied < size) )
    {
    buffer->buf[ buffer->write++ ] = bytes[ bytesCopied++ ] & mask;
    if ( buffer->write == buffer->size )
      {
      buffer->write = 0;
      }
    }

  return bytesCopied;
  }

/***************************************************************************
 * z85230BufReadStreamByte - read up to the specified number of bytes
 *
 * RETURNS
 * the number of bytes read
 */
int z85230BufReadStreamByte( Z85230BUF_STREAM * buffer, char * byte )
  {
  /* support a limited form of concurrency by accessing buffer->write only
   * once in this function
   */
  int bufSize = buffer->write - buffer->read;
  
  if ( bufSize == 0 )
    {
    /* buffer empty */
    return 0;
    }

  *byte = buffer->buf[ buffer->read++ ];

  Z85230_ASSERT( buffer->read <= buffer->size );

  if ( buffer->read >=  buffer->size )
    {
    /* wrap around buffer */
    buffer->read = 0;
    }

  return 1;
  }

/***************************************************************************
 * z85230BufWriteStreamByte - read up to the specified number of bytes
 *
 * RETURNS
 * the number of bytes read
 */
int z85230BufWriteStreamByte( Z85230BUF_STREAM * buffer, char byte )
  {
  /* support a limited form of concurrency by accessing buffer->read only
   * once in this function
   */
  int bufFree = buffer->read - buffer->write - 1;
  
  if ( bufFree == 0 )
    {
    /* buffer full */
    return 0;
    }

  buffer->buf[ buffer->write++ ] = byte;

  Z85230_ASSERT( buffer->write <= buffer->size );

  if ( buffer->write >=  buffer->size )
    {
    /* wrap around buffer */
    buffer->write = 0;
    }

  return 1;
  }

/***************************************************************************
 * z85230BufFlushStream - empty the buffer
 *
 * RETURNS
 * N/A
 */
void z85230BufFlushStream( Z85230BUF_STREAM * buffer )
  {
  buffer->read = 0;
  buffer->write = 0 ;
  }

/***************************************************************************
 * z85230DmaReadPtrUp - update the counter to reflect a DMA transfer
 *
 * RETURNS
 * N/A
 */
void  z85230DmaReadPtrUp( Z85230BUF_STREAM * buffer, int dma_bytes )
{
  buffer->read += (dma_bytes % buffer->size);
  buffer->read = (buffer->read % buffer->size);
}

/***************************************************************************
 * z85230DmaWritePtrUp - update the counter to reflect a DMA transfer
 *
 * RETURNS
 * N/A
 */
void  z85230DmaWritePtrUp( Z85230BUF_STREAM * buffer, int dma_bytes )
{
  buffer->write += (dma_bytes % buffer->size);
  buffer->write = (buffer->write % buffer->size);
}

/***************************************************************************
 * z85230DmaGetTxStream - get a pointer to the next byte to be transfered
 *
 * RETURNS
 * pointer to the next byte to be transfered/A
 */
UINT8 *z85230DmaGetTxStream(  Z85230BUF_STREAM * buffer )
{
  return &(buffer->buf[ buffer->read ]);
}

/***************************************************************************
 * z85230DmaGetTxStreamSize - get the size of the current stream.
 * streams that stradle boundaries will be broken into two
 *
 * RETURNS
 * size of the current stream
 */
UINT32 z85230DmaGetTxStreamSize(  Z85230BUF_STREAM * buffer )
{
  int size = buffer->write - buffer->read;

  if ( size < 0 )
    {
    size = buffer->size-buffer->read;
    }

  return size;
}

/***************************************************************************
 * z85230DmaGetRxStream - get a pointer to the next byte to be transfered
 *
 * RETURNS
 * pointer to the next byte to be transfered/A
 */
UINT8 *z85230DmaGetRxStream(  Z85230BUF_STREAM * buffer )
{
  return &(buffer->buf[ buffer->write ]);
}
 
/***************************************************************************
 * z85230DmaGetRxStreamSize - get the size of the current stream.
 * streams that stradle boundaries will be broken into two
 *
 * RETURNS
 * size of the current stream
 */
UINT32 z85230DmaGetRxStreamSize(  Z85230BUF_STREAM * buffer )
{
  int size ; 

  if( buffer->write >= buffer->read )
    {
    size = buffer->size - buffer->write ;
    }
  else
    {
    size =  buffer->read ;
    }
 
  return size;
}

/***************************************************************************
 * z85230DmaGetStreamSize - get the size of the current stream.
 * streams that stradle boundaries will be broken into two
 *
 * RETURNS
 * size of the current stream
 */
UINT32 z85230DmaGetReadValue(  Z85230BUF_STREAM * buffer )
{
  int value ;

  value = buffer->read;

  return value ;
}

/***************************************************************************
 * z85230CopyDmaStream - copy the contents of the DMA buffer to 
 * the ring buffer
 *
 * RETURNS
 * NA
 */
void z85230CopyDmaStream( Z85230BUF_STREAM *buffer,
                          UINT8            *dma_buf,
                          int              dma_size
                        )
{
  int size = 0 ;
  int remainder ;
  
  /* this transfer fits into the remaining buffer space */
  if(   ( buffer->write >= buffer->read )
     && (( buffer->size - buffer->write ) >= dma_size )
    )
    {
    memcpy( &(buffer->buf[buffer->write]), dma_buf, dma_size );
    buffer->write += dma_size ;
    buffer->write %= buffer->size ;
    return ;
    }
  /* transfer the first block to the end of buffer */
  if( buffer->write >= buffer->read )
    {
    size = buffer->size - buffer->write ;
    memcpy( &(buffer->buf[buffer->write]), dma_buf, size );
    buffer->write = 0 ;
    }
  /* transfer to front of buffer */
  remainder = dma_size - size ;
  if(remainder < (buffer->read - buffer->write))
    {
    memcpy( &(buffer->buf[buffer->write]), dma_buf+size, remainder );
    buffer->write += remainder ;
    return ;
    }
  /* if we havn't exited by now, we have an overflow condition 
   * copy what we can and get out.  We should keep the write pointer
   * to 1 less than the read
   */
  remainder = buffer->read - buffer->write - 1 ;
  if( remainder > 0 )
    {
    memcpy( &(buffer->buf[buffer->write]), dma_buf+size, remainder );
    buffer->write += remainder ;
    return ;
    }
}