sd_test.c

GM8120 linux driver.

/***************************************************************************
* Copyright  Faraday Technology Corp 2002-2003.  All rights reserved.      *
*--------------------------------------------------------------------------*
* Name:sd.c                                                                *
* Description: SD test program                                             *
* Author: Ted Hsu                                                          *
****************************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

#include "fLib.h"
#include "filectrl.h"
#include "sd.h"
#include "command.h"
#include "DMA.h"

BOOL CPRM_Order_Change;
extern SDCardStruct fLib_SDCard;

UINT32 SDDevCmd(CommandTableStruct_T *CmdTable);
UINT32 SD_SectorReadCmd(CommandTableStruct_T *CmdTable);
UINT32 SD_SectorWriteCmd(CommandTableStruct_T *CmdTable);
UINT32 SD_DirCmd(CommandTableStruct_T *CmdTable);
UINT32 SD_ChangeDirCmd(CommandTableStruct_T *CmdTable);
UINT32 SD_MakeCmd(CommandTableStruct_T *CmdTable);
UINT32 SD_DeleteCmd(CommandTableStruct_T *CmdTable);
UINT32 SD_RenameCmd(CommandTableStruct_T *CmdTable);
UINT32 SD_CopyCmd(CommandTableStruct_T *CmdTable);
UINT32 SD_ReadFileCmd(CommandTableStruct_T *CmdTable);


void SD_quit(void);

CommandTableStruct_T SD_CmdTable[] =
{
	{{"sddev", NULL,}, "sddev [-r pio/dma]\n",
		0, 0, 0, 0, 1, 0, SDDevCmd, 0, 0, 
		{NULL,},
		{
			{"-r", IS_STR_WITH_OPTION, {"pio", "dma", NULL,}, NULL, 0, FALSE, "[-r] - re-initialize SD and set to PIO or DMA mode\n"}, 
		},
	},
	{{"sr", NULL,}, "sr sector_num sector_count\n",
		0, 0, 2, 2, 0, 0, SD_SectorReadCmd, 0, 0, 
		{
			{IS_NUM|IS_USER_SYMBOL, NULL, 0, FALSE, "sector_num - which sector to read\n"}, 
			{IS_NUM|IS_USER_SYMBOL, NULL, 0, FALSE, "sector_count - number of sectors to read\n"}, 
		},
	},
	{{"sw", NULL,}, "sw pattern sector_num sector_count\n",
		0, 0, 3, 3, 0, 0, SD_SectorWriteCmd, 0, 0, 
		{
			{IS_NUM|IS_USER_SYMBOL, NULL, 0, FALSE, "pattern - data to write\n"}, 
			{IS_NUM|IS_USER_SYMBOL, NULL, 0, FALSE, "sector_num - which sector to write\n"}, 
			{IS_NUM|IS_USER_SYMBOL, NULL, 0, FALSE, "sector_count - number of sectors to write\n"}, 
		},
	},
	{{"dir", NULL,}, "dir [directory/file]\n",
		0, 0, 1, 0, 0, 0, SD_DirCmd, 0, 0, 
		{
			{IS_STR, NULL, 0, FALSE, "[directory/file] - directory or file\n"}, 
		},
	},
	{{"cd", NULL,}, "cd [directory]\n",
		0, 0, 1, 1, 0, 0, SD_ChangeDirCmd, 0, 0, 
		{
			{IS_STR, NULL, 0, FALSE, "[directory] - directory\n"}, 
		},
	},
	{{"mk", NULL,}, "mk [name] [-d]\n",
		0, 0, 1, 1, 1, 0, SD_MakeCmd, 0, 0, 
		{
			{IS_STR, NULL, 0, FALSE, "[name] - file or directory name\n"}, 
		},
		{
			{"-d", IS_NULL, {NULL,}, NULL, 0, FALSE, "[-d] - [name] is directory\n"}, 
		},
	},
	{{"remove", "del", NULL,}, "remove/del [name] [-d]\n",
		0, 0, 1, 1, 1, 0, SD_DeleteCmd, 0, 0, 
		{
			{IS_STR, NULL, 0, FALSE, "[name] - file or directory name\n"}, 
		},
		{
			{"-d", IS_NULL, {NULL,}, NULL, 0, FALSE, "[-d] - [name] is directory\n"}, 
		},
	},
	{{"rename", "ren", NULL,}, "rename/ren old_name new_name\n",
		0, 0, 2, 2, 0, 0, SD_RenameCmd, 0, 0, 
		{
			{IS_STR, NULL, 0, FALSE, "old_name -\n"}, {IS_STR, NULL, 0, FALSE, "new_name -\n"},
		},
	},
	{{"copy", "cp", NULL,}, "copy/cp src_file dst_file\n",
		0, 0, 2, 2, 0, 0, SD_CopyCmd, 0, 0, 
		{
			{IS_STR, NULL, 0, FALSE, "src_file -\n"}, {IS_STR, NULL, 0, FALSE, "dst_file -\n"},
		},
	},
	{{"readfile", "rf", NULL,}, "readfile/rf file_name base length [-b/-h]\n", 
		0, 0, 3, 3, 2, 0, SD_ReadFileCmd, 0, 0, 
		{
			{IS_STR, NULL, 0, FALSE, "file_name -\n"}, 
		 	{IS_NUM|IS_USER_SYMBOL, NULL, 0, FALSE, "base -\n"}, 
		 	{IS_NUM|IS_USER_SYMBOL, NULL, 0, FALSE, "length - N bytes for reading\n"},
		},
		{
			{"-b", IS_NULL, {NULL,}, NULL, 0, FALSE, "[-b/-h] - " }, 
			{"-h", IS_NULL, {NULL,}, NULL, 0, FALSE, NULL},
		},
	},
	{{"quit", NULL,}, "quit\n",
		0, 0, 1, 0, 0, 0, SD_quit, 0, 0, 
		{
			{IS_STR, NULL, 0, FALSE, "quit\n"}, 
		},
	},
	{NULL,
	},
};

#define SD_DMA_CHANNEL		2

int my_sd_quit=0;
void SD_quit()
{
    my_sd_quit=1;
}

int SD_main(int argc, int *argv[])
{
    char Buf[80];
	UINT32 Status;
	UINT32 i,result,mode;

   	printf("Select the mode: 1.PIO   2.DMA\r\n");
   	scanf("%d",&mode);
   	printf("\r");
   	
	fLib_CloseInt(IRQ_SDC);

   	if (!fLib_ConnectInt(IRQ_SDC, fLib_SDCntrInterruptHandler))
		return FALSE;
 
 	fLib_SetIntTrig(IRQ_SDC,EDGE,H_ACTIVE);
	
	fLib_EnableInt(IRQ_SDC);
	
 	fLib_InitDMA(FALSE, FALSE, 1 << SD_DMA_CHANNEL);
 	//fLib_DisableDCache();
 	
	CPRM_Order_Change = FALSE;
	 	
	// no DMA
	if(mode==1)
        result=fLib_SDHostInterfaceInit(&fLib_SDCard, CPE_SD_BASE, FALSE, SD_DMA_CHANNEL, 'S', SYS_CLK/2);
	// DMA
	else if(mode==2)
	    result=fLib_SDHostInterfaceInit(&fLib_SDCard, CPE_SD_BASE, TRUE, SD_DMA_CHANNEL, 'S', SYS_CLK/2);
	
	if(!result)
	{
		printf("Can not found SD or MMC card, Please insert!!!\n");

	    Status = SDC_ReadReg(SDC_STATUS_REG);
		while (1) {
	       if ((Status & SDC_STATUS_REG_CARD_INSERT) == SDC_CARD_INSERT)
		      break; 
	       Status = SDC_ReadReg(SDC_STATUS_REG);
		}
		//return FALSE;
	}
		

	fLib_InsertCommand(SD_CmdTable);
	fLib_InitUserSymbol(NULL);

#if 1
	
	while(my_sd_quit==0)
	{
		printf("\nSD>>>");
		gets(Buf);
		fLib_ExecuteCommand(Buf);		
	}
	my_sd_quit=0;
#else

    while (1) {
		for (i = 0; i < 10; i++) {
		  sprintf(Buf,"sr %d 4",i * 8);
	      fLib_ExecuteCommand(Buf);
		}
	}
	
#endif 

    return TRUE;
}

UINT32 SDDevCmd(CommandTableStruct_T *CmdTable)
{
	SD_CSD *CSD;
	SD_CID *CID;
	PartitionTableStruct *ParTable;
	ExtendFDCDescriptorStruct *FDCDesc;
	

	if(CmdTable->Opt[0].IsSet)
	{
		fLib_SDCardRemove(&fLib_SDCard);
		if(CmdTable->Opt[0].Value == 0)
			fLib_SDHostInterfaceInit(&fLib_SDCard, CPE_SD_BASE, FALSE, 0, 'S', SYS_CLK/2);
		else
			fLib_SDHostInterfaceInit(&fLib_SDCard, CPE_SD_BASE, TRUE, SD_DMA_CHANNEL, 'S', SYS_CLK/2);
	}

	printf("============SDCard=====================================\n");
	printf("ErrorCode:0x%0.8X CardStatus:0x%0.8X", SD_ErrorCode, SD_CardStatus);
	
	if(!SDC_CheckCardExist(&fLib_SDCard))
	{
		printf("SD Card does not exist!!!");
		return FALSE;			
	}	
	/* print OCR, RCA register */
	printf("OCR>> 0x%0.8X\nRCA>> 0x%0.4X\n", (UINT32)fLib_SDCard.OCR, fLib_SDCard.RCA);
	
	/* print CID register */
	printf("CID>> 0x%0.8X 0x%0.8X 0x%0.8X 0x%0.8X\n", fLib_SDCard.CIDWord[0], fLib_SDCard.CIDWord[1], fLib_SDCard.CIDWord[2], fLib_SDCard.CIDWord[3]);	
	CID = &(fLib_SDCard.CID);
	printf("      MID:0x%0.2X OID:0x%0.4X PNM:%s PRV:%d.%d PSN:0x%0.8X\n", CID->ManufacturerID, CID->ApplicationID, CID->ProductName, 
		CID->ProductRevisionHigh, CID->ProductRevisionLow, CID->ProductSerialNumber);
	printf("      MDT:%d/%d\n", CID->ManufactureMonth, CID->ManufactureYear);
	
	/* print CSD register */
	printf("CSD>> 0x%0.8X 0x%0.8X 0x%0.8X 0x%0.8X\n", fLib_SDCard.CSDWord[0], fLib_SDCard.CSDWord[1], fLib_SDCard.CSDWord[2], fLib_SDCard.CSDWord[3]);	
	
	CSD = &(fLib_SDCard.CSD);	
	printf("      CSDStructure:%d Spec.Version:%d\n", CSD->CSDStructure, CSD->MMCSpecVersion);
	printf("      TAAC:%fns NSAC:%f clock cycles\n", CSD->TAAC,CSD->NSAC);
	printf("      TransferSpeed:%d bit/s CardCommandClass:0x%0.3X\n", CSD->TransferSpeed, CSD->CardCmdClass);
	printf("      ReadBlLen:%d ReadBlPartial:%X WriteBlkMisalign:%X ReadBlkMisalign:%X\n", CSD->ReadBlockLength, CSD->ReadBlockPartial, CSD->WriteBlockMisalign, CSD->ReadBlockMisalign);
	printf("      DSP:%X BlockNumber:%d MemorySize:%d \n", CSD->DSRImplemant, CSD->BlockNumber, CSD->MemorySize);
	
	printf("      VDD_R_MIN:%fmA VDD_R_MAX:%fmA\n", CSD->VDDReadMin, CSD->VDDReadMax);
	printf("      VDD_W_MIN:%fmA VDD_W_MAX:%fmA\n", CSD->VDDWriteMin, CSD->VDDWriteMax);
	printf("      EraseBlkEnable:%d EraseSectorSize:%d WpGrpSize:%d WpGrpEnable:%X\n", CSD->EraseBlkEnable, CSD->EraseSectorSize, CSD->WriteProtectGroupSize, CSD->WriteProtectGroupEnable);
	printf("      WriteSpeedFactor:%d WriteBlLen:%d WriteBlPartial:%X\n", CSD->WriteSpeedFactor, CSD->WriteBlockLength, CSD->WriteBlockPartial);
	printf("      Copy:%X PermWrProtect:%X TmpWrProtect:%X FileFormat:%X\n", CSD->CopyFlag, CSD->PermanentWriteProtect, CSD->TemporaryWriteProtect, CSD->FileFormat);
	printf("      ReadTimoutCycle:0x%0.8X WriteTimoutCycle:0x%0.8X\n", fLib_SDCard.ReadAccessTimoutCycle, fLib_SDCard.WriteAccessTimoutCycle);
	
	/* print SCR register */
	printf("SCR>> 0x%0.8X 0x%0.8X \n", *(((UINT32 *)&fLib_SDCard.SCR)), *(((UINT32 *)&fLib_SDCard.SCR) + 1));	
	printf("      SCR_STRUCTURE:%d, SD_SPEC:%d, Data_status_after_erase:%d\n", fLib_SDCard.SCR.SCR_STRUCTURE, fLib_SDCard.SCR.SD_SPEC, fLib_SDCard.SCR.DATA_STAT_AFTER_ERASE);
	printf("      sd_security:%d, SD_BUS_WIDTH:%X\n", fLib_SDCard.SCR.SD_SECURITY, fLib_SDCard.SCR.SD_BUS_WIDTH);
	
	/* print partition table */
	ParTable = &fLib_SDCard.FileSys.PartitionTable;
	printf("BootIndicator:0x%0.2X StartHead:%d StartSector:%d StartCylinder:%d\n", ParTable->BootIndicator, ParTable->StartingHead, ParTable->StartingSector, ParTable->StartingCylinder);
	printf("SystemID:0x%0.2X EndHead:0x%0.2X EndSector:%d EndCylinder:%d\n", ParTable->SystemID, ParTable->EndingHead, ParTable->EndingSector, ParTable->EndingCylinder);
	printf("RelativeSector:%d TotalSector:%d\n", ParTable->RelativeSector, ParTable->TotalSector);
	
	/* print FDC descriptor */
	FDCDesc = &fLib_SDCard.FileSys.FDCDesc;
	printf("JumpCommand:0x%0.2X 0x%0.2X 0x%0.2X SystemIdentifier:%c%c%c%c%c%c%c%c\n", FDCDesc->JumpCommand[0], FDCDesc->JumpCommand[1], FDCDesc->JumpCommand[2], 
		FDCDesc->SystemIdentifier[0], FDCDesc->SystemIdentifier[1],FDCDesc->SystemIdentifier[2],FDCDesc->SystemIdentifier[3],
		FDCDesc->SystemIdentifier[4],FDCDesc->SystemIdentifier[5],FDCDesc->SystemIdentifier[6],FDCDesc->SystemIdentifier[7]);
	printf("SectorSize:%d SectorPerCluster:%d ReservedSectorCount:%d FATNumber:%d\n", FDCDesc->SectorSize, FDCDesc->SectorPerCluster, FDCDesc->ReservedSectorCount, FDCDesc->FATNumber);
	printf("RootDirEntryNumber:%d TotalSector:%d MediumIdentifier:0x%0.2X SectorPerFAT:%d\n", FDCDesc->RootDirEntryNumber, FDCDesc->TotalSector, FDCDesc->MediumIdentifier, FDCDesc->SectorPerFAT);
	printf("SectorPerTrack:%d SlideNumber:%d HiddenSectorNumber:%d TotalSector2:%d\n", FDCDesc->SectorPerTrack, FDCDesc->SlideNumber, FDCDesc->HiddenSectorNumber, FDCDesc->TotalSector2);
	printf("PhyDiskNumber:0x%0.2X Reserved0:%d ExtendSignature:0x%0.2X VolumeID:0x%0.8X\n", FDCDesc->PhyDiskNumber, FDCDesc->Reserved0, FDCDesc->ExtendSignature, FDCDesc->VolumeID);
	printf("FileSystemType:%c%c%c%c%c%c%c%c SignatureWord:0x%0.4X\n", FDCDesc->FileSystemType[0], FDCDesc->FileSystemType[1], FDCDesc->FileSystemType[2], 
	FDCDesc->FileSystemType[3], FDCDesc->FileSystemType[4], FDCDesc->FileSystemType[5], FDCDesc->FileSystemType[6], FDCDesc->FileSystemType[7], FDCDesc->SignatureWord);

	return OK_COMMAND;
}

UINT32 SD_SectorReadCmd(CommandTableStruct_T *CmdTable)
{
	INT8 Buf[0x2000];
//	int	i;
	
	if(!fLib_SDCardReadSector(&fLib_SDCard, CmdTable->Argu[0].Value, CmdTable->Argu[1].Value, 512, Buf))
	{
		printf("read error!!!\n");
//		return ERROR_COMMAND;
	}
	else
		printf("\nread OK!!!\n");
#if 0	
	for(i = 0; i < 512 * CmdTable->Argu[1].Value; i++)
	{
		if((i % 16) == 0)
			printf("\n%0.4X ", i);
		printf("%0.2X ", Buf[i]);
	}
	return OK_COMMAND;
#endif	
	return OK_COMMAND;
}

UINT32 SD_SectorWriteCmd(CommandTableStruct_T *CmdTable)
{
	INT8 Buf[0x800];
	int	i;
	
	for(i = 0; i < 512;i++)
		Buf[i] = CmdTable->Argu[0].Value + i;
		
	if (!fLib_SDCardWriteSector(&fLib_SDCard, CmdTable->Argu[1].Value, CmdTable->Argu[2].Value, 512, Buf))
	{
		printf("Write error!!!\n");
		return ERROR_COMMAND;
	}
	else 
	   printf("Write OK!!!\n");

	return OK_COMMAND;
}

UINT32 SD_DirCmd(CommandTableStruct_T *CmdTable)
{
	INT8 MsgStr[0x1000];
	
	if(!fLib_DirDirectory((CmdTable->Argu[0].IsSet ? CmdTable->Argu[0].Str : NULL), MsgStr))
		return ERROR_COMMAND;

	printf(MsgStr);
	return OK_COMMAND;
}

UINT32 SD_ChangeDirCmd(CommandTableStruct_T *CmdTable)
{
	if (fLib_ChangeDirectory(CmdTable->Argu[0].Str)) {
		printf("Change to %s directory OK!!!\n", CmdTable->Argu[0].Str);
		return OK_COMMAND;
	}
	else {
		printf("Change to %s directory error!!!\n", CmdTable->Argu[0].Str);
	}
	return ERROR_COMMAND;
}

UINT32 SD_MakeCmd(CommandTableStruct_T *CmdTable)
{
	if(CmdTable->Opt[0].IsSet)
	{
		if(fLib_MakeDirectory(CmdTable->Argu[0].Str))
		{
			printf("Make %s directory OK!!!\n", CmdTable->Argu[0].Str);
			return OK_COMMAND;
		}
	}
	else
	{
		if(fLib_MakeEmptyFile(CmdTable->Argu[0].Str))
		{
			printf("Make %s file OK!!!\n", CmdTable->Argu[0].Str);
			return OK_COMMAND;
		}
	}
	printf("Make %s file or directory error!!!\n", CmdTable->Argu[0].Str);

	return ERROR_COMMAND;
}

UINT32 SD_DeleteCmd(CommandTableStruct_T *CmdTable)
{
	if (CmdTable->Opt[0].IsSet) {
		if (fLib_DeleteDirectory(CmdTable->Argu[0].Str)) {
			printf("Del %s directory OK!!!\n", CmdTable->Argu[0].Str);
			return OK_COMMAND;
		}
	}
	else {
		if (remove(CmdTable->Argu[0].Str) != -1) {
			printf("Del %s file OK!!!\n", CmdTable->Argu[0].Str);
			return OK_COMMAND;
		}
	}
	
	printf("Del %s directory or file error!!!\n", CmdTable->Argu[0].Str);
	return ERROR_COMMAND;
}

UINT32 SD_RenameCmd(CommandTableStruct_T *CmdTable)
{
	if(rename(CmdTable->Argu[0].Str, CmdTable->Argu[1].Str) != 0)
	{	
		printf("Can not rename %s file!!!\n", CmdTable->Argu[0].Str);
		return ERROR_COMMAND;
	}
	printf("%s file has been rename to %s!\n", CmdTable->Argu[0].Str, CmdTable->Argu[1].Str);
	return OK_COMMAND;
}

UINT32 SD_CopyCmd(CommandTableStruct_T *CmdTable)
{
	FILE *src, *dst;
	INT8 *buf;
	INT32 nRead;
	//UINT32 StartTime, EndTime;
	
	if((src = fopen(CmdTable->Argu[0].Str, "r")) == NULL)
	{
		printf("Can not open %s file for reading\n", CmdTable->Argu[0].Str);
		return ERROR_COMMAND;
	}
	if((dst = fopen(CmdTable->Argu[1].Str, "w")) == NULL)
	{
		printf("Can not open %s file for writting\n", CmdTable->Argu[1].Str);
		fclose(src);
		return ERROR_COMMAND;
	}

	buf = malloc(5000);	
	//StartTime = clock();
	while(!feof(src))
	{
		nRead = fread(buf, 1, 4096, src);
		//printf("nread=%d\n", nRead);
		fwrite(buf, 1, nRead, dst);
	}
	
	//EndTime = clock();
	
	//printf("Executes %d ticks\n", EndTime-StartTime);
	fclose(dst);
	fclose(src);
	
	free(buf);
	return OK_COMMAND;
}

UINT32 SD_ReadFileCmd(CommandTableStruct_T *CmdTable)
{
	return OK_COMMAND;
}