/*-----------------------------------------------------------------------*/
/* MMC/SDC (in SPI mode) control module 				   */
/*-----------------------------------------------------------------------*/
#include "C8051F060.h"

#include <stdio.h>

#include "diskio.h"
//#include "Board.h"

#define CARD_WP_PIN
#define CARD_INS_PIN

sbit CARD_SELECT_PIN = P1 ^ 7;


/* MMC/SD command (in SPI) */
#define CMD0	(0x40+0)	/* GO_IDLE_STATE */
#define CMD1	(0x40+1)	/* SEND_OP_COND */
#define CMD9	(0x40+9)	/* SEND_CSD */
#define CMD10	(0x40+10)	/* SEND_CID */
#define CMD12	(0x40+12)	/* STOP_TRANSMISSION */
#define CMD17	(0x40+17)	/* READ_SINGLE_BLOCK */
#define CMD18	(0x40+18)	/* READ_MULTIPLE_BLOCK */
#define CMD24	(0x40+24)	/* WRITE_BLOCK */
#define CMD25	(0x40+25)	/* WRITE_MULTIPLE_BLOCK */
#define CMD58	(0x40+58)	/* READ_OCR */

#define ACMD13	(0xC0+13)	/* SD_STATUS (SDC) */
#define	ACMD23	(0xC0+23)	/* SET_WR_BLK_ERASE_COUNT (SDC) */
#define	ACMD41	(0xC0+41)	/* SEND_OP_COND (SDC) */

#define POWER_ON()
#define POWER_OFF()

static volatile
DSTATUS data Stat = STA_NOINIT;	/* Disk status */

static volatile
unsigned long xdata Timer;			/* 100Hz decrement timer */

static
BYTE data CardType;			/* b0:MMC, b1:SDv1, b2:SDv2, b3:Block addressing */
/*-----------------------------------------------------------------------*/
/* Module Private Functions 											 */
void SELECT()
{
	CARD_SELECT_PIN = 0; /* MMC CS = L */
}

void DESELECT()
{
	CARD_SELECT_PIN = 1; /* MMC CS = H */
}

static
BYTE MCU_SPI(BYTE outgoing)
{
	BYTE data Old_Page = SFRPAGE,incomming;

	SFRPAGE = SPI0_PAGE;

	SPI0DAT = outgoing;

	while (!SPIF);					//當SPI中斷為到，即數據為傳輸完時則循環等待.				
	SPIF = 0;	

	incomming = SPI0DAT; 

	SFRPAGE = Old_Page;

	return(incomming);
}

/*--------------------------------*/
/* Transmit a byte to MMC via SPI */
/* (Platform dependent) 		  */

static
void xmit_spi(BYTE dat)		//Send Byte
{
	MCU_SPI(dat);
}

/*---------------------------------*/
/* Receive a byte from MMC via SPI */
/* (Platform dependent) 		   */

static
BYTE rcvr_spi(void)			//Receive Byte
{
	return MCU_SPI(0xff);
}


static
void rcvr_spi_m(BYTE *dst)
{
	*dst = rcvr_spi();
}


/*---------------------*/
/* Wait for card ready */

static
BYTE wait_ready()
{
	BYTE data res;

	Timer = 5000;			/* Wait for ready in timeout of 500ms */
	rcvr_spi();
	do
	{
		res = rcvr_spi();
	}
	while ((res != 0xFF) && Timer--);

	return res;
}

/*--------------------------------*/
/* Receive a data packet from MMC */

extern
BOOL rcvr_datablock(BYTE *buff, /* Data buffer to store received data */
	BYTE data wc				/* Word count (0 means 256 words) */)
{
	BYTE token;

	Timer = 1000;
	do
	{
		/* Wait for data packet in timeout of 100ms */
		token = rcvr_spi();
	}
	while ((token == 0xFF) && Timer--);

	if (token != 0xFE)
	{
		return FALSE;
	}	/* If not valid data token, retutn with error */

	do
	{
		/* Receive the data block into buffer */
		rcvr_spi_m(buff++);
		rcvr_spi_m(buff++);
	}
	while (--wc);

	rcvr_spi();						/* Discard CRC */
	rcvr_spi();

	return TRUE;					/* Return with success */
}



/*---------------------------*/
/* Send a data packet to MMC */

#ifndef _READONLY
static
BOOL xmit_datablock(const BYTE *buff, /* 512 byte data block to be transmitted */
					BYTE data token			/* Data/Stop token */)
{
	BYTE resp, wc = 0;


	if (wait_ready() != 0xFF)
	{
		return FALSE;
	}

	xmit_spi(token);					/* Xmit data token */
	if (token != 0xFD)
	{
		/* Is data token */
		do
		{
			/* Xmit the 512 byte data block to MMC */
			xmit_spi(*buff++);
			xmit_spi(*buff++);
		}
		while (--wc);
		xmit_spi(0xFF);					/* CRC (Dummy) */
		xmit_spi(0xFF);
		resp = rcvr_spi();				/* Reveive data response */
		if ((resp & 0x1F) != 0x05)		/* If not accepted, return with error */
		{
			return FALSE;
		}
	}

	return TRUE;
}
#endif


/*------------------------------*/
/* Send a command packet to MMC */
extern
BYTE send_cmd(BYTE data cmd, /* Command byte */
	DWORD data arg		/* Argument */)
{
	BYTE data n, res;


	if (wait_ready() != 0xFF)
	{
		return 0xFF;
	}

	/* Send command packet */
	xmit_spi(cmd);						/* Command */
	xmit_spi((BYTE) (arg >> 24));		/* Argument[31..24] */
	xmit_spi((BYTE) (arg >> 16));		/* Argument[23..16] */
	xmit_spi((BYTE) (arg >> 8));			/* Argument[15..8] */
	xmit_spi((BYTE) arg);				/* Argument[7..0] */
	xmit_spi(0x95);						/* CRC (valid for only CMD0) */

	/* Receive command response */
	if (cmd == CMD12)
	{
		rcvr_spi();
	}		/* Skip a stuff byte when stop reading */
	n = 10;								/* Wait for a valid response in timeout of 10 attempts */
	do
	{
		res = rcvr_spi();
	}
	while ((res & 0x80) && --n);

	return res;			/* Return with the response value */
}




/*-----------------------------------------------------------------------*/
/* Public Functions 													 */


/*-----------------------*/
/* Initialize Disk Drive */
/* (Platform dependent)  */

DSTATUS disk_initialize(BYTE drv /* Physical drive nmuber (0..) */)
{
	BYTE data i = drv;
	BYTE data n;
	unsigned int data nn;

	POWER_ON();					/* Socket power ON */

	for (nn = 3000; nn; nn--)
		;	

	Stat |= STA_NOINIT;
	if (!(Stat & STA_NODISK))
	{
		n = 10;						/* Dummy clock */
		do
		{
			rcvr_spi();
		}
		while (--n);

		SELECT();			/* CS = L */

		if (send_cmd(CMD0, 0) == 1)
		{
			/* Enter Idle state */
			Timer = 10000;					/* Wait for card ready in timeout of 1 sec */

			while (Timer-- && send_cmd(CMD1, 0))
			{
				;}

			if (Timer > 0)
			{
				Stat &= ~STA_NOINIT;
			}	/* When device goes ready, clear STA_NOINIT */
		}

		DESELECT();			/* CS = H */

		rcvr_spi();			/* Idle (Release DO) */
	}

	if (Stat & STA_NOINIT)
	{
		disk_shutdown();
	}

	return Stat;
}

/*-----------------------*/
/* Shutdown 			 */
/* (Platform dependent)  */


DSTATUS disk_shutdown()
{
	return 0;
}


/*--------------------*/
/* Return Disk Status */

DSTATUS disk_status(BYTE drv/* Physical drive nmuber (0..) */)
{
	BYTE data i = drv;

	return Stat;
}



/*----------------*/
/* Read Sector(s) */

DRESULT disk_read(BYTE drv, /* Physical drive nmuber (0..) */
	BYTE *buff, /* Data buffer to store read data */
	DWORD data sector, /* Sector number (LBA) */
	BYTE data count			/* Sector count (1..255) */)
{
	BYTE data i = drv;

	if (Stat & STA_NOINIT)
	{
		return RES_NOTRDY;
	}
	if (!count)
	{
		return RES_PARERR;
	}

	sector *= 512;		/* LBA --> byte address */

	SELECT();			/* CS = L */

	if (count == 1)
	{
		/* Single block read */
		if ((send_cmd(CMD17, sector) == 0)	/* READ_SINGLE_BLOCK */ &&
			rcvr_datablock(buff,
						   (BYTE)
						   (512 / 2)))
		{
			count = 0;
		}
	}
	else
	{
		/* Multiple block read */
		if (send_cmd(CMD18, sector) == 0)
		{
			/* READ_MULTIPLE_BLOCK */
			do
			{
				if (!rcvr_datablock(buff, (BYTE) (512 / 2)))
				{
					break;
				}
				buff += 512;
			}
			while (--count);
			send_cmd(CMD12, 0);				/* STOP_TRANSMISSION */
		}
	}

	DESELECT();			/* CS = H */
	rcvr_spi();			/* Idle (Release DO) */

	return count ? RES_ERROR : RES_OK;
}



/*-----------------*/
/* Write Sector(s) */

#ifndef _READONLY
DRESULT disk_write(BYTE data drv, /* Physical drive nmuber (0..) */
	const BYTE *buff, /* Data to be written */
	DWORD data sector, /* Sector number (LBA) */
	BYTE data count			/* Sector count (1..255) */)
{
	BYTE data i = drv;

	if (Stat & STA_NOINIT)
	{
		return RES_NOTRDY;
	}
	if (Stat & STA_PROTECT)
	{
		return RES_WRPRT;
	}
	if (!count)
	{
		return RES_PARERR;
	}
	sector *= 512;		/* LBA --> byte address */

	SELECT();			/* CS = L */

	if (count == 1)
	{
		/* Single block write */
		if ((send_cmd(CMD24, sector) == 0)	/* WRITE_BLOCK */ &&
			xmit_datablock(buff,
						   0xFE))
		{
			count = 0;
		}
	}
	else
	{
		/* Multiple block write */
		if (send_cmd(CMD25, sector) == 0)
		{
			/* WRITE_MULTIPLE_BLOCK */
			do
			{
				if (!xmit_datablock(buff, 0xFC))
				{
					break;
				}
				buff += 512;
			}
			while (--count);
			if (!xmit_datablock(0, 0xFD))	/* STOP_TRAN token */
			{
				count = 1;
			}
		}
	}

	DESELECT();			/* CS = H */
	rcvr_spi();			/* Idle (Release DO) */

	return count ? RES_ERROR : RES_OK;
}
#endif



/*--------------------------*/
/* Miscellaneous Functions  */

DRESULT disk_ioctl(BYTE data drv, /* Physical drive nmuber (0..) */
	BYTE data ctrl, /* Control code */
	void *buff		/* Buffer to send/receive data block */)
{
	BYTE data i = drv;

	DRESULT data res;
	BYTE n, csd[16], *ptr = buff;
	WORD data csm, csize;


	if (Stat & STA_NOINIT)
	{
		return RES_NOTRDY;
	}

	SELECT();		/* CS = L */

	res = RES_ERROR;
	switch (ctrl)
	{
		case CTRL_SYNC :
			/* Make sure that no pending write process */
			SELECT();
			if (wait_ready() == 0xFF)
			{
				res = RES_OK;
			}
			break;

		case GET_SECTOR_COUNT :
			/* Get number of sectors on the disk (unsigned long) */
			if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16 / 2))
			{
				/* Calculate disk size */
				csm = 1 << (((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2);
				csize = ((WORD) (csd[8] & 3) >> 6) +
						(WORD) (csd[7] << 2) +
						((WORD) (csd[6] & 3) << 10) +
						1;
#ifdef _BYTE_ACC
				ST_DWORD(ptr, (DWORD) csize * csm);
#else
				*(DWORD *) ptr = (DWORD) csize * csm;
#endif
				res = RES_OK;
			}
			break;

		case GET_SECTOR_SIZE :
			/* Get R/W sector size (WORD) */
			*(WORD *) buff = 512;
			res = RES_OK;
			break;

		case GET_BLOCK_SIZE :
			/* Get erase block size in unit of sector (DWORD) */
			if (CardType & 4)
			{
				/* SDC ver 2.00 */
				if (send_cmd(ACMD13, 0) == 0)
				{
					/* Read SD status */
					rcvr_spi();
					if (rcvr_datablock(csd, 16))
					{
						/* Read partial block */
						for (n = 64 - 16; n; n--)
						{
							rcvr_spi();
						}	/* Purge trailing data */
						*(DWORD *) buff = 16UL << (csd[10] >> 4);
						res = RES_OK;
					}
				}
			}
			else
			{
				/* SDC ver 1.XX or MMC */
				if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16))
				{
					/* Read CSD */
					if (CardType & 2)
					{
						/* SDC ver 1.XX */
						*(DWORD *) buff = (((csd[10] & 63) << 1) +
										   ((WORD) (csd[11] & 128) >> 7) +
										   1) <<
										  ((csd[13] >> 6) - 1);
					}
					else
					{
						/* MMC */
						*(DWORD *) buff = ((WORD) ((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) <<
																				  3) +
																				 ((csd[11] & 224) >>
																				  5) +
																				 1);
					}
					res = RES_OK;
				}
			}
			break;

		case MMC_GET_TYPE :
			/* Get card type flags (1 byte) */
			*ptr = CardType;
			res = RES_OK;
			break;

		case MMC_GET_CSD :
			/* Receive CSD as a data block (16 bytes) */
			if ((send_cmd(CMD9, 0) == 0)	/* READ_CSD */ &&
				rcvr_datablock(ptr,
							   16 /
																			 2))
			{
				res = RES_OK;
			}
			break;

		case MMC_GET_CID :
			/* Receive CID as a data block (16 bytes) */
			if ((send_cmd(CMD10, 0) == 0)	/* READ_CID */ &&
				rcvr_datablock(ptr,
							   16 /
																			 2))
			{
				res = RES_OK;
			}
			break;

		case MMC_GET_OCR :
			/* Receive OCR as an R3 resp (4 bytes) */
			if (send_cmd(CMD58, 0) == 0)
			{
				/* READ_OCR */
				for (n = 0; n < 4; n++)
				{
					*ptr++ = rcvr_spi();
				}
				res = RES_OK;
			}
			break;

		case MMC_GET_SDSTAT :
			/* Receive SD statsu as a data block (64 bytes) */
			if (send_cmd(ACMD13, 0) == 0)
			{
				/* SD_STATUS */
				rcvr_spi();
				if (rcvr_datablock(ptr, 64))
				{
					res = RES_OK;
				}
			}
			break;

		default:
			res = RES_PARERR;
	}

	DESELECT();			/* CS = H */
	rcvr_spi();			/* Idle (Release DO) */

	return res;
}



/*---------------------------------------*/
/* Device timer interrupt procedure 	 */
/* This must be called in period of 10ms */
/* (Platform dependent) 				 */

void disk_timerproc(void)
{
	;}