eaw/tzpuFusionX
1
0
Fork 0
Code Issues Packages Projects Releases 9 Wiki Activity
Files
master
tzpuFusionX/software/linux/boot/drivers/mstar/flash_isp/mtd_isp.c

693 lines
16 KiB
C
Executable File
Raw Permalink Blame History

/*
* mtd_isp.c- Sigmastar
*
* Copyright (C) 2018 Sigmastar Technology Corp.
*
* Author: karl.xiao <karl.xiao@sigmastar.com.tw>
*
* 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 <common.h>
#include <flash.h>
#include <malloc.h>
#include <asm/errno.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/concat.h>
//#include <mtd/cfi_flash.h>
#include "MsTypes.h"
#include "drvDeviceInfo.h"
#include "drvSERFLASH.h"
extern MS_BOOL bDetect;
extern hal_SERFLASH_t _hal_SERFLASH;
#include "asm/arch/mach/platform.h"
#ifdef CONFIG_MS_MTD_ISP_FLASH
//#define CONFIG_MTD_PARTITIONS
/* Define max times to check status register before we give up. */
#define MAX_READY_WAIT_COUNT 100000
#define CMD_SIZE 4
#ifdef CONFIG_MTD_PARTITIONS
#define mtd_has_partitions() (1)
#else
#define mtd_has_partitions() (0)
#endif
#define mutex_init(...)
#define mutex_lock(...)
#define mutex_unlock(...)
//struct mutex
//{
//};
//#define DEBUG(x...) printk(x...)
struct serflash
{
struct mutex lock;
struct mtd_info mtd;
unsigned partitioned:1;
u8 erase_opcode;
};
static inline struct serflash *mtd_to_serflash(struct mtd_info *mtd)
{
return container_of(mtd, struct serflash, mtd);
}
/* Erase flash fully or part of it */
static int serflash_erase(struct mtd_info *mtd, struct erase_info *instr)
{
struct serflash *flash = mtd_to_serflash(mtd);
flash=flash;
//ulong addr,len,start_sec,end_sec;
ulong addr,len;
// uint64_t addr_bak;
printk(KERN_WARNING"%s: addr 0x%08x, len %ld\n",
__func__, (u32)instr->addr, (long int)instr->len);
/* range and alignment check */
if (instr->addr + instr->len > mtd->size)
return -EINVAL;
// addr_bak = instr->addr;
// if ((do_div(instr->addr , mtd->erasesize)) != 0 ||(do_div(instr->len, mtd->erasesize) != 0))
// {
// return -EINVAL;
// }
// instr->addr = addr_bak;
addr = instr->addr;
len = instr->len;
mutex_lock(&flash->lock);
/*write protect false before erase*/
if (!MDrv_SERFLASH_WriteProtect(0))
{
mutex_unlock(&flash->lock);
return -EIO;
}
/* erase the whole chip */
if (len == mtd->size && !MDrv_SERFLASH_EraseChip())
{
instr->state = MTD_ERASE_FAILED;
MDrv_SERFLASH_WriteProtect(1);
mutex_unlock(&flash->lock);
return -EIO;
}
else
{
if (len)
{
if (!MDrv_SERFLASH_AddressErase(addr, len, 1))
{
instr->state = MTD_ERASE_FAILED;
MDrv_SERFLASH_WriteProtect(1);
mutex_unlock(&flash->lock);
return -EIO;
}
}
}
MDrv_SERFLASH_WriteProtect(1);
mutex_unlock(&flash->lock);
instr->state = MTD_ERASE_DONE;
mtd_erase_callback(instr);
return 0;
}
/*
* Read an address range from the flash chip. The address range
* may be any size provided it is within the physical boundaries.
*/
static int serflash_read(struct mtd_info *mtd, loff_t from, size_t len,
size_t *retlen, u_char *buf)
{
struct serflash *flash = mtd_to_serflash(mtd);
printk(KERN_WARNING "%s %s 0x%08x, len %zd\n",
__func__, "from", (u32)from, len);
/* sanity checks */
if (!len)
return 0;
if (from + len > flash->mtd.size)
return -EINVAL;
mutex_lock(&flash->lock);
#if 0
/* Wait till previous write/erase is done. */
if (wait_till_ready(flash))
{
/* REVISIT status return?? */
mutex_unlock(&flash->lock);
return 1;
}
#endif
if (MDrv_SERFLASH_Read(from, len, (unsigned char *)buf))
{
*retlen = len;
}
else
{
*retlen = 0;
mutex_unlock(&flash->lock);
return -EIO;
}
mutex_unlock(&flash->lock);
return 0;
}
/*
* Write an address range to the flash chip. Data must be written in
* FLASH_PAGESIZE chunks. The address range may be any size provided
* it is within the physical boundaries.
*/
static int serflash_write(struct mtd_info *mtd, loff_t to, size_t len,
size_t *retlen, const u_char *buf)
{
struct serflash *flash = mtd_to_serflash(mtd);
// u32 erase_start, erase_end;
printk(KERN_WARNING "%s %s 0x%08x, len %zd\n",
__func__, "to", (u32)to, len);
if (retlen)
*retlen = 0;
/* sanity checks */
if (!len)
return(0);
if (to + len > flash->mtd.size)
return -EINVAL;
// calculate erase sectors
// erase_start = (u32)to / mtd->erasesize;
// erase_end = (u32)(to+len) / mtd->erasesize - 1;
mutex_lock(&flash->lock);
#if 0
/* Wait until finished previous write command. */
if (wait_till_ready(flash))
{
mutex_unlock(&flash->lock);
return 1;
}
#endif
if (!MDrv_SERFLASH_WriteProtect(0))
{
mutex_unlock(&flash->lock);
return -EIO;
}
//modified by daniel.lee 2010/0514
/*
if (!MDrv_SERFLASH_BlockErase(erase_start, erase_end, TRUE))
{
mutex_unlock(&flash->lock);
return -EIO;
}
*/
if (MDrv_SERFLASH_Write(to, len, (unsigned char *)buf))
{
if (retlen)
*retlen = len;
}
else
{
if (retlen)
*retlen = 0;
MDrv_SERFLASH_WriteProtect(1);
mutex_unlock(&flash->lock);
return -EIO;
}
MDrv_SERFLASH_WriteProtect(1);
mutex_unlock(&flash->lock);
return 0;
}
#endif //CONFIG_MS_MTD_ISP_FLASH
/*
#define MSTAR_SERFLASH_SIZE (8 * 1024 * 1024)
#define SERFLASH_PART_PARTITION_0_OFFSET 0
#define SERFLASH_PART_PARTITION_0_SIZE (32+512+32) * 1024
#define SERFLASH_PART_PARTITION_1_OFFSET (SERFLASH_PART_PARTITION_0_OFFSET + SERFLASH_PART_PARTITION_0_SIZE)
#define SERFLASH_PART_PARTITION_1_SIZE 512 * 1024
#define SERFLASH_PART_PARTITION_2_OFFSET (SERFLASH_PART_PARTITION_1_OFFSET + SERFLASH_PART_PARTITION_1_SIZE)
#define SERFLASH_PART_PARTITION_2_SIZE 512 * 1024
#define SERFLASH_PART_PARTITION_3_OFFSET (SERFLASH_PART_PARTITION_2_OFFSET + SERFLASH_PART_PARTITION_2_SIZE)
#define SERFLASH_PART_PARTITION_3_SIZE MSTAR_SERFLASH_SIZE - SERFLASH_PART_PARTITION_3_OFFSET
//
//#if ( (NAND_PART_APPLICATION_OFFSET) >= MSTAR_SERFLASH_SIZE)
// #error "Error: NAND partition is not correct!!!"
//#endif
static const struct mtd_partition serflash_partition_info[] =
{
{
.name = "boot",
.offset = SERFLASH_PART_PARTITION_0_OFFSET,
.size = SERFLASH_PART_PARTITION_0_SIZE
},
{
.name = "kernel",
.offset = SERFLASH_PART_PARTITION_1_OFFSET,
.size = SERFLASH_PART_PARTITION_1_SIZE
},
{
.name = "rootfs",
.offset = SERFLASH_PART_PARTITION_2_OFFSET,
.size = SERFLASH_PART_PARTITION_2_SIZE
},
{
.name = "user",
.offset = SERFLASH_PART_PARTITION_3_OFFSET,
.size = SERFLASH_PART_PARTITION_3_SIZE
}
};
#define SERFLASH_NUM_PARTITIONS ARRAY_SIZE(serflash_partition_info)
*/
#ifdef CONFIG_MS_MTD_ISP_FLASH
unsigned int g_size=0;
/*
* board specific setup should have ensured the SPI clock used here
* matches what the READ command supports, at least until this driver
* understands FAST_READ (for clocks over 25 MHz).
*/
int serflash_probe(void)
{
struct serflash *flash;
struct flash_info *info;
unsigned i;
// jedec_probe() will read id, so initialize hardware first
MDrv_SERFLASH_Init();
if (bDetect == FALSE)
{
printk(KERN_WARNING"no flash_info!!");
return -ENODEV;
}
flash = kzalloc(sizeof *flash, GFP_KERNEL);
if (!flash)
return -ENOMEM;
mutex_init(&flash->lock);
flash->mtd.priv = flash;
#if 0
/*
* Atmel serial flash tend to power up
* with the software protection bits set
*/
if (info->jedec_id >> 16 == 0x1f)
{
write_enable(flash);
write_sr(flash, 0);
}
#endif
flash->mtd.name ="nor0";
flash->mtd.type = MTD_NORFLASH;
flash->mtd.writesize = 1;
flash->mtd.flags = MTD_CAP_NORFLASH;
MDrv_SERFLASH_DetectSize((MS_U32*)&flash->mtd.size);
flash->mtd._erase = serflash_erase;
flash->mtd._read = serflash_read;
flash->mtd._write = serflash_write;
g_size = flash->mtd.size;
flash->mtd.erasesize = (_hal_SERFLASH.u32SecSize);
//dev_info(&spi->dev, "%s (%d Kbytes)\n", info->name,
//flash->mtd.size / 1024);
printk(
"mtd .name = %s, .size = 0x%.8x (%uMiB) "
".erasesize = 0x%.8x .numeraseregions = %d\n",
flash->mtd.name,
(unsigned int)flash->mtd.size, (unsigned int)(flash->mtd.size >>20),
(unsigned int)flash->mtd.erasesize,
flash->mtd.numeraseregions);
if (flash->mtd.numeraseregions)
for (i = 0; i < flash->mtd.numeraseregions; i++)
printk(
"mtd.eraseregions[%d] = { .offset = 0x%.8x, "
".erasesize = 0x%.8x (%uKiB), "
".numblocks = %d }\n",
i, (u32)flash->mtd.eraseregions[i].offset,
(unsigned int)flash->mtd.eraseregions[i].erasesize,
(flash->mtd.eraseregions[i].erasesize >>10 ),
(unsigned int)flash->mtd.eraseregions[i].numblocks);
/* partitions should match sector boundaries; and it may be good to
* use readonly partitions for writeprotected sectors (BP2..BP0).
*/
/*
if (mtd_has_partitions())
{
struct mtd_partition *parts = NULL;
int nr_parts = 0;
if (nr_parts > 0)
{
for (i = 0; i < nr_parts; i++)
{
printk(KERN_WARNING "partitions[%d] = "
"{.name = %s, .offset = 0x%.8x, "
".size = 0x%.8x (%uKiB) }\n",
i, parts[i].name,
(unsigned int)(parts[i].offset),
(unsigned int)(parts[i].size),
(unsigned int)(parts[i].size / 1024));
}
flash->partitioned = 1;
return add_mtd_partitions(&flash->mtd, parts, nr_parts);
}
else
return add_mtd_partitions(&flash->mtd, serflash_partition_info, SERFLASH_NUM_PARTITIONS);
}
*/
return add_mtd_device(&flash->mtd) == 1 ? -ENODEV : 0;
}
unsigned long flash_init (void)
{
serflash_probe();
if (g_size>0)
return (g_size);
return 0;
}
#endif // CONFIG_MS_MTD_ISP_FLASH
#ifdef CONFIG_CMD_SF
#include <spi_flash.h>
int _spi_flash_read(struct spi_flash *flash, u32 offset,
size_t len, void *buf)
{
//printk(KERN_WARNING "%s from 0x%x, len 0x%x, to 0x%x ", __func__, (u32)offset, len, (unsigned int)buf);
u32 ret = -EIO;
u32 readsize = 0;
//u32 starttime = get_timer(0);
/* sanity checks */
if (!len)
return -EINVAL;
if (offset + len > flash->size)
return -EINVAL;
#if 0
if (MDrv_SERFLASH_Read(offset, len, (unsigned char *)buf))
{
ret = 0;
}
#else
if (offset < 0x1000000)
{
MDrv_SERFLASH_WriteExtAddrRegister(0);
readsize = len > (0x1000000 - offset) ? (0x1000000 - offset) : len;
memcpy(buf, (const void *)(MS_SPI_ADDR|offset), readsize);
len = len - readsize;
}
if (len)
{
u32 regEAR = 0;
offset += readsize;
regEAR = offset >> 24;
if (regEAR)
MDrv_SERFLASH_WriteExtAddrRegister(regEAR);
memcpy(buf+readsize, (const void *)(MS_SPI_ADDR|(offset&0xFFFFFF)), len);
if (regEAR)
MDrv_SERFLASH_WriteExtAddrRegister(0);
}
ret = 0;
#endif
//printk(KERN_WARNING "(cost %ld ms)\n", get_timer(0) - starttime);
return ret;
}
int _spi_flash_write(struct spi_flash *flash, u32 offset,
size_t len, const void *buf)
{
printk(KERN_WARNING "%s to 0x%x, len 0x%x from 0x%x ", __func__,(u32)offset, len, (unsigned int)buf);
u32 ret = -EIO;
u32 starttime = get_timer(0);
/* sanity checks */
if (!len)
return (-EINVAL);
if (offset + len > flash->size)
return (-EINVAL);
if (!MDrv_SERFLASH_WriteProtect(0))
{
return (-EIO);
}
if (MDrv_SERFLASH_Write(offset, len, (unsigned char *)buf))
{
ret = 0;
}
MDrv_SERFLASH_WriteProtect(1);
printk(KERN_WARNING "(cost %ld ms)\n", get_timer(0) - starttime);
return ret;
}
#define FLASH_BLOCK_SIZE 65536
int _spi_flash_erase(struct spi_flash *flash, u32 offset,
size_t len)
{
printk(KERN_WARNING"%s: addr 0x%x, len 0x%x ", __func__, (u32)offset, len);
u32 ret = -EIO;
u32 u32ErasedSize;
u32 starttime = get_timer(0);
/* range and alignment check */
if (!len)
return (-EINVAL);
if (offset + len > flash->size)
return (-EINVAL);
/*write protect false before erase*/
if (!MDrv_SERFLASH_WriteProtect(0))
{
return -EIO;
}
/* erase the whole chip */
//if (len == flash->size)
//{
// ret = MDrv_SERFLASH_EraseChip();
// goto Done;
//}
if(offset % FLASH_BLOCK_SIZE)
{
u32ErasedSize = FLASH_BLOCK_SIZE - offset%FLASH_BLOCK_SIZE;
if (len < u32ErasedSize)
{
u32ErasedSize = len;
}
if(MDrv_SERFLASH_SectorErase(offset, offset+u32ErasedSize-1))
{
offset += u32ErasedSize;
len -= u32ErasedSize;
ret = 0;
}
else
{
ret = (-EINVAL);
goto Done;
}
}
if(len >= FLASH_BLOCK_SIZE)
{
u32ErasedSize = len - len%FLASH_BLOCK_SIZE;
if( MDrv_SERFLASH_AddressErase(offset, u32ErasedSize, 1))
{
offset += u32ErasedSize;
len -= u32ErasedSize;
ret = 0;
}
else
{
ret = (-EINVAL);
goto Done;
}
}
if(len)
{
u32ErasedSize = len;
if(MDrv_SERFLASH_SectorErase(offset, offset+u32ErasedSize-1))
{
offset += u32ErasedSize;
len -= u32ErasedSize;
ret = 0;
}
else
{
ret = (-EINVAL);
goto Done;
}
}
Done:
MDrv_SERFLASH_WriteExtAddrRegister(0);
MDrv_SERFLASH_WriteProtect(1);
printk(KERN_WARNING "(cost %ld ms)\n", get_timer(0) - starttime);
return ret;
}
struct spi_flash *spi_flash_probe(unsigned int bus, unsigned int cs,
unsigned int max_hz, unsigned int spi_mode)
{
// struct spi_slave *spi;
struct spi_flash *flash = NULL;
//const SERFLASH_Info *Info = NULL;
/*
spi = spi_setup_slave(bus, cs, max_hz, spi_mode);
if (!spi) {
printf("SF: Failed to set up slave\n");
return err_manufacturer_probe;
}
*/
// jedec_probe() will read id, so initialize hardware first
MDrv_SERFLASH_Init();
//bDetect is the global variable from halserflash.c
if (bDetect == FALSE)
{
printk(KERN_WARNING"no flash_info!!");
goto err_manufacturer_probe;
}
flash = malloc(sizeof(struct spi_flash));
if (!flash) {
debug("SF: Failed to allocate memory\n");
goto err_mem;
}
flash->spi = NULL;
flash->name = "nor0";
flash->write = _spi_flash_write;
flash->erase = _spi_flash_erase;
flash->read = _spi_flash_read;
//Info = MDrv_SERFLASH_GetInfo();
flash->page_size = (_hal_SERFLASH.u16PageSize);
flash->sector_size = (_hal_SERFLASH.u32SecSize);
MDrv_SERFLASH_DetectSize((MS_U32*)&flash->size);
if (!flash) {
printf("SF: Unsupported manufacturer\n");
goto err_manufacturer_probe;
}
printf("SF: Detected %s with total size ", flash->name);
print_size(flash->size, "\n");
return flash;
err_manufacturer_probe:
//err_read_id:
//err_claim_bus:
err_mem:
return NULL;
}
void spi_flash_free(struct spi_flash *flash)
{
free(flash);
}
#endif
Reference in New Issue View Git Blame Copy Permalink