[PATCH v1 3/3] rockchip: cmd: add rockmtd command
Kever Yang
kever.yang at rock-chips.com
Thu Sep 28 05:11:00 CEST 2023
Hi Johan,
On 2023/8/24 21:29, Johan Jonker wrote:
> Rockmtd creates a virtual block device to transfer Rockchip
> boot block data to and from NAND with block orientated tools
> like "ums" and "rockusb".
>
> It uses the Rockchip MTD driver to scan for boot blocks and copies
> data from the first block in a GPT formated virtual disk.
> Data must be written in U-boot "idbloader.img" format and start at
> partition "loader1" offset 64. The data header is parsed
> for length and offset. When the last sector is received
> it erases up to 5 erase blocks on NAND and writes bootblocks
> in a pattern depending on the NAND ID. Data is then verified.
> When a block turns out bad the block header is discarded.
>
> Signed-off-by: Johan Jonker <jbx6244 at gmail.com>
> ---
> cmd/Kconfig | 7 +
> cmd/Makefile | 1 +
> cmd/rockmtd.c | 1429 +++++++++++++++++++++++++++++++++++++++++++++++++
> 3 files changed, 1437 insertions(+)
> create mode 100644 cmd/rockmtd.c
>
> diff --git a/cmd/Kconfig b/cmd/Kconfig
> index 2d6e5f993f04..87f862076355 100644
> --- a/cmd/Kconfig
> +++ b/cmd/Kconfig
> @@ -1553,6 +1553,13 @@ config CMD_USB_SDP
> Enables the command "sdp" which is used to have U-Boot emulating the
> Serial Download Protocol (SDP) via USB.
>
> +config CMD_ROCKMTD
> + bool "rockmtd"
For most of modules for rockchip platform, it's naming with rockchip_ or
short with prefix rk**,
so I think it's better to use rkmtd for this command.
rockusb is the only one I know with prefix "rock", which is used with
very long history before
linux/u-boot driver available.
Thanks,
- Kever
> + help
> + Rockmtd creates a virtual block device to transfer Rockchip
> + boot block data to and from NAND with block orientated tools
> + like "ums" and "rockusb".
> +
> config CMD_ROCKUSB
> bool "rockusb"
> depends on USB_FUNCTION_ROCKUSB
> diff --git a/cmd/Makefile b/cmd/Makefile
> index 9f8c0b058bea..19b609ace782 100644
> --- a/cmd/Makefile
> +++ b/cmd/Makefile
> @@ -150,6 +150,7 @@ obj-$(CONFIG_CMD_REISER) += reiser.o
> obj-$(CONFIG_CMD_REMOTEPROC) += remoteproc.o
> obj-$(CONFIG_CMD_RNG) += rng.o
> obj-$(CONFIG_CMD_KASLRSEED) += kaslrseed.o
> +obj-$(CONFIG_CMD_ROCKMTD) += rockmtd.o
> obj-$(CONFIG_CMD_ROCKUSB) += rockusb.o
> obj-$(CONFIG_CMD_RTC) += rtc.o
> obj-$(CONFIG_SANDBOX) += host.o
> diff --git a/cmd/rockmtd.c b/cmd/rockmtd.c
> new file mode 100644
> index 000000000000..cf5259ecb4d7
> --- /dev/null
> +++ b/cmd/rockmtd.c
> @@ -0,0 +1,1429 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/*
> + * (C) 2023 Johan Jonker <jbx6244 at gmail.com>
> + */
> +
> +#include <blk.h>
> +#include <command.h>
> +#include <common.h>
> +#include <dm.h>
> +#include <dm/device-internal.h>
> +#include <dm/lists.h>
> +#include <dm/root.h>
> +#include <dm/uclass-internal.h>
> +#include <efi_api.h>
> +#include <nand.h>
> +#include <linux/mtd/mtd.h>
> +#include <linux/mtd/rawnand.h>
> +#include <memalign.h>
> +#include <part.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <u-boot/crc.h>
> +
> +#define LBA 64 + 512 + 33
> +
> +#define RK_TAG 0xFCDC8C3B
> +#define NFC_SYS_DATA_SIZE 4
> +
> +struct nand_para_info {
> + u8 id_bytes;
> + u8 nand_id[6];
> + u8 vendor;
> + u8 die_per_chip;
> + u8 sec_per_page;
> + u16 page_per_blk;
> + u8 cell;
> + u8 plane_per_die;
> + u16 blk_per_plane;
> + u16 operation_opt;
> + u8 lsb_mode;
> + u8 read_retry_mode;
> + u8 ecc_bits;
> + u8 access_freq;
> + u8 opt_mode;
> + u8 die_gap;
> + u8 bad_block_mode;
> + u8 multi_plane_mode;
> + u8 slc_mode;
> + u8 reserved[5];
> +};
> +
> +struct bootblk {
> + int blk;
> + int boot_size;
> + int offset;
> +};
> +
> +struct rockmtd_dev {
> + struct blk_desc *desc;
> + char *label;
> + legacy_mbr *mbr;
> + gpt_header *gpt_h;
> + gpt_header *gpt_h2;
> + gpt_entry *gpt_e;
> + char *check;
> + char *idb;
> + char *str;
> + char uuid_part_str[UUID_STR_LEN + 1];
> + char uuid_disk_str[UUID_STR_LEN + 1];
> + char *datbuf;
> + char *oobbuf;
> + struct mtd_info *mtd;
> + struct nand_para_info *info;
> + u16 page_table[512];
> + u32 idb_need_write_back;
> + struct bootblk idblock[5];
> + u32 blk_counter;
> + u32 boot_blks;
> + u32 offset;
> + u32 boot_size;
> +};
> +
> +struct sector0 {
> + u32 magic;
> + u8 reserved[4];
> + u32 rc4_flag;
> + u16 boot_code1_offset;
> + u16 boot_code2_offset;
> + u8 reserved1[490];
> + u16 flash_data_size;
> + u16 flash_boot_size;
> + u8 reserved2[2];
> +} __packed;
> +
> +struct rk_nfc_nand_chip {
> + struct nand_chip chip;
> +
> + u16 boot_blks;
> + u16 metadata_size;
> + u32 boot_ecc;
> + u32 timing;
> +
> + u8 nsels;
> + u8 sels[0];
> + /* Nothing after this field. */
> +};
> +
> +struct nand_para_info nand_para_tbl[] = {
> + {6, {0x2c, 0x64, 0x44, 0x4b, 0xa9, 0x00}, 4, 1, 16, 256, 2, 2, 2048, 0x01df, 3, 17, 40, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0x44, 0x44, 0x4b, 0xa9, 0x00}, 4, 1, 16, 256, 2, 2, 1064, 0x01df, 3, 17, 40, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0x68, 0x04, 0x4a, 0xa9, 0x00}, 4, 1, 8, 256, 2, 2, 2048, 0x011f, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x88, 0x04, 0x4b, 0xa9, 0x00}, 4, 1, 16, 256, 2, 2, 2048, 0x011f, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0xa8, 0x05, 0xcb, 0xa9, 0x00}, 4, 2, 16, 256, 2, 2, 2048, 0x011f, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0x68, 0x04, 0x46, 0x89, 0x00}, 4, 1, 8, 256, 2, 2, 2048, 0x011f, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0x48, 0x04, 0x4a, 0xa5, 0x00}, 4, 1, 8, 256, 2, 2, 1024, 0x011f, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0x84, 0x64, 0x3c, 0xa5, 0x00}, 4, 1, 32, 512, 2, 2, 1024, 0x01df, 3, 17, 40, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x84, 0x64, 0x54, 0xa9, 0x00}, 4, 1, 32, 512, 2, 2, 1024, 0x01df, 4, 18, 60, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0xd7, 0x94, 0x3e, 0x84, 0x00}, 4, 1, 8, 128, 2, 2, 4096, 0x0117, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0x48, 0x04, 0x46, 0x85, 0x00}, 4, 1, 8, 256, 2, 2, 1024, 0x011f, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0x88, 0x05, 0xc6, 0x89, 0x00}, 4, 2, 8, 256, 2, 2, 2048, 0x011f, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x88, 0x24, 0x4b, 0xa9, 0x00}, 4, 1, 16, 256, 2, 2, 2048, 0x011f, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0x68, 0x00, 0x27, 0xa9, 0x00}, 4, 1, 16, 128, 1, 2, 2048, 0x011f, 0, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x64, 0x64, 0x56, 0xa5, 0x00}, 4, 1, 24, 512, 2, 2, 700, 0x01df, 4, 18, 60, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0x84, 0xc5, 0x4b, 0xa9, 0x00}, 4, 2, 16, 256, 2, 2, 2048, 0x01df, 3, 17, 40, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0xd5, 0xd1, 0xa6, 0x68, 0x00}, 4, 2, 8, 64, 1, 2, 2048, 0x0117, 0, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0xdc, 0x90, 0xa6, 0x54, 0x00}, 4, 1, 8, 64, 1, 2, 1024, 0x0117, 0, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x64, 0x64, 0x54, 0xa4, 0x00}, 4, 1, 32, 512, 2, 1, 1024, 0x01df, 4, 18, 60, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x84, 0x44, 0x32, 0xaa, 0x00}, 4, 1, 32, 512, 2, 1, 2184, 0x05c7, 5, 19, 60, 32, 1, 0, 1, 0, 1, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x64, 0x44, 0x32, 0xa5, 0x00}, 4, 1, 32, 512, 2, 1, 1048, 0x05c7, 5, 19, 60, 32, 1, 0, 1, 0, 1, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x64, 0x64, 0x3c, 0xa5, 0x00}, 4, 1, 32, 512, 2, 1, 1044, 0x01df, 3, 17, 40, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x84, 0x44, 0x32, 0xaa, 0x00}, 4, 1, 32, 512, 2, 1, 2184, 0x05c7, 5, 19, 60, 32, 1, 0, 4, 0, 1, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x84, 0x44, 0x34, 0xaa, 0x00}, 4, 1, 32, 512, 2, 1, 2184, 0x05c7, 5, 19, 60, 32, 1, 0, 4, 0, 1, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x84, 0xc4, 0x34, 0xaa, 0x00}, 4, 1, 32, 512, 2, 1, 2184, 0x05c7, 5, 19, 60, 32, 1, 0, 1, 0, 1, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x84, 0x44, 0x34, 0xa4, 0x00}, 4, 1, 32, 512, 2, 1, 2184, 0x05c7, 5, 19, 60, 32, 1, 0, 1, 0, 1, {0, 0, 0, 0, 0}},
> + {5, {0x2c, 0x84, 0x64, 0x3c, 0xa9, 0x00}, 4, 1, 32, 512, 2, 2, 1024, 0x01df, 3, 17, 40, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x2c, 0xa4, 0x64, 0x32, 0xaa, 0x04}, 4, 1, 32, 1024, 2, 1, 2192, 0x05c7, 10, 19, 60, 32, 1, 0, 4, 0, 1, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0xde, 0x94, 0xd2, 0x04, 0x43}, 2, 1, 16, 256, 2, 2, 2048, 0x01d9, 1, 1, 24, 32, 4, 0, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0xd7, 0x94, 0xda, 0x74, 0xc3}, 2, 1, 16, 256, 2, 2, 1024, 0x01d9, 1, 2, 40, 32, 4, 0, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0xd7, 0x94, 0x91, 0x60, 0x44}, 2, 1, 16, 256, 2, 2, 1046, 0x01d9, 1, 3, 40, 32, 4, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0xde, 0x94, 0xda, 0x74, 0xc4}, 2, 1, 16, 256, 2, 2, 2090, 0x01d9, 1, 4, 40, 32, 4, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0xde, 0x94, 0xeb, 0x74, 0x44}, 2, 1, 32, 256, 2, 2, 1066, 0x01d9, 1, 7, 40, 32, 4, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0xd5, 0x94, 0xda, 0x74, 0xc4}, 2, 1, 16, 256, 2, 2, 530, 0x01d9, 1, 3, 40, 32, 4, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0xd7, 0x94, 0x9a, 0x74, 0x42}, 2, 1, 16, 256, 2, 2, 1024, 0x0119, 1, 0, 24, 32, 4, 0, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0xde, 0x14, 0xa7, 0x42, 0x4a}, 2, 1, 32, 256, 2, 2, 1060, 0x01d9, 2, 5, 40, 32, 4, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0xd7, 0x14, 0x9e, 0x34, 0x4a}, 2, 1, 16, 256, 2, 2, 1056, 0x01d9, 2, 5, 40, 32, 4, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0xde, 0x94, 0xa7, 0x42, 0x48}, 2, 1, 32, 256, 2, 2, 1060, 0x01d9, 2, 5, 40, 32, 4, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0xde, 0x14, 0xab, 0x42, 0x4a}, 2, 1, 32, 256, 2, 2, 1056, 0x01d9, 2, 6, 40, 32, 3, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0x3a, 0x14, 0xab, 0x42, 0x4a}, 2, 1, 32, 256, 2, 2, 2092, 0x01d9, 2, 5, 40, 32, 3, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0xd5, 0x94, 0x9a, 0x74, 0x42}, 2, 1, 16, 256, 2, 1, 1024, 0x0111, 1, 0, 24, 32, 4, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xad, 0x3a, 0x14, 0x03, 0x08, 0x50}, 2, 1, 32, 388, 2, 2, 1362, 0x01d9, 9, 8, 40, 32, 3, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x89, 0x64, 0x44, 0x4b, 0xa9, 0x00}, 7, 1, 16, 256, 2, 2, 2048, 0x01df, 3, 17, 40, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x89, 0x88, 0x24, 0x4b, 0xa9, 0x84}, 7, 1, 16, 256, 2, 2, 2048, 0x01df, 3, 17, 40, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x89, 0x88, 0x24, 0x4b, 0xa9, 0x00}, 7, 1, 16, 256, 2, 2, 2048, 0x0117, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x89, 0x68, 0x24, 0x4a, 0xa9, 0x00}, 7, 1, 8, 256, 2, 2, 2048, 0x0117, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x89, 0x68, 0x04, 0x4a, 0xa9, 0x00}, 7, 1, 8, 256, 2, 2, 2048, 0x0117, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x89, 0xd7, 0x94, 0x3e, 0x84, 0x00}, 7, 1, 8, 256, 2, 2, 2048, 0x0117, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x89, 0x68, 0x04, 0x46, 0xa9, 0x00}, 7, 1, 8, 256, 2, 2, 2048, 0x0117, 1, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {5, {0x89, 0x64, 0x64, 0x3c, 0xa1, 0x00}, 7, 1, 32, 512, 2, 1, 1024, 0x01c7, 4, 17, 40, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {5, {0x89, 0x84, 0x64, 0x3c, 0xa5, 0x00}, 7, 1, 32, 512, 2, 2, 1024, 0x01c7, 4, 17, 40, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x89, 0x88, 0x24, 0x3b, 0xa9, 0x00}, 7, 1, 16, 192, 2, 2, 2048, 0x0117, 12, 0, 24, 32, 1, 0, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0xd7, 0x84, 0x93, 0x72, 0x57}, 1, 1, 32, 256, 2, 1, 1060, 0x05c1, 2, 33, 40, 32, 2, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0xde, 0x84, 0x93, 0x72, 0x57}, 1, 1, 32, 256, 2, 1, 2092, 0x05c1, 2, 33, 40, 32, 2, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0x3a, 0x85, 0x93, 0x76, 0x57}, 1, 2, 32, 256, 2, 1, 2092, 0x05e1, 2, 33, 40, 32, 2, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0xd5, 0x84, 0x32, 0x72, 0x56}, 1, 1, 16, 128, 2, 1, 2056, 0x05c1, 2, 33, 40, 32, 2, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0xd7, 0x94, 0x32, 0x76, 0x56}, 1, 1, 16, 128, 2, 2, 2058, 0x05d1, 2, 33, 40, 32, 2, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0xde, 0x94, 0x82, 0x76, 0x56}, 1, 1, 16, 256, 2, 2, 2062, 0x05d1, 1, 33, 40, 32, 2, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0xde, 0x94, 0x93, 0x76, 0x50}, 1, 1, 32, 256, 2, 2, 1066, 0x05d9, 2, 34, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0x3a, 0x95, 0x93, 0x7a, 0x50}, 1, 2, 32, 256, 2, 2, 1066, 0x05d9, 2, 34, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0xd7, 0x94, 0x32, 0x76, 0x55}, 1, 1, 16, 128, 2, 2, 2050, 0x0191, 2, 0, 24, 32, 1, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0xde, 0x94, 0x93, 0x76, 0x57}, 1, 1, 32, 256, 2, 2, 1058, 0x05d9, 2, 33, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0xd7, 0x84, 0x93, 0x72, 0x50}, 1, 1, 32, 256, 2, 1, 1060, 0x05c1, 2, 34, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0xde, 0x94, 0x93, 0x76, 0x51}, 1, 1, 32, 256, 2, 2, 1074, 0x05d9, 2, 35, 40, 32, 3, 1, 4, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0x3a, 0x94, 0x93, 0x76, 0x51}, 1, 1, 32, 256, 2, 2, 2106, 0x05d9, 2, 35, 40, 32, 3, 1, 4, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0xd7, 0x84, 0x93, 0x72, 0x51}, 1, 1, 32, 256, 2, 1, 1056, 0x05d9, 2, 35, 40, 32, 3, 1, 4, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x98, 0xde, 0x94, 0x93, 0x76, 0xd1}, 1, 1, 32, 256, 2, 2, 1074, 0x05d9, 2, 35, 40, 32, 3, 1, 4, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x45, 0xde, 0x94, 0x93, 0x76, 0x57}, 8, 1, 32, 256, 2, 2, 1058, 0x05d9, 2, 66, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x45, 0xd7, 0x84, 0x93, 0x72, 0x57}, 8, 1, 32, 256, 2, 1, 1060, 0x05c1, 2, 66, 40, 32, 2, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x45, 0xde, 0xa4, 0x82, 0x76, 0x56}, 8, 1, 16, 256, 2, 2, 2082, 0x01d9, 1, 65, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x45, 0xde, 0x94, 0x93, 0x76, 0x50}, 8, 1, 32, 256, 2, 2, 1066, 0x05d9, 2, 67, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x45, 0xd7, 0x84, 0x93, 0x72, 0x50}, 8, 1, 32, 256, 2, 1, 1060, 0x05c1, 2, 67, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x45, 0xde, 0xa4, 0x82, 0x76, 0xd7}, 8, 1, 16, 256, 2, 2, 2090, 0x04d9, 1, 66, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x45, 0xde, 0x84, 0x93, 0x72, 0x57}, 8, 1, 32, 256, 2, 1, 2092, 0x05c1, 2, 66, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x45, 0x3a, 0x94, 0x93, 0x76, 0x51}, 8, 1, 32, 256, 2, 2, 2106, 0x01d9, 2, 68, 40, 32, 3, 1, 4, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x45, 0xde, 0x94, 0x93, 0x76, 0x51}, 8, 1, 32, 256, 2, 2, 1074, 0x01d9, 2, 68, 40, 32, 3, 1, 4, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x45, 0x3a, 0xa4, 0x93, 0x7a, 0x50}, 8, 1, 32, 256, 2, 2, 2138, 0x05d9, 2, 0, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x45, 0xde, 0x94, 0x82, 0x76, 0x56}, 8, 1, 16, 256, 2, 2, 2062, 0x01d9, 1, 0, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0x45, 0xde, 0x94, 0x93, 0x76, 0xd7}, 8, 1, 32, 256, 2, 2, 1058, 0x05d9, 2, 66, 40, 32, 3, 1, 1, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xec, 0xd7, 0x94, 0x7e, 0x64, 0x44}, 0, 1, 16, 128, 2, 2, 2048, 0x01d9, 2, 49, 60, 36, 3, 0, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xec, 0xde, 0xd5, 0x7e, 0x68, 0x44}, 0, 2, 16, 128, 2, 2, 2048, 0x01f9, 2, 49, 60, 36, 3, 0, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xec, 0xd7, 0x94, 0x7a, 0x54, 0x43}, 0, 1, 16, 128, 2, 2, 2076, 0x0199, 2, 0, 40, 36, 3, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xec, 0xde, 0xd5, 0x7a, 0x58, 0x43}, 0, 2, 16, 128, 2, 2, 2076, 0x01b9, 2, 0, 40, 36, 3, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xec, 0xd5, 0x94, 0x76, 0x54, 0x43}, 0, 1, 16, 128, 2, 2, 1038, 0x0119, 2, 0, 24, 36, 3, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xec, 0xd7, 0x14, 0x76, 0x54, 0xc2}, 0, 1, 16, 128, 2, 2, 2076, 0x0491, 2, 0, 24, 40, 3, 1, 3, 0, 0, {0, 0, 0, 0, 0}},
> + {6, {0xec, 0xde, 0x94, 0xc3, 0xa4, 0xca}, 0, 1, 32, 792, 2, 1, 688, 0x04c1, 11, 50, 40, 32, 3, 1, 1, 0, 1, {0, 0, 0, 0, 0}},
> +};
> +
> +void rockmtd_rc4(u8 *buf, u32 len)
> +{
> + u8 S[256], K[256], temp;
> + u32 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];
> + }
> +}
> +
> +static int rockmtd_write_oob(struct mtd_info *mtd, ulong off, u_char *datbuf, u_char *oobbuf)
> +{
> + off &= ~(mtd->writesize - 1);
> + loff_t addr = (loff_t)off;
> + struct mtd_oob_ops ops;
> + int ret;
> +
> + memset(&ops, 0, sizeof(ops));
> + ops.datbuf = datbuf;
> + ops.oobbuf = oobbuf;
> + ops.len = mtd->writesize;
> + ops.ooblen = mtd->oobsize;
> + ops.mode = MTD_OPS_PLACE_OOB;
> + ret = mtd_write_oob(mtd, addr, &ops);
> + if (ret < 0) {
> + debug("Error (%d) writing page %08lx\n", ret, off);
> + return 1;
> + }
> +
> + return 0;
> +}
> +
> +static int rockmtd_read_oob(struct mtd_info *mtd, ulong off, u_char *datbuf, u_char *oobbuf)
> +{
> + off &= ~(mtd->writesize - 1);
> + loff_t addr = (loff_t)off;
> + struct mtd_oob_ops ops;
> + int ret;
> +
> + memset(&ops, 0, sizeof(ops));
> + ops.datbuf = datbuf;
> + ops.oobbuf = oobbuf;
> + ops.len = mtd->writesize;
> + ops.ooblen = mtd->oobsize;
> + ops.mode = MTD_OPS_PLACE_OOB;
> + ret = mtd_read_oob(mtd, addr, &ops);
> + if (ret < 0) {
> + debug("error (%d) reading page %08lx\n", ret, off);
> + return 1;
> + }
> +
> + return 0;
> +}
> +
> +static int rockmtd_erase(struct mtd_info *mtd, ulong off)
> +{
> + off &= ~(mtd->writesize - 1);
> + loff_t addr = (loff_t)off;
> + struct erase_info info;
> + int ret;
> +
> + memset(&info, 0, sizeof(info));
> + info.mtd = mtd;
> + info.addr = addr;
> + info.len = mtd->erasesize;
> + info.scrub = 1;
> + ret = mtd_erase(mtd, &info);
> + if (ret) {
> + debug("error (%d) erasing page %08lx\n", ret, off);
> + return 1;
> + }
> +
> + return 0;
> +}
> +
> +void rockmtd_scan_block(struct rockmtd_dev *plat)
> +{
> + u32 blk;
> +
> + plat->blk_counter = 0;
> +
> + for (blk = 0; blk < plat->boot_blks; blk++) {
> + rockmtd_read_oob(plat->mtd, blk * plat->mtd->erasesize, plat->datbuf, plat->oobbuf);
> + if (*(u32 *)plat->datbuf == RK_TAG) {
> + struct sector0 *sec0 = (struct sector0 *)plat->datbuf;
> +
> + rockmtd_rc4(plat->datbuf, 512);
> +
> + plat->idblock[plat->blk_counter].blk = blk;
> + plat->idblock[plat->blk_counter].offset = sec0->boot_code1_offset;
> + plat->idblock[plat->blk_counter].boot_size = sec0->flash_boot_size;
> +
> + debug("\nblk : %d\n", plat->idblock[plat->blk_counter].blk);
> + debug("offset : %d\n", plat->idblock[plat->blk_counter].offset);
> + debug("boot_size : %d\n", plat->idblock[plat->blk_counter].boot_size);
> +
> + plat->blk_counter += 1;
> +
> + if (plat->blk_counter >= ARRAY_SIZE(plat->idblock))
> + return;
> + }
> + }
> +}
> +
> +void rockmtd_read_block(struct rockmtd_dev *plat, u32 idx, u8 *buf)
> +{
> + ulong off = plat->idblock[idx].blk * plat->mtd->erasesize;
> + struct nand_chip *chip = mtd_to_nand(plat->mtd);
> + struct nand_ecc_ctrl *ecc = &chip->ecc;
> + int counter = 0;
> + u32 spare0 = 0;
> + u32 *p_spare;
> + int sector;
> + int page;
> +
> + rockmtd_read_oob(plat->mtd, off,
> + plat->datbuf, plat->oobbuf);
> +
> + memcpy(buf, plat->datbuf, 2048);
> +
> + while (counter < plat->idblock[idx].boot_size) {
> + if (spare0)
> + page = (plat->idblock[idx].offset + spare0) / 4;
> + else
> + page = (plat->idblock[idx].offset + counter) / 4;
> +
> + rockmtd_read_oob(plat->mtd,
> + off + page * plat->mtd->writesize,
> + plat->datbuf, plat->oobbuf);
> +
> + sector = plat->idblock[idx].offset + counter;
> +
> + memcpy(&buf[(sector / 4) * 2048], plat->datbuf, 2048);
> +
> + p_spare = (u32 *)&plat->oobbuf[(ecc->steps - 1) * NFC_SYS_DATA_SIZE];
> +
> + spare0 = *p_spare;
> + if (spare0 == -1)
> + break;
> +
> + counter += 4;
> + }
> +}
> +
> +void rockmtd_write_block(struct rockmtd_dev *plat, u32 idx, u8 *buf)
> +{
> + ulong off = plat->idblock[idx].blk * plat->mtd->erasesize;
> + struct nand_chip *chip = mtd_to_nand(plat->mtd);
> + struct nand_ecc_ctrl *ecc = &chip->ecc;
> + int counter = 0;
> + u32 *p_spare;
> + int sector;
> + int page;
> + int j, w, r;
> +
> + rockmtd_erase(plat->mtd, off);
> +
> + memset(plat->datbuf, 0xff, plat->mtd->writesize);
> + memcpy(plat->datbuf, buf, 2048);
> + memset(plat->oobbuf, 0xff, plat->mtd->oobsize);
> +
> + rockmtd_write_oob(plat->mtd, off,
> + plat->datbuf, plat->oobbuf);
> +
> + while (counter < plat->idblock[idx].boot_size) {
> + sector = plat->idblock[idx].offset + counter;
> +
> + memset(plat->datbuf, 0xff, plat->mtd->writesize);
> + memcpy(plat->datbuf, &buf[(sector / 4) * 2048], 2048);
> + memset(plat->oobbuf, 0xff, plat->mtd->oobsize);
> +
> + p_spare = (u32 *)&plat->oobbuf[(ecc->steps - 1) * NFC_SYS_DATA_SIZE];
> +
> + *p_spare = (plat->page_table[sector / 4 + 1] - 1) * 4;
> +
> + page = plat->page_table[sector / 4];
> +
> + rockmtd_write_oob(plat->mtd,
> + off + page * plat->mtd->writesize,
> + plat->datbuf, plat->oobbuf);
> +
> + counter += 4;
> + }
> +
> + memset(plat->check, 0xff, 512 * 512);
> + rockmtd_read_block(plat, idx, plat->check);
> +
> + for (j = 0; j < 2048; j++) {
> + w = *(buf + j);
> + r = *(plat->check + j);
> +
> + if (r != w)
> + goto dumpblock;
> + }
> +
> + for (j = 0; j < (plat->idblock[idx].boot_size * 512); j++) {
> + w = *(buf + plat->idblock[idx].offset * 512 + j);
> + r = *(plat->check + plat->idblock[idx].offset * 512 + j);
> +
> + if (r != w)
> + goto dumpblock;
> + }
> +
> + debug("write OK\n");
> + return;
> +
> +dumpblock:
> + debug("write and check error:%x r=%x w=%x\n", j, r, w);
> +
> + plat->idblock[idx].offset = 0;
> + plat->idblock[idx].boot_size = 0;
> +
> + memset(plat->datbuf, 0xff, plat->mtd->writesize);
> + memset(plat->datbuf, 0, 2048);
> + memset(plat->oobbuf, 0xff, plat->mtd->oobsize);
> +
> + rockmtd_write_oob(plat->mtd, off, plat->datbuf, plat->oobbuf);
> +}
> +
> +ulong rockmtd_bread(struct udevice *udev, lbaint_t start,
> + lbaint_t blkcnt, void *dst)
> +{
> + struct blk_desc *block_dev = dev_get_uclass_plat(udev);
> + struct udevice *parent_dev = dev_get_parent(udev);
> + struct rockmtd_dev *plat = dev_get_plat(parent_dev);
> + char *buf = dst;
> + int i;
> +
> + if (blkcnt == 0)
> + return 0;
> +
> + if (start > (block_dev->lba - 1) ||
> + (start + blkcnt) > block_dev->lba)
> + return 0;
> +
> + memset(dst, 0xff, blkcnt * block_dev->blksz);
> +
> + for (i = start; i < (start + blkcnt); i++) {
> + if (i == 0) {
> + debug("mbr : %d\n", i);
> +
> + memcpy(&buf[(i - start) * block_dev->blksz],
> + plat->mbr, sizeof(legacy_mbr));
> + } else if (i == 1) {
> + debug("gpt_h : %d\n", i);
> +
> + memcpy(&buf[(i - start) * block_dev->blksz],
> + plat->gpt_h, sizeof(gpt_header));
> + } else if (i == (block_dev->lba - 1)) {
> + debug("gpt_h2 : %d\n", i);
> +
> + memcpy(&buf[(i - start) * block_dev->blksz],
> + plat->gpt_h2, sizeof(gpt_header));
> + } else if (i == 2 || i == (block_dev->lba - 33)) {
> + debug("gpt_e : %d\n", i);
> +
> + memcpy(&buf[(i - start) * block_dev->blksz],
> + plat->gpt_e, sizeof(gpt_entry));
> + } else if (i >= 64 && i < (block_dev->lba - 33)) {
> + debug("idb rd : %d\n", i);
> +
> + memcpy(&buf[(i - start) * block_dev->blksz],
> + &plat->idb[(i - 64) * block_dev->blksz], block_dev->blksz);
> + }
> + }
> +
> + return blkcnt;
> +}
> +
> +ulong rockmtd_bwrite(struct udevice *udev, lbaint_t start,
> + lbaint_t blkcnt, const void *src)
> +{
> + struct blk_desc *block_dev = dev_get_uclass_plat(udev);
> + struct udevice *parent_dev = dev_get_parent(udev);
> + struct rockmtd_dev *plat = dev_get_plat(parent_dev);
> + int i, j;
> +
> + if (blkcnt == 0)
> + return 0;
> +
> + if (start > (block_dev->lba - 1) ||
> + (start + blkcnt) > block_dev->lba)
> + return 0;
> +
> + for (i = start; i < (start + blkcnt); i++) {
> + debug("idb wr : %d\n", i);
> +
> + if (i >= 64 && i < (block_dev->lba - 33)) {
> + if (i == 64) {
> + debug("first block\n");
> +
> + plat->idb_need_write_back = 1;
> + memset(plat->idb, 0xff, 512 * 512);
> + }
> +
> + if (plat->idb_need_write_back) {
> + char *buf = (char *)src;
> +
> + memcpy(&plat->idb[(i - 64) * block_dev->blksz],
> + &buf[(i - start) * block_dev->blksz],
> + block_dev->blksz);
> +
> + if (i == 64) {
> + memcpy(plat->check, plat->idb, 512);
> +
> + if (*(u32 *)plat->check == RK_TAG) {
> + struct sector0 *sec0 = (struct sector0 *)plat->check;
> +
> + rockmtd_rc4(plat->check, 512);
> +
> + plat->offset = sec0->boot_code1_offset;
> + plat->boot_size = sec0->flash_boot_size;
> +
> + if (plat->offset + plat->boot_size > 512) {
> + debug("max size limit\n");
> + plat->idb_need_write_back = 0;
> + }
> + } else {
> + debug("no IDB block found\n");
> + plat->idb_need_write_back = 0;
> + }
> + }
> +
> + if (i == (64 + plat->offset + plat->boot_size - 1)) {
> + debug("last block\n");
> +
> + plat->idb_need_write_back = 0;
> +
> + if (!plat->blk_counter) {
> + plat->idblock[0].blk = 2;
> + plat->idblock[1].blk = 3;
> + plat->idblock[2].blk = 4;
> + plat->idblock[3].blk = 5;
> + plat->idblock[4].blk = 6;
> + plat->blk_counter = 5;
> + }
> +
> + for (j = 0; j < plat->blk_counter; j++) {
> + if (plat->idblock[j].blk < plat->boot_blks) {
> + plat->idblock[j].offset = plat->offset;
> + plat->idblock[j].boot_size = plat->boot_size;
> + rockmtd_write_block(plat, j, plat->idb);
> + }
> + }
> +
> + rockmtd_scan_block(plat);
> +
> + memset(plat->idb, 0xff, 512 * 512);
> +
> + if (plat->blk_counter)
> + rockmtd_read_block(plat, 0, plat->idb);
> + }
> + }
> + } else if (plat->idb_need_write_back) {
> + plat->idb_need_write_back = 0;
> +
> + memset(plat->idb, 0xff, 512 * 512);
> +
> + if (plat->blk_counter)
> + rockmtd_read_block(plat, 0, plat->idb);
> + }
> + }
> +
> + return blkcnt;
> +}
> +
> +static const struct blk_ops rockmtd_blk_ops = {
> + .read = rockmtd_bread,
> + .write = rockmtd_bwrite,
> +};
> +
> +U_BOOT_DRIVER(rockmtd_blk) = {
> + .name = "rockmtd_blk",
> + .id = UCLASS_BLK,
> + .ops = &rockmtd_blk_ops,
> +};
> +
> +void rockmtd_build_page_table(struct rockmtd_dev *plat, u32 lsb_mode)
> +{
> + u32 counter;
> + u32 counter2;
> +
> + switch (lsb_mode) {
> + case 0:
> + counter = 0;
> + do {
> + u16 val = counter;
> +
> + plat->page_table[counter++] = val;
> + } while (counter != 512);
> + break;
> + case 1:
> + counter = 0;
> + do {
> + u16 val = counter;
> +
> + if (counter > 3) {
> + u16 offset;
> +
> + if (counter & 1)
> + offset = 3;
> + else
> + offset = 2;
> + val = 2 * counter - offset;
> + }
> + plat->page_table[counter++] = val;
> + } while (counter != 512);
> + break;
> + case 2:
> + counter = 0;
> + do {
> + u16 val = counter;
> +
> + if (counter > 1)
> + val = 2 * counter - 1;
> + plat->page_table[counter++] = val;
> + } while (counter != 512);
> + break;
> + case 3:
> + counter = 0;
> + do {
> + u16 val = counter;
> +
> + if (counter > 5) {
> + u16 offset;
> +
> + if (counter & 1)
> + offset = 5;
> + else
> + offset = 4;
> + val = 2 * counter - offset;
> + }
> + plat->page_table[counter++] = val;
> + } while (counter != 512);
> + break;
> + case 4:
> + counter = 8;
> + plat->page_table[0] = 0;
> + plat->page_table[1] = 1;
> + plat->page_table[2] = 2;
> + plat->page_table[3] = 3;
> + plat->page_table[4] = 4;
> + plat->page_table[5] = 5;
> + plat->page_table[6] = 7;
> + plat->page_table[7] = 8;
> + do {
> + u32 offset;
> + u32 val;
> +
> + if (counter & 1)
> + offset = 7;
> + else
> + offset = 6;
> + val = 2 * counter - offset;
> + plat->page_table[counter++] = val;
> + } while (counter != 512);
> + break;
> + case 5:
> + counter = 0;
> + counter2 = 16;
> + do {
> + u16 val = counter;
> +
> + plat->page_table[counter++] = val;
> + } while (counter != 16);
> + do {
> + plat->page_table[counter++] = counter2;
> + counter2 = counter2 + 2;
> + } while (counter != 512);
> + break;
> + case 6:
> + counter = 0;
> + counter2 = 0;
> + do {
> + u16 val = counter;
> +
> + if (counter > 5) {
> + u16 offset;
> +
> + if (counter & 1)
> + offset = 12;
> + else
> + offset = 10;
> + val = counter2 - offset;
> + }
> + plat->page_table[counter++] = val;
> + counter2 = counter2 + 3;
> + } while (counter != 512);
> + break;
> + case 9:
> + counter = 3;
> + counter2 = 3;
> + plat->page_table[0] = 0;
> + plat->page_table[1] = 1;
> + plat->page_table[2] = 2;
> + do {
> + plat->page_table[counter++] = counter2;
> + counter2 = counter2 + 2;
> + } while (counter != 512);
> + break;
> + case 10:
> + counter = 0;
> + counter2 = 63;
> + do {
> + u16 val = counter;
> +
> + plat->page_table[counter++] = val;
> + } while (counter != 63);
> + do {
> + plat->page_table[counter++] = counter2;
> + counter2 = counter2 + 2;
> + } while (counter != 512);
> + break;
> + case 11:
> + counter = 0;
> + do {
> + u16 val = counter;
> +
> + plat->page_table[counter++] = val;
> + } while (counter != 8);
> + do {
> + u32 offset;
> + u32 val;
> +
> + if (counter & 1)
> + offset = 7;
> + else
> + offset = 6;
> + val = 2 * counter - offset;
> + plat->page_table[counter++] = val;
> + } while (counter != 512);
> + break;
> + case 12:
> + counter = 4;
> + plat->page_table[0] = 0;
> + plat->page_table[1] = 1;
> + plat->page_table[2] = 2;
> + plat->page_table[3] = 3;
> + do {
> + u32 val = counter - 1 + (counter >> 1);
> +
> + plat->page_table[counter++] = val;
> + } while (counter != 512);
> + break;
> + }
> +}
> +
> +static inline u32 efi_crc32(const void *buf, u32 len)
> +{
> + return crc32(0, buf, len);
> +}
> +
> +int rockmtd_init_plat(struct udevice *dev)
> +{
> + static const efi_guid_t partition_basic_data_guid = PARTITION_BASIC_DATA_GUID;
> + struct rockmtd_dev *plat = dev_get_plat(dev);
> + size_t efiname_len, dosname_len;
> + uchar name[] = "loader1";
> + u32 calc_crc32;
> + int k;
> +
> + if (!plat)
> + debug("no plat ptr!\n");
> +
> + gen_rand_uuid_str(plat->uuid_disk_str, UUID_STR_FORMAT_GUID);
> + gen_rand_uuid_str(plat->uuid_part_str, UUID_STR_FORMAT_GUID);
> +
> + debug("uuid_part_str : %s\n", plat->uuid_part_str);
> + debug("uuid_disk_str : %s\n", plat->uuid_disk_str);
> +
> + plat->idb = malloc_cache_aligned(512 * 512);
> +
> + if (!plat->idb) {
> + debug("idb malloc failed\n");
> + return -ENOMEM;
> + }
> +
> + plat->check = malloc_cache_aligned(512 * 512);
> +
> + if (!plat->check) {
> + debug("check malloc failed\n");
> + free(plat->idb);
> + return -ENOMEM;
> + }
> +
> + plat->mbr = malloc(sizeof(legacy_mbr));
> +
> + if (!plat->mbr) {
> + debug("mbr malloc failed\n");
> + free(plat->idb);
> + free(plat->check);
> + return -ENOMEM;
> + }
> +
> + plat->gpt_e = malloc(sizeof(gpt_entry));
> +
> + if (!plat->gpt_e) {
> + debug("gpt_e malloc failed\n");
> + free(plat->idb);
> + free(plat->check);
> + free(plat->mbr);
> + return -ENOMEM;
> + }
> +
> + plat->gpt_h = malloc(sizeof(gpt_header));
> +
> + if (!plat->gpt_h) {
> + debug("gpt_h malloc failed\n");
> + free(plat->idb);
> + free(plat->check);
> + free(plat->mbr);
> + free(plat->gpt_e);
> + return -ENOMEM;
> + }
> +
> + plat->gpt_h2 = malloc(sizeof(gpt_header));
> +
> + if (!plat->gpt_h2) {
> + debug("gpt_h2 malloc failed\n");
> + free(plat->idb);
> + free(plat->check);
> + free(plat->mbr);
> + free(plat->gpt_e);
> + free(plat->gpt_h);
> + return -ENOMEM;
> + }
> +
> + /* Init idb */
> + memset(plat->idb, 0xff, 512 * 512);
> +
> + /* Init mbr */
> + memset((char *)plat->mbr, 0, sizeof(legacy_mbr));
> +
> + plat->mbr->signature = MSDOS_MBR_SIGNATURE;
> + plat->mbr->partition_record[0].sys_ind = EFI_PMBR_OSTYPE_EFI_GPT;
> + plat->mbr->partition_record[0].start_sect = 1;
> + plat->mbr->partition_record[0].nr_sects = LBA - 1;
> +
> + /* Init gpt_e */
> + memset(plat->gpt_e, 0, sizeof(gpt_entry));
> +
> + plat->gpt_e->starting_lba = cpu_to_le64(64);
> + plat->gpt_e->ending_lba = cpu_to_le64(LBA - 34);
> +
> + debug("starting_lba : %llu\n", le64_to_cpu(plat->gpt_e->starting_lba));
> + debug("ending_lba : %llu\n", le64_to_cpu(plat->gpt_e->ending_lba));
> +
> + memcpy(plat->gpt_e->partition_type_guid.b, &partition_basic_data_guid, 16);
> +
> + uuid_str_to_bin(plat->uuid_part_str, plat->gpt_e->unique_partition_guid.b,
> + UUID_STR_FORMAT_GUID);
> +
> + efiname_len = sizeof(plat->gpt_e->partition_name) / sizeof(efi_char16_t);
> + dosname_len = sizeof(name);
> +
> + for (k = 0; k < min(dosname_len, efiname_len); k++)
> + plat->gpt_e->partition_name[k] = (efi_char16_t)(name[k]);
> +
> + /* Init gpt_h */
> + memset(plat->gpt_h, 0, sizeof(gpt_header));
> +
> + plat->gpt_h->signature = cpu_to_le64(GPT_HEADER_SIGNATURE_UBOOT);
> + plat->gpt_h->revision = cpu_to_le32(GPT_HEADER_REVISION_V1);
> + plat->gpt_h->header_size = cpu_to_le32(sizeof(gpt_header));
> + plat->gpt_h->first_usable_lba = cpu_to_le64(64);
> + plat->gpt_h->last_usable_lba = cpu_to_le64(LBA - 34);
> + plat->gpt_h->num_partition_entries = cpu_to_le32(1);
> + plat->gpt_h->sizeof_partition_entry = cpu_to_le32(sizeof(gpt_entry));
> +
> + uuid_str_to_bin(plat->uuid_disk_str, plat->gpt_h->disk_guid.b,
> + UUID_STR_FORMAT_GUID);
> +
> + plat->gpt_h->partition_entry_array_crc32 = 0;
> + calc_crc32 = efi_crc32((const unsigned char *)plat->gpt_e,
> + le32_to_cpu(plat->gpt_h->num_partition_entries) *
> + le32_to_cpu(plat->gpt_h->sizeof_partition_entry));
> + plat->gpt_h->partition_entry_array_crc32 = cpu_to_le32(calc_crc32);
> +
> + debug("partition crc32 : 0x%08x\n", calc_crc32);
> +
> + plat->gpt_h->my_lba = cpu_to_le64(1);
> + plat->gpt_h->partition_entry_lba = cpu_to_le64(2);
> + plat->gpt_h->alternate_lba = cpu_to_le64(LBA - 1);
> +
> + plat->gpt_h->header_crc32 = 0;
> + calc_crc32 = efi_crc32((const unsigned char *)plat->gpt_h,
> + le32_to_cpu(plat->gpt_h->header_size));
> + plat->gpt_h->header_crc32 = cpu_to_le32(calc_crc32);
> +
> + debug("header h1 crc32 : 0x%08x\n", calc_crc32);
> +
> + /* Init gpt_h2 */
> + memcpy(plat->gpt_h2, plat->gpt_h, sizeof(gpt_header));
> +
> + plat->gpt_h2->my_lba = cpu_to_le64(LBA - 1);
> + plat->gpt_h2->partition_entry_lba =
> + cpu_to_le64(le64_to_cpu(plat->gpt_h2->last_usable_lba) + 1);
> + plat->gpt_h2->alternate_lba = cpu_to_le64(1);
> +
> + plat->gpt_h2->header_crc32 = 0;
> + calc_crc32 = efi_crc32((const unsigned char *)plat->gpt_h2,
> + le32_to_cpu(plat->gpt_h2->header_size));
> + plat->gpt_h2->header_crc32 = cpu_to_le32(calc_crc32);
> +
> + debug("header h2 crc32 : 0x%08x\n", calc_crc32);
> +
> + part_init(plat->desc);
> +
> + return 0;
> +}
> +
> +static int rockmtd_sb_bind(struct udevice *dev)
> +{
> + struct rockmtd_dev *plat = dev_get_plat(dev);
> + struct udevice *bdev;
> + struct blk_desc *desc;
> + int ret;
> +
> + ret = blk_create_devicef(dev, "rockmtd_blk", "blk", UCLASS_RKMTD,
> + -1, 512, 0, &bdev);
> + if (ret)
> + return log_msg_ret("blk", ret);
> +
> + desc = dev_get_uclass_plat(bdev);
> + desc->lba = LBA;
> + sprintf(desc->vendor, "0x%.4x", 0x2207);
> + memcpy(desc->product, "ROCKMTD", sizeof("ROCKMTD"));
> + memcpy(desc->revision, "V1.00", sizeof("V1.00"));
> + plat->desc = desc;
> +
> + return 0;
> +}
> +
> +static inline struct rk_nfc_nand_chip *rk_nfc_to_rknand(struct nand_chip *chip)
> +{
> + return container_of(chip, struct rk_nfc_nand_chip, chip);
> +}
> +
> +static int rockmtd_sb_attach_mtd(struct udevice *dev)
> +{
> + struct rockmtd_dev *plat = dev_get_plat(dev);
> + struct rk_nfc_nand_chip *rknand;
> + struct nand_chip *chip;
> + struct mtd_info *mtd;
> + struct udevice *blk;
> + int ret;
> + u8 id[6];
> + int i, j;
> +
> + /* Sanity check that rockmtd_sb_bind() has been used */
> + ret = blk_find_from_parent(dev, &blk);
> + if (ret)
> + return ret;
> +
> + mtd = get_nand_dev_by_index(0);
> + if (!mtd)
> + return -ENOSYS;
> +
> + chip = mtd_to_nand(mtd);
> + rknand = rk_nfc_to_rknand(chip);
> + plat->boot_blks = rknand->boot_blks;
> + plat->mtd = mtd;
> +
> + if (chip->select_chip)
> + chip->select_chip(mtd, 0);
> +
> + nand_readid_op(chip, 0, id, 6);
> +
> + if (chip->select_chip)
> + chip->select_chip(mtd, -1);
> +
> + for (i = 0; i < ARRAY_SIZE(nand_para_tbl); i++) {
> + plat->info = (struct nand_para_info *)&nand_para_tbl[i];
> + for (j = 0; j < plat->info->id_bytes; j++) {
> + if (plat->info->nand_id[j] != id[j])
> + break;
> + if (j == plat->info->id_bytes - 1)
> + goto valid;
> + }
> + }
> +
> + debug("no nand_para_info found\n");
> + return -ENODEV;
> +valid:
> + debug("FLASH ID :");
> +
> + for (j = 0; j < plat->info->id_bytes; j++)
> + debug(" %x", id[j]);
> +
> + debug("\n");
> +
> + rockmtd_build_page_table(plat, plat->info->lsb_mode);
> +
> + plat->datbuf = malloc(mtd->writesize);
> + if (!plat->datbuf) {
> + debug("No memory for page buffer\n");
> + return -ENOMEM;
> + }
> +
> + plat->oobbuf = malloc(mtd->oobsize);
> + if (!plat->oobbuf) {
> + debug("No memory for page buffer\n");
> + free(plat->datbuf);
> + return -ENOMEM;
> + }
> +
> + debug("erasesize %8d\n", mtd->erasesize);
> + debug("writesize %8d\n", mtd->writesize);
> + debug("oobsize %8d\n", mtd->oobsize);
> + debug("boot_blks %8d\n", rknand->boot_blks);
> + debug("lsb_mode %8d\n", plat->info->lsb_mode);
> +
> + ret = rockmtd_init_plat(dev);
> + if (ret) {
> + debug("rockmtd_init_plat failed\n");
> + free(plat->datbuf);
> + free(plat->oobbuf);
> + return -ENOENT;
> + }
> +
> + rockmtd_scan_block(plat);
> +
> + memset(plat->idb, 0xff, 512 * 512);
> +
> + if (plat->blk_counter)
> + rockmtd_read_block(plat, 0, plat->idb);
> +
> + return 0;
> +}
> +
> +int rockmtd_sb_detach_mtd(struct udevice *dev)
> +{
> + struct rockmtd_dev *plat = dev_get_plat(dev);
> + int ret;
> +
> + free(plat->idb);
> + free(plat->check);
> + free(plat->mbr);
> + free(plat->gpt_e);
> + free(plat->gpt_h);
> + free(plat->gpt_h2);
> + free(plat->datbuf);
> + free(plat->oobbuf);
> +
> + ret = device_remove(dev, DM_REMOVE_NORMAL);
> + if (ret)
> + return log_msg_ret("rem", ret);
> +
> + ret = device_chld_unbind(dev, NULL);
> + if (ret)
> + return log_msg_ret("unb", ret);
> +
> + return 0;
> +}
> +
> +struct rockmtd_ops {
> + int (*attach_mtd)(struct udevice *dev);
> + int (*detach_mtd)(struct udevice *dev);
> +};
> +
> +#define rockmtd_get_ops(dev) ((struct rockmtd_ops *)(dev)->driver->ops)
> +
> +struct rockmtd_ops rockmtd_sb_ops = {
> + .attach_mtd = rockmtd_sb_attach_mtd,
> + .detach_mtd = rockmtd_sb_detach_mtd,
> +};
> +
> +U_BOOT_DRIVER(rockmtd_drv) = {
> + .name = "rockmtd_drv",
> + .id = UCLASS_RKMTD,
> + .ops = &rockmtd_sb_ops,
> + .bind = rockmtd_sb_bind,
> + .plat_auto = sizeof(struct rockmtd_dev),
> +};
> +
> +struct rockmtd_priv {
> + struct udevice *cur_dev;
> +};
> +
> +struct udevice *rockmtd_get_cur_dev(void)
> +{
> + struct uclass *uc = uclass_find(UCLASS_RKMTD);
> +
> + if (uc) {
> + struct rockmtd_priv *priv = uclass_get_priv(uc);
> +
> + return priv->cur_dev;
> + }
> +
> + return NULL;
> +}
> +
> +void rockmtd_set_cur_dev(struct udevice *dev)
> +{
> + struct uclass *uc = uclass_find(UCLASS_RKMTD);
> +
> + if (uc) {
> + struct rockmtd_priv *priv = uclass_get_priv(uc);
> +
> + priv->cur_dev = dev;
> + }
> +}
> +
> +struct udevice *rockmtd_find_by_label(const char *label)
> +{
> + struct udevice *dev;
> + struct uclass *uc;
> +
> + uclass_id_foreach_dev(UCLASS_RKMTD, dev, uc) {
> + struct rockmtd_dev *plat = dev_get_plat(dev);
> +
> + if (plat->label && !strcmp(label, plat->label))
> + return dev;
> + }
> +
> + return NULL;
> +}
> +
> +int rockmtd_attach_mtd(struct udevice *dev)
> +{
> + struct rockmtd_ops *ops = rockmtd_get_ops(dev);
> +
> + if (!ops->attach_mtd)
> + return -ENOSYS;
> +
> + return ops->attach_mtd(dev);
> +}
> +
> +int rockmtd_detach_mtd(struct udevice *dev)
> +{
> + struct rockmtd_ops *ops = rockmtd_get_ops(dev);
> +
> + if (!ops->detach_mtd)
> + return -ENOSYS;
> +
> + if (dev == rockmtd_get_cur_dev())
> + rockmtd_set_cur_dev(NULL);
> +
> + return ops->detach_mtd(dev);
> +}
> +
> +int rockmtd_create_device(const char *label, struct udevice **devp)
> +{
> + char dev_name[30], *str, *label_new;
> + struct rockmtd_dev *plat;
> + struct udevice *dev, *blk;
> + int ret;
> +
> + /* unbind any existing device with this label */
> + dev = rockmtd_find_by_label(label);
> + if (dev) {
> + ret = rockmtd_detach_mtd(dev);
> + if (ret)
> + return log_msg_ret("det", ret);
> +
> + ret = device_unbind(dev);
> + if (ret)
> + return log_msg_ret("unb", ret);
> + }
> +
> + snprintf(dev_name, sizeof(dev_name), "rockmtd-%s", label);
> + str = strdup(dev_name);
> + if (!str)
> + return -ENOMEM;
> +
> + label_new = strdup(label);
> + if (!label_new) {
> + ret = -ENOMEM;
> + goto no_label;
> + }
> +
> + ret = device_bind_driver(dm_root(), "rockmtd_drv", str, &dev);
> + if (ret)
> + goto no_dev;
> +
> + device_set_name_alloced(dev);
> +
> + if (!blk_find_from_parent(dev, &blk)) {
> + struct blk_desc *desc = dev_get_uclass_plat(blk);
> +
> + desc->removable = true;
> + }
> +
> + plat = dev_get_plat(dev);
> + plat->label = label_new;
> + *devp = dev;
> +
> + return 0;
> +
> +no_dev:
> + free(label_new);
> +no_label:
> + free(str);
> +
> + return ret;
> +}
> +
> +int rockmtd_create_attach_mtd(const char *label, struct udevice **devp)
> +{
> + struct udevice *dev;
> + int ret;
> +
> + ret = rockmtd_create_device(label, &dev);
> + if (ret)
> + return log_msg_ret("cre", ret);
> +
> + ret = rockmtd_attach_mtd(dev);
> + if (ret) {
> + device_unbind(dev);
> + return log_msg_ret("att", ret);
> + }
> + *devp = dev;
> +
> + return 0;
> +}
> +
> +UCLASS_DRIVER(rockmtd) = {
> + .name = "rockmtd",
> + .id = UCLASS_RKMTD,
> + .post_bind = dm_scan_fdt_dev,
> + .priv_auto = sizeof(struct rockmtd_priv),
> +};
> +
> +static int do_rockmtd_bind(struct cmd_tbl *cmdtp, int flag, int argc,
> + char *const argv[])
> +{
> + struct udevice *dev;
> + const char *label;
> + int ret;
> +
> + argc--;
> + argv++;
> +
> + if (argc < 1)
> + return CMD_RET_USAGE;
> +
> + if (argc > 1)
> + return CMD_RET_USAGE;
> +
> + label = argv[0];
> + ret = rockmtd_create_attach_mtd(label, &dev);
> + if (ret) {
> + printf("Cannot create device / bind mtd\n");
> + return CMD_RET_FAILURE;
> + }
> +
> + return 0;
> +}
> +
> +static struct udevice *parse_rockmtd_label(const char *label)
> +{
> + struct udevice *dev;
> +
> + dev = rockmtd_find_by_label(label);
> + if (!dev) {
> + int devnum;
> + char *ep;
> +
> + devnum = hextoul(label, &ep);
> + if (*ep ||
> + uclass_find_device_by_seq(UCLASS_RKMTD, devnum, &dev)) {
> + printf("No such device '%s'\n", label);
> + return NULL;
> + }
> + }
> +
> + return dev;
> +}
> +
> +static int do_rockmtd_unbind(struct cmd_tbl *cmdtp, int flag, int argc,
> + char *const argv[])
> +{
> + struct udevice *dev;
> + const char *label;
> + int ret;
> +
> + if (argc < 2)
> + return CMD_RET_USAGE;
> +
> + label = argv[1];
> + dev = parse_rockmtd_label(label);
> + if (!dev)
> + return CMD_RET_FAILURE;
> +
> + ret = rockmtd_detach_mtd(dev);
> + if (ret) {
> + printf("Cannot detach mtd\n");
> + return CMD_RET_FAILURE;
> + }
> +
> + ret = device_unbind(dev);
> + if (ret) {
> + printf("Cannot unbind device '%s'\n", dev->name);
> + return CMD_RET_FAILURE;
> + }
> +
> + return 0;
> +}
> +
> +static void show_rockmtd_dev(struct udevice *dev)
> +{
> + struct rockmtd_dev *plat = dev_get_plat(dev);
> + struct blk_desc *desc;
> + struct udevice *blk;
> + int ret;
> +
> + printf("%3d ", dev_seq(dev));
> +
> + ret = blk_get_from_parent(dev, &blk);
> + if (ret)
> + return;
> +
> + desc = dev_get_uclass_plat(blk);
> + printf("%12lu %-15s\n", (unsigned long)desc->lba, plat->label);
> +}
> +
> +static int do_rockmtd_info(struct cmd_tbl *cmdtp, int flag, int argc,
> + char *const argv[])
> +{
> + struct udevice *dev;
> +
> + if (argc < 1)
> + return CMD_RET_USAGE;
> +
> + dev = NULL;
> + if (argc >= 2) {
> + dev = parse_rockmtd_label(argv[1]);
> + if (!dev)
> + return CMD_RET_FAILURE;
> + }
> +
> + printf("%3s %12s %-15s\n", "dev", "blocks", "label");
> + if (dev) {
> + show_rockmtd_dev(dev);
> + } else {
> + struct uclass *uc;
> +
> + uclass_id_foreach_dev(UCLASS_RKMTD, dev, uc)
> + show_rockmtd_dev(dev);
> + }
> +
> + return 0;
> +}
> +
> +static int do_rockmtd_dev(struct cmd_tbl *cmdtp, int flag, int argc,
> + char *const argv[])
> +{
> + struct udevice *dev;
> + const char *label;
> +
> + if (argc < 1 || argc > 3)
> + return CMD_RET_USAGE;
> +
> + if (argc == 1) {
> + struct rockmtd_dev *plat;
> +
> + dev = rockmtd_get_cur_dev();
> + if (!dev) {
> + printf("No current rockmtd device\n");
> + return CMD_RET_FAILURE;
> + }
> + plat = dev_get_plat(dev);
> + printf("Current rockmtd device: %d: %s\n", dev_seq(dev),
> + plat->label);
> + return 0;
> + }
> +
> + label = argv[1];
> + dev = parse_rockmtd_label(argv[1]);
> + if (!dev)
> + return CMD_RET_FAILURE;
> +
> + rockmtd_set_cur_dev(dev);
> +
> + return 0;
> +}
> +
> +static struct cmd_tbl cmd_rockmtd_sub[] = {
> + U_BOOT_CMD_MKENT(bind, 4, 0, do_rockmtd_bind, "", ""),
> + U_BOOT_CMD_MKENT(unbind, 4, 0, do_rockmtd_unbind, "", ""),
> + U_BOOT_CMD_MKENT(info, 3, 0, do_rockmtd_info, "", ""),
> + U_BOOT_CMD_MKENT(dev, 0, 1, do_rockmtd_dev, "", ""),
> +};
> +
> +static int do_rockmtd(struct cmd_tbl *cmdtp, int flag, int argc,
> + char *const argv[])
> +{
> + struct cmd_tbl *c;
> +
> + argc--;
> + argv++;
> +
> + c = find_cmd_tbl(argv[0], cmd_rockmtd_sub, ARRAY_SIZE(cmd_rockmtd_sub));
> +
> + if (c)
> + return c->cmd(cmdtp, flag, argc, argv);
> + else
> + return CMD_RET_USAGE;
> +}
> +
> +U_BOOT_CMD(
> + rockmtd, 8, 1, do_rockmtd,
> + "Rockchip MTD sub-system",
> + "bind <label> - bind ROCKMTD device\n"
> + "rockmtd unbind <label> - unbind ROCKMTD device\n"
> + "rockmtd info [<label>] - show all available ROCKMTD devices\n"
> + "rockmtd dev [<label>] - show or set current ROCKMTD device\n"
> +);
> --
> 2.30.2
>
More information about the U-Boot
mailing list