fileiodrv.c

56f8300E系列dsp的BOOTloader

/*******************************************************************************
*
* Motorola Inc.
* (c) Copyright 2001, 2002 Motorola, Inc.
* ALL RIGHTS RESERVED.
*
********************************************************************************
*
* FileName:    fileiodrv.c
*
* Description: source file for fileio device driver.
*
* Notes:  
*
*******************************************************************************/
#include "string.h"
#include "assert.h"
#include "fileiodrv.h"


extern const struct io_sFileIOInterface fileioInterfaceVT;
extern struct fileio_Handle fileDriver[];
extern const int fileioFilesLimit;

static unsigned short FilesOpen;
static handle_t UartHandle;

/*****************************************************************************/
handle_t fileioOpen(const char * pName, int OFlags, ...)
{
	struct fileio_Handle  *pFileIO;
	handle_t        Uart;
	int             Length;	
	int             CompareResult;
	unsigned short  NewUartState;
	struct sHeader  FileIOSetup;
	int             handleCnt;
		
#ifdef OPEN_NAME_CHECKING_NEEDED
	if(strncmp(pName, FILE_IO_NAME, FILE_IO_NAME_LENGTH) == 0)
	{
#endif
		for (handleCnt = 0; handleCnt < fileioFilesLimit; handleCnt++)
		{
			if (fileDriver[handleCnt].OFlags == 0)
			{
			
				pFileIO = &fileDriver[handleCnt];
				if (OFlags & (O_WRONLY | O_RDONLY))
				{
					pFileIO->sFileIOInterface = (io_sInterface *) &fileioInterfaceVT;
					pFileIO->FileNumber = 0x30 + handleCnt;
					pFileIO->OFlags = OFlags;
				}
				else
				{
					return IO_INVALID_HANDLE;
				}
				
					
				if(FilesOpen == 0)
				{
					/* open SCI 0 in Blocking mode with 8 bit word length without parity */
					/* and on 56k baud rate.  */ 
					
					#ifdef BSP_DEVICE_NAME_SERIAL_0
						Uart = open(BSP_DEVICE_NAME_SERIAL_0, O_RDWR, 56000);
					#else
						#warning BSP_DEVICE_NAME_SERIAL_0 must be defined if using File IO
					#endif
				
					if (Uart  == (handle_t) -1)
					{
						assert(!" Open SCI0 device failed.");
					}

					//fileio_Handle->UartHandle  = Uart;
					UartHandle  = Uart;
				}
		        
				FilesOpen++;

				FileIOSetup.FileNumber = 0x30 + handleCnt;
				FileIOSetup.Command  = FILE_IO_COMMAND_OPEN;
			
				if(strncmp(pName, FILE_IO_SDK_PATH, FILE_IO_SDK_PATH_LENGTH))
				{
					FileIOSetup.NumBytes = (char)strlen(pName) - 4;
					FileIOSetup.Path     = 'N';
					
					write(UartHandle, &FileIOSetup, FILE_IO_SHEADER_LENGTH * sizeof(char));
											
					write(UartHandle, pName + 5, sizeof(char));
					write(UartHandle, ":", sizeof(char));
			
					Length = strlen(pName) - 6;
					write(UartHandle, pName + 6, Length * sizeof(char));
				}
				else
				{
					FileIOSetup.NumBytes = (char)strlen(pName) - FILE_IO_SDK_PATH_LENGTH;
					FileIOSetup.Path     = 'S';
					
					write(UartHandle, &FileIOSetup, FILE_IO_SHEADER_LENGTH * sizeof(char));
					write(UartHandle, pName + 18, (FileIOSetup.NumBytes)*sizeof(char));
				}
			
				write(UartHandle, &OFlags, sizeof(char));

				return (handle_t) pFileIO;
			}
		}
	    assert("Can not open more than FILEIOFILESLIMIT files at once!!!");

#ifdef OPEN_NAME_CHECKING_NEEDED
	}
#endif

	return IO_INVALID_HANDLE;
}

/*****************************************************************************/
int fileioClose(handle_t FileDesc)
{
//	handle_t     UartHandle      = ((fileio_Handle *)FileDesc)->UartHandle;	
	struct sCloseHeader CloseCommand;

	CloseCommand.FileNumber = ((struct fileio_Handle *)FileDesc)->FileNumber;
	CloseCommand.Command    = FILE_IO_COMMAND_CLOSE;
	CloseCommand.FD         = ((struct fileio_Handle *)FileDesc)->OFlags;

	write(UartHandle, &CloseCommand, FILE_IO_SCLOSE_HEADER_LENGTH * sizeof(char));
	
	while (ioctl(UartHandle, SCI_GET_STATUS, NULL) & SCI_STATUS_WRITE_INPROGRESS )
	{
	}

	((struct fileio_Handle *)FileDesc)->OFlags = 0;
	((struct fileio_Handle *)FileDesc)->FileNumber = 0;
	FilesOpen--;
    
	if (FilesOpen == 0)
	{
		close(UartHandle);
		UartHandle = IO_INVALID_HANDLE;
	}
	else if (FilesOpen < 0)
	{
		assert("Tried to close a file that was not open");
	}
    
	return 1;
}

/*****************************************************************************/
ssize_t fileioRead(handle_t FileDesc, void * pUserBuffer, size_t NBytes)
{
//	handle_t  UartHandle   = ((fileio_Handle *)FileDesc)->UartHandle;
	unsigned int Bytes       = FILE_IO_BUFFER_SIZE;
	struct sHeader   ReadCommand;
	char    * pBuffer     = (char *)pUserBuffer;
	ssize_t   ReadCount;
	ssize_t   TotalCount  = 0;
	unsigned char Size;
	unsigned int RealBlockSize;

	ReadCommand.FileNumber = ((struct fileio_Handle *) FileDesc)->FileNumber;
	ReadCommand.Command = FILE_IO_COMMAND_READ;
	ReadCommand.Path = 0;
	
	do
	{
		if(NBytes < FILE_IO_BUFFER_SIZE)
		{
			Bytes = NBytes;
		}

		ReadCommand.NumBytes = Bytes;
		write(UartHandle, &ReadCommand, FILE_IO_SHEADER_LENGTH * sizeof(char));

		ReadCount = read (UartHandle, &Size, 1);
		RealBlockSize = Size;
		ReadCount = read (UartHandle, pBuffer, RealBlockSize);
		
		TotalCount += ReadCount;
		pBuffer    += Bytes;
		
	}while(((NBytes -= Bytes) != 0) || (RealBlockSize != Bytes));

	return TotalCount;
}

/*****************************************************************************/
ssize_t fileioWrite(handle_t FileDesc, const void * pUserBuffer, size_t Size)
{
//	handle_t  UartHandle  = ((fileio_Handle *)FileDesc)->UartHandle;
	struct sHeader   WriteCommand;
	unsigned int Bytes       = FILE_IO_BUFFER_SIZE;
	char    * pBuffer     = (char *)pUserBuffer;
	ssize_t   ReturnCount = (ssize_t)Size;

	WriteCommand.FileNumber = ((struct fileio_Handle *) FileDesc)->FileNumber;
	WriteCommand.Command = FILE_IO_COMMAND_WRITE;
	WriteCommand.Path = 0;

	do
	{
		if(Size < FILE_IO_BUFFER_SIZE)
		{
			Bytes = Size;
		}
		
		WriteCommand.NumBytes = Bytes;
		
		write(UartHandle, &WriteCommand, FILE_IO_SHEADER_LENGTH * sizeof(char));
		write(UartHandle, pBuffer, Bytes);
		
		pBuffer += Bytes;
		
	}while((Size -= Bytes) != 0);

	return ReturnCount;
}

/*****************************************************************************/
unsigned int ioctlFILEIO(handle_t FileDesc, void * pParams)
{
	struct fileio_Handle * pFileIO = (struct fileio_Handle *) FileDesc;
	
	return 0;
}