ap/os/linux/linux-3.4.x/drivers/mtd/mtdadapter.c

/* drivers/mtd/mtdadapt.c 
* 
* Mtd api adapt driver for nand&nor. 
* 
* Copyright (c) 2018 ZTE Ltd. 
* 
* This software is licensed under the terms of the GNU General Public 
* License version 2, as published by the Free Software Foundation, and 
* may be copied, distributed, and modified under those terms. 
* 
* This program is distributed in the hope that it will be useful, 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
* GNU General Public License for more details. 
* 
*/ 

#include <linux/slab.h> 
#include <linux/kernel.h> 
#include <linux/mtd/mtd.h>
#include <linux/module.h>

#define READ_ZLOADER_FLAG_SIZE 0x800
#define WRITE_ZLOADER_FLAG_SIZE 0x3000


extern struct mtd_info *mtd_fota;
extern int g_zload_read_only_flag;

#ifndef USE_CPPS_KO
extern unsigned int zOss_NvItemRead(unsigned int NvItemID, unsigned char *NvItemData, unsigned int NvItemLen);
extern unsigned int zOss_NvItemWrite(unsigned int NvItemID, unsigned char *NvItemData, unsigned int NvItemLen);
#endif

/*zdd need modify*/
int zDrvNand_ChangeNvrAttr(unsigned int rw )
{
    int ret = 0;
 //   ret = nand_nv_mid_r_set_to_rw(rw);
	return ret;
}
EXPORT_SYMBOL(zDrvNand_ChangeNvrAttr);

/*
* nv read interface.
* dwstart: nv addr to read
* dwLen: length of nv to read
* to: memory addr
*/
int zDrvNand_Read(unsigned int dwStart, unsigned int dwLen, unsigned char* to)
{
    int ret = 0;

	#ifdef USE_CPPS_KO
	ret = cpps_callbacks.zOss_NvItemRead(dwStart, to, dwLen);
	#else
	ret = zOss_NvItemRead(dwStart, to, dwLen);
    	#endif
		
	return ret;
}
EXPORT_SYMBOL(zDrvNand_Read);

/*
* nv write interface.
* dwstart: nv addr to program
* dwLen: length of nv to program
* from: memory addr
*/
int zDrvNand_Program(unsigned int dwStart, unsigned int dwLen, unsigned char* from)
{
    int ret = 0;

	#ifdef USE_CPPS_KO
	ret = cpps_callbacks.zOss_NvItemWrite(dwStart,from, dwLen);
	#else
	ret = zOss_NvItemWrite(dwStart,from, dwLen);
	#endif
	
	return ret;
}
EXPORT_SYMBOL(zDrvNand_Program);

/*zdd need modify*/
int zDrvNand_SmsRead(unsigned int dwStart, unsigned int dwLen, unsigned char* to)
{
    int ret = 0;

	//ret = zftl_wrapper_read((char *)"sms", dwStart, dwLen, to);
    
	return ret;
}

/*zdd need modify*/
int zDrvNand_SmsProgram(unsigned int dwStart, unsigned int dwLen, unsigned char* from)
{
    int ret = 0;

	//ret = zftl_wrapper_write((unsigned char *)"sms", dwStart, dwLen, from);

	return ret;
}

/*zdd need modify*/
int zDrvNand_SimNvRead(unsigned int dwStart, unsigned int dwLen, unsigned char* to)
{
    int ret = 0;
#if 0//fyi  
    NAND_LOCK
	nand_clk_gate(SYSCLK_ENABLE);
    ret = nand_simnv_read(dwStart, dwLen, to);
	nand_clk_gate(SYSCLK_DISABLE);
	NAND_UNLOCK

	if(ret == -1)
	{
		zftl_res = 1;
		zDrvNand_SetSimNvFlag(dwStart);/*ECC REBOOT*/
		zftl_res = 0;
	}
#endif
	//ret = zftl_wrapper_read((unsigned char *)"simnv", dwStart, dwLen, to);

	return ret;
}

/*zdd need modify*/
int zDrvNand_SimNvProgram(unsigned int dwStart, unsigned int dwLen, unsigned char* from)
{
    int ret = 0;
#if 0//fyi     
    NAND_LOCK
	nand_clk_gate(SYSCLK_ENABLE);
    ret = nand_simnv_program(dwStart, dwLen, from);
	nand_clk_gate(SYSCLK_DISABLE);
	NAND_UNLOCK
	if(ret == -1)
	{
		zftl_res = 1;
		zDrvNand_SetSimNvFlag(dwStart);/*ECC REBOOT*/
		zftl_res = 0;
	}
#endif
	//ret = zftl_wrapper_write((unsigned char *)"simnv", dwStart, dwLen, from);

	return ret;
}

/*zdd need modify*/
int zDrvNand_SimNvFacRead(unsigned int dwStart, unsigned int dwLen, unsigned char* to)
{
    int ret = 0;
#if 0//fyi     
    NAND_LOCK
	nand_clk_gate(SYSCLK_ENABLE);
    ret = nand_simnvfac_read(dwStart, dwLen, to);
	nand_clk_gate(SYSCLK_DISABLE);
	NAND_UNLOCK
#endif
	//ret = zftl_wrapper_read((unsigned char *)"simnvfac", dwStart, dwLen, to);

	return ret;
}

/*zdd need modify*/
int zDrvNand_SimNvFacProgram(unsigned int dwStart, unsigned int dwLen, unsigned char* from)
{
    int ret = 0;
#if 0//fyi  
    NAND_LOCK
	nand_clk_gate(SYSCLK_ENABLE);
    ret = nand_simnvfac_program(dwStart, dwLen, from);
	nand_clk_gate(SYSCLK_DISABLE);
	NAND_UNLOCK
#endif
	//ret = zftl_wrapper_write((unsigned char *)"simnvfac", dwStart, dwLen, from);

	return ret;
}

/*zdd need modify*/
int zDrvNand_NvRwEccMake(unsigned int dwStart, unsigned int dwLen)
{
    char buffer[2048];
	
	//if( dwStart >= NVRW_SIZE||dwStart < 0 || (dwStart +dwLen)> NVRW_SIZE|| dwLen > 2048)
   //     return -1;
//fyi	nand_nvrw_mid_ecc_make(dwStart,dwLen,buffer);
	return 0;
}
EXPORT_SYMBOL(zDrvNand_NvRwEccMake);

/*zdd need modify*/
int zDrvNand_EccMake(unsigned char* partName,unsigned int dwStart, unsigned int dwLen)
{
	return 0;
}
EXPORT_SYMBOL(zDrvNand_EccMake);

/*
* get the bootflag from flash.
* return: 0, dl off   1, dl on
*/
unsigned int zDrvNand_ReadBootflag( void )
{
    unsigned int bootflag = 0;
	
	char value = 0;
    int retlen = 0;
    
    unsigned char *buffer = kzalloc(READ_ZLOADER_FLAG_SIZE,GFP_KERNEL);
    if( buffer == NULL )
        return -1;

    if(mtd_read(mtd_fota,0,READ_ZLOADER_FLAG_SIZE,&retlen,buffer))/* BOOTFLAGÔÚnandµÄµÚ20~27×Ö½Ú */
    {
        kfree(buffer);
        return 1;
    }
	memcpy(&value, buffer+2, 1); 
	bootflag = value;
   
    if( bootflag == 0x5a)
    {
        bootflag = 1;
    }
	else
	{
        bootflag = 0;
	}
    kfree(buffer);

	return bootflag;
}
EXPORT_SYMBOL(zDrvNand_ReadBootflag);

/*
* write the bootflag to flash.
* flag: 0,dl off   else dl on
*/
unsigned int zDrvNand_WriteBootflag(unsigned int flag)
{

    unsigned int ret = 0;
	char value = 0;
	int bootflag = 0;
	int retlen = 0;
    struct erase_info ei;
	
    unsigned char *buffer = kzalloc(WRITE_ZLOADER_FLAG_SIZE,GFP_KERNEL);

    if( buffer == NULL )
        return -1;

    if(mtd_read(mtd_fota,0,WRITE_ZLOADER_FLAG_SIZE,&retlen,buffer))/* BOOTFLAGÔÚnandµÄµÚ20~27×Ö½Ú */
    {
        kfree(buffer);
        return -1;
    }
	if(flag == 0 )
	{
	    bootflag = 0x00;
        memset(&value, bootflag, 1);
	}
    else
    {
        bootflag = 0x5a;
        memset(&value, bootflag, 1);
    }
	
    memcpy(buffer+2, &value, 1);
    memset(&ei, 0, sizeof(struct erase_info));
    ei.mtd  = mtd_fota;
    ei.addr = 0;
    ei.len  = mtd_fota->erasesize;
	g_zload_read_only_flag = 1;
    ret = mtd_erase(mtd_fota, &ei);                  /*²Á³ýµÚÒ»¿é*/
	ret = mtd_write(mtd_fota,0,WRITE_ZLOADER_FLAG_SIZE,&retlen,buffer);
	g_zload_read_only_flag = 0;
    kfree(buffer);

    return 0;

}
EXPORT_SYMBOL(zDrvNand_WriteBootflag);

/*
* get the usbtimeout flag from flash.
* return: should be 1~10
*/
unsigned int zDrvNand_ReadUsbtimeout( void )
{

    unsigned int usbtimeout = 0;
	char value = 0;
    int retlen = 0;
    
    unsigned char *buffer = kzalloc(READ_ZLOADER_FLAG_SIZE,GFP_KERNEL);
    if( buffer == NULL )
        return -1;

    if(mtd_read(mtd_fota,0,READ_ZLOADER_FLAG_SIZE,&retlen,buffer))/* BOOTFLAGÔÚnandµÄµÚ20~27×Ö½Ú */
    {
        kfree(buffer);
        return -1;
    }
	memcpy(&value, buffer+3, 1); 
	usbtimeout = value;
	
    kfree(buffer);
	return usbtimeout;   

}
EXPORT_SYMBOL(zDrvNand_ReadUsbtimeout);

/*
* write the usbtimeout flag to flash.
* flag: should be 1~10
*/
unsigned int zDrvNand_WriteUsbtimeout( unsigned int flag )
{

    unsigned int ret = 0;
	uint8_t oob[256];
	int i =0;
	int times = 0;
	int retlen = 0;
	char value = 0;
	struct erase_info ei;
	
    unsigned char *buffer = kzalloc(WRITE_ZLOADER_FLAG_SIZE,GFP_KERNEL);  /* ZLOADERºÍ·ÖÇø±í¹²8192BYTES */

	if( buffer == NULL )
        return -1;

    if(mtd_read(mtd_fota,0,WRITE_ZLOADER_FLAG_SIZE,&retlen,buffer))/* BOOTFLAGÔÚnandµÄµÚ20~27×Ö½Ú */
    {
        kfree(buffer);
        return -1;
    }
    
    memset(&value, flag, 1);
    memcpy(buffer+3, &value, 1);

	memset(&ei, 0, sizeof(struct erase_info));
    ei.mtd  = mtd_fota;
    ei.addr = 0;
    ei.len  = mtd_fota->erasesize;
	g_zload_read_only_flag = 1;
    ret = mtd_erase(mtd_fota, &ei);                  /*²Á³ýµÚÒ»¿é*/
	ret = mtd_write(mtd_fota,0,WRITE_ZLOADER_FLAG_SIZE,&retlen,buffer);
	g_zload_read_only_flag = 0;
    kfree(buffer);
   		
	return ret; 
}
EXPORT_SYMBOL(zDrvNand_WriteUsbtimeout);