uti.c

常见卡(SD,NAND,XD,MS,ATA,CF)完整DRIVER

/*
*******************************************************************************
*                               Magic Pixel
*                  5F, No.3, Creation Road III, Science_Based 
*                   Industrial Park, Hsinchu, Taiwan, R.O.C
*               (c) Copyright 2004, Magic Pixel Inc, Hsinchu, Taiwan
*
* All rights reserved. Magic Pixel's source code is an unpublished work and the 
* use of a copyright notice does not imply otherwise. This source code contains
* confidential, trad secret material. Any attempt or participation in 
* deciphering, decoding, reverse engineering or in ay way altering the source 
* code is strictly prohibited, unless the prior written consent of Magic 
* Pixel is obtained.
*
* Filename      : uti.c
* Programmer(s) : 
* Created       : 
* Descriptions  :
*******************************************************************************
*/
/*
// define this module show debug message or not,  0 : disable, 1 : enable
*/
#define LOCAL_DEBUG_ENABLE 0

/*
// Include section 
*/
#include "global612.h"
#include "mpTrace.h"
#include "uti.h"
#include "Mcard.h"


/*
// Constant declarations
*/
#define MB_2    0x00200000
#define MB_4    0x00400000
#define MB_8    0x00800000
#define MB_16   0x01000000
#define MB_32   0x02000000
#define MB_64   0x04000000
#define MB_128  0x08000000
#define MB_256  0x10000000
#define MB_512  0x20000000
#define GB_1    0x40000000
#define GB_2    0x80000000


/*
// Structure declarations
*/
/*
// Type declarations
*/
/*
// Variable declarations
*/
static const DWORD dwDiskParam[][5] = {
	//size | Heads | Sectors | ClusterSize | BU(Boundary Uint)
	{MB_2, 2, 16, 16, 16},
	{MB_4, 2, 32, 16, 16},
	{MB_8, 2, 32, 16, 16},
	{MB_16, 255, 63, 8, 32},
	{MB_32, 255, 63, 1, 32},
	{MB_64, 255, 63, 1, 128},
	{MB_128, 255, 63, 2, 128},
	{MB_256, 255, 63, 4, 256},
	{MB_512, 255, 63, 8, 256},
	{GB_1, 255, 63, 8, 512},
	{GB_2, 255, 63, 8, 512},
	{0, 0, 0, 0, 0}
};

static BYTE bSystemID[8] = { 'M', 'A', 'G', 'I', 'C', ' ', ' ', ' ' };
static BYTE bVolumeLabel[11] = { 'N', 'O', ' ', 'T', 'Y', 'P', 'E', ' ', ' ', ' ', ' ' };
static BYTE bFileSystemType[8] = { 'F', 'A', 'T', '1', '2', ' ', ' ', ' ' };
static volatile BYTE bMcardIntFlag;

#pragma alignvar(4)

/*
// Static function prototype
*/
static DWORD Rem(DWORD dwNumerator, DWORD dwDenominator);
static DWORD Ip(DWORD dwNumerator, DWORD dwDenominator);
static DWORD Ceil(DWORD dwNumerator, DWORD dwDenominator);

/*
// Definition of internal functions
*/
void McardSetClock(BYTE bClock)
{
	register CLOCK *sClock;

	sClock = (CLOCK *) CLOCK_BASE;
	mClrMcardCks();
	mSetMcardCks(bClock & 0xf);
	//sClock->Clkss1 &= ~(0xf << 28);
	//sClock->Clkss1 |= ((bClock & 0xf) << 28);
	sClock->MdClken |= 0x00002000;
}

void McardClrInt(void)
{
	bMcardIntFlag = 0;
}

BYTE McardGetInt(void)
{
	return bMcardIntFlag;
}

void McardIsr(void)
{
	bMcardIntFlag = 1;
}

SWORD McardGetParameter(ST_DISK_PARAMETER * sDiskParam, DWORD dwSize)
{
	/*
	   SD Memory Card Specifications
	   Part 2. File System Specification Version 1.0 

	   Reference Maximum Data Area size and format parameters
	   Capacity | Sect/Clus| Max Data Area | Clus | FATSec | Hidden | FAT bits | UserData Offset
	   ~4MB        16            8032         498     2        27      12          64 
	   ~8MB        16            16224        1010    3        25      12          64 
	   ~16MB       32            32448        1011    3        57      12          96 
	   ~32MB       32            64896        2025    6        51      12          96 
	   ~64MB       32            129792       4053    12       39      12          96 
	   ~128MB      32            259584       8106    32       95      16          192
	   ~256MB      32            519168       16216   64       95      16          256
	   ~512MB      32            1038336      32432   127      225     16          512
	   ~1024MB     32            2076672      64872   254      227     16          768
	   ~2048MB     64            4153344      64884   254      227     16          768
	   Table C-1 Sectors per Cluster and Boundary Unit Recommendation (Data Area)
	   Card Capacity | Sectors/Cluster  | Boundary Unit
	   ~8MB                16                  16 
	   ~64MB               32                  32 
	   ~256MB              32                  64 
	   ~1024MB             32                  128
	   ~2048MB             64                  128
	 */
	/*
	   Annex D: Format Parameter Computations
	   In this section, format parameter computations is proposed. Data Area should be formatted by the
	   following steps.
	 */
	DWORD i, BU, SC, RDE, SS, RSC, TS, FAT, SF, SSA, n, NOM, MAX, SF1;
	DWORD *pdwDiskParam;

	//1. Sectors per Cluster(SC) is determined from the area size.
	for (pdwDiskParam = (DWORD *) dwDiskParam; pdwDiskParam != 0; pdwDiskParam++)
	{
		if (dwSize <= pdwDiskParam[0])
		{
			sDiskParam->wNumHeads = (WORD) pdwDiskParam[1];
			sDiskParam->wTrackSectors = (WORD) pdwDiskParam[2];
			SC = sDiskParam->wClusterSize = (WORD) pdwDiskParam[3];
			BU = (WORD) pdwDiskParam[4];
			break;
		}
		else if (pdwDiskParam[0] == 0)
		{
			MP_DEBUG("-E- SD card size too large!!");
			return FAIL;
		}
	}
//Lighter 4/13: fat 16 bug fixed
	//3. Sector Size(SS) is 512.
	SS = sDiskParam->wSectorSize = 512;
	//5. Total Sectors(TS) is the number of all sectors of the area.
	TS = sDiskParam->dwTotalSectors = dwSize >> 9;
	if (dwSize < MB_32)        //Fat16
	{//Lighter 4/13: fat 16 bug fixed
	//2. Number of Root-directory Entries(RDE) is 512.
        	RDE = sDiskParam->wRootEntries = 512;
	//4. Reserved Sector Count(RSC) is 1.
        	RSC = sDiskParam->wReserveSectors = 1;
	//6. FAT bits(12[FAT12], 16[FAT16]) is determined by SC and TS.
            if (dwSize <= MB_16)
		{
			FAT = sDiskParam->bFatType = 12;
		}
		else
		{
			FAT = sDiskParam->bFatType = 16;
		}
	}
	else        //Fat32
	{//Lighter 4/13: fat 16 bug fixed
	//2. Number of Root-directory Entries(RDE) is 512.
        	RDE = sDiskParam->wRootEntries = 0;
    
	//4. Reserved Sector Count(RSC) is 1.
        	RSC = sDiskParam->wReserveSectors = 32; //
//        	RSC = sDiskParam->wReserveSectors = 36; //rick modify for 512M
    
	//6. FAT bits(12[FAT12], 16[FAT16]) is determined by SC and TS.
		//FAT = sDiskParam->bFatType = 16;
		FAT = sDiskParam->bFatType = 32;
                sDiskParam->wBackupBootSecter = 6;
	}

	//7. Sectors per FAT(SF) is computed as following: 
	//SF = ceil{(TS / SC * FAT) / (SS * 8)}
	SF = Ceil((TS / SC * FAT), (SS * 8));

	while (1)
	{
		//8. Number of sectors in the system area(SSA) is computed as following:
		//SSA = RSC + 2 * SF + ceil{(32 * RDE) / SS}
		SSA = RSC + (2 * SF) + Ceil((32 * RDE), SS);

		//9. Number of Sectors in Master Boot Record(NOM) is computed as following:
		//Here, n means the minimum natural number satisfying above expression. And BU means the
		//Boundary Unit determined by Annex C.
		for (n = 1; n < 16; n++)
		{
			if ((BU * n) > SSA)
{
				break;
			}
		}
		NOM = (BU * n) - SSA;

		//10. If NOM isn't equal to BU, NOM is added BU.
		if (NOM != BU)
		{
			NOM += BU;
		}

		//11. Maximum Cluster Number(MAX) is computed as following:
		//MAX = ip{(TS - NOM - SSA) / SC} + 1;
		MAX = Ip((TS - NOM - SSA), SC) + 1;

		//12. Sectors per FAT(SF1) is recalculated as following:
		//SF1 = Ceil{((2 + (MAX - 1)) * FAT) / (SS * 8)}
		//In this formula, 'MAX-1' means the number of clusters. And '2+(MAX-1)' means the number of
		//FAT entries including two signature entries.
		SF1 = Ceil(((2 + (MAX - 1)) * FAT), (SS * 8));

		//13. If SF1 isn't equal to SF, SF1 is used as SF. And recalculate from step 8.
		//14. If SF1 is equal to SF, parameter computing is complete.
		if (SF1 != SF)
		{
			SF = SF1;
		}
		else
		{
			break;
		}
	}
    
     //mpDebugPrint("Sector %d, %d",NOM,SF);
	sDiskParam->dwHiddenSectors = NOM;
	sDiskParam->wNumFatSectors = SF;
	return PASS;
}


static BYTE bPartition1MBR[16];
static BYTE bPartition2MBR[16];
void McardMakeMbr(ST_DISK_PARAMETER * sDiskParam, BYTE * pbBuffer,DWORD dwParNum)
{
//#define MBR_ADDR 0x1BE
	WORD MBR_ADDR;
	BYTE bEndSectors,i,w;
	DWORD dwLogSectors, bEndCylinder;
	DWORD dwSectorOffset;
	dwSectorOffset = sDiskParam->dwHiddenSectors;
	i=w=sDiskParam->bParNum;
	dwSectorOffset = sDiskParam->dwHiddenSectors;
	while(i)
	{
		sDiskParam--;
		dwSectorOffset +=(sDiskParam->dwParSize>>9);
		i--;
	}
	sDiskParam+=w;
//	sDiskParam->dwHiddenSectors = dwSectorOffset;
	if( dwParNum == 0)
		MBR_ADDR = 0x1BE;
	else if(dwParNum == 1)
	{
		MBR_ADDR = 0x1BE;
		for(i=0;i<16;i++)
			pbBuffer[MBR_ADDR+i] = bPartition1MBR[i];	
		MBR_ADDR = 0x1CE;

	}
	//make partition 1
	pbBuffer[MBR_ADDR] = 0x80;	//x86 default boot partiion
	pbBuffer[MBR_ADDR + 1] = Ip(Rem(sDiskParam->dwHiddenSectors, (sDiskParam->wNumHeads * sDiskParam->wTrackSectors)), sDiskParam->wTrackSectors);	//H:head
	pbBuffer[MBR_ADDR + 2] = Rem(sDiskParam->dwHiddenSectors, sDiskParam->wTrackSectors) + 1;	//S:sector
	pbBuffer[MBR_ADDR + 3] = Ip(sDiskParam->dwHiddenSectors, (sDiskParam->wNumHeads * sDiskParam->wTrackSectors));	//C:cylinder
	if (sDiskParam->bFatType == 12) // rick	0802
	{//Lighter 4/13: fat 16 bug fixed
		pbBuffer[MBR_ADDR + 4] = 0x01;
	}
	else if (sDiskParam->bFatType == 16) // rick	0802	
	{//Lighter 4/13: fat 16 bug fixed
		pbBuffer[MBR_ADDR + 4] = 0x04;
	}
	else
	{
		pbBuffer[MBR_ADDR + 4] = 11;//Lighter 4/13: fat 16 bug fixed
	}
	dwLogSectors = sDiskParam->dwTotalSectors - sDiskParam->dwHiddenSectors;
	pbBuffer[MBR_ADDR + 5] = Ip(Rem((sDiskParam->dwHiddenSectors + dwLogSectors - 1), (sDiskParam->wNumHeads * sDiskParam->wTrackSectors)), sDiskParam->wTrackSectors);	//H:end head
	bEndSectors = Rem((sDiskParam->dwHiddenSectors + dwLogSectors - 1), sDiskParam->wTrackSectors) + 1;	//S:end sector
	bEndCylinder = Ip((sDiskParam->dwHiddenSectors + dwLogSectors - 1), (sDiskParam->wNumHeads * sDiskParam->wTrackSectors));	//C:end cylinder
	bEndCylinder = (bEndCylinder & 0x3ff);
	pbBuffer[MBR_ADDR + 6] = bEndSectors | ((bEndCylinder & 0x300) >> 2);
	pbBuffer[MBR_ADDR + 7] = (bEndCylinder & 0xff);
	
//	pbBuffer[MBR_ADDR + 8] = (BYTE) (sDiskParam->dwHiddenSectors & 0x000000ff);
//	pbBuffer[MBR_ADDR + 9] = (BYTE) ((sDiskParam->dwHiddenSectors & 0x0000ff00) >> 8);
//	pbBuffer[MBR_ADDR + 10] = (BYTE) ((sDiskParam->dwHiddenSectors & 0x00ff0000) >> 16);
//	pbBuffer[MBR_ADDR + 11] = (BYTE) ((sDiskParam->dwHiddenSectors & 0xff000000) >> 24);

	pbBuffer[MBR_ADDR + 8] = (BYTE) (dwSectorOffset& 0x000000ff);
	pbBuffer[MBR_ADDR + 9] = (BYTE) ((dwSectorOffset & 0x0000ff00) >> 8);
	pbBuffer[MBR_ADDR + 10] = (BYTE) ((dwSectorOffset & 0x00ff0000) >> 16);
	pbBuffer[MBR_ADDR + 11] = (BYTE) ((dwSectorOffset & 0xff000000) >> 24);


	pbBuffer[MBR_ADDR + 12] = (BYTE) (dwLogSectors & 0x000000ff);
	pbBuffer[MBR_ADDR + 13] = (BYTE) ((dwLogSectors & 0x0000ff00) >> 8);
	pbBuffer[MBR_ADDR + 14] = (BYTE) ((dwLogSectors & 0x00ff0000) >> 16);
	pbBuffer[MBR_ADDR + 15] = (BYTE) ((dwLogSectors & 0xff000000) >> 24);
	pbBuffer[510] = 0x55;
	pbBuffer[511] = 0xaa;
	if(dwParNum == 0)
	{	
		for(i=0;i<16;i++)
			bPartition1MBR[i] = pbBuffer[MBR_ADDR+i];
	}
}
//SWORD McardCheckMbr(ST_DISK_PARAMETER * sDiskParam, BYTE * pbBuffer)
SWORD McardCheckMbr(ST_DISK_PARAMETER * sDiskParam, BYTE * pbBuffer,DWORD dwParNum)//rick 0803
{
//#define MBR_ADDR 0x1BE//rick 0803
#define MBR_RELATIVE_ADDR (MBR_ADDR + 8)
#define MBR_LOGICAL__ADDR (MBR_ADDR + 12)
	DWORD MBR_ADDR;//rick 0803
	if(dwParNum == 0)
		MBR_ADDR = 0x1BE;
	else if(dwParNum == 1)
		MBR_ADDR = 0x1CE;

	if ((pbBuffer[510] != 0x55) || (pbBuffer[511] != 0xaa))
	{
		return FAIL;

	}