sd.c

基于S3C2440处理器的sd卡驱动程序

/****************************************Copyright (c)**************************************************
**                               Guangzou ZLG-MCU Development Co.,LTD.
**                                      graduate school
**                                 http://www.zlgmcu.com
**
**--------------File Info-------------------------------------------------------------------------------
** File name:			empty.c
** Last modified Date:  2005-4-16
** Last Version:		1.0
** Descriptions:		empty driver for ZLG/FS 1.0 
**
**------------------------------------------------------------------------------------------------------
** Created by:			Chenmingji
** Created date:		2005-4-16
** Version:				1.0
** Descriptions:		The original version
**
**------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
** Version:
** Descriptions:
**
********************************************************************************************************/
#define IN_SD   				     /* "EMPTY" 为文件的主文件名  */

#include <string.h>
#include <assert.h>
#include "drv_extr.h"
#include "sd_extr.h"


extern void SD_print_info(sd_struct *sds);

void Test_Read_Info()
{
	//added by Hexiaohua
	SD_print_info(&sds);

}


void Test_Read_One_Block()
{
	INT8U *buf;
	void *pointer;
	int i=0;
	int rst;
	int status;
	{
   		status = NU_Allocate_Memory(&system_memory, &pointer, 0x200, NU_NO_SUSPEND);
	    assert(status == NU_SUCCESS);	/* be sure success */
	}
	buf = pointer;
	memset(buf, '0', 512);
	//blockaddr = Uart_GetIntNum();
	//blockaddr = 0;
	Uart_Printf("Block addr:");
	i = Uart_GetIntNum();
	//for(i=1; i<10; i++)
	{

		rst = SD_ReadBlock(&sds, i, buf);
		if( SD_NO_ERR == rst )
		{
			int j;
			Uart_Printf("\r\n-----------Read From %d Block---------\r\n", i);
			j=0;
			while(j<512)
			{
				Uart_Printf("%02x ", buf[j] );
				j++;
				if( (j & 0xf)  == 0 )
				{
					Uart_Printf("\r\n");
				}
			}
		}
		else
		{
			Uart_Printf("\r\n Fail:%2x\r\n", rst);
		}
	}
	
	status = NU_Deallocate_Memory(buf);
	assert(status == NU_SUCCESS);
}
void Test_Write_One_Block()
{
	INT8U buf[512];
	int i=0;
	char ch;
	int r;
	Uart_Printf("\r\n------------Begin Write One Block------------\r\n");
	Uart_Printf("Input Data:");
	ch = Uart_Getch();
	memset(buf, ch, 512);

	Uart_Printf("\r\nBlock addr:");
	
	i = Uart_GetIntNum();
	if(i>10 ||  i == 0)
		i = 1;
	r = SD_WriteBlock(&sds, i, buf);
	if( SD_NO_ERR ==  r)
	{
		Uart_Printf("\r\n------------Write %d Block OK------------\r\n",i);
	}
	Uart_Printf("\r\n------------End Write One Block:%x------------\r\n", r);	
}

void Read_Multiple_Block()
{
	int i;
	void *pointer;
	unsigned char *buf;
	int status;
	{
   		status = NU_Allocate_Memory(&system_memory, &pointer, 16 * 0x200, NU_NO_SUSPEND);
	    assert(status == NU_SUCCESS);	/* be sure success */
	}

	buf = pointer;
	Uart_Printf("Block addr From:");
	i = Uart_GetIntNum();

	SD_ReadBlock_1(&sds, i,16, buf);

	NU_Deallocate_Memory(pointer);
	
}
void Write_Multiple_Block()
{
	int i;
	unsigned char buf[1024];
	memset(buf, 0, 1024);
	Uart_Printf("\r\nBlock addr From:");
	i = Uart_GetIntNum();
	if( SD_NO_ERR == SD_WriteBlock_1(&sds, i, 2, buf) )
	{
		Uart_Printf("\r\nWrite OK\r\n");
	}
			Uart_Printf("\r\nWrite end\r\n");
}
void Test_SD_Init()
{
	if( SD_NO_ERR == SD_Initialize(&sds) )
	{
		Uart_Printf("SD Init OK\r\n");
	}
	else
	{
		Uart_Printf("SD INIT FAIL\r\n");
	}
}
void *fun[][2] =
{
	(void*)Test_SD_Init,			"Initialize SD card	",
	(void*)Test_Read_Info,			"Read SD Config info",
	(void*)Test_Read_One_Block,		"Read one Block		",
	(void*)Test_Write_One_Block,	"Write One Block	",
	(void*)Read_Multiple_Block,		"Read Multiple Block",
	(void*)Write_Multiple_Block, 	"Write Multiple Block",
	//(void*)Test
	0,0
};
void Print_Hint()
{
	int i=0;
	Uart_Printf("\r\n-----SD/MMC Test-----\r\n\r\n");
	while(1)
	{   //display menu
	    Uart_Printf("%2d:%s\r\n",i,fun[i][1]);
		i++;
	    if((int)(fun[i][0])==0)
	    {
			 Uart_Printf("\r\n");
			 break;
	    }
	   // if((i%4)==0) Uart_Printf("\r\n");
	}
	Uart_Printf("Select(-1 exit):");
}
void Test_SD()
{
	int i;
	while(1)
	{
		Print_Hint();
		i = Uart_GetIntNum();
		Uart_Printf("\r\n");
		if( i == -1 )
			break;
		if(i>=0 && (i<(sizeof(fun)/8 -1)) ) 
	    	( (void (*)(void))(fun[i][0]) )();	// execute selected function.		
			
	}
}


/*********************************************************************************************************
** 函数名称: Empty      ---> 使用您自己的函数名称
** 功能描述: 底层驱动程序与上层的接口程序
**
** 输　入: Cammand：define DISK_INIT:                 初始化，必须实现
**                  define DISK_CLOSE:                关闭，必须实现
**                  define DISK_READ_SECTOR:          读扇区，必须实现
**                  define DISK_WRITE_SECTOR:         写扇区，必须实现
**                  define DISK_DRIVER_VER:           查看驱动程序接口版本号，必须实现
**                  define DISK_CHECK_CMD:            查看命令是否实现，必须实现
**                  define DISK_LOW_FORMAT:           低级格式化，可选命令
**                  define DISK_FREE_SECTOR:          释放扇区，可选命令
**                  define DISK_GET_SECTOR_NUMBER:    获得设备总扇区数，可选命令
**                  define DISK_GET_BYTES_PER_SECTOR: 获得每扇区字节数，可选命令
**                  define DISK_CHECK_CHANGE:         查看介质是否改变，可选命令
**                  define DISK_GET_SECTORS_PER_BLOCK:获取每块扇区数，可选命令
**                  define DISK_READ_BLOCK:           读数据块，可选命令
**                  define DISK_WRITE_BLOCK:          写数据块，可选命令
**        Parameter: 剩余参数，其中Parameter->RsvdForLow用于存储驱动程序支持的物理设备相关信息，
**                             如使用的资源等。使用它可以使一个驱动支持多个物理设备。                 
** 输　出: DISK_READ_OK:      读扇区完成
**        DISK_READ_NOT_OK:   读扇区失败
**        DISK_WRITE_OK:      写扇区完成
**        DISK_WRITE_NOT_OK:  写扇区失败
**        DISK_INIT_OK:       初始化完成
**        DISK_INIT_NOT_OK:   初始化失败
**        DISK_FALSE:         真
**        DISK_TRUE:          假
**        BAD_DISK_COMMAND:   无效的命令
** 全局变量: 无
** 调用模块: 无
**
** 作　者: 陈明计
** 日　期: 2005-4-16
**-------------------------------------------------------------------------------------------------------
** 修改人:
** 日　期:
**------------------------------------------------------------------------------------------------------
********************************************************************************************************/
#if 0
uint16 SDCammand(uint8 Cammand, void *Parameter) /*使用您自己的函数名称 */
{
    uint16 rt;
    Disk_RW_Parameter * Dp;
    //FFSDisk *Disk;
    
    Dp = (Disk_RW_Parameter *)Parameter;
    //Disk = (FFSDisk *) Dp->RsvdForLow;
    
    OS_ENTER_CRITICAL();            /* 关中断，根据需要添加 */
    /* 可选命令如果没有实现，则rt =  BAD_DISK_COMMAND*/
    switch (Cammand)
    {
        case DISK_INIT:
            /* 初始化驱动程序，必须实现 */
            /* Parameter没有使用 */
            /* rt=DISK_INIT_OK或DISK_INIT_NOT_OK*/
            if (SD_Initialize(&sds) == 0)
            	rt = DISK_INIT_OK;
            else
            	rt = DISK_INIT_NOT_OK;
            break;
            
        case DISK_CLOSE:
            /* 关闭驱动程序，必须实现 */
            /* Parameter没有使用 */
            rt = DISK_RETURN_OK;
            //rt = BAD_DISK_COMMAND;
            break;
            
        case DISK_READ_SECTOR:
        	if (SD_ReadBlock(&sds,Dp->SectorIndex, Dp->Buf) == 0)
        		rt = DISK_READ_OK;
        	else
        		rt = DISK_READ_NOT_OK;
            /* 读物理扇区，必须实现 */
            /* Dp->Buf：存储读到的数据 */
            /* Dp->SectorIndex：物理扇区索引 */
            /* rt=DISK_READ_OK或DISK_READ_NOT_OK*/
            break;
            
        case DISK_WRITE_SECTOR:
        	if (SD_WriteBlock(&sds,Dp->SectorIndex, Dp->Buf) == 0)
        		rt = DISK_WRITE_OK;
        	else
        		rt = DISK_WRITE_NOT_OK;        
            /* 写物理扇区，必须实现 */
            /* Dp->Buf：需要写的数据 */
            /* Dp->SectorIndex：物理扇区索引 */
            /* rt=DISK_WRITE_OK或DISK_WRITE_NOT_OK*/
            break;
            
        case DISK_DRIVER_VER:
            Dp->SectorIndex = 110;  /* 版本为1.10，指的是ZLG/FS的版本 */
            rt = DISK_RETURN_OK;
            break;
            
        case DISK_CHECK_CMD:
            rt = DISK_FALSE;
            /* 以下那个命令没有实现就注释掉相应的语句 */
            if ((Dp->SectorIndex == DISK_INIT)
               || (Dp->SectorIndex == DISK_CLOSE)
               || (Dp->SectorIndex == DISK_READ_SECTOR)
               || (Dp->SectorIndex == DISK_WRITE_SECTOR)
               || (Dp->SectorIndex == DISK_DRIVER_VER)
               || (Dp->SectorIndex == DISK_CHECK_CMD)
             //  || (Dp->SectorIndex == DISK_LOW_FORMAT)
             //  || (Dp->SectorIndex == DISK_FREE_SECTOR)
               || (Dp->SectorIndex == DISK_GET_SECTOR_NUMBER)
               || (Dp->SectorIndex == DISK_GET_BYTES_PER_SECTOR)
               || (Dp->SectorIndex == DISK_CHECK_CHANGE)
             //  || (Dp->SectorIndex == DISK_GET_SECTORS_PER_BLOCK)
             //  || (Dp->SectorIndex == DISK_READ_BLOCK)
             //  || (Dp->SectorIndex == DISK_WRITE_BLOCK)
               )
            {
                rt = DISK_TRUE;
            }
            break;
            
        //case DISK_LOW_FORMAT:
            /* 低级格式化，可选命令 */
            /* Dp->SectorIndex：0:一般低级格式化 */
            /* Dp->SectorIndex：其它:第一次低级格式化 */
        //    rt = DISK_RETURN_OK;
        //    break;
            
        //case DISK_FREE_SECTOR:
            /* 释放扇区，可选命令，ZLG/FFS使用此命令 */
            /* 此命令让驱动程序知道哪些扇区不再保存有用数据 */
            /* Dp->SectorIndex：物理扇区索引 */
            //rt = DISK_RETURN_OK;
        //    break;
            
        case DISK_GET_SECTOR_NUMBER:
            /* 获得设备总扇区数，可选命令 */
            //Dp->SectorIndex = 有效的物理扇区总数;
            Dp->SectorIndex = sds.block_num;
            rt = DISK_RETURN_OK;
            break;
            
        case DISK_GET_BYTES_PER_SECTOR:
            /* 获得每扇区字节数，可选命令 */
            //Dp->SectorIndex = 每扇区字节数;
            Dp->SectorIndex = sds.block_len;
            rt = DISK_RETURN_OK;
            break;
            
        case DISK_CHECK_CHANGE:
            /* 查看介质是否改变，可选命令 */
            if (card_change != 0)
            //if (介质改变(如更换了SD卡))
            {
                rt = DISK_TRUE;
                card_change = 0;
            }
            else
            {
                rt = DISK_FALSE;
            }
            break;
      
        //case DISK_GET_SECTORS_PER_BLOCK:
            /* 获取每块扇区数，可选命令 */
            //Dp->SectorIndex = 每块扇区数;
        //  rt = DISK_RETURN_OK;
        //  break;
            
        //case DISK_READ_BLOCK:
            /* 读数据块，可选命令 */
            /* Dp->Buf：存储读到的数据 */
            /* Dp->SectorIndex：块的第一个物理扇区索引 */
            /* rt=DISK_READ_OK或DISK_READ_NOT_OK*/
        //  break;
            
        //case DISK_WRITE_BLOCK:
            /* 写数据块，可选命令 */
            /* Dp->Buf：需要写的数据 */
            /* Dp->SectorIndex：块的第一个物理扇区索引 */
            /* rt=DISK_WRITE_OK或DISK_WRITE_NOT_OK*/
        //  break;
            
        default:
            rt = BAD_DISK_COMMAND;
            break;
    }
    OS_EXIT_CRITICAL();            /* 开中断，如果前面使用了OS_ENTER_CRITICAL()，则添加 */
    return rt;
}

/*********************************************************************************************************
**                            End Of File
********************************************************************************************************/
#endif