BPI/BPI-CM9-Linux
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
main
BPI-CM9-Linux/aml-comp/uboot/bl33/v2025/drivers/amlogic/amfc/amfc.c
T
Qubot 818cb714e3 Import complete source tree
2026-08-24 10:03:24 +08:00

2296 lines
77 KiB
C
Raw Permalink Blame History

// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
* Copyright (c) 2019 Amlogic, Inc. All rights reserved.
*/
#include <asm/types.h>
#include <cpu_func.h>
#include <asm/io.h>
#include <stdio.h>
#include <malloc.h>
#include <amlogic/amfc.h>
#include <command.h>
#include <asm/amlogic/arch/timer.h>
#include <amlogic/cpu_id.h>
#include <asm/amlogic/arch/register.h>
#include <linux/errno.h>
#include <vsprintf.h>
#include <rand.h>
#define CONFIG_AMFC_TEST 0
#define TABLE_SRC 0
#define TABLE_DST 1
#if CONFIG_AMFC_TEST
#include <linux/zstd.h>
#include <abuf.h>
static unsigned long total_sw_compressed_size;
static unsigned long total_hw_compressed_size;
static unsigned long total_hw_compress_time;
static unsigned long total_hw_decompress_time;
static unsigned long total_hw_self_decompress_time;
bool self;
int table_test_mask;
static struct amfc_cmd_list test_acl1 __attribute__((aligned(64)));
static struct amfc_cmd_list test_acl2 __attribute__((aligned(64)));
#endif
#define HW_VERSION_10 0x100
#define HW_VERSION_11 0x101
#define HW_VERSION_12 0x102
static unsigned int hw_version;
int amfc_init(void)
{
unsigned int value;
cpu_id_t cpu_id = get_cpu_id();
switch (cpu_id.family_id) {
case MESON_CPU_MAJOR_ID_S7D:
if (cpu_id.chip_rev == 0x0A) { // 500MHz
writel(0 | (1 << 6) | (5 << 7), CLKCTRL_AMFC_CLK_CTRL);
break;
}
case MESON_CPU_MAJOR_ID_S6:
// 666MHz
writel(0 | (1 << 6) | (4 << 7), CLKCTRL_AMFC_CLK_CTRL);
break;
case MESON_CPU_MAJOR_ID_T6D:
case MESON_CPU_MAJOR_ID_T6W:
case MESON_CPU_MAJOR_ID_T6X:
// 666MHz
writel(0 | (1 << 8) | (1 << 9), CLKCTRL_AMFC_CLK_CTRL);
break;
case MESON_CPU_MAJOR_ID_A9:
case MESON_CPU_MAJOR_ID_C5:
// 666MHz
writel(0 | (1 << 8) | (4 << 9), CLKCTRL_AMFC_CLK_CTRL);
break;
default:
printf("unsupported CPU id:%x\n", cpu_id.family_id);
return -1;
}
hw_version = readl(AMFC_GL_VERSION);
printf("AMFC VLSI version:%x, feature:%x\n",
readl(AMFC_GL_VERSION), readl(AMFC_GL_CMD1_FEATURE));
writel(0, AMFC_GL_CMD0_CONTROL);
writel(0, AMFC_GL_CMD1_CONTROL);
writel(3, AMFC_GL_CMD0_IRQCLR);
writel(3, AMFC_GL_CMD1_IRQCLR);
writel(0, AMFC_GL_MISC); // cmd0/1 mixed mode
writel((2 << 6) | (2 << 4) | (1 << 1) | (1), AMFC_CODEC_CTRL);
writel(1, AMFC_ZSTD_MODE_MISC);
value = readl(AMFC_WR_MIF_CTRL);
value &= ~(0x7 << 8);
value |= (2 << 8);
writel(value, AMFC_WR_MIF_CTRL);
value = readl(AMFC_RD_MIF_CTRL);
value &= ~(0x7 << 8);
value |= (2 << 8);
writel(value, AMFC_RD_MIF_CTRL);
return 0;
}
static struct amfc_cmd_list acl __attribute__((aligned(64)));
static int page_table_mode = 0;
static int log_en = 0;
static void dump_addr(void *buf, unsigned int size)
{
int i;
unsigned int *p = (unsigned int *)buf;
printf("%s addr:%px, size:%d\n", __func__, buf, size);
for (i = 0; i < size / 4; i += 4) {
printf("%px: %08x %08x %08x %08x\n",
p + i, p[i], p[i + 1], p[i + 2], p[i + 3]);
}
}
static int build_tables(unsigned int *table, unsigned long base, ssize_t size, int type)
{
int i, count, need_reverse = 0;
unsigned long tmp, end = base + size - 1;
if (!table || size < PAGE_SIZE)
return -1;
if ((base & ~PAGE_MASK) && hw_version < HW_VERSION_11) {
printf("%s, base:%lx not align to %d\n",
__func__, base, PAGE_SIZE);
return -1;
}
/* physical contiguous in uboot */
count = (end >> PAGE_SHIFT) - (base >> PAGE_SHIFT) + 1;
/*
* type and page_table_mode for test
* page_table_mode = 1 --> src/dst all sequence table
* page_table_mode = 2 --> src sequence/dst reverse
* page_table_mode = 3 --> src reverse/dst sequence
* page_table_mode = 4 --> src/dst all reverse table
* page_table_mode = 5 --> dst sequence table/src not use page_table,
* for EROFS test
*/
if ((page_table_mode == 2 && type == TABLE_DST) ||
(page_table_mode == 3 && type == TABLE_SRC) ||
(page_table_mode == 4))
need_reverse = 1;
if (need_reverse)
base += (count - 1) * PAGE_SIZE;
for (i = 0; i < count; i++) {
tmp = ((base >> PAGE_SHIFT) << 6) | 1;
table[i] = tmp;
if (need_reverse)
base -= PAGE_SIZE;
else
base += PAGE_SIZE;
}
flush_dcache_range((unsigned long)table,
(unsigned long)table + count * 4);
return 0;
}
#define ADDR_SRC 0
#define ADDR_DST 1
static void set_up_addr(struct amfc_cmd_list *acl, unsigned long addr, int type)
{
unsigned int low, high = 0;
low = addr & 0xffffffff;
#ifdef CONFIG_64BIT
high = (addr >> 32) & 0xf;
#endif
switch (type) {
case ADDR_SRC:
acl->src_addr = low;
acl->src_addr_h = high;
break;
case ADDR_DST:
acl->dst_addr = low;
acl->dst_addr_h = high;
break;
default:
break;
}
}
/*
* src: source buffer that need decompress
* dst: destination buffer that need store
* src_size: size of source buffer
* dst_size: size for destination buffer, caller should make sure
* dst size is enough
* stream: stream mode support, 0: disable, 1: enable
* return value: decompressed size if success, negative value if failed
*/
int amfc_decompress(void *src, void *dst, ssize_t src_size, ssize_t dst_size, int stream)
{
unsigned int *src_table = NULL, *dst_table = NULL, *tmp;
int table_size;
unsigned int status, off;
int cmd_time;
int timeout = ((src_size + PAGE_SIZE) / PAGE_SIZE) * 100 + 5000;
unsigned long inv_end = (unsigned long)dst + dst_size;
unsigned long secmon_start = readl(SYSCTRL_SEC_STATUS_REG17) + (1 << 20);
int ret;
if (!src || !dst || src_size < 0 || dst_size < 0)
return -1;
if (log_en)
printf("%s, acl:%p, src:%p, dst:%p, src size:%ld, dst size:%ld\n",
__func__, &acl, src, dst, (long)src_size, (long)dst_size);
/* setup command list */
memset(&acl, 0, sizeof(acl));
acl.src_size = src_size;
acl.dst_size = dst_size;
if (page_table_mode && src_size >= PAGE_SIZE) {
table_size = sizeof(int) * (src_size / PAGE_SIZE) +
PAGE_SIZE * 2;
src_table = malloc(table_size);
if (!src_table)
return -ENOMEM;
tmp = (unsigned int *)(((unsigned long)src_table + PAGE_SIZE) & PAGE_MASK);
if (hw_version > HW_VERSION_10) {
off = (unsigned long)src & (~PAGE_MASK);
acl.link_addr |= off << 16;
}
build_tables(tmp, (unsigned long)src, src_size, TABLE_SRC);
set_up_addr(&acl, virt_to_phys(tmp), ADDR_SRC);
acl.src_scatter = 1;
if (log_en)
printf("%s, table_size:%d, src_table:%p, tmp:%p\n",
__func__, table_size, src_table, tmp);
} else {
set_up_addr(&acl, virt_to_phys(src), ADDR_SRC);
}
if (page_table_mode && dst_size >= PAGE_SIZE) {
table_size = sizeof(int) * (dst_size / PAGE_SIZE) +
PAGE_SIZE * 2;
dst_table = malloc(table_size);
if (!dst_table)
return -ENOMEM;
tmp = (unsigned int *)(((unsigned long)dst_table + PAGE_SIZE) & PAGE_MASK);
if (hw_version > HW_VERSION_10) {
off = (unsigned long)dst & (~PAGE_MASK);
acl.link_addr |= off;
}
build_tables(tmp, (unsigned long)dst, dst_size, TABLE_DST);
set_up_addr(&acl, virt_to_phys(tmp), ADDR_DST);
acl.dst_scatter = 1;
if (log_en)
printf("%s, table_size:%d, dst_table:%p, tmp:%p\n",
__func__, table_size, dst_table, tmp);
} else {
set_up_addr(&acl, virt_to_phys(dst), ADDR_DST);
}
acl.stream = stream ? 1 : 0;
acl.algorithm = ALGORITHM_ZSTD;
acl.end = 1;
acl.compress = CMD_DECOMPRESS;
acl.owner = 1;
acl.status = 0xffffffff;
flush_dcache_range((unsigned long)src, (unsigned long)src + src_size);
flush_dcache_range((unsigned long)&acl, (unsigned long)&acl + sizeof(acl));
if (inv_end > secmon_start && (unsigned long)dst < secmon_start)
inv_end = secmon_start;
invalidate_dcache_range((unsigned long)dst, inv_end);
/* sw reset */
writel(0x80000000, AMFC_GL_CMD1_CONTROL);
writel(0x03, AMFC_GL_CMD1_IRQCLR);
writel((unsigned long)&acl >> ADDR_SHIFT, AMFC_GL_CMD1_DESC_BASE0_ADDR);
/* trigger */
writel(1, AMFC_GL_CMD1_CONTROL);
cmd_time = get_time();
/* wait for done or error */
while (1) {
status = readl(AMFC_GL_CMD1_STATUS);
if ((status & AMFC_IRQ_MASK))
break;
if (get_time() - cmd_time > timeout) {
printf("time out\n");
break;
}
}
cmd_time = get_time() - cmd_time;
invalidate_dcache_range((unsigned long)dst, inv_end);
invalidate_dcache_range((unsigned long)&acl, (unsigned long)&acl + sizeof(acl));
status = readl(AMFC_GL_CMD1_STATUS);
if (!(status & AMFC_ERROR_MASK)) {
#if CONFIG_AMFC_TEST
if (self)
total_hw_self_decompress_time += readl(AMFC_CMD1_TIME_MEASURE);
else
total_hw_decompress_time += readl(AMFC_CMD1_TIME_MEASURE);
#endif
writel(0x01, AMFC_GL_CMD1_IRQCLR);
if (log_en)
printf("decompress done:%x %x, size:%d, cycles:%d, time:%d us\n",
acl.status, status, acl.result_size,
readl(AMFC_CMD1_TIME_MEASURE), cmd_time);
if (stream)
ret = acl.result_size & ~(0x80000000);
else
ret = acl.result_size;
if (ret <= 0) {
ret = -EINVAL;
dump_addr((void *)AMFC_GL_VERSION, 300);
dump_addr((void *)&acl, 32);
dump_addr((void *)src, 32);
dump_addr((void *)dst, 32);
dump_addr((void *)(long)acl.src_addr, 32);
dump_addr((void *)(long)acl.dst_addr, 32);
writel(0x03, AMFC_GL_CMD1_IRQCLR);
}
} else {
printf("decompress failed:%x %x, time:%d us, acl:%p, src:%p, dst:%p, src_size:%ld, dst_size:%ld, timeout:%d\n",
acl.status, readl(AMFC_GL_CMD1_STATUS),
readl(AMFC_CMD1_TIME_MEASURE),
&acl, src, dst, (long)src_size, (long)dst_size, timeout);
dump_addr((void *)0xfe024000, 300);
dump_addr((void *)&acl, 32);
dump_addr((void *)src, 32);
dump_addr((void *)dst, 32);
writel(0x03, AMFC_GL_CMD1_IRQCLR);
ret = -EINVAL;
}
if (src_table)
free(src_table);
if (dst_table)
free(dst_table);
return ret;
}
int amfc_compress(void *src, void *dst, ssize_t src_size, ssize_t dst_size)
{
#ifdef CONFIG_AMFC_COMPRESS
unsigned int *src_table = NULL, *dst_table = NULL, *tmp;
int table_size;
unsigned int status, off;
int cmd_time;
int timeout = ((src_size + PAGE_SIZE) / PAGE_SIZE) * 20 + 5000;
int ret;
if (log_en)
printf("%s, acl:%p, src:%p, dst:%p, src sizs:%ld, dst size:%ld\n",
__func__, &acl, src, dst, src_size, dst_size);
/* setup command list */
memset(&acl, 0, sizeof(acl));
acl.src_size = src_size;
acl.dst_size = dst_size;
if (page_table_mode && src_size > PAGE_SIZE) {
table_size = sizeof(int) * (src_size / PAGE_SIZE) +
PAGE_SIZE * 2;
src_table = malloc(table_size);
if (!src_table)
return -ENOMEM;
tmp = (unsigned int *)(((unsigned long)src_table + PAGE_SIZE) & PAGE_MASK);
if (hw_version > HW_VERSION_10) {
off = (unsigned long)src & (~PAGE_MASK);
acl.link_addr |= (off << 16);
}
build_tables(tmp, (unsigned long)src, src_size, TABLE_SRC);
set_up_addr(&acl, virt_to_phys(tmp), ADDR_SRC);
acl.src_scatter = 1;
if (log_en)
printf("%s, table_size:%d, src_table:%p, tmp:%p\n",
__func__, table_size, src_table, tmp);
} else {
set_up_addr(&acl, virt_to_phys(src), ADDR_SRC);
}
if (page_table_mode && dst_size > PAGE_SIZE) {
table_size = sizeof(int) * (dst_size / PAGE_SIZE) +
PAGE_SIZE * 2;
dst_table = malloc(table_size);
if (!dst_table)
return -ENOMEM;
tmp = (unsigned int *)(((unsigned long)dst_table + PAGE_SIZE) & PAGE_MASK);
if (hw_version > HW_VERSION_10) {
off = (unsigned long)dst & (~PAGE_MASK);
acl.link_addr |= off;
}
build_tables(tmp, (unsigned long)dst, dst_size, TABLE_DST);
set_up_addr(&acl, virt_to_phys(tmp), ADDR_DST);
acl.dst_scatter = 1;
#if CONFIG_AMFC_TEST
if (table_test_mask)
tmp[2] = 0;
#endif
if (log_en)
printf("%s, table_size:%d, dst_table:%p, tmp:%p\n",
__func__, table_size, dst_table, tmp);
} else {
set_up_addr(&acl, virt_to_phys(dst), ADDR_DST);
}
acl.algorithm = ALGORITHM_ZSTD;
acl.end = 1;
acl.compress = CMD_COMPRESS;
acl.owner = 1;
acl.status = 0xffffffff;
flush_dcache_range((unsigned long)src, (unsigned long)src + src_size);
flush_dcache_range((unsigned long)&acl, (unsigned long)&acl + sizeof(acl));
invalidate_dcache_range((unsigned long)dst, (unsigned long)dst + dst_size);
/* SW reset */
writel(0x80000000, AMFC_GL_CMD0_CONTROL);
writel(0x03, AMFC_GL_CMD0_IRQCLR);
writel((unsigned long)&acl >> ADDR_SHIFT, AMFC_GL_CMD0_DESC_BASE0_ADDR);
/* trigger */
writel(1, AMFC_GL_CMD0_CONTROL);
cmd_time = get_time();
// wait for done or error
while (1) {
status = readl(AMFC_GL_CMD0_STATUS);
if ((status & AMFC_IRQ_MASK))
break;
if (get_time() - cmd_time > timeout) {
printf("time out\n");
break;
}
}
cmd_time = get_time() - cmd_time;
invalidate_dcache_range((unsigned long)dst, (unsigned long)dst + dst_size);
invalidate_dcache_range((unsigned long)&acl, (unsigned long)&acl + sizeof(acl));
status = readl(AMFC_GL_CMD0_STATUS);
if (!(status & AMFC_ERROR_MASK)) {
#if CONFIG_AMFC_TEST
total_hw_compress_time += readl(AMFC_CMD0_TIME_MEASURE);
#endif
writel(0x01, AMFC_GL_CMD0_IRQCLR);
if (log_en)
printf("compress done:%x %x, size:%d, cycles:%d, time:%d us\n",
acl.status, status, acl.result_size,
readl(AMFC_CMD0_TIME_MEASURE), cmd_time);
ret = acl.result_size;
} else {
printf("compress failed:%x %x, time:%d us, acl:%p, src:%p, dst:%p, src_size:%ld, dst_size:%ld, timeout:%d\n",
acl.status, readl(AMFC_GL_CMD0_STATUS),
readl(AMFC_CMD0_TIME_MEASURE),
&acl, src, dst, src_size, dst_size, timeout);
dump_addr((void *)AMFC_GL_VERSION, 300);
dump_addr((void *)&acl, 32);
dump_addr((void *)src, 32);
dump_addr((void *)dst, 32);
writel(0x03, AMFC_GL_CMD0_IRQCLR);
ret = -EINVAL;
}
return ret;
#else
return -ENODEV;
#endif
}
#if CONFIG_AMFC_TEST
#define EROFS_MAX_SIZE (PAGE_SIZE * 64)
struct pack_file {
char *name;
int type;
unsigned int size;
unsigned int offset;
};
/*
* one raw file and different compressed args files
*/
struct pack_file test_files[] = {
{"compress/521-new-log-2023-08-18_10_53_51.log", 0, 10858121, 0},
{"amfc_4m4k_level1/compress/521-new-log-2023-08-18_10_53_51.log.zsd", 1, 1076412, 10858496},
{"amfc_4m4k_level3/compress/521-new-log-2023-08-18_10_53_51.log.zsd", 1, 1212912, 11935744},
{"amfc_4m4k_level22/compress/521-new-log-2023-08-18_10_53_51.log.zsd", 1, 704301, 13152256},
{"amfc_4m128k_level1/compress/521-new-log-2023-08-18_10_53_51.log.zsd", 1, 926383, 13856768},
{"amfc_4m128k_level3/compress/521-new-log-2023-08-18_10_53_51.log.zsd", 1, 1057632, 14786560},
{"amfc_4m128k_level22/compress/521-new-log-2023-08-18_10_53_51.log.zsd", 1, 610781, 15847424},
{"compress/android_r_anon.bin", 0, 16777216, 16461824},
{"amfc_4m4k_level1/compress/android_r_anon.bin.zsd", 1, 4557912, 33243136},
{"amfc_4m4k_level3/compress/android_r_anon.bin.zsd", 1, 4353752, 37801984},
{"amfc_4m4k_level22/compress/android_r_anon.bin.zsd", 1, 3796876, 42156032},
{"amfc_4m128k_level1/compress/android_r_anon.bin.zsd", 1, 4800941, 45953024},
{"amfc_4m128k_level3/compress/android_r_anon.bin.zsd", 1, 4510906, 50757632},
{"amfc_4m128k_level22/compress/android_r_anon.bin.zsd", 1, 3784060, 55271424},
{"compress/DroidLogicTvInput.apk", 0, 10823186, 59056128},
{"amfc_4m4k_level1/compress/DroidLogicTvInput.apk.zsd", 1, 5880370, 69881856},
{"amfc_4m4k_level3/compress/DroidLogicTvInput.apk.zsd", 1, 5659473, 75763712},
{"amfc_4m4k_level22/compress/DroidLogicTvInput.apk.zsd", 1, 5260621, 81424384},
{"amfc_4m128k_level1/compress/DroidLogicTvInput.apk.zsd", 1, 5932553, 86687744},
{"amfc_4m128k_level3/compress/DroidLogicTvInput.apk.zsd", 1, 5698327, 92622848},
{"amfc_4m128k_level22/compress/DroidLogicTvInput.apk.zsd", 1, 5145713, 98324480},
{"compress/droidlogic-tv.jar", 0, 477934, 103473152},
{"amfc_4m4k_level1/compress/droidlogic-tv.jar.zsd", 1, 194111, 103952384},
{"amfc_4m4k_level3/compress/droidlogic-tv.jar.zsd", 1, 184103, 104148992},
{"amfc_4m4k_level22/compress/droidlogic-tv.jar.zsd", 1, 158674, 104333312},
{"amfc_4m128k_level1/compress/droidlogic-tv.jar.zsd", 1, 202254, 104493056},
{"amfc_4m128k_level3/compress/droidlogic-tv.jar.zsd", 1, 189089, 104697856},
{"amfc_4m128k_level22/compress/droidlogic-tv.jar.zsd", 1, 155530, 104890368},
{"compress/framework-res.apk", 0, 49495950, 105046016},
{"amfc_4m4k_level1/compress/framework-res.apk.zsd", 1, 16369915, 154542080},
{"amfc_4m4k_level3/compress/framework-res.apk.zsd", 1, 16087772, 170913792},
{"amfc_4m4k_level22/compress/framework-res.apk.zsd", 1, 15306909, 187002880},
{"amfc_4m128k_level1/compress/framework-res.apk.zsd", 1, 16283236, 202313728},
{"amfc_4m128k_level3/compress/framework-res.apk.zsd", 1, 15961873, 218599424},
{"amfc_4m128k_level22/compress/framework-res.apk.zsd", 1, 15155446, 234561536},
{"compress/Image_1", 0, 22347776, 249720832},
{"amfc_4m4k_level1/compress/Image_1.zsd", 1, 10684238, 272072704},
{"amfc_4m4k_level3/compress/Image_1.zsd", 1, 9889053, 282759168},
{"amfc_4m4k_level22/compress/Image_1.zsd", 1, 8067883, 292651008},
{"amfc_4m128k_level1/compress/Image_1.zsd", 1, 10509407, 300720128},
{"amfc_4m128k_level3/compress/Image_1.zsd", 1, 9685857, 311230464},
{"amfc_4m128k_level22/compress/Image_1.zsd", 1, 7817946, 320917504},
{"compress/NotoColorEmoji.ttf", 0, 2961984, 328736768},
{"amfc_4m4k_level1/compress/NotoColorEmoji.ttf.zsd", 1, 1794329, 331702272},
{"amfc_4m4k_level3/compress/NotoColorEmoji.ttf.zsd", 1, 1721225, 333500416},
{"amfc_4m4k_level22/compress/NotoColorEmoji.ttf.zsd", 1, 1542996, 335224832},
{"amfc_4m128k_level1/compress/NotoColorEmoji.ttf.zsd", 1, 1811509, 336769024},
{"amfc_4m128k_level3/compress/NotoColorEmoji.ttf.zsd", 1, 1723016, 338583552},
{"amfc_4m128k_level22/compress/NotoColorEmoji.ttf.zsd", 1, 1498439, 340307968},
{"compress/uImage", 0, 11194624, 341807104},
{"amfc_4m4k_level1/compress/uImage.zsd", 1, 11166211, 353005568},
{"amfc_4m4k_level3/compress/uImage.zsd", 1, 11163633, 364175360},
{"amfc_4m4k_level22/compress/uImage.zsd", 1, 11156644, 375341056},
{"amfc_4m128k_level1/compress/uImage.zsd", 1, 11170371, 386498560},
{"amfc_4m128k_level3/compress/uImage.zsd", 1, 11167452, 397672448},
{"amfc_4m128k_level22/compress/uImage.zsd", 1, 11149718, 408842240},
{"compress/zero.bin", 0, 2097152, 419995648},
{"amfc_4m4k_level1/compress/zero.bin.zsd", 1, 2070, 422096896},
{"amfc_4m4k_level3/compress/zero.bin.zsd", 1, 2069, 422100992},
{"amfc_4m4k_level22/compress/zero.bin.zsd", 1, 2068, 422105088},
{"amfc_4m128k_level1/compress/zero.bin.zsd", 1, 87, 422109184},
{"amfc_4m128k_level3/compress/zero.bin.zsd", 1, 86, 422113280},
{"amfc_4m128k_level22/compress/zero.bin.zsd", 1, 85, 422117376},
{}
};
/*
* pack file test for performance and data consistent.
* test file and above array are generated by scripts
* You need preload packed test file to a ddr address and then
* use command like:
*
* s7_pxp# amfc pack_test 12000000 30000000 34000000
*
* dst address must not overlap with base + file_size
* dst2 address must not overlap with dst 1
*/
static void amfc_pack_test(unsigned long base, void *dst, void *dst2)
{
int i, ret;
struct pack_file *pack;
void *src, *cur_src_addr = NULL;
int cur_src_size = 0;
for (i = 0; i < ARRAY_SIZE(test_files); i++) {
pack = &test_files[i];
if (!pack->name)
break;
src = (void *)(base + pack->offset);
if (!pack->type) {
/*
* check hw compress and hw decompress
*/
printf("-----------------------------\n");
printf("compress %s\n", pack->name);
ret = amfc_compress(src, dst, pack->size, pack->size);
cur_src_size = pack->size;
cur_src_addr = src;
if (ret > 0) {
printf("decompress %s\n", pack->name);
ret = amfc_decompress(dst, dst2, ret, pack->size, 0);
ret = memcmp(dst2, src, pack->size);
printf("compare %p -> %p with %d %s\n\n",
dst2, cur_src_addr, cur_src_size,
ret ? "FAIL!!" : "OK!!");
} else {
printf("compress failed\n");
}
} else {
/*
* check sw compressed and hw decompress
*/
printf("decompress %s\n", pack->name);
ret = amfc_decompress(src, dst, pack->size, cur_src_size, 0);
ret = memcmp(dst, cur_src_addr, cur_src_size);
printf("compare %p -> %p with %d %s\n\n",
dst, cur_src_addr, cur_src_size,
ret ? "FAIL!!" : "OK!!");
}
if (tstc()) {
printf("key abort\n");
(void)getchar();
break;
}
}
}
static unsigned char test_page[EROFS_MAX_SIZE * 2] __attribute__((aligned(4096)));
static int get_sw_compressed_size(void *src)
{
int i = 0;
unsigned char *p;
p = (unsigned char *)src + PAGE_SIZE - 1;
while (*p == 0) {
i++;
p--;
}
return i > PAGE_SIZE ? 0 : PAGE_SIZE - i;
}
static void *contain_zstd_page(void *src, int cluster)
{
unsigned char *p = (unsigned char *)src;
int i = 0;
/* skip leading zero */
while ((i < cluster) && (p[i] == 0)) {
i++;
}
if (i >= cluster)
return NULL;
p += i;
if (p[0] == 0x28 && p[1] == 0xb5 && p[2] == 0x2f && p[3] == 0xfd) {
return p;
} else
return NULL;
}
static int memcmp1(void *p1, void *p2, int size)
{
unsigned int *i1, *i2;
int i;
int ret = 0;
i1 = (unsigned int *)p1;
i2 = (unsigned int *)p2;
for (i = 0; i < size / 4; i++) {
if (i1[i] != i2[i]) {
printf("i:%d, addr:%p->%p, value:%x->%x\n",
i, i1, i2, i1[i], i2[i]);
ret = 1;
}
}
return ret;
}
/*
* data is captured from Android system by
* https://scgit.amlogic.com/#/c/329847/
* pattern: a raw page + a zstd compressed page interleave
*
* before test, you should change a captured data to hex and pre-load it
* to DDR via load_mem.tcl in PXP
*/
static void amfc_zram_test(void *src, unsigned long size, int cmp)
{
unsigned long i;
unsigned char *p, *z;
int sw_csize, hw_csize;
int no_compress = 0;
int sw_decompress = 0;
int hw_compress = 0;
int hw_decompress = 0;
int sd_error = 0;
total_sw_compressed_size = 0;
total_hw_compressed_size = 0;
total_hw_compress_time = 0;
total_hw_decompress_time = 0;
total_hw_self_decompress_time = 0;
for (i = 0; i < size; i += PAGE_SIZE) {
p = (unsigned char *)(src + i);
if (self) { // sw compressed page
self = 0;
z = contain_zstd_page(p, PAGE_SIZE);
if (z) {
sw_csize = PAGE_SIZE - (z - p);
total_sw_compressed_size += sw_csize;
amfc_decompress(z, test_page, sw_csize, PAGE_SIZE, 0);
sw_decompress++;
if (cmp && memcmp(test_page, (void *)((unsigned long)p - PAGE_SIZE), PAGE_SIZE)) {
printf("hw decompress address :%p not match\n", p);
}
}
} else { // src page
self = 1;
memset(test_page, 0, sizeof(test_page));
hw_csize = amfc_compress(p, test_page, PAGE_SIZE, PAGE_SIZE);
hw_compress++;
if (hw_csize > 0) {
total_hw_compressed_size += hw_csize;
amfc_decompress(test_page, test_page + PAGE_SIZE, hw_csize, PAGE_SIZE, 0);
hw_decompress++;
if (cmp && memcmp1(test_page + PAGE_SIZE, (void *)p, PAGE_SIZE)) {
char cmd[128] = {0};
printf("hw self-decompress address :%p, size:%d not match\n", p, hw_csize);
sprintf(cmd, "md %lx %x\n", (unsigned long)test_page, hw_csize / 4 + 10);
run_command(cmd, 0);
sd_error++;
}
} else {
no_compress++;
printf("hw compress address :%p failed\n", p);
}
}
if (!(i & 0x3f000)) {
printf("ADDR:%lx, sw_csize:%8ld, hw_csize:%8ld, hw_ctime:%8ld us, hw_dtime:%8ld, hw_sdtime:%8ld, no_comp:%4d, sw_dec_page:%5d, hw_dec_page:%5d, hw_com_page:%5d, sd_error:%d\n",
(unsigned long)p, total_sw_compressed_size,
total_hw_compressed_size,
total_hw_compress_time, total_hw_decompress_time,
total_hw_self_decompress_time, no_compress,
sw_decompress, hw_decompress, hw_compress, sd_error);
}
if (tstc()) {
printf("key abort\n");
(void)getchar();
break;
}
}
printf("ADDR:%lx, sw_csize:%8ld, hw_csize:%8ld, hw_ctime:%8ld us, hw_dtime:%8ld, hw_sdtime:%8ld, no_comp:%4d, sw_dec_page:%5d, hw_dec_page:%5d, hw_com_page:%5d, sd_error:%d\n",
(unsigned long)p, total_sw_compressed_size, total_hw_compressed_size,
total_hw_compress_time, total_hw_decompress_time,
total_hw_self_decompress_time,
no_compress, sw_decompress, hw_decompress, hw_compress, sd_error);
}
static void *get_zstd_addr(void *src, int cluster, int *c_size)
{
unsigned char *p = (unsigned char *)src;
int i = 0;
unsigned long addr, remain;
/* skip leading zero */
while ((i < cluster) && (p[i] == 0)) {
i++;
}
if (i >= cluster)
return NULL;
p += i;
if (p[0] == 0x28 && p[1] == 0xb5 && p[2] == 0x2f && p[3] == 0xfd) {
if (cluster > PAGE_SIZE) {
/* search next zstd page in this cluster to detect real size */
remain = cluster - i;
remain &= PAGE_MASK;
addr = ((unsigned long)p + PAGE_SIZE) & PAGE_MASK;
while (remain) {
if (contain_zstd_page((void *)addr, PAGE_SIZE)) {
//printf("have zstd page addr:%lx, p:%p, i:%d, remain:%ld, cluster:%d\n",
// addr, p, i, remain, cluster);
break;
}
addr += PAGE_SIZE;
remain -= PAGE_SIZE;
}
*c_size = addr - (unsigned long)p;
//printf("addr:%lx, p:%p, i:%d, remain:%ld, cluster:%d, real size:%d\n",
// addr, p, i, remain, cluster, *c_size);
} else
*c_size = cluster - i;
return p;
} else
return NULL;
}
/*
* Refer https://confluence.amlogic.com/display/SW/EROFS+with+ZSTD+and+performance+compare to
* build a ZSTD supported erofs image
*
* before test, you should change a erofs image to hex and pre-load it
* to DDR via load_mem.tcl in PXP
*/
static void amfc_erofs_test(void *src, unsigned long size, int pcluster, int verify)
{
unsigned long i, total_decompress, total_sw_csize;
unsigned char *p;
int hw_decompress = 0, ret, c_size;
struct abuf in, out;
int decompress_fail = 0;
int match_fail = 0;
total_decompress = 0;
total_sw_csize = 0;
total_hw_decompress_time = 0;
self = 0;
for (i = 0; i < size; i += PAGE_SIZE) {
p = get_zstd_addr(src + i, pcluster, &c_size);
//if (c_size < 64) {
// // HW BUG:
// //1, source address must align to 64 bytes, if src size is tool small, decode will hung
// //2, if size set to 4k but too many leading zero, decode will hung
// //3, for erofs test, page table mode must closed.
// printf("skip size too small:%lx, c_size:%d\n", (unsigned long)src + i, c_size);
// continue;
//}
if (p) { // zstd compressed page
hw_decompress = amfc_decompress(p, test_page, c_size, EROFS_MAX_SIZE, 0);
if (hw_decompress) {
/* sw_decompress and double check */
total_decompress += hw_decompress;
total_sw_csize += c_size;
if (verify) {
abuf_init_set(&in, p, c_size);
abuf_init_set(&out, test_page + EROFS_MAX_SIZE,
EROFS_MAX_SIZE);
ret = zstd_decompress(&in, &out);
if (ret >= 0 && ret == hw_decompress) {
if (memcmp(test_page, test_page + EROFS_MAX_SIZE, ret)) {
match_fail++;
printf("hw decompress %p %d->%d not match\n", p, c_size, ret);
}
} else {
printf("sw decompress %p %d %d <-> %d failed\n",
p, c_size, hw_decompress, ret);
}
}
} else {
decompress_fail++;
}
}
if (!(i & 0x3f000)) {
printf("ADDR:%lx, hw_decompressed:%8ld, time:%8ld, dec failed:%4d, match failed:%4d, sw_csize:%ld\n",
(unsigned long)src + i, total_decompress,
total_hw_decompress_time,
decompress_fail, match_fail, total_sw_csize);
}
if (tstc()) {
printf("key abort\n");
(void)getchar();
break;
}
}
printf("ADDR:%lx, hw_decompressed:%8ld, time:%8ld, dec failed:%4d, match failed:%4d, sw_csize:%ld\n",
(unsigned long)src + i, total_decompress,
total_hw_decompress_time,
decompress_fail, match_fail, total_sw_csize);
}
static void show_acl(struct amfc_cmd_list *p_acl, int count)
{
int i;
for (i = 0; i < count; i++) {
printf("%p: %08x %08x %08x %08x %08x %08x %08x %08x\n",
p_acl + i, p_acl[i].src_addr, p_acl[i].dst_addr,
p_acl[i].link_addr, p_acl[i].src_size,
p_acl[i].dst_size, p_acl[i].control,
p_acl[i].status, p_acl[i].result_size);
}
}
static void run_table_test(struct amfc_cmd_list *p_acl, void *src,
void *dst, void *dst2, long size)
{
unsigned int status;
int count;
count = ALIGN(size, PAGE_SIZE) / PAGE_SIZE;
flush_dcache_range((unsigned long)src, (unsigned long)src + size);
flush_dcache_range((unsigned long)dst, (unsigned long)dst + size);
flush_dcache_range((unsigned long)dst2, (unsigned long)dst2 + size);
flush_dcache_range((unsigned long)p_acl, (unsigned long)p_acl + (count + 3) * sizeof(acl));
/* SW reset */
writel(0x80000000, AMFC_GL_CMD0_CONTROL);
writel(0x03, AMFC_GL_CMD0_IRQCLR);
writel((unsigned long)p_acl >> ADDR_SHIFT, AMFC_GL_CMD0_DESC_BASE0_ADDR);
/* trigger */
writel(1, AMFC_GL_CMD0_CONTROL);
// wait for done or error
while (1) {
status = readl(AMFC_GL_CMD0_STATUS);
if ((status & AMFC_IRQ_MASK))
break;
if (tstc()) {
printf("key abort\n");
(void)getchar();
break;
}
}
status = readl(AMFC_GL_CMD0_STATUS);
if (!(status & AMFC_ERROR_MASK)) {
writel(0x01, AMFC_GL_CMD0_IRQCLR);
} else {
writel(0x03, AMFC_GL_CMD0_IRQCLR);
printf("test failed:%x %x\n",
p_acl[0].status, readl(AMFC_GL_CMD0_STATUS));
}
}
/*
* before test, you should change a simple text file(size > 16KB) to hex and pre-load it
* to DDR via load_mem.tcl in PXP
*/
static void amfc_table_test(void *src, void *dst, void *dst2, unsigned long size)
{
struct amfc_cmd_list *p_acl, *p_raw;
int count, i;
count = ALIGN(size, PAGE_SIZE) / PAGE_SIZE;
p_acl = malloc((count + 3) * sizeof(acl));
if (!p_acl)
return;
memset(dst, 0, size);
p_raw = p_acl;
memset(p_acl, 0, (count + 3) * sizeof(acl));
if ((unsigned long)p_acl & 0x3f) // not aligned to 64 bytes
p_acl = (struct amfc_cmd_list *)(((unsigned long)p_acl + 0x40) & ~0x3f);
printf("acl:%p, src:%p, dst:%p, dst2:%p, size:%ld\n", p_acl, src, dst, dst2, size);
// case 1: compress src to dst by table mode
for (i = 0; i < count; i++) {
p_acl[i].src_addr = ((unsigned long)src + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
p_acl[i].src_size = PAGE_SIZE;
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].control = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_COMPRESS;
p_acl[i].owner = 1;
}
printf("table test case 1: compress with no end bit\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count);
// case 2: decompress dst to dst2 by table mode
for (i = 0; i < count; i++) {
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].control = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
p_acl[i].owner = 1;
}
p_acl[i - 1].end = 1;
printf("table test case 2: decompress with end bit\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count);
// case 3: decompress and compress interleave mode
for (i = 0; i < count; i++) {
if (i & 0x01) {
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].control = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
p_acl[i].owner = 1;
} else {
p_acl[i].src_addr = ((unsigned long)src + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
p_acl[i].src_size = PAGE_SIZE;
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].control = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_COMPRESS;
p_acl[i].owner = 1;
}
}
p_acl[i - 1].end = 1;
printf("table test case 3: enc/dec interleave table mode\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count);
// case 4: bad table with no owner bit set
for (i = 0; i < count; i++) {
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].control = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
if (i != 1)
p_acl[i].owner = 1;
}
p_acl[i - 1].end = 1;
printf("table test case 4: descriptor error with no owner\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count);
// case 5: bad table with no wrong algorithm
for (i = 0; i < count; i++) {
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].control = 0;
if (i == 1)
p_acl[i].algorithm = ALGORITHM_LZ4HC;
else
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
p_acl[i].owner = 1;
}
p_acl[i - 1].end = 1;
printf("table test case 5: descriptor error with wrong algorithm\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count);
// case 6: bad table with zero src size
for (i = 0; i < count; i++) {
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
if (i != 1)
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
else
p_acl[i].src_size = 0;
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].control = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
p_acl[i].owner = 1;
}
p_acl[i - 1].end = 1;
printf("table test case 6: descriptor error with zero source size\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count);
// case 7: bad table with zero dst size
for (i = 0; i < count; i++) {
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
if (i != 1)
p_acl[i].dst_size = PAGE_SIZE;
else
p_acl[i].dst_size = 0;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].control = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
p_acl[i].owner = 1;
}
p_acl[i - 1].end = 1;
printf("table test case 7: descriptor error with zero dst size\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count);
// case 8: bad table with zero link address
for (i = 0; i < count; i++) {
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].control = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
if (i == 1)
p_acl[i].link_mode = 1;
p_acl[i].owner = 1;
}
p_acl[i - 1].end = 1;
printf("table test case 8: descriptor error with zero link address\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count);
// case 9: bad table with dst size over flow
for (i = 0; i < count; i++) {
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
if (i != 1)
p_acl[i].dst_size = PAGE_SIZE;
else
p_acl[i].dst_size = 10;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].control = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
p_acl[i].owner = 1;
}
p_acl[i - 1].end = 1;
printf("table test case 9: descriptor error with dst size overflow\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count);
// case 10: bad table with decompress src size too small
for (i = 0; i < count; i++) {
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
if (i == 1)
p_acl[i].src_size = 10;
else
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].control = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
p_acl[i].owner = 1;
}
p_acl[i - 1].end = 1;
printf("table test case 10: descriptor error with decompress size too small\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count);
// case 11: bad table with compress size too small
for (i = 0; i < count; i++) {
p_acl[i].src_addr = ((unsigned long)src + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
if (i == 1)
p_acl[i].src_size = 2;
else
p_acl[i].src_size = PAGE_SIZE;
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].control = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_COMPRESS;
p_acl[i].owner = 1;
}
p_acl[i - 1].end = 1;
printf("table test case 11: bad table with compress size too small\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count);
free(p_raw);
}
/*
* before test, you should change a simple text file(size > 64KB) to hex and pre-load it
* to DDR via load_mem.tcl in PXP
*/
static void amfc_link_test(void *src, void *dst, void *dst2, unsigned long size)
{
struct amfc_cmd_list *p_acl, *p_raw;
int count, i;
count = ALIGN(size, PAGE_SIZE) / PAGE_SIZE;
p_acl = malloc((count + 3) * sizeof(acl));
if (!p_acl)
return;
memset(dst, 0, size);
p_raw = p_acl;
memset(p_acl, 0, (count + 3) * sizeof(acl));
if ((unsigned long)p_acl & 0x3f) // not aligned to 64 bytes
p_acl = (struct amfc_cmd_list *)(((unsigned long)p_acl + 0x40) & ~0x3f);
printf("acl:%p, src:%p, dst:%p, dst2:%p, size:%ld\n", p_acl, src, dst, dst2, size);
// case 1: compress src to dst by link mode
for (i = 0; i < count; i += 2) {
p_acl[i].src_addr = ((unsigned long)src + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].link_addr = ((unsigned long)&p_acl[i + 2]) >> ADDR_SHIFT;
p_acl[i].src_size = PAGE_SIZE;
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].link_mode = 1;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_COMPRESS;
p_acl[i].owner = 1;
}
printf("link test case 1: compress with NULL link end\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count + 3);
// case 2: decompress dst to dst2 by table mode
memset(p_acl, 0, (count + 2 ) * sizeof(*p_acl));
for (i = 0; i < count; i += 2) {
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = ((unsigned long)&p_acl[i + 2]) >> ADDR_SHIFT;
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].link_mode = 1;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
p_acl[i].owner = 1;
}
p_acl[i - 2].end = 1; // end but build a valid link next descriptor
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = 0;
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].link_mode = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
p_acl[i].owner = 1;
p_acl[i].end = 1; // end
printf("link test case 2: decompress with end bit but have a valid link descriptor\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count + 3);
// case 3: decompress and compress interleave link mode
memset(p_acl, 0, (count + 2 ) * sizeof(*p_acl));
for (i = 0; i < count; i += 2) {
if (i & 0x02) {
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = ((unsigned long)&p_acl[i + 2]) >> ADDR_SHIFT;
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].link_mode = 1;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
p_acl[i].owner = 1;
} else {
p_acl[i].src_addr = ((unsigned long)src + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].link_addr = ((unsigned long)&p_acl[i + 2]) >> ADDR_SHIFT;
p_acl[i].src_size = PAGE_SIZE;
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].link_mode = 1;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_COMPRESS;
p_acl[i].owner = 1;
}
}
p_acl[i - 2].end = 1;
p_acl[i - 2].link_mode = 0;
printf("link test case 3: enc/dec interleave link mode\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count + 3);
// case 4: valid link descriptor but link mode disabled
memset(p_acl, 0, (count + 2 ) * sizeof(*p_acl));
for (i = 0; i < count; i++) {
p_acl[i].src_addr = ((unsigned long)src + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].src_size = PAGE_SIZE;
p_acl[i].dst_size = PAGE_SIZE;
if (!i) { // link to 3rd desc
p_acl[i].link_addr = ((unsigned long)&p_acl[i + 2]) >> ADDR_SHIFT;
}
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_COMPRESS;
p_acl[i].owner = 1;
}
p_acl[i - 1].end = 1;
printf("link test case 4: valid link descriptor but link mode disabled \n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count + 3);
// case 5: circular link
memset(p_acl, 0, (count + 2 ) * sizeof(*p_acl));
for (i = 0; i < count; i += 2) {
p_acl[i].src_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst2 + PAGE_SIZE * i);
p_acl[i].link_addr = ((unsigned long)&p_acl[i + 2]) >> ADDR_SHIFT;
p_acl[i].src_size = get_sw_compressed_size(dst + PAGE_SIZE * i);
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].link_mode = 1;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_DECOMPRESS;
p_acl[i].owner = 1;
}
p_acl[i - 2].link_addr = ((unsigned long)&p_acl[0]) >> ADDR_SHIFT;
printf("link test case 5: circular link\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count + 3);
// case 6: table and link
memset(p_acl, 0, (count + 2 ) * sizeof(*p_acl));
for (i = 0; i < count; i ++) {
p_acl[i].src_addr = ((unsigned long)src + PAGE_SIZE * i);
p_acl[i].dst_addr = ((unsigned long)dst + PAGE_SIZE * i);
p_acl[i].src_size = PAGE_SIZE;
p_acl[i].dst_size = PAGE_SIZE;
p_acl[i].status = 0xffffffff;
p_acl[i].result_size = 0;
p_acl[i].algorithm = ALGORITHM_ZSTD;
p_acl[i].compress = CMD_COMPRESS;
p_acl[i].owner = 1;
if (i == 2) {
p_acl[i].link_addr = ((unsigned long)&p_acl[i + 4]) >> ADDR_SHIFT;
p_acl[i].link_mode = 1;
}
}
p_acl[i - 1].end = 1;
printf("link test case 6: table and link\n");
run_table_test(p_acl, src, dst, dst2, size);
show_acl(p_acl, count + 3);
free(p_raw);
}
static int check_zero(void *start, int range)
{
unsigned char *p = (unsigned char *)start;
int i;
for (i = 0; i < range; i++)
if (p[i])
return 1;
return 0;
}
static void amfc_address_test(void *src, void *dst,
void *dst2, int src_size)
{
int i, ret;
void *p, *p1, *p2;
char cmd_buf[128] = {};
// 1, compress dst not align test
printf("==== compress dst and decompress src not aligned test\n");
for (i = 0; i < 64; i++) {
p = (void *)(dst + i);
memset(dst, 0, src_size + 128);
memset(dst2, 0, src_size + 128);
run_command("dcache flush", 0);
ret = amfc_compress(src, p, src_size, src_size);
if (ret > 0) {
amfc_decompress(p, dst2, ret, src_size, 0);
if (memcmp(src, dst2, src_size)) {
printf("%s, src:%p, dst:%p, dst2:%p, ret:%d, src_size:%d, i:%d not match\n",
__func__, src, p, dst2, ret, src_size, i);
}
p1 = p + ret;
p2 = (void *)(((unsigned long)p1 + 64) & ~63);
if (check_zero(dst, i)) {
printf("left over write\n");
sprintf(cmd_buf, "md %lx 10\n", (long)dst);
run_command(cmd_buf, 0);
}
if (check_zero(p1, p2 - p1)) {
printf("right over write\n");
sprintf(cmd_buf, "md %lx 10\n", (long)p1);
run_command(cmd_buf, 0);
}
}
}
// 2, compress src not aligned
memset(dst, 0, src_size + 128);
amfc_compress(src, dst, src_size, src_size);
printf("==== compress src not aligned test\n");
for (i = 0; i < 64; i++) {
p = (void *)(dst + src_size + i);
memset(p, 0, src_size + 128);
memset(dst2, 0, src_size + 128);
memcpy(p, src, src_size);
run_command("dcache flush", 0);
ret = amfc_compress(p, dst2, src_size, src_size);
if (ret > 0) {
if (memcmp(dst, dst2, ret)) {
printf("%s, dst:%p, dst2:%p, ret:%d, src_size:%d i:%d, not match\n",
__func__, dst, dst2, ret, src_size, i);
}
}
}
// 3, decompress dest not aligned
memset(dst, 0, src_size + 128);
ret = amfc_compress(src, dst, src_size, src_size);
printf("==== decompress dst not aligned test\n");
for (i = 0; i < 64; i++) {
p = (void *)(dst2 + i);
memset(dst2, 0, src_size + 128);
run_command("dcache flush", 0);
ret = amfc_decompress(dst, p, ret, src_size, 0);
if (ret > 0) {
if (memcmp(p, src, src_size)) {
printf("%s, p:%p, src:%p, ret:%d, src_size:%d, i:%d not match\n",
__func__, p, src, ret, src_size, i);
}
if (check_zero(dst2, i)) {
printf("left over write\n");
sprintf(cmd_buf, "md %lx 10\n", (long)dst2);
run_command(cmd_buf, 0);
}
p1 = p + src_size;
p2 = (void *)(((unsigned long)p1 + 64) & ~63);
if (check_zero(p1, p2 - p1)) {
printf("right over write\n");
sprintf(cmd_buf, "md %lx 10\n", (long)p1);
run_command(cmd_buf, 0);
}
}
}
}
static void amfc_pagetable_test(void *src, void *dst, void *dst2, int size)
{
int i, j, ret;
char *p = src;
page_table_mode = 1;
/* set to fixed pattern */
for (i = 0; i < size + PAGE_SIZE; i++) {
p[i] = i & 0xff;
}
p = dst2;
for (j = 0; j <= PAGE_SIZE; j++) {
memset(dst, 0, size + PAGE_SIZE * 2);
memset(dst2, 0, size + PAGE_SIZE * 3);
flush_dcache_range((unsigned long)dst2, (unsigned long)dst2 + size + PAGE_SIZE * 3);
ret = amfc_compress(src + j, dst + j, size + j, size + j);
if (ret < 0) {
printf("%d compress %p failed:%d\n", j, src + j, ret);
return;
}
ret = amfc_decompress(dst + j, dst2 + j, ret, size + j, 0);
if (ret < 0) {
printf("%d decompress %p failed:%d\n", j, src + j, ret);
return;
}
if (memcmp(src + j, dst2 + j, size + j)) {
printf("%d compare %p %p not match\n", j, src + j, dst2 + j);
return;
}
for (i = 0; i < j; i++) {
if (p[i] || p[j + size + j]) {
printf("%d mem overwrite %p %p\n", j, p + i, p + j + size + j);
return;
}
}
}
printf("test pass \n");
}
static void amfc_stream_mode_test(void *src, void *dst, void *dst2, int size)
{
int i, ret, src_size;
char *p = src;
page_table_mode = 1;
/* set to fixed pattern */
for (i = 0; i < size + PAGE_SIZE; i++) {
p[i] = i & 0xff;
}
p = dst2;
src_size = amfc_compress(src, dst, size, size);
if (src_size < 0) {
printf("compress %p failed:%d\n", src, src_size);
return;
}
for (i = 1; i < size; i++) {
memset(dst2, 0, size + PAGE_SIZE * 3);
flush_dcache_range((unsigned long)dst2, (unsigned long)dst2 + size + PAGE_SIZE * 3);
ret = amfc_decompress(dst, dst2, src_size, i, 1);
if (ret < -1) {
printf("%d decompress %p failed:%d\n", i, src, ret);
return;
}
if (memcmp(src, dst2, i)) {
printf("%d compare %p %p not match\n", i, src, dst2);
return;
}
if (p[i]) {
printf("%d mem overwrite %p\n", i, p + i);
return;
}
}
printf("test pass \n");
}
static void amfc_reset_test(unsigned long cnt)
{
char *p_enc_src, *p_enc_dst, *p_dec_src, *p_dec_dst;
int enc_src_size, enc_dst_size, dec_src_size, dec_dst_size;
int i = 0;
int cmd_time;
int timeout, old_log;
unsigned int status, delay;
unsigned long enc_time, dec_time;
int fail0 = 0, fail1 = 0;
old_log = log_en;
p_enc_src = (char *)0x01000000;
p_enc_dst = (char *)0x02000000;
p_dec_src = (char *)0x03000000;
p_dec_dst = (char *)0x04000000;
enc_src_size = dec_dst_size = enc_dst_size = 0x01000000;
timeout = ((enc_src_size + PAGE_SIZE) / PAGE_SIZE) * 100 + 5000;
for (i = 0; i < p_enc_dst - p_enc_src; i++) {
p_enc_src[i] = i & 0xff;
}
log_en = 0;
enc_time = get_time();
dec_src_size = amfc_compress(p_enc_src, p_dec_src, enc_src_size, enc_dst_size);
enc_time = get_time() - enc_time;
if (dec_src_size < 0)
printf("build test buffer failed\n");
else
printf("source compressed to size:%d\n", dec_src_size);
dec_time = get_time();
amfc_decompress(p_dec_src, p_dec_dst, dec_src_size, dec_dst_size, 0);
dec_time = get_time() - dec_time;
log_en = old_log;
printf("enc time:%ld, dec_time:%ld, loop:%ld\n", enc_time, dec_time, cnt);
i = 0;
while (i < cnt) {
/* build 2 descriptors 0 for enc, 1 for dec */
// case 1, cmd0 work and reset cmd 1 with random delay
memset(&test_acl1, 0, sizeof(test_acl1));
memset(&test_acl2, 0, sizeof(test_acl2));
test_acl1.src_size = enc_src_size;
test_acl1.dst_size = enc_dst_size;
set_up_addr(&test_acl1, (unsigned long)p_enc_src, ADDR_SRC);
set_up_addr(&test_acl1, (unsigned long)p_enc_dst, ADDR_DST);
test_acl1.algorithm = ALGORITHM_ZSTD;
test_acl1.end = 1;
test_acl1.compress = CMD_COMPRESS;
test_acl1.owner = 1;
test_acl1.status = 0xffffffff;
flush_dcache_range((unsigned long)p_enc_src, (unsigned long)p_enc_src + enc_src_size);
flush_dcache_range((unsigned long)&test_acl1, (unsigned long)&test_acl1 + sizeof(acl));
invalidate_dcache_range((unsigned long)p_enc_dst, enc_dst_size);
test_acl2.src_size = dec_src_size;
test_acl2.dst_size = dec_dst_size;
set_up_addr(&test_acl2, (unsigned long)p_dec_src, ADDR_SRC);
set_up_addr(&test_acl2, (unsigned long)p_dec_dst, ADDR_DST);
test_acl2.algorithm = ALGORITHM_ZSTD;
test_acl2.end = 1;
test_acl2.compress = CMD_DECOMPRESS;
test_acl2.owner = 1;
test_acl2.status = 0xffffffff;
flush_dcache_range((unsigned long)p_dec_src, (unsigned long)p_dec_src + dec_src_size);
flush_dcache_range((unsigned long)&test_acl2, (unsigned long)&test_acl2 + sizeof(acl));
invalidate_dcache_range((unsigned long)p_dec_dst, dec_dst_size);
/* sw reset */
writel(0x80000000, AMFC_GL_CMD1_CONTROL);
writel(0x03, AMFC_GL_CMD1_IRQCLR);
writel((unsigned long)&test_acl2 >> ADDR_SHIFT, AMFC_GL_CMD1_DESC_BASE0_ADDR);
/* SW reset */
writel(0x80000000, AMFC_GL_CMD0_CONTROL);
writel(0x03, AMFC_GL_CMD0_IRQCLR);
writel((unsigned long)&test_acl1 >> ADDR_SHIFT, AMFC_GL_CMD0_DESC_BASE0_ADDR);
/* trigger 2 cmd */
writel(1, AMFC_GL_CMD0_CONTROL);
writel(1, AMFC_GL_CMD1_CONTROL);
delay = rand() % (enc_time + 1);
udelay(delay);
/* reset cmd 1 and check if cmd0 will timeout? */
writel(0x80000000, AMFC_GL_CMD1_CONTROL);
cmd_time = get_time();
/* wait for done or error */
while (1) {
status = readl(AMFC_GL_CMD0_STATUS);
if ((status & IRQ_DONE)) {
printf("%s, cmd 1 reset while cmd 0 is working, test pass, delay:%d, loop:%d\n", __func__, delay, i);
break;
}
if ((status & IRQ_ERR)) {
printf("%s, cmd 1 reset while cmd 0 is working, error occur, delay:%d, loop:%d\n", __func__, delay, i);
dump_addr((void *)&test_acl1, 32);
fail0++;
break;
}
if (get_time() - cmd_time > timeout) {
printf("%s, time out, cmd1 reset while cmd 0 working test failed, delay:%d, loop:%d\n", __func__, delay, i);
dump_addr((void *)&test_acl1, 32);
fail0++;
break;
}
}
invalidate_dcache_range((unsigned long)&test_acl1, (unsigned long)&test_acl1+ sizeof(acl));
// case 2, cmd1 work and reset cmd 0 with random delay
memset(&test_acl1, 0, sizeof(test_acl1));
memset(&test_acl2, 0, sizeof(test_acl2));
test_acl1.src_size = enc_src_size;
test_acl1.dst_size = enc_dst_size;
set_up_addr(&test_acl1, (unsigned long)p_enc_src, ADDR_SRC);
set_up_addr(&test_acl1, (unsigned long)p_enc_dst, ADDR_DST);
test_acl1.algorithm = ALGORITHM_ZSTD;
test_acl1.end = 1;
test_acl1.compress = CMD_COMPRESS;
test_acl1.owner = 1;
test_acl1.status = 0xffffffff;
flush_dcache_range((unsigned long)p_enc_src, (unsigned long)p_enc_src + enc_src_size);
flush_dcache_range((unsigned long)&test_acl1, (unsigned long)&test_acl1 + sizeof(acl));
invalidate_dcache_range((unsigned long)p_enc_dst, enc_dst_size);
test_acl2.src_size = dec_src_size;
test_acl2.dst_size = dec_dst_size;
set_up_addr(&test_acl2, (unsigned long)p_dec_src, ADDR_SRC);
set_up_addr(&test_acl2, (unsigned long)p_dec_dst, ADDR_DST);
test_acl2.algorithm = ALGORITHM_ZSTD;
test_acl2.end = 1;
test_acl2.compress = CMD_DECOMPRESS;
test_acl2.owner = 1;
test_acl2.status = 0xffffffff;
flush_dcache_range((unsigned long)p_dec_src, (unsigned long)p_dec_src + dec_src_size);
flush_dcache_range((unsigned long)&test_acl2, (unsigned long)&test_acl2 + sizeof(acl));
invalidate_dcache_range((unsigned long)p_dec_dst, dec_dst_size);
/* sw reset */
writel(0x80000000, AMFC_GL_CMD1_CONTROL);
writel(0x03, AMFC_GL_CMD1_IRQCLR);
writel((unsigned long)&test_acl2 >> ADDR_SHIFT, AMFC_GL_CMD1_DESC_BASE0_ADDR);
/* SW reset */
writel(0x80000000, AMFC_GL_CMD0_CONTROL);
writel(0x03, AMFC_GL_CMD0_IRQCLR);
writel((unsigned long)&test_acl1 >> ADDR_SHIFT, AMFC_GL_CMD0_DESC_BASE0_ADDR);
/* trigger 2 cmd */
writel(1, AMFC_GL_CMD0_CONTROL);
writel(1, AMFC_GL_CMD1_CONTROL);
delay = rand() % (dec_time + 1);
udelay(delay);
/* reset cmd 0 and check if cmd1 will timeout? */
writel(0x80000000, AMFC_GL_CMD0_CONTROL);
cmd_time = get_time();
/* wait for done or error */
while (1) {
status = readl(AMFC_GL_CMD1_STATUS);
if ((status & IRQ_DONE)) {
printf("%s, cmd 0 reset while cmd 1 is working, test pass, delay:%d, loop:%d\n", __func__, delay, i);
break;
}
if ((status & IRQ_ERR)) {
printf("%s, cmd 0 reset while cmd 1 is working, error occur, delay:%d, loop:%d\n", __func__, delay, i);
dump_addr((void *)&test_acl2, 32);
dump_addr((void *)AMFC_GL_VERSION, AMFC_SECURE_TOP_REG - AMFC_GL_VERSION + 4);
fail1++;
break;
}
if (get_time() - cmd_time > timeout) {
printf("%s, time out, cmd 0 reset while cmd 1 working test failed, delay:%d, loop:%d\n", __func__, delay, i);
dump_addr((void *)&test_acl2, 32);
fail1++;
break;
}
}
invalidate_dcache_range((unsigned long)&test_acl2, (unsigned long)&test_acl2+ sizeof(acl));
i++;
}
printf("%s, faile:%d %d, loop:%d\n", __func__, fail0, fail1, i);
}
static void amfc_stream_auto_reset_test(void)
{
char *p_enc_src, *p_enc_dst, *p_dec_src, *p_dec_dst;
int enc_src_size, enc_dst_size, dec_src_size, dec_dst_size;
int i = 0;
int cmd_time;
int timeout;
unsigned int status;
p_enc_src = (char *)0x01000000;
p_enc_dst = (char *)0x02000000;
p_dec_src = (char *)0x03000000;
p_dec_dst = (char *)0x04000000;
enc_src_size = dec_dst_size = enc_dst_size = 0x01000000;
timeout = ((enc_src_size + PAGE_SIZE) / PAGE_SIZE) * 100 + 5000;
for (i = 0; i < p_enc_dst - p_enc_src; i++) {
p_enc_src[i] = i & 0xff;
}
dec_src_size = amfc_compress(p_enc_src, p_dec_src, enc_src_size, enc_dst_size);
if (dec_src_size < 0)
printf("build test buffer failed\n");
else
printf("source compressed to size:%d\n", dec_src_size);
/* build 2 descriptors 0 for enc, 1 for dec */
memset(&test_acl1, 0, sizeof(test_acl1));
memset(&test_acl2, 0, sizeof(test_acl2));
test_acl1.src_size = enc_src_size;
test_acl1.dst_size = enc_dst_size;
set_up_addr(&test_acl1, (unsigned long)p_enc_src, ADDR_SRC);
set_up_addr(&test_acl1, (unsigned long)p_enc_dst, ADDR_DST);
test_acl1.algorithm = ALGORITHM_ZSTD;
test_acl1.end = 1;
// test_acl1.stream = 1;
test_acl1.compress = CMD_COMPRESS;
test_acl1.owner = 1;
test_acl1.status = 0xffffffff;
flush_dcache_range((unsigned long)p_enc_src, (unsigned long)p_enc_src + enc_src_size);
flush_dcache_range((unsigned long)&test_acl1, (unsigned long)&test_acl1 + sizeof(acl));
invalidate_dcache_range((unsigned long)p_enc_dst, enc_dst_size);
test_acl2.src_size = dec_src_size;
test_acl2.dst_size = 10000;
set_up_addr(&test_acl2, (unsigned long)p_dec_src, ADDR_SRC);
set_up_addr(&test_acl2, (unsigned long)p_dec_dst, ADDR_DST);
test_acl2.algorithm = ALGORITHM_ZSTD;
test_acl2.end = 1;
test_acl2.stream = 1; // setup stream
test_acl2.compress = CMD_DECOMPRESS;
test_acl2.owner = 1;
test_acl2.status = 0xffffffff;
flush_dcache_range((unsigned long)p_dec_src, (unsigned long)p_dec_src + dec_src_size);
flush_dcache_range((unsigned long)&test_acl2, (unsigned long)&test_acl2 + sizeof(acl));
invalidate_dcache_range((unsigned long)p_dec_dst, dec_dst_size);
/* sw reset */
writel(0x80000000, AMFC_GL_CMD1_CONTROL);
writel(0x03, AMFC_GL_CMD1_IRQCLR);
writel((unsigned long)&test_acl2 >> ADDR_SHIFT, AMFC_GL_CMD1_DESC_BASE0_ADDR);
/* SW reset */
writel(0x80000000, AMFC_GL_CMD0_CONTROL);
writel(0x03, AMFC_GL_CMD0_IRQCLR);
writel((unsigned long)&test_acl1 >> ADDR_SHIFT, AMFC_GL_CMD0_DESC_BASE0_ADDR);
/* trigger 2 cmd */
writel(1, AMFC_GL_CMD0_CONTROL);
writel(1, AMFC_GL_CMD1_CONTROL);
cmd_time = get_time();
/* wait cmd1 for done or error */
while (1) {
status = readl(AMFC_GL_CMD1_STATUS);
if ((status & IRQ_DONE)) {
if (hw_version < HW_VERSION_12)
writel(0x80000000, AMFC_GL_CMD1_CONTROL);
break;
}
if ((status & IRQ_ERR)) {
printf("%s, cmd 1 stream error occur\n", __func__);
break;
}
if (get_time() - cmd_time > timeout) {
printf("%s, time out, cmd1 stream timeout\n", __func__);
break;
}
}
cmd_time = get_time();
/* wait for done or error */
while (1) {
status = readl(AMFC_GL_CMD0_STATUS);
if ((status & IRQ_DONE)) {
printf("%s, cmd 1 stream while cmd 0 is working, test pass\n", __func__);
break;
}
if ((status & IRQ_ERR)) {
printf("%s, cmd 1 stream while cmd 0 is working, error occur\n", __func__);
break;
}
if (get_time() - cmd_time > timeout) {
printf("%s, time out, cmd1 stream while cmd 0 working test failed\n", __func__);
break;
}
}
invalidate_dcache_range((unsigned long)&test_acl1, (unsigned long)&test_acl1+ sizeof(acl));
dump_addr((void *)&test_acl1, 32);
invalidate_dcache_range((unsigned long)&test_acl2, (unsigned long)&test_acl2+ sizeof(acl));
dump_addr((void *)&test_acl2, 32);
}
const unsigned test_data[]={
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000,
0xb5280000 , 0x1040fd2f , 0x006cff00 , 0x30302000,
0x0002300a , 0x40f167f4 , 0x003c4400 , 0x00010000,
0x805fa7fd , 0x0000003c , 0xf7fd0001 , 0x003c1001,
0x00010000 , 0x1001f7fd , 0x0000003c , 0xf7fd0001,
0x003c1001 , 0x00010000 , 0x1001f7fd , 0x0000003c,
0xf7fd0001 , 0x003c1001 , 0x00010000 , 0x1001f7fd,
0x0000003c , 0xf7fd0001 , 0x003c1001 , 0x00010000,
0x1001f7fd , 0x0000003c , 0xf7fd0001 , 0x003c1001,
0x00010000 , 0x1001f7fd , 0x0000003c , 0xf7fd0001,
0x003c1001 , 0x00010000 , 0x1001f7fd , 0x0000003c,
0xf7fd0001 , 0x003d1001 , 0x00010000 , 0x1001f7fd,
0x00000000 , 0x00000000 , 0x00000000 , 0x00000000
};
static void amfc_page_boundary_test(void)
{
unsigned char *p_src, *p_dst;
int src_size, dst_size, ret;
p_src = (unsigned char *)0x01000000;
p_dst = (unsigned char *)0x02000000;
src_size = 4096;
dst_size = 65600;
memcpy(p_src, test_data, sizeof(test_data));
page_table_mode = 1;
ret = amfc_decompress(p_src, p_dst, src_size, dst_size, 0);
if (ret < 0) {
printf("%s, test failed, ret:%d\n", __func__, ret);
} else {
printf("%s, test pass, ret:%d\n", __func__, ret);
}
}
#endif
static int do_amfc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
unsigned long src;
unsigned long dst;
unsigned long src_size;
unsigned long dst_size;
int ret;
if (argc < 2)
return -1;
if (!strcmp(argv[1], "set")) {
if (argc != 4)
return -1;
if (!strcmp(argv[2], "page_table")) {
page_table_mode = simple_strtoul(argv[3], NULL, 16);
printf("set page_table_mode to:%d\n", page_table_mode);
}
if (!strcmp(argv[2], "log")) {
log_en = simple_strtoul(argv[3], NULL, 16);
printf("set log to:%d\n", log_en);
}
return 0;
}
#if CONFIG_AMFC_TEST
if (!strcmp(argv[1], "pack_test")) {
if (argc != 5)
return -1;
src = simple_strtoul(argv[2], NULL, 16);
dst = simple_strtoul(argv[3], NULL, 16);
src_size = simple_strtoul(argv[4], NULL, 16);
amfc_pack_test(src, (void *)dst, (void *)src_size);
return 0;
}
if (!strcmp(argv[1], "zram_test")) {
if (argc != 5)
return -1;
src = simple_strtoul(argv[2], NULL, 16);
src_size = simple_strtoul(argv[3], NULL, 16);
dst_size = simple_strtoul(argv[4], NULL, 16);
amfc_zram_test((void *)src, src_size, dst_size);
return 0;
}
if (!strcmp(argv[1], "erofs_test")) {
if (argc != 6)
return -1;
src = simple_strtoul(argv[2], NULL, 16);
dst = simple_strtoul(argv[3], NULL, 16);
src_size = simple_strtoul(argv[4], NULL, 16);
dst_size = simple_strtoul(argv[5], NULL, 16);
amfc_erofs_test((void *)src, dst, src_size, dst_size);
return 0;
}
if (!strcmp(argv[1], "table_test")) {
if (argc != 6)
return -1;
src = simple_strtoul(argv[2], NULL, 16);
dst = simple_strtoul(argv[3], NULL, 16);
src_size = simple_strtoul(argv[4], NULL, 16);
dst_size = simple_strtoul(argv[5], NULL, 16);
amfc_table_test((void *)src, (void *)dst, (void *)src_size, dst_size);
return 0;
}
if (!strcmp(argv[1], "link_test")) {
if (argc != 6)
return -1;
src = simple_strtoul(argv[2], NULL, 16);
dst = simple_strtoul(argv[3], NULL, 16);
src_size = simple_strtoul(argv[4], NULL, 16);
dst_size = simple_strtoul(argv[5], NULL, 16);
amfc_link_test((void *)src, (void *)dst, (void *)src_size, dst_size);
return 0;
}
if (!strcmp(argv[1], "table_mask")) {
if (argc != 3)
return -1;
table_test_mask = simple_strtoul(argv[2], NULL, 16);
return 0;
}
if (!strcmp(argv[1], "addr_test")) {
if (argc != 6)
return -1;
src = simple_strtoul(argv[2], NULL, 16);
dst = simple_strtoul(argv[3], NULL, 16);
src_size = simple_strtoul(argv[4], NULL, 16);
dst_size = simple_strtoul(argv[5], NULL, 16);
amfc_address_test((void *)src, (void *)dst, (void *)src_size, dst_size);
return 0;
}
if (!strcmp(argv[1], "pagetable_test")) {
if (argc != 6)
return -1;
src = simple_strtoul(argv[2], NULL, 16);
dst = simple_strtoul(argv[3], NULL, 16);
src_size = simple_strtoul(argv[4], NULL, 16);
dst_size = simple_strtoul(argv[5], NULL, 16);
amfc_pagetable_test((void *)src, (void *)dst, (void *)src_size, dst_size);
return 0;
}
if (!strcmp(argv[1], "stream_test")) {
if (argc != 6)
return -1;
src = simple_strtoul(argv[2], NULL, 16);
dst = simple_strtoul(argv[3], NULL, 16);
src_size = simple_strtoul(argv[4], NULL, 16);
dst_size = simple_strtoul(argv[5], NULL, 16);
amfc_stream_mode_test((void *)src, (void *)dst, (void *)src_size, dst_size);
}
if (!strcmp(argv[1], "reset_test")) {
if (argc != 3)
return -1;
src = simple_strtoul(argv[2], NULL, 16);
amfc_reset_test(src);
return 0;
}
if (!strcmp(argv[1], "stream_auto_reset_test")) {
amfc_stream_auto_reset_test();
return 0;
}
if (!strcmp(argv[1], "page_bound_test")) {
amfc_page_boundary_test();
return 0;
}
#endif
if (argc != 6)
return -1;
src = simple_strtoul(argv[2], NULL, 16);
dst = simple_strtoul(argv[3], NULL, 16);
src_size = simple_strtoul(argv[4], NULL, 16);
dst_size = simple_strtoul(argv[5], NULL, 16);
if (!strcmp(argv[1], "compress"))
ret = amfc_compress((void *)src, (void *)dst, src_size, dst_size);
else if (!strcmp(argv[1], "decompress"))
ret = amfc_decompress((void *)src, (void *)dst, src_size, dst_size, 0);
return 0;
}
U_BOOT_CMD(
amfc, 7, 0, do_amfc,
"amfc subsystem",
"compress/decompress [src_addr] [dst_addr] [src_size] [dst_size]\n"
"set:\n"
" page_table [0/1] ---- enable/disable page table mode\n"
"memcmp [src] [dst] [size] ----compare two memory region\n"
"All parameters in hex value"
);
Reference in New Issue View Git Blame Copy Permalink