overload.c

This zip file shows the use ROM Services in order to speed up an application and reduce its code siz

//*----------------------------------------------------------------------------
//*         ATMEL Microcontroller Software Support  -  ROUSSET  -
//*----------------------------------------------------------------------------
//* The software is delivered "AS IS" without warranty or condition of any
//* kind, either express, implied or statutory. This includes without
//* limitation any warranty or condition with respect to merchantability or
//* fitness for any particular purpose, or against the infringements of
//* intellectual property rights of others.
//*----------------------------------------------------------------------------
//* File Name           : main.c
//* Object              : main application written in C
//* Creation            : FB   21/11/2002
//*
//*----------------------------------------------------------------------------
#include <stdio.h>

#include "embedded_services.h"
#include "lib_AT91RM9200.h"

#define AT91C_Xmodem_Trame_Size			128			// Size of the Xmodem Trame 
#define AT91C_TIMEOUT_DATAFLASH			10000  		// Timeout for AT91F_DataFlashWaitReady

extern char						Buffer_Xmodem[132]; // Size Of Xmodem Packet
extern int 						destination;
extern AT91S_SvcDataFlash		svcDataFlash;
extern AT91S_SvcDataFlashStatus AT91F_DataFlashWaitReady(unsigned int);

///////////////////////////////////////////////////////////////////////////////////////////////////
// Overloaded functions for Partial Page Write
///////////////////////////////////////////////////////////////////////////////////////////////////

//*-----------------------------------------------------------------------------
//* Function Name       : AT91F_PartialPageWrite
//* Object              : Erase partielly a page
//* Input Parameters    : <page> = page number
//*						: <AdrInpage> = adr to begin the fading
//*                     : <length> = Number of bytes to erase
//*-----------------------------------------------------------------------------
AT91S_SvcDataFlashStatus AT91F_PartialPageWrite (
	AT91PS_SvcDataFlash pSvcDataFlash,
	unsigned char *src,
	unsigned int dest,
	unsigned int size)
{
	unsigned int page;
	unsigned int AdrInPage;

	page = dest / (pSvcDataFlash->pDevice->pages_size);
	AdrInPage = dest % (pSvcDataFlash->pDevice->pages_size);

	AT91F_DataFlashWaitReady(AT91C_TIMEOUT_DATAFLASH);

	//* Read the contents of the page in the Sram Buffer
	pSvcDataFlash->MainMemoryToBufferTransfert(pSvcDataFlash, DB_PAGE_2_BUF1_TRF, page);

	AT91F_DataFlashWaitReady(AT91C_TIMEOUT_DATAFLASH);

	pSvcDataFlash->WriteBuffer (pSvcDataFlash, DB_BUF1_WRITE, src, AdrInPage, size);

	AT91F_DataFlashWaitReady(AT91C_TIMEOUT_DATAFLASH);

	//* Rewrite the modified Sram Buffer in the main memory
	return(pSvcDataFlash->WriteBufferToMain(pSvcDataFlash, DB_BUF1_PAGE_ERASE_PGM, (page*pSvcDataFlash->pDevice->pages_size)));
}

//*-----------------------------------------------------------------------------
//* Function Name       : AT91F_DataFlashWrite_Overloaded
//* Object              :
//* Input Parameters    : <*src> = Source buffer
//*                     : <dest> = dataflash adress
//*                     : <size> = data buffer size
//*-----------------------------------------------------------------------------
AT91S_SvcDataFlashStatus AT91F_DataFlashWrite_Overloaded (
	AT91PS_SvcDataFlash pSvcDataFlash,
	unsigned char *src,
	int dest,
	int size )
{
	unsigned int length;

    if ( (dest + size) > (pSvcDataFlash->pDevice->pages_size * (pSvcDataFlash->pDevice->pages_number)))
		return DATAFLASH_MEMORY_OVERFLOW;
		
	//* If destination does not fit a page start address
    if ((dest % pSvcDataFlash->pDevice->pages_size)  != 0 )
    {
		length = pSvcDataFlash->pDevice->pages_size - (dest % (pSvcDataFlash->pDevice->pages_size));

		if (size < length)
			length = size;

		if(!AT91F_PartialPageWrite(pSvcDataFlash,src, dest, length))
			return DATAFLASH_ERROR;

		//* Update size, source and destination pointers
        size -= length;
        dest += length;
        src += length;
    }

    while (( size - pSvcDataFlash->pDevice->pages_size ) >= 0 )
    {
		// program dataflash page
		if(!AT91F_PartialPageWrite(pSvcDataFlash, src, dest, pSvcDataFlash->pDevice->pages_size ))
			return DATAFLASH_ERROR;

		AT91F_DataFlashWaitReady(AT91C_TIMEOUT_DATAFLASH);

		//* Update size, source and destination pointers
        size -= pSvcDataFlash->pDevice->pages_size ;
        dest += pSvcDataFlash->pDevice->pages_size ;
        src  += pSvcDataFlash->pDevice->pages_size ;
    }

    //* If still some bytes to read
    if ( size > 0 ) 
    {
		// program dataflash page
		if(!AT91F_PartialPageWrite(pSvcDataFlash, src, dest, size) )
			return DATAFLASH_ERROR;

		AT91F_DataFlashWaitReady(AT91C_TIMEOUT_DATAFLASH);
	}
    return DATAFLASH_OK;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// Overloaded functions for Xmodem upload on dataflash
///////////////////////////////////////////////////////////////////////////////////////////////////

//*--------------------------------------------------------------------------------------
//* Function Name       : AT91F_DataFlashProcess()
//* Object              :
//* Input Parameters    :
//* Output Parameters   :
//*--------------------------------------------------------------------------------------
void  AT91F_DataFlashProcess (void)
{
	AT91F_DataFlashWrite_Overloaded(&svcDataFlash,(unsigned char *) Buffer_Xmodem,destination,AT91C_Xmodem_Trame_Size);
	destination += AT91C_Xmodem_Trame_Size;
}

//*----------------------------------------------------------------------------
//* Function Name       : AT91F_SvcXmodemReadHandler_Overloaded()
//* Object              : Receive an XMODEM file with the USART, update the
//*                       linked buffer structure
//* Input Parameters    : AT91PS_SvcXmodem, AT91PS_USART->US_CSR
//* Output Parameters   : none
//*----------------------------------------------------------------------------
AT91S_SvcCommStatus AT91F_SvcXmodemReadHandler_Overloaded(AT91PS_SvcXmodem pSvcXmodem, unsigned int csr)
{
	AT91PS_USART      pUsart  = pSvcXmodem->pUsart;
	AT91PS_Buffer      pBuffer = (AT91PS_Buffer) pSvcXmodem->parent.pBuffer;
	AT91PS_SBuffer	   pSBuffer = (AT91PS_SBuffer)(pBuffer->pChild);

	char *pData;
	unsigned int bufSize;
	char c;

	if ( (csr & AT91C_US_RXRDY) ) {
		// Stop sending 'C'
		pSvcXmodem->tempo.Stop(&(pSvcXmodem->tempo));
		pSvcXmodem->isPacketDesc = 1;
		pBuffer->GetRdBuffer(pBuffer, &pData, &bufSize);
		pSvcXmodem->pData    = pData;

		c = AT91F_US_GetChar( (AT91PS_USART) pUsart);
		switch (c) {
			case AT91C_XMODEM_STX:
				pSvcXmodem->dataSize = AT91C_XMODEM_DATA_SIZE_STX;
				AT91F_US_ReceiveFrame (	(AT91PS_USART) pUsart,
										pSvcXmodem->packetDesc,
										AT91C_XMODEM_PACKET_SIZE,
										pData,
										AT91C_XMODEM_DATA_SIZE_STX + AT91C_XMODEM_CRC_SIZE);
				break;
			case AT91C_XMODEM_SOH:
				pSvcXmodem->dataSize = AT91C_XMODEM_DATA_SIZE_SOH;
				AT91F_US_ReceiveFrame (	(AT91PS_USART) pUsart,
										pSvcXmodem->packetDesc,
										AT91C_XMODEM_PACKET_SIZE,
										pData,
										AT91C_XMODEM_DATA_SIZE_SOH + AT91C_XMODEM_CRC_SIZE);
				break;
			case AT91C_XMODEM_EOT:
				AT91F_US_PutChar( (AT91PS_USART) pUsart, AT91C_XMODEM_ACK);
				AT91F_US_DisableIt((AT91PS_USART) pUsart, AT91C_US_RXRDY | AT91C_US_ENDRX | AT91C_US_RXBUFF);
				if ( (pSvcXmodem->packetId == 1) || bufSize)
					pBuffer->FillRdBuffer(pBuffer, bufSize);
				pSvcXmodem->eot = 1;
				return AT91C_COMMSVC_SUCCESS;
			default:
				AT91F_US_ReceiveFrame (	(AT91PS_USART) pUsart,
										pData,
										AT91C_XMODEM_PACKET_SIZE + AT91C_XMODEM_DATA_SIZE_SOH + AT91C_XMODEM_CRC_SIZE,
										0,
										0);
				AT91F_US_PutChar( (AT91PS_USART) pUsart, AT91C_XMODEM_ACK);
				break;
		}

		AT91F_US_DisableIt((AT91PS_USART) pUsart, AT91C_US_RXRDY);
		AT91F_US_EnableIt((AT91PS_USART) pUsart, AT91C_US_ENDRX);
	}

	else if ( (csr & AT91C_US_ENDRX) || (csr & AT91C_US_RXBUFF) ) {
		if (pSvcXmodem->isPacketDesc) {
			pSvcXmodem->packetStatus = pSvcXmodem->CheckHeader(pSvcXmodem->packetId, pSvcXmodem->packetDesc);
			pSvcXmodem->isPacketDesc = 0;
			AT91F_US_DisableIt((AT91PS_USART) pUsart, AT91C_US_ENDRX);
			AT91F_US_EnableIt((AT91PS_USART) pUsart, AT91C_US_RXBUFF);

		}
		else {
			if (pSvcXmodem->packetStatus && pSvcXmodem->CheckData(pSvcXmodem)) {
				// overload CheckData
				pSvcXmodem->pData -= pSvcXmodem->dataSize;

				pBuffer->FillRdBuffer(pBuffer, pSvcXmodem->dataSize);
				// overload FillRdBuffer
				pSBuffer->pRdBuffer -= pSvcXmodem->dataSize;

				AT91F_DataFlashProcess();

				AT91F_US_PutChar( (AT91PS_USART) pUsart, AT91C_XMODEM_ACK);
				++(pSvcXmodem->packetId);
			}
			else
				AT91F_US_PutChar( (AT91PS_USART) pUsart, AT91C_XMODEM_NAK);

			AT91F_US_DisableIt((AT91PS_USART) pUsart, AT91C_US_ENDRX | AT91C_US_RXBUFF);
			AT91F_US_EnableIt((AT91PS_USART) pUsart, AT91C_US_RXRDY);
		}
	}
	return AT91C_COMMSVC_SUCCESS;
}