/*
|
* Copyright (c) 2018 Fuzhou Rockchip Electronics Co., Ltd
|
*
|
* SPDX-License-Identifier: GPL-2.0
|
*/
|
|
#include <common.h>
|
#include <dm.h>
|
|
#include "rkflash_api.h"
|
#include "rkflash_blk.h"
|
#include "rkflash_debug.h"
|
|
#ifdef CONFIG_RKSFC_NOR
|
|
#define IDB_ALIGN_64 128 /* 64 KB */
|
#define IDB_ALIGN_32 64 /* 32 KB */
|
|
static void P_RC4(u8 *buf, u16 len)
|
{
|
u8 S[256], K[256], temp;
|
u16 i, j, t, x;
|
u8 key[16] = {124, 78, 3, 4, 85, 5, 9, 7,
|
45, 44, 123, 56, 23, 13, 23, 17};
|
|
j = 0;
|
for (i = 0; i < 256; i++) {
|
S[i] = (u8)i;
|
j &= 0x0f;
|
K[i] = key[j];
|
j++;
|
}
|
|
j = 0;
|
for (i = 0; i < 256; i++) {
|
j = (j + S[i] + K[i]) % 256;
|
temp = S[i];
|
S[i] = S[j];
|
S[j] = temp;
|
}
|
|
i = 0;
|
j = 0;
|
for (x = 0; x < len; x++) {
|
i = (i + 1) % 256;
|
j = (j + S[i]) % 256;
|
temp = S[i];
|
S[i] = S[j];
|
S[j] = temp;
|
t = (S[i] + (S[j] % 256)) % 256;
|
buf[x] = buf[x] ^ S[t];
|
}
|
}
|
|
int rksfc_nor_init(struct udevice *udev)
|
{
|
struct rkflash_info *priv = dev_get_priv(udev);
|
struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info;
|
struct snor_info_packet *packet;
|
struct id_block_tag *idb_tag;
|
int ret;
|
|
ret = snor_init(p_dev);
|
if (ret == SFC_OK && p_dev->read_lines == DATA_LINES_X1) {
|
idb_tag = kzalloc(NOR_SECS_PAGE * 512, GFP_KERNEL);
|
if (!idb_tag)
|
return SFC_OK;
|
|
if (sfc_get_version() >= SFC_VER_4)
|
snor_read(p_dev, IDB_ALIGN_32, NOR_SECS_PAGE,
|
idb_tag);
|
else
|
snor_read(p_dev, IDB_ALIGN_64, NOR_SECS_PAGE,
|
idb_tag);
|
packet = (struct snor_info_packet *)&idb_tag->dev_param[0];
|
if (idb_tag->id == IDB_BLOCK_TAG_ID) {
|
P_RC4((u8 *)idb_tag, sizeof(struct id_block_tag));
|
snor_reinit_from_table_packet(p_dev, packet);
|
rkflash_print_error("snor reinit, ret= %d\n", ret);
|
}
|
kfree(idb_tag);
|
}
|
|
return ret;
|
}
|
|
u32 rksfc_nor_get_capacity(struct udevice *udev)
|
{
|
struct rkflash_info *priv = dev_get_priv(udev);
|
struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info;
|
|
return snor_get_capacity(p_dev);
|
}
|
|
int rksfc_nor_read(struct udevice *udev, u32 sec, u32 n_sec, void *p_data)
|
{
|
u32 ret;
|
u32 offset, count = 0;
|
char *buf = (char *)p_data;
|
struct rkflash_info *priv = dev_get_priv(udev);
|
struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info;
|
|
if (sec + n_sec - 1 < FLASH_VENDOR_PART_START ||
|
sec > FLASH_VENDOR_PART_END) {
|
ret = snor_read(p_dev, sec, n_sec, p_data);
|
if (ret != n_sec)
|
return ret;
|
} else {
|
memset(p_data, 0, 512 * n_sec);
|
if (sec < FLASH_VENDOR_PART_START) {
|
count = FLASH_VENDOR_PART_START - sec;
|
buf = (char *)p_data;
|
ret = snor_read(p_dev, sec, count, buf);
|
if (ret != count)
|
return ret;
|
}
|
if ((sec + n_sec - 1) > FLASH_VENDOR_PART_END) {
|
count = sec + n_sec - 1 - FLASH_VENDOR_PART_END;
|
offset = FLASH_VENDOR_PART_END - sec + 1;
|
buf = (char *)p_data + offset * 512;
|
ret = snor_read(p_dev,
|
FLASH_VENDOR_PART_END + 1,
|
count, buf);
|
if (ret != count)
|
return ret;
|
}
|
}
|
|
return n_sec;
|
}
|
|
/* Workaround for GPT not aligned program */
|
int rksfc_nor_simply_over_write(struct udevice *udev,
|
u32 sec,
|
u32 n_sec,
|
const void *p_data)
|
{
|
struct rkflash_info *priv = dev_get_priv(udev);
|
struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info;
|
u8 *pbuf_temp;
|
u32 addr_aligned, offset, remain;
|
|
addr_aligned = sec / NOR_SECS_PAGE * NOR_SECS_PAGE;
|
offset = sec - addr_aligned;
|
remain = (offset + n_sec + NOR_SECS_PAGE - 1) / NOR_SECS_PAGE * NOR_SECS_PAGE;
|
|
pbuf_temp = malloc(remain * 512);
|
snor_read(p_dev, addr_aligned, remain, pbuf_temp);
|
memcpy(pbuf_temp + offset * 512, p_data, n_sec * 512);
|
snor_write(p_dev, addr_aligned, remain, pbuf_temp);
|
free(pbuf_temp);
|
|
return n_sec;
|
}
|
|
int rksfc_nor_write(struct udevice *udev,
|
u32 sec,
|
u32 n_sec,
|
const void *p_data)
|
{
|
u32 ret;
|
u32 offset, count = 0;
|
char *buf = (char *)p_data;
|
struct rkflash_info *priv = dev_get_priv(udev);
|
struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info;
|
u32 sfc_nor_density = rksfc_nor_get_capacity(udev);
|
|
if (sec >= (sfc_nor_density - 33))
|
return rksfc_nor_simply_over_write(udev, sec, n_sec, p_data);
|
|
if (sec + n_sec - 1 < FLASH_VENDOR_PART_START ||
|
sec > FLASH_VENDOR_PART_END) {
|
ret = snor_write(p_dev, sec, n_sec, (void *)p_data);
|
if (ret != n_sec)
|
return ret;
|
} else {
|
if (sec < FLASH_VENDOR_PART_START) {
|
count = FLASH_VENDOR_PART_START - sec;
|
buf = (char *)p_data;
|
ret = snor_write(p_dev, sec, count, buf);
|
if (ret != count)
|
return ret;
|
}
|
if ((sec + n_sec - 1) > FLASH_VENDOR_PART_END) {
|
count = sec + n_sec - 1 - FLASH_VENDOR_PART_END;
|
offset = FLASH_VENDOR_PART_END - sec + 1;
|
buf = (char *)p_data + offset * 512;
|
ret = snor_write(p_dev,
|
FLASH_VENDOR_PART_END + 1,
|
count, buf);
|
if (ret != count)
|
return ret;
|
}
|
}
|
|
return n_sec;
|
}
|
|
int rksfc_nor_vendor_read(struct blk_desc *dev_desc,
|
u32 sec,
|
u32 n_sec,
|
void *p_data)
|
{
|
struct rkflash_info *priv = dev_get_priv(dev_desc->bdev->parent);
|
struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info;
|
|
return snor_read(p_dev, sec, n_sec, p_data);
|
}
|
|
int rksfc_nor_vendor_write(struct blk_desc *dev_desc,
|
u32 sec,
|
u32 n_sec,
|
void *p_data)
|
{
|
struct rkflash_info *priv = dev_get_priv(dev_desc->bdev->parent);
|
struct SFNOR_DEV *p_dev = (struct SFNOR_DEV *)&priv->flash_dev_info;
|
|
return snor_write(p_dev, sec, n_sec, p_data);
|
}
|
|
#endif
|
|
#ifdef CONFIG_RKSFC_NAND
|
int rksfc_nand_init(struct udevice *udev)
|
{
|
int ret;
|
|
ret = sfc_nand_init();
|
if (ret) {
|
return ret;
|
} else {
|
sfc_nand_ftl_ops_init();
|
|
return sftl_init();
|
}
|
}
|
|
int rksfc_nand_read(struct udevice *udev, u32 index, u32 count, void *buf)
|
{
|
int ret;
|
|
ret = sftl_read(index, count, (u8 *)buf);
|
if (!ret)
|
return count;
|
else
|
return -EIO;
|
}
|
|
int rksfc_nand_write(struct udevice *udev,
|
u32 index,
|
u32 count,
|
const void *buf)
|
{
|
int ret;
|
|
ret = sftl_write(index, count, (u8 *)buf);
|
if (!ret)
|
return count;
|
else
|
return -EIO;
|
}
|
|
u32 rksfc_nand_get_density(struct udevice *udev)
|
{
|
return sftl_get_density();
|
}
|
|
int rksfc_nand_vendor_read(struct blk_desc *dev_desc,
|
u32 sec,
|
u32 n_sec,
|
void *p_data)
|
{
|
int ret;
|
|
ret = sftl_vendor_read(sec, n_sec, (u8 *)p_data);
|
if (!ret)
|
return n_sec;
|
else
|
return -EIO;
|
}
|
|
int rksfc_nand_vendor_write(struct blk_desc *dev_desc,
|
u32 sec,
|
u32 n_sec,
|
void *p_data)
|
{
|
int ret;
|
|
ret = sftl_vendor_write(sec, n_sec, (u8 *)p_data);
|
if (!ret)
|
return n_sec;
|
else
|
return -EIO;
|
}
|
|
#endif
|
|
#ifdef CONFIG_RKNANDC_NAND
|
int rknand_flash_init(struct udevice *udev)
|
{
|
return sftl_init();
|
}
|
|
int rknand_flash_read(struct udevice *udev, u32 index, u32 count, void *buf)
|
{
|
int ret;
|
|
ret = sftl_read(index, count, (u8 *)buf);
|
if (!ret)
|
return count;
|
else
|
return -EIO;
|
}
|
|
int rknand_flash_write(struct udevice *udev,
|
u32 index,
|
u32 count,
|
const void *buf)
|
{
|
int ret;
|
|
ret = sftl_write(index, count, (u8 *)buf);
|
if (!ret)
|
return count;
|
else
|
return -EIO;
|
}
|
|
u32 rknand_flash_get_density(struct udevice *udev)
|
{
|
return sftl_get_density();
|
}
|
|
int rknand_flash_vendor_read(struct blk_desc *dev_desc,
|
u32 sec,
|
u32 n_sec,
|
void *p_data)
|
{
|
int ret;
|
|
ret = sftl_vendor_read(sec, n_sec, (u8 *)p_data);
|
if (!ret)
|
return n_sec;
|
else
|
return -EIO;
|
}
|
|
int rknand_flash_vendor_write(struct blk_desc *dev_desc,
|
u32 sec,
|
u32 n_sec,
|
void *p_data)
|
{
|
int ret;
|
|
ret = sftl_vendor_write(sec, n_sec, (u8 *)p_data);
|
if (!ret)
|
return n_sec;
|
else
|
return -EIO;
|
}
|
|
#endif
|
