/***********************************************************************************
* File              : ide_access.C
* Processor    : ADSP-BF533  
* IDDE          : VisualDSP++3.5
* Description  : define bunch of IDE driver interface functions to FAT including:
*                  
*                    fnIDE_SectorByte();
*                    funIDE_WriteSectorByte();
*			 fnIDE_SectorWord();
*			 fnIDE_SectorDWORD();
*			 fnIDE_SectorData();
*			 fnIDE_WriteSectorData();
*			 fnIDE_BufferSector();
*			 fnIDE_WriteBufferSector();
*			 fnIDE_InitDrive();
*                    
***********************************************************************************/

#include "ide_base.h"
#include "ide_access.h"
#include "type.h"

IDE_BUFFER buffers;

IDE_DRIVER IDE_current;

/**********************************************************************************
* Function     : nIDE_SectorByte
* Description : Read one byte from a specified address of current sector
* Input         : WORD Sublocation
* Return       : one byte value
***********************************************************************************/

BYTE fnIDE_SectorByte(WORD sublocation)
{
	BYTE data=0;          
	
    	data=buffers.currentsector.u8data[sublocation];	  // Read Data from specified pos
	return (data);
}

/**********************************************************************************
* Function     : fnIDE_WriteSectorByte
* Description : write one byte to a specified address of current sector
* Input         : WORD Sublocation
* Return       : one byte written value
***********************************************************************************/

BYTE fnIDE_WriteSectorByte(WORD sublocation, BYTE value)
{
	buffers.currentsector.u8data[sublocation]=value;
	return (value);
}

/**********************************************************************************
* Function     : fnIDE_SectorWord
* Description : read one word from a specified address of current sector
* Input         : WORD Sublocation
* Return       : one word read value
***********************************************************************************/

WORD fnIDE_SectorWord(WORD sublocation) // Return Word at position specified
{
	WORD data=0; 
	 
	data	=buffers.currentsector.u8data[sublocation];	  // Read Data from specified pos
	data   +=buffers.currentsector.u8data[sublocation+1]<<8;
	return (data);					  			 // Return value
}


/**********************************************************************************
* Function     : fnIDE_SectorDWord
* Description : read double word from a specified address of current sector
* Input         : WORD Sublocation
* Return       : double word read value
***********************************************************************************/

DWORD fnIDE_SectorDWORD(WORD sublocation) // Return Word at position specified
{
	DWORD data=0; 
	 
	data	=buffers.currentsector.u8data[sublocation];	  // Read Data from specified pos
	data   +=buffers.currentsector.u8data[sublocation+1]<<8;
	data   +=buffers.currentsector.u8data[sublocation+2]<<16;
	data   +=buffers.currentsector.u8data[sublocation+3]<<24;
	return (data);					  			 // Return value
}

/**********************************************************************************
* Function     : fnIDE_SectorData
* Description : read a section of data from a specified starting address of current sector
* Input         : WORD Sublocation - starting address
*                     BYTE *buffer - reading data buffer
*                    WORD size - size of reading data section
***********************************************************************************/

void fnIDE_SectorData(WORD sublocation, BYTE *buffer, WORD size)
{
	WORD i;
	for(i=0;i<size;i++)
	{
		buffer[i]=buffers.currentsector.u8data[sublocation+i];
	}
}

/**********************************************************************************
* Function     : fnIDE_WriteSectorData
* Description : write a section of data from a specified starting address of current sector
* Input         : WORD Sublocation - starting address
*                     BYTE *buffer - writing data buffer
*                    WORD size -  size of writing data section
* Return       : double word read value
***********************************************************************************/

void fnIDE_WriteSectorData(WORD sublocation, BYTE *buffer, WORD size)
{
	WORD i;
	for(i=0;i<size;i++)
	{
		buffers.currentsector.u8data[sublocation+i]=buffer[i];
	}
}

/**********************************************************************************
* Function     : fnIDE_BufferSector
* Description : read a specified logic sector
* Input         : BYTE *buffer - reading data buffer
*                    DWORD LBALocation -  address of logic sector
*                    BYTE count - counts of reading sectors(up to 256), count=0 means read 256 sectors
* Return       : 0-normal; 1-error
***********************************************************************************/

int fnIDE_BufferSector(WORD *buf,DWORD LBALocation,BYTE count)
{
	
	WORD    i,temp;
	BYTE 	j;
	BYTE	errorcode;

	Wait_ReadyBusy(); 
	            
	buffers.SectorCurrentlyLoaded=LBALocation; // update current sector loaded
	
    	*pDriveHead	=((LBALocation >> 24) & 0xFF) | 0xE0;
    	*pCylinderHigh	=(LBALocation >> 16) & 0xFF;
    	*pCylinderLow	=(LBALocation >> 8) & 0xFF;
    	*pSectorNumber	=LBALocation & 0xFF;
    	*pSectorCount	= count; 		   	 	   
    	*pCommand	= 0x21;//IDE_CMD_READSECTOR;		   // Read sector
	
	
	Wait_DRQ();
	j=count;
	temp=0;
	do
	{
		
		Wait_DRQ();
    		for(i=0; i < SECTORWORDSIZE; i++)
    		{
    			buf[temp+i]=*pDataPort;
    		}
    		j--;
    		temp += SECTORWORDSIZE ;
    	}while(j!=0);
	
    	errorcode	= CheckforError();
	if (errorcode!=0) 
		return 1; 
	
	return 0;
}

/**********************************************************************************
* Function     : fnIDE_WriteBufferSector
* Description : write a specified logic sector
* Input         : BYTE *buffer - writing data buffer
*                    DWORD LBALocation -  address of logic sector
*                    BYTE count - counts of writing sectors(up to 256), count=0 means write 256 sectors
* Return       : 0-normal; 1-error
***********************************************************************************/

int fnIDE_WriteBufferSector(WORD *buf,DWORD LBALocation,BYTE count)
{
	WORD    i,temp;
	BYTE    j;
	BYTE	errorcode;
	
	if (LBALocation>=IDE_current.maxLBA) 
	   {
	   printf("\r\nIDE_BufferSector: Out of Range Disc Read of 0x%lx", LBALocation);
	   return 1;
	   }
	
	Wait_ReadyBusy();
	//if (buffers.SectorCurrentlyLoaded!=LBALocation) // Dont reload if already loaded
	//{              
	buffers.SectorCurrentlyLoaded=LBALocation; // update current sector loaded
	
    	*pDriveHead	=((LBALocation >> 24) & 0xFF) | 0xE0;//bit6=1:LBA mode bit6=0:CHS mode
    	*pCylinderHigh	=(LBALocation >> 16) & 0xFF;
    	*pCylinderLow	=(LBALocation >> 8) & 0xFF;
    	*pSectorNumber	=LBALocation & 0xFF;
	//}
    	/*temp= (LBALocation/IDE_current.head_num)/IDE_current.one_cylinder_sector;
    	*pDriveHead= (LBALocation/IDE_current.one_cylinder_sector)%IDE_current.head_num;
    	*pCylinderHigh	=(temp>>8)&0xFF;
    	*pCylinderLow	=temp&0xFF;
    	*pSectorNumber	=(LBALocation%IDE_current.one_cylinder_sector)+1;*/
    	*pSectorCount	= count; 		   	 	   // 1 Sector to be read only
    	*pCommand	= 0x31;//IDE_CMD_READSECTOR;		   // Read sector
	
	/*errorcode	= CheckforError();
	if (errorcode!=0) 
		return 1; 		   // Were there any Errors ?			   */
	
	Wait_DRQ();			 // Wait till Data is available in IDE buffer
	
	j=count;
	temp=0;					 // Reading Status Register reset INT too
	do
	{
		
		Wait_DRQ();
    		for(i=0; i < SECTORWORDSIZE; i++)
    		{
    			*pDataPort=buf[temp+i];
    		}
    		j--;
    		temp += SECTORWORDSIZE ;
    	}while(j!=0);
    
    	errorcode	= CheckforError();
		if (errorcode!=0) 
			return 1; 
				 // Were there any Errors ?
	
	//}
	return 0;
}
/**********************************************************************************
* Function     : fnIDE_InitDrive
* Description : get HD information
* Input         : none
* Return       : none
***********************************************************************************/

void fnIDE_InitDrive(void)
{
	WORD i,cnt;
	BYTE chardata;
	DWORD TotalLBAs=0;
	
	IdeIdle();
   	// Wait till not busy and RDY?
	Wait_ReadyBusy();

   	// Send Command for drive identification 
   	*pCommand = IDE_CMD_IDENTIFY;
   	// Wait for DRQ
	Wait_DRQ();

   	// Read in first 62 bytes of the drive identification
   	for (i=0; i<256; i++)
   	{
		// Read data words from drives buffer
		buffers.currentsector.u16data[i] = *pDataPort;		   
	}
	buffers.SectorCurrentlyLoaded=0xFFFFFFFF;

		// Assuming drive supports LBA find max LBA sector
	TotalLBAs = buffers.currentsector.u16data[61];
	TotalLBAs = TotalLBAs << 16;
	IDE_current.maxLBA = TotalLBAs + buffers.currentsector.u16data[60];
	IDE_current.head_num = buffers.currentsector.u16data[3];
	IDE_current.cylinder_num = buffers.currentsector.u16data[1];
	IDE_current.one_cylinder_sector = buffers.currentsector.u16data[6];
	i=0;
	for (cnt=10; cnt<19; cnt++) 
	{
		chardata = buffers.currentsector.u16data[cnt]>>8;
		IDE_current.serialnum[i] = chardata;
		i++;		
		chardata = buffers.currentsector.u16data[cnt];
		IDE_current.serialnum[i] = chardata;
		i++;
	}
	IDE_current.serialnum[i]='\0';	
	i=0;	
	for (cnt=27; cnt<46; cnt++) 
	{
		chardata = buffers.currentsector.u16data[cnt]>>8;
		IDE_current.modelnum[i] = chardata;
		i++;		
		chardata = buffers.currentsector.u16data[cnt];
		IDE_current.modelnum[i] = chardata;
		i++;
	}
	IDE_current.modelnum[i] = '\0'	;
	
#ifdef DEBUG	
	printf("\r\nHard Disc Auto Detect Parameters");
	printf("\r\n--------------------------------\r\n");
	// Detect HDD or CDROM
	printf("\r\nType of device: ");		
	if (buffers.currentsector.u16data[0]&0x8000) 
		printf("ATA Device ");
	else 
		printf("ATAPI Device ");
		
		// Detect removable media
	if (buffers.currentsector.u16data[i]&0x0080) 
		printf("which has removable media");

		// Heads 
	printf("\r\nThe number of heads is = %d",IDE_current.head_num);
		
		// Cylinders
	printf("\r\nThe number of Cylinders is =  %d",IDE_current.cylinder_num);

		// Sectors Per Track 
	printf("\r\nThe number of Sectors per track is = %d", IDE_current.one_cylinder_sector);

		// Serial Number
	printf("\r\nThe number of Serial Number of the device is = %s",IDE_current.serialnum);
		// Model Number
	printf("\r\nThe number of Model Number of the device is = %s",IDE_current.modelnum);	
	// CHS or LBA
	if(!((buffers.currentsector.u16data[49] >> 8) & 0x1)) 
		printf("\r\nCHS Mode Only (NO LBA)");
	else
		printf("\r\nLBA Supported");
		
	// Report max lba address
	printf("\r\nLBA sectors is 0x%lx\n", TotalLBAs);
#endif
		 
}