1692 lines
44 KiB
C
1692 lines
44 KiB
C
// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
|
|
/*
|
|
* Copyright (c) 2019 Amlogic, Inc. All rights reserved.
|
|
*/
|
|
|
|
#include <command.h>
|
|
#include <malloc.h>
|
|
#include <amlogic/aml_model.h>
|
|
#include <amlogic/media/vout/lcd/aml_lcd.h>
|
|
#include <amlogic/media/vout/panel_utils/lcd_memory.h>
|
|
|
|
static int do_lcd_probe(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_probe(0);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_enable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
char *mode, *str;
|
|
|
|
str = env_get("outputmode");
|
|
if (!str) {
|
|
printf("no outputmode\n");
|
|
return -1;
|
|
}
|
|
|
|
mode = (char *)malloc(64);
|
|
if (!mode) {
|
|
printf("%s: create mode failed\n", __func__);
|
|
return -1;
|
|
}
|
|
memset(mode, 0, 64);
|
|
sprintf(mode, "%s", str);
|
|
|
|
aml_lcd_driver_enable(0, mode);
|
|
|
|
free(mode);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_disable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_disable(0);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_power(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int val = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
val = (unsigned int)simple_strtoul(argv[1], NULL, 10);
|
|
|
|
aml_lcd_driver_power_ctrl(0, val);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_ss(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
int value, temp;
|
|
int ret = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "level") == 0) {
|
|
if (argc == 3) {
|
|
value = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
value &= 0xff;
|
|
aml_lcd_driver_set_ss(0, value, 0xff, 0xff);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "freq") == 0) {
|
|
if (argc == 3) {
|
|
value = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
value &= 0xf;
|
|
aml_lcd_driver_set_ss(0, 0xff, value, 0xff);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "mode") == 0) {
|
|
if (argc == 3) {
|
|
value = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
value &= 0xf;
|
|
aml_lcd_driver_set_ss(0, 0xff, 0xff, value);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "set") == 0) {
|
|
if (argc == 3) {
|
|
value = (unsigned int)simple_strtoul(argv[2], NULL, 16);
|
|
value &= 0xffff;
|
|
temp = value >> 8;
|
|
aml_lcd_driver_set_ss(0, (value & 0xff),
|
|
((temp >> LCD_CLK_SS_BIT_FREQ) & 0xf),
|
|
((temp >> LCD_CLK_SS_BIT_MODE) & 0xf));
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "get") == 0) {
|
|
aml_lcd_driver_get_ss(0);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int do_lcd_clk(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_clk_info(0);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int val = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
val = (unsigned int)simple_strtoul(argv[1], NULL, 16);
|
|
|
|
aml_lcd_driver_debug_print(0, val);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_dump(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_info(0);
|
|
aml_lcd_driver_reg_info(0);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_info(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_info(0);
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_AML_LCD_TCON
|
|
static int do_lcd_tcon(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
struct aml_lcd_drv_s *pdrv = aml_lcd_get_driver(0);
|
|
unsigned int addr, val, len;
|
|
int ret = 0, i;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (!pdrv) {
|
|
printf("no lcd driver\n");
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[1], "reg") == 0) {
|
|
if (pdrv->tcon_reg_print)
|
|
pdrv->tcon_reg_print();
|
|
else
|
|
printf("no lcd tcon_reg_print\n");
|
|
} else if (strcmp(argv[1], "table") == 0) {
|
|
if (pdrv->tcon_table_print)
|
|
pdrv->tcon_table_print();
|
|
else
|
|
printf("no lcd tcon_table_print\n");
|
|
} else if (strcmp(argv[1], "tw") == 0) {
|
|
addr = (unsigned int)simple_strtoul(argv[2], NULL, 16);
|
|
val = (unsigned int)simple_strtoul(argv[3], NULL, 16);
|
|
if (pdrv->tcon_table_write) {
|
|
val = pdrv->tcon_table_write(addr, val);
|
|
printf("write tcon table[0x%04x] = 0x%02x\n",
|
|
addr, val);
|
|
} else {
|
|
printf("no tcon_table_write\n");
|
|
}
|
|
} else if (strcmp(argv[1], "tr") == 0) {
|
|
addr = (unsigned int)simple_strtoul(argv[2], NULL, 16);
|
|
if (pdrv->tcon_table_read) {
|
|
val = pdrv->tcon_table_read(addr);
|
|
printf("read tcon table[0x%04x] = 0x%02x\n",
|
|
addr, val);
|
|
} else {
|
|
printf("no tcon_table_write\n");
|
|
}
|
|
} else if (strcmp(argv[1], "wb") == 0) {
|
|
if (pdrv->tcon_reg_write) {
|
|
addr = (unsigned int)simple_strtoul(argv[2], NULL, 16);
|
|
val = (unsigned int)simple_strtoul(argv[3], NULL, 16);
|
|
pdrv->tcon_reg_write(addr, val, 1);
|
|
printf
|
|
("tcon byte write: 0x%04x = 0x%02x, readback 0x%02x\n",
|
|
addr, val, pdrv->tcon_reg_read(addr, 1));
|
|
} else {
|
|
printf("no tcon_reg_write\n");
|
|
}
|
|
} else if (strcmp(argv[1], "rb") == 0) {
|
|
if (pdrv->tcon_reg_read) {
|
|
addr = (unsigned int)simple_strtoul(argv[2], NULL, 16);
|
|
val = pdrv->tcon_reg_read(addr, 1);
|
|
printf("tcon byte read: 0x%04x = 0x%02x\n", addr, val);
|
|
} else {
|
|
printf("no tcon_reg_read\n");
|
|
}
|
|
} else if (strcmp(argv[1], "db") == 0) {
|
|
if (pdrv->tcon_reg_read) {
|
|
addr = (unsigned int)simple_strtoul(argv[2], NULL, 16);
|
|
len = (unsigned int)simple_strtoul(argv[3], NULL, 10);
|
|
printf("tcon byte reg dump:\n");
|
|
for (i = 0; i < len; i++) {
|
|
val = pdrv->tcon_reg_read((addr + i), 1);
|
|
printf(" 0x%04x = 0x%02x\n", (addr + i), val);
|
|
}
|
|
} else {
|
|
printf("no tcon_reg_read\n");
|
|
}
|
|
} else if (strcmp(argv[1], "w") == 0) {
|
|
if (pdrv->tcon_reg_write) {
|
|
addr = (unsigned int)simple_strtoul(argv[2], NULL, 16);
|
|
val = (unsigned int)simple_strtoul(argv[3], NULL, 16);
|
|
pdrv->tcon_reg_write(addr, val, 0);
|
|
printf("tcon write: 0x%04x = 0x%08x, readback 0x%08x\n",
|
|
addr, val, pdrv->tcon_reg_read(addr, 0));
|
|
} else {
|
|
printf("no tcon_reg_write\n");
|
|
}
|
|
} else if (strcmp(argv[1], "r") == 0) {
|
|
if (pdrv->tcon_reg_read) {
|
|
addr = (unsigned int)simple_strtoul(argv[2], NULL, 16);
|
|
val = pdrv->tcon_reg_read(addr, 0);
|
|
printf("tcon read: 0x%04x = 0x%08x\n", addr, val);
|
|
} else {
|
|
printf("no tcon_reg_read\n");
|
|
}
|
|
} else if (strcmp(argv[1], "d") == 0) {
|
|
if (pdrv->tcon_reg_read) {
|
|
addr = (unsigned int)simple_strtoul(argv[2], NULL, 16);
|
|
len = (unsigned int)simple_strtoul(argv[3], NULL, 10);
|
|
printf("tcon reg dump:\n");
|
|
for (i = 0; i < len; i++) {
|
|
val = pdrv->tcon_reg_read((addr + i), 0);
|
|
printf(" 0x%04x = 0x%08x\n", (addr + i), val);
|
|
}
|
|
} else {
|
|
printf("no tcon_reg_read\n");
|
|
}
|
|
} else if (strcmp(argv[1], "data") == 0) {
|
|
if (argc == 3) {
|
|
i = (unsigned char)simple_strtoul(argv[2], NULL, 10);
|
|
if (pdrv->tcon_data_print)
|
|
pdrv->tcon_data_print(i);
|
|
else
|
|
printf("no lcd tcon_data_print\n");
|
|
} else {
|
|
if (pdrv->tcon_data_print)
|
|
pdrv->tcon_data_print(0xff);
|
|
else
|
|
printf("no lcd tcon_data_print\n");
|
|
}
|
|
} else if (strcmp(argv[1], "tee") == 0) {
|
|
if (strcmp(argv[2], "on") == 0)
|
|
val = 1;
|
|
else
|
|
val = 0;
|
|
if (pdrv->tcon_mem_tee_protect)
|
|
pdrv->tcon_mem_tee_protect(val);
|
|
else
|
|
printf("no lcd tcon_mem_tee_protect\n");
|
|
} else if (strcmp(argv[1], "spi") == 0) {
|
|
if (pdrv->tcon_spi_print)
|
|
pdrv->tcon_spi_print();
|
|
else
|
|
printf("no lcd tcon_spi_print\n");
|
|
} else if (strcmp(argv[1], "check") == 0) {
|
|
if (pdrv->tcon_forbidden_check)
|
|
pdrv->tcon_forbidden_check();
|
|
else
|
|
printf("no lcd tcon_forbidden_check\n");
|
|
} else if (strcmp(argv[1], "reset") == 0) {
|
|
if (pdrv->tcon_global_reset)
|
|
pdrv->tcon_global_reset(pdrv);
|
|
else
|
|
printf("no lcd tcon_global_reset\n");
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
static int do_lcd_vbyone(cmd_tbl_t *cmdtp, int flag, int argc,
|
|
char * const argv[])
|
|
{
|
|
int ret = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "rst") == 0) {
|
|
aml_lcd_vbyone_rst(0);
|
|
} else if (strcmp(argv[1], "cdr") == 0) {
|
|
ret = aml_lcd_vbyone_cdr(0);
|
|
if (ret)
|
|
printf("[0]: vbyone force cdr fail!\n");
|
|
else
|
|
printf("[0]: vbyone force cdr ok.\n");
|
|
} else if (strcmp(argv[1], "lock") == 0) {
|
|
ret = aml_lcd_vbyone_lock(0);
|
|
if (ret)
|
|
printf("[0]: vbyone force lock fail!\n");
|
|
else
|
|
printf("[0]: vbyone force lock ok.\n");
|
|
} else {
|
|
return 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_reg(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_reg_info(0);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int num;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
num = (unsigned int)simple_strtoul(argv[1], NULL, 10);
|
|
aml_lcd_driver_test(0, num);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_window(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
struct lcd_window_attr_s window_attr;
|
|
|
|
if (argc != 11)
|
|
return -1;
|
|
|
|
window_attr.pos.start_x =
|
|
(unsigned short)simple_strtoul(argv[1], NULL, 10);
|
|
window_attr.pos.start_y =
|
|
(unsigned short)simple_strtoul(argv[2], NULL, 10);
|
|
window_attr.pos.end_x =
|
|
(unsigned short)simple_strtoul(argv[3], NULL, 10);
|
|
window_attr.pos.end_y =
|
|
(unsigned short)simple_strtoul(argv[4], NULL, 10);
|
|
window_attr.color_in.red =
|
|
(unsigned short)simple_strtoul(argv[5], NULL, 10);
|
|
window_attr.color_in.green =
|
|
(unsigned short)simple_strtoul(argv[6], NULL, 10);
|
|
window_attr.color_in.blue =
|
|
(unsigned short)simple_strtoul(argv[7], NULL, 10);
|
|
window_attr.color_out.red =
|
|
(unsigned short)simple_strtoul(argv[8], NULL, 10);
|
|
window_attr.color_out.green =
|
|
(unsigned short)simple_strtoul(argv[9], NULL, 10);
|
|
window_attr.color_out.blue =
|
|
(unsigned short)simple_strtoul(argv[10], NULL, 10);
|
|
aml_lcd_driver_window(0, &window_attr);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_cursor(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
struct lcd_cursor_attr_s cursor_attr;
|
|
|
|
if (argc != 8 && argc != 2)
|
|
return -1;
|
|
cursor_attr.status = (unsigned char)simple_strtoul(argv[1], NULL, 10);
|
|
if (cursor_attr.status && argc != 8)
|
|
return -1;
|
|
if (argc == 8) {
|
|
cursor_attr.mode = (unsigned char)simple_strtoul(argv[2], NULL, 10);
|
|
cursor_attr.x = (unsigned short)simple_strtoul(argv[3], NULL, 10);
|
|
cursor_attr.y = (unsigned short)simple_strtoul(argv[4], NULL, 10);
|
|
|
|
cursor_attr.red = (unsigned short)simple_strtoul(argv[5], NULL, 10);
|
|
cursor_attr.green = (unsigned short)simple_strtoul(argv[6], NULL, 10);
|
|
cursor_attr.blue = (unsigned short)simple_strtoul(argv[7], NULL, 10);
|
|
}
|
|
aml_lcd_driver_cursor(0, &cursor_attr);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_check(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_config_check(0);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_prbs(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int ms, prbs_freq = 0, prbs_mode_flag;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "vx1") == 0) {
|
|
if (argc == 3)
|
|
prbs_mode_flag = LCD_PRBS_MODE_VX1;
|
|
else
|
|
return -1;
|
|
ms = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
} else if (strcmp(argv[1], "lvds") == 0) {
|
|
if (argc == 3)
|
|
prbs_mode_flag = LCD_PRBS_MODE_LVDS;
|
|
else
|
|
return -1;
|
|
ms = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
} else if (strcmp(argv[1], "freq") == 0) {
|
|
if (argc == 4)
|
|
prbs_mode_flag = LCD_PRBS_MODE_FREQ;
|
|
else
|
|
return -1;
|
|
prbs_freq = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
ms = (unsigned int)simple_strtoul(argv[3], NULL, 10);
|
|
} else {
|
|
prbs_mode_flag = LCD_PRBS_MODE_LVDS | LCD_PRBS_MODE_VX1;
|
|
ms = (unsigned int)simple_strtoul(argv[1], NULL, 10);
|
|
}
|
|
|
|
aml_lcd_driver_prbs(0, ms, prbs_freq, prbs_mode_flag);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_panel_dump(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
if (argc == 2)
|
|
aml_lcd_panel_dump(0, argv[1]);
|
|
else
|
|
aml_lcd_panel_dump(0, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
u32 size, i, j;
|
|
char *name;
|
|
phys_addr_t pa = 0;
|
|
unsigned char *vaddr = NULL;
|
|
int ret;
|
|
|
|
if (argc == 1)
|
|
goto do_lcd_mem_err;
|
|
|
|
if (strcmp(argv[1], "add") == 0) {
|
|
if (argc < 4)
|
|
goto do_lcd_mem_err;
|
|
size = simple_strtoul(argv[2], NULL, 10);
|
|
name = argv[3];
|
|
pa = lrm_phys_alloc(size, name);
|
|
} else if (strcmp(argv[1], "add_tail") == 0) {
|
|
if (argc < 4)
|
|
goto do_lcd_mem_err;
|
|
size = simple_strtoul(argv[2], NULL, 10);
|
|
name = argv[3];
|
|
pa = lrm_phys_alloc_tail(size, name);
|
|
} else if (strcmp(argv[1], "rm") == 0) {
|
|
if (argc < 3)
|
|
goto do_lcd_mem_err;
|
|
name = argv[2];
|
|
ret = lrm_get_by_name(name, &pa, &size);
|
|
if (ret) {
|
|
printf("error: %s: not find\n", name);
|
|
return 0;
|
|
}
|
|
lrm_free(NULL, pa);
|
|
} else if (strcmp(argv[1], "get") == 0) {
|
|
if (argc < 3)
|
|
goto do_lcd_mem_err;
|
|
name = argv[2];
|
|
ret = lrm_get_by_name(name, &pa, &size);
|
|
if (ret) {
|
|
printf("error: %s: not find\n", name);
|
|
return 0;
|
|
}
|
|
vaddr = (unsigned char *)lrm_phys_to_virt(pa, size);
|
|
printf("data addr: 0x%x:", (unsigned int)pa);
|
|
for (i = 0; i < size; i += 16) {
|
|
printf("%04x:", i);
|
|
for (j = 0; j < 16; j++) {
|
|
if ((i + j) >= size)
|
|
break;
|
|
printf(" %02x", vaddr[i + j]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
} else if (strcmp(argv[1], "show") == 0) {
|
|
lrm_show();
|
|
} else if (strcmp(argv[1], "param") == 0) {
|
|
if (argc < 3)
|
|
goto do_lcd_mem_err;
|
|
if (strcmp(argv[2], "show") == 0) { //read from param_mem
|
|
aml_lcd_panel_mem_debug(NULL);
|
|
} else if (strcmp(argv[2], "get") == 0) { //read from param_mem
|
|
if (argc < 4)
|
|
goto do_lcd_mem_err;
|
|
name = argv[3];
|
|
aml_lcd_panel_mem_debug(name);
|
|
} else if (strcmp(argv[2], "test") == 0) { //read from lrm
|
|
if (argc < 4) {
|
|
aml_lcd_panel_param_test(NULL);
|
|
} else {
|
|
name = argv[3];
|
|
aml_lcd_panel_param_test(name);
|
|
}
|
|
}
|
|
} else if (strcmp(argv[1], "bootargs") == 0) {
|
|
if (argc >= 3) {
|
|
name = argv[2];
|
|
vaddr = lrm_bootargs_get_data(name, &size);
|
|
if (vaddr) {
|
|
for (i = 0; i < size; i += 16) {
|
|
printf("%04x:", i);
|
|
for (j = 0; j < 16; j++) {
|
|
if ((i + j) >= size)
|
|
break;
|
|
printf(" %02x", vaddr[i + j]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
lrm_bootargs_dump();
|
|
} else if (strcmp(argv[1], "update") == 0) {
|
|
lrm_handle_mem_info_to_kernel();
|
|
} else {
|
|
goto do_lcd_mem_err;
|
|
}
|
|
|
|
return 0;
|
|
|
|
do_lcd_mem_err:
|
|
printf("format: lcd mem [cmd] [param...]\n"
|
|
"help:\n"
|
|
"lcd mem update: save panel mem data to lrm\n"
|
|
"lcd mem show: dump lrm data info\n"
|
|
"lcd mem add size name: alloc lrm mem for param 'name'\n"
|
|
"lcd mem add_tail: alloc lrm tail_mem for param 'name'\n"
|
|
"lcd mem rm name: remove lrm mem for param 'name'\n"
|
|
"lcd mem get name: dump data of param 'name' in lrm\n"
|
|
"lcd mem param show: list param in panel param_mem\n"
|
|
"lcd mem param get name: dump data of param 'name' in panel param_mem\n"
|
|
"lcd mem bootargs: list bootargs in panel bootargs_mem\n"
|
|
"lcd mem bootargs name: dump data of bootargs 'name' in panel bootargs_mem\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_AML_LCD_EXTERN
|
|
static int do_lcd_ext(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int temp;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "info") == 0) {
|
|
aml_lcd_driver_ext_info(0);
|
|
} else if (strcmp(argv[1], "power") == 0) {
|
|
if (argc < 3)
|
|
return -1;
|
|
temp = simple_strtoul(argv[2], NULL, 10);
|
|
if (temp)
|
|
aml_lcd_driver_ext_power_on(0);
|
|
else
|
|
aml_lcd_driver_ext_power_off(0);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static int do_lcd_bl(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
int level;
|
|
int ret = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "on") == 0) {
|
|
aml_lcd_driver_bl_on(0);
|
|
} else if (strcmp(argv[1], "off") == 0) {
|
|
aml_lcd_driver_bl_off(0);
|
|
} else if (strcmp(argv[1], "set") == 0) {
|
|
if (argc == 3) {
|
|
level = (int)simple_strtol(argv[2], NULL, 10);
|
|
aml_lcd_driver_set_bl_level(0, level);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "get") == 0) {
|
|
level = aml_lcd_driver_get_bl_level(0);
|
|
printf("lcd get_bl_level: %d\n", level);
|
|
} else if (strcmp(argv[1], "info") == 0) {
|
|
aml_lcd_driver_bl_config_print(0);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int do_lcd1_probe(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_probe(1);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_enable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_enable(1, "NULL");
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_disable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_disable(1);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_power(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int val = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
val = (unsigned int)simple_strtoul(argv[1], NULL, 10);
|
|
|
|
aml_lcd_driver_power_ctrl(1, val);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_ss(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
int value, temp;
|
|
int ret = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "level") == 0) {
|
|
if (argc == 3) {
|
|
value = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
value &= 0xff;
|
|
aml_lcd_driver_set_ss(1, value, 0xff, 0xff);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "freq") == 0) {
|
|
if (argc == 3) {
|
|
value = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
value &= 0xf;
|
|
aml_lcd_driver_set_ss(1, 0xff, value, 0xff);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "mode") == 0) {
|
|
if (argc == 3) {
|
|
value = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
value &= 0xf;
|
|
aml_lcd_driver_set_ss(1, 0xff, 0xff, value);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "set") == 0) {
|
|
if (argc == 3) {
|
|
value = (unsigned int)simple_strtoul(argv[2], NULL, 16);
|
|
value &= 0xffff;
|
|
temp = value >> 8;
|
|
aml_lcd_driver_set_ss(1, (value & 0xff),
|
|
((temp >> LCD_CLK_SS_BIT_FREQ) & 0xf),
|
|
((temp >> LCD_CLK_SS_BIT_MODE) & 0xf));
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "get") == 0) {
|
|
aml_lcd_driver_get_ss(1);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int do_lcd1_clk(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_clk_info(1);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int val = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
val = (unsigned int)simple_strtoul(argv[1], NULL, 16);
|
|
|
|
aml_lcd_driver_debug_print(1, val);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_dump(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_info(1);
|
|
aml_lcd_driver_reg_info(1);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_info(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_info(1);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_vbyone(cmd_tbl_t *cmdtp, int flag, int argc,
|
|
char * const argv[])
|
|
{
|
|
int ret = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "rst") == 0) {
|
|
aml_lcd_vbyone_rst(1);
|
|
} else if (strcmp(argv[1], "cdr") == 0) {
|
|
ret = aml_lcd_vbyone_cdr(1);
|
|
if (ret)
|
|
printf("[1]: vbyone force cdr fail!\n");
|
|
else
|
|
printf("[1]: vbyone force cdr ok.\n");
|
|
} else if (strcmp(argv[1], "lock") == 0) {
|
|
ret = aml_lcd_vbyone_lock(1);
|
|
if (ret)
|
|
printf("[1]: vbyone force lock fail!\n");
|
|
else
|
|
printf("[1]: vbyone force lock ok.\n");
|
|
} else {
|
|
return 0;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int do_lcd1_reg(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_reg_info(1);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int num;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
num = (unsigned int)simple_strtoul(argv[1], NULL, 10);
|
|
aml_lcd_driver_test(1, num);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_window(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
struct lcd_window_attr_s window_attr;
|
|
|
|
if (argc != 11)
|
|
return -1;
|
|
|
|
window_attr.pos.start_x =
|
|
(unsigned short)simple_strtoul(argv[1], NULL, 10);
|
|
window_attr.pos.start_y =
|
|
(unsigned short)simple_strtoul(argv[2], NULL, 10);
|
|
window_attr.pos.end_x =
|
|
(unsigned short)simple_strtoul(argv[3], NULL, 10);
|
|
window_attr.pos.end_y =
|
|
(unsigned short)simple_strtoul(argv[4], NULL, 10);
|
|
window_attr.color_in.red =
|
|
(unsigned short)simple_strtoul(argv[5], NULL, 10);
|
|
window_attr.color_in.green =
|
|
(unsigned short)simple_strtoul(argv[6], NULL, 10);
|
|
window_attr.color_in.blue =
|
|
(unsigned short)simple_strtoul(argv[7], NULL, 10);
|
|
window_attr.color_out.red =
|
|
(unsigned short)simple_strtoul(argv[8], NULL, 10);
|
|
window_attr.color_out.green =
|
|
(unsigned short)simple_strtoul(argv[9], NULL, 10);
|
|
window_attr.color_out.blue =
|
|
(unsigned short)simple_strtoul(argv[10], NULL, 10);
|
|
aml_lcd_driver_window(1, &window_attr);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_cursor(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
struct lcd_cursor_attr_s cursor_attr;
|
|
|
|
if (argc != 8 && argc != 2)
|
|
return -1;
|
|
cursor_attr.status = (unsigned char)simple_strtoul(argv[1], NULL, 10);
|
|
if (cursor_attr.status && argc != 8)
|
|
return -1;
|
|
if (argc == 8) {
|
|
cursor_attr.mode = (unsigned char)simple_strtoul(argv[2], NULL, 10);
|
|
cursor_attr.x = (unsigned short)simple_strtoul(argv[3], NULL, 10);
|
|
cursor_attr.y = (unsigned short)simple_strtoul(argv[4], NULL, 10);
|
|
|
|
cursor_attr.red = (unsigned short)simple_strtoul(argv[5], NULL, 10);
|
|
cursor_attr.green = (unsigned short)simple_strtoul(argv[6], NULL, 10);
|
|
cursor_attr.blue = (unsigned short)simple_strtoul(argv[7], NULL, 10);
|
|
}
|
|
aml_lcd_driver_cursor(1, &cursor_attr);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int do_lcd1_check(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_config_check(1);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_prbs(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int ms, prbs_freq = 0, prbs_mode_flag;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "vx1") == 0) {
|
|
if (argc == 3)
|
|
prbs_mode_flag = LCD_PRBS_MODE_VX1;
|
|
else
|
|
return -1;
|
|
ms = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
} else if (strcmp(argv[1], "lvds") == 0) {
|
|
if (argc == 3)
|
|
prbs_mode_flag = LCD_PRBS_MODE_LVDS;
|
|
else
|
|
return -1;
|
|
ms = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
} else if (strcmp(argv[1], "freq") == 0) {
|
|
if (argc == 4)
|
|
prbs_mode_flag = LCD_PRBS_MODE_FREQ;
|
|
else
|
|
return -1;
|
|
prbs_freq = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
ms = (unsigned int)simple_strtoul(argv[3], NULL, 10);
|
|
} else {
|
|
prbs_mode_flag = LCD_PRBS_MODE_LVDS | LCD_PRBS_MODE_VX1;
|
|
ms = (unsigned int)simple_strtoul(argv[1], NULL, 10);
|
|
}
|
|
|
|
aml_lcd_driver_prbs(1, ms, prbs_freq, prbs_mode_flag);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd1_panel_dump(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
if (argc == 2)
|
|
aml_lcd_panel_dump(1, argv[1]);
|
|
else
|
|
aml_lcd_panel_dump(1, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_AML_LCD_EXTERN
|
|
static int do_lcd1_ext(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int temp;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "info") == 0) {
|
|
aml_lcd_driver_ext_info(1);
|
|
} else if (strcmp(argv[1], "power") == 0) {
|
|
if (argc < 3)
|
|
return -1;
|
|
temp = simple_strtoul(argv[2], NULL, 10);
|
|
if (temp)
|
|
aml_lcd_driver_ext_power_on(1);
|
|
else
|
|
aml_lcd_driver_ext_power_off(1);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static int do_lcd1_bl(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
int level;
|
|
int ret = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "on") == 0) {
|
|
aml_lcd_driver_bl_on(1);
|
|
} else if (strcmp(argv[1], "off") == 0) {
|
|
aml_lcd_driver_bl_off(1);
|
|
} else if (strcmp(argv[1], "set") == 0) {
|
|
if (argc == 3) {
|
|
level = (int)simple_strtol(argv[2], NULL, 10);
|
|
aml_lcd_driver_set_bl_level(1, level);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "get") == 0) {
|
|
level = aml_lcd_driver_get_bl_level(1);
|
|
printf("lcd1 get_bl_level: %d\n", level);
|
|
} else if (strcmp(argv[1], "info") == 0) {
|
|
aml_lcd_driver_bl_config_print(1);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int do_lcd2_probe(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_probe(2);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd2_enable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_enable(2, "NULL");
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd2_disable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_disable(2);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd2_power(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int val = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
val = (unsigned int)simple_strtoul(argv[1], NULL, 10);
|
|
|
|
aml_lcd_driver_power_ctrl(2, val);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd2_ss(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
int value, temp;
|
|
int ret = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "level") == 0) {
|
|
if (argc == 3) {
|
|
value = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
value &= 0xff;
|
|
aml_lcd_driver_set_ss(2, value, 0xff, 0xff);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "freq") == 0) {
|
|
if (argc == 3) {
|
|
value = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
value &= 0xf;
|
|
aml_lcd_driver_set_ss(2, 0xff, value, 0xff);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "mode") == 0) {
|
|
if (argc == 3) {
|
|
value = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
value &= 0xf;
|
|
aml_lcd_driver_set_ss(2, 0xff, 0xff, value);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "set") == 0) {
|
|
if (argc == 3) {
|
|
value = (unsigned int)simple_strtoul(argv[2], NULL, 16);
|
|
value &= 0xffff;
|
|
temp = value >> 8;
|
|
aml_lcd_driver_set_ss(2, (value & 0xff),
|
|
((temp >> LCD_CLK_SS_BIT_FREQ) & 0xf),
|
|
((temp >> LCD_CLK_SS_BIT_MODE) & 0xf));
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "get") == 0) {
|
|
aml_lcd_driver_get_ss(2);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int do_lcd2_clk(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_clk_info(2);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd2_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int val = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
val = (unsigned int)simple_strtoul(argv[1], NULL, 16);
|
|
|
|
aml_lcd_driver_debug_print(2, val);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd2_dump(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_info(2);
|
|
aml_lcd_driver_reg_info(2);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd2_info(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_info(2);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd2_reg(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_driver_reg_info(2);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd2_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int num;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
num = (unsigned int)simple_strtoul(argv[1], NULL, 10);
|
|
aml_lcd_driver_test(2, num);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd2_check(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_config_check(2);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd2_prbs(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int ms, prbs_freq = 0, prbs_mode_flag;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "vx1") == 0) {
|
|
if (argc == 3)
|
|
prbs_mode_flag = LCD_PRBS_MODE_VX1;
|
|
else
|
|
return -1;
|
|
ms = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
} else if (strcmp(argv[1], "lvds") == 0) {
|
|
if (argc == 3)
|
|
prbs_mode_flag = LCD_PRBS_MODE_LVDS;
|
|
else
|
|
return -1;
|
|
ms = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
} else if (strcmp(argv[1], "freq") == 0) {
|
|
if (argc == 4)
|
|
prbs_mode_flag = LCD_PRBS_MODE_FREQ;
|
|
else
|
|
return -1;
|
|
prbs_freq = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
ms = (unsigned int)simple_strtoul(argv[3], NULL, 10);
|
|
} else {
|
|
prbs_mode_flag = LCD_PRBS_MODE_LVDS | LCD_PRBS_MODE_VX1;
|
|
ms = (unsigned int)simple_strtoul(argv[1], NULL, 10);
|
|
}
|
|
|
|
aml_lcd_driver_prbs(2, ms, prbs_freq, prbs_mode_flag);
|
|
return 0;
|
|
}
|
|
|
|
static int do_lcd2_panel_dump(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
if (argc == 2)
|
|
aml_lcd_panel_dump(2, argv[1]);
|
|
else
|
|
aml_lcd_panel_dump(2, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_AML_LCD_EXTERN
|
|
static int do_lcd2_ext(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
unsigned int temp;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "info") == 0) {
|
|
aml_lcd_driver_ext_info(2);
|
|
} else if (strcmp(argv[1], "power") == 0) {
|
|
if (argc < 3)
|
|
return -1;
|
|
temp = simple_strtoul(argv[2], NULL, 10);
|
|
if (temp)
|
|
aml_lcd_driver_ext_power_on(2);
|
|
else
|
|
aml_lcd_driver_ext_power_off(2);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
static int do_lcd2_bl(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
int level;
|
|
int ret = 0;
|
|
|
|
if (argc == 1)
|
|
return -1;
|
|
|
|
if (strcmp(argv[1], "on") == 0) {
|
|
aml_lcd_driver_bl_on(2);
|
|
} else if (strcmp(argv[1], "off") == 0) {
|
|
aml_lcd_driver_bl_off(2);
|
|
} else if (strcmp(argv[1], "set") == 0) {
|
|
if (argc == 3) {
|
|
level = (int)simple_strtol(argv[2], NULL, 10);
|
|
aml_lcd_driver_set_bl_level(2, level);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
} else if (strcmp(argv[1], "get") == 0) {
|
|
level = aml_lcd_driver_get_bl_level(2);
|
|
printf("lcd2 get_bl_level: %d\n", level);
|
|
} else if (strcmp(argv[1], "info") == 0) {
|
|
aml_lcd_driver_bl_config_print(2);
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int do_mipi_dsi_cmd(int index, cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
int temp, i;
|
|
unsigned char rd_c[4] = {0, 0, 0, 0};
|
|
unsigned char wr_c[32] = {0};
|
|
|
|
if (argc < 3)
|
|
return -1;
|
|
|
|
if (!strcmp(argv[1], "HS") || !strcmp(argv[1], "LP")) {
|
|
temp = (argv[1][0] == 'H') ? 0x10 : 0x00;
|
|
if (!strcmp(argv[2], "HIGH"))
|
|
temp |= 0x0;
|
|
if (!strcmp(argv[2], "LOW"))
|
|
temp |= 0x1;
|
|
if (!strcmp(argv[2], "PRBS7"))
|
|
temp |= 0x2;
|
|
if (!strcmp(argv[2], "PRBS11"))
|
|
temp |= 0x3;
|
|
if (!strcmp(argv[2], "PRBS15"))
|
|
temp |= 0x4;
|
|
if (!strcmp(argv[2], "PRBS31"))
|
|
temp |= 0x5;
|
|
|
|
aml_lcd_mipi_dsi_dphy_test(index, temp);
|
|
return 0;
|
|
}
|
|
|
|
if (!strcmp(argv[1], "LPCD") || !strcmp(argv[1], "LPRX")) {
|
|
aml_lcd_mipi_dsi_dphy_test(index, 0x20);
|
|
return 0;
|
|
}
|
|
|
|
if (strcmp(argv[1], "mpmode") == 0) {
|
|
temp = (unsigned int)simple_strtoul(argv[2], NULL, 10);
|
|
aml_lcd_mipi_dsi_mode(index, temp);
|
|
return 0;
|
|
}
|
|
|
|
if (argc < 4)
|
|
return -1;
|
|
|
|
wr_c[0] = (unsigned char)simple_strtoul(argv[2], NULL, 16); // data_type
|
|
wr_c[1] = (unsigned char)simple_strtoul(argv[3], NULL, 10); // count
|
|
for (i = 0; i < (wr_c[1] > 30 ? 30 : wr_c[1]); i++)
|
|
wr_c[i + 2] = (unsigned char)simple_strtoul(argv[4 + i], NULL, 16); // count
|
|
|
|
if (strcmp(argv[1], "mpread") == 0) {
|
|
temp = aml_lcd_mipi_dsi_read(index, &wr_c[0], &rd_c[0], 4);
|
|
if (temp < 0 || temp > 4) {
|
|
printf("lcd%d mipi dsi read failed\n", index);
|
|
return 0;
|
|
}
|
|
printf("lcd%d mipi dsi read %d: ", index, temp);
|
|
while (temp) {
|
|
printf("0x%02x ", rd_c[temp - 1]);
|
|
temp--;
|
|
}
|
|
printf("\n");
|
|
return 0;
|
|
} else if (strcmp(argv[1], "mpcmd") == 0) {
|
|
aml_lcd_mipi_dsi_cmd(index, &wr_c[0]);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int do_lcd_dsi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
return do_mipi_dsi_cmd(0, cmdtp, flag, argc, argv);
|
|
}
|
|
|
|
static int do_lcd1_dsi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
return do_mipi_dsi_cmd(1, cmdtp, flag, argc, argv);
|
|
}
|
|
|
|
static int do_lcd_list(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
aml_lcd_list();
|
|
return argc;
|
|
}
|
|
|
|
static int do_lcd0_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
if (argc != 2)
|
|
return 0;
|
|
|
|
aml_lcd_set(0, argv[1]);
|
|
return argc;
|
|
}
|
|
|
|
static int do_lcd1_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
if (argc != 2)
|
|
return 0;
|
|
|
|
aml_lcd_set(1, argv[1]);
|
|
return argc;
|
|
}
|
|
|
|
static int do_lcd2_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
if (argc != 2)
|
|
return 0;
|
|
|
|
aml_lcd_set(2, argv[1]);
|
|
return argc;
|
|
}
|
|
|
|
U_BOOT_CMD(lcd_list, 4, 0, do_lcd_list, "lcd dts config setting helper", "");
|
|
|
|
static cmd_tbl_t cmd_lcd_sub[] = {
|
|
U_BOOT_CMD_MKENT(list, 2, 0, do_lcd_list, "", ""),
|
|
U_BOOT_CMD_MKENT(set, 2, 0, do_lcd0_set, "", ""),
|
|
U_BOOT_CMD_MKENT(probe, 2, 0, do_lcd_probe, "", ""),
|
|
U_BOOT_CMD_MKENT(enable, 2, 0, do_lcd_enable, "", ""),
|
|
U_BOOT_CMD_MKENT(disable, 2, 0, do_lcd_disable, "", ""),
|
|
U_BOOT_CMD_MKENT(power, 3, 0, do_lcd_power, "", ""),
|
|
U_BOOT_CMD_MKENT(ss, 4, 0, do_lcd_ss, "", ""),
|
|
U_BOOT_CMD_MKENT(clk, 2, 0, do_lcd_clk, "", ""),
|
|
U_BOOT_CMD_MKENT(print, 3, 0, do_lcd_print, "", ""),
|
|
U_BOOT_CMD_MKENT(dump, 2, 0, do_lcd_dump, "", ""),
|
|
U_BOOT_CMD_MKENT(info, 2, 0, do_lcd_info, "", ""),
|
|
#ifdef CONFIG_AML_LCD_TCON
|
|
U_BOOT_CMD_MKENT(tcon, 3, 0, do_lcd_tcon, "", ""),
|
|
#endif
|
|
U_BOOT_CMD_MKENT(vbyone, 3, 0, do_lcd_vbyone, "", ""),
|
|
// U_BOOT_CMD_MKENT(edp, 3, 0, do_lcd_edp, "", ""),
|
|
U_BOOT_CMD_MKENT(dsi, 32, 0, do_lcd_dsi, "", ""),
|
|
U_BOOT_CMD_MKENT(reg, 2, 0, do_lcd_reg, "", ""),
|
|
U_BOOT_CMD_MKENT(test, 3, 0, do_lcd_test, "", ""),
|
|
U_BOOT_CMD_MKENT(window, 3, 0, do_lcd_window, "", ""),
|
|
U_BOOT_CMD_MKENT(check, 2, 0, do_lcd_check, "", ""),
|
|
U_BOOT_CMD_MKENT(cursor, 4, 0, do_lcd_cursor, "", ""),
|
|
U_BOOT_CMD_MKENT(prbs, 2, 0, do_lcd_prbs, "", ""),
|
|
U_BOOT_CMD_MKENT(panel_dump, 3, 0, do_lcd_panel_dump, "", ""),
|
|
U_BOOT_CMD_MKENT(mem, 4, 0, do_lcd_mem, "", ""),
|
|
#ifdef CONFIG_AML_LCD_EXTERN
|
|
U_BOOT_CMD_MKENT(ext, 4, 0, do_lcd_ext, "", ""),
|
|
#endif
|
|
U_BOOT_CMD_MKENT(bl, 4, 0, do_lcd_bl, "", ""),
|
|
};
|
|
|
|
static cmd_tbl_t cmd_lcd1_sub[] = {
|
|
U_BOOT_CMD_MKENT(list, 2, 0, do_lcd_list, "", ""),
|
|
U_BOOT_CMD_MKENT(set, 2, 0, do_lcd1_set, "", ""),
|
|
U_BOOT_CMD_MKENT(probe, 2, 0, do_lcd1_probe, "", ""),
|
|
U_BOOT_CMD_MKENT(enable, 2, 0, do_lcd1_enable, "", ""),
|
|
U_BOOT_CMD_MKENT(disable, 2, 0, do_lcd1_disable, "", ""),
|
|
U_BOOT_CMD_MKENT(power, 3, 0, do_lcd1_power, "", ""),
|
|
U_BOOT_CMD_MKENT(ss, 4, 0, do_lcd1_ss, "", ""),
|
|
U_BOOT_CMD_MKENT(clk, 2, 0, do_lcd1_clk, "", ""),
|
|
U_BOOT_CMD_MKENT(print, 3, 0, do_lcd1_print, "", ""),
|
|
U_BOOT_CMD_MKENT(dump, 2, 0, do_lcd1_dump, "", ""),
|
|
U_BOOT_CMD_MKENT(info, 2, 0, do_lcd1_info, "", ""),
|
|
U_BOOT_CMD_MKENT(vbyone, 3, 0, do_lcd1_vbyone, "", ""),
|
|
// U_BOOT_CMD_MKENT(edp, 3, 0, do_lcd1_edp, "", ""),
|
|
U_BOOT_CMD_MKENT(dsi, 32, 0, do_lcd1_dsi, "", ""),
|
|
U_BOOT_CMD_MKENT(reg, 2, 0, do_lcd1_reg, "", ""),
|
|
U_BOOT_CMD_MKENT(test, 3, 0, do_lcd1_test, "", ""),
|
|
U_BOOT_CMD_MKENT(window, 3, 0, do_lcd1_window, "", ""),
|
|
U_BOOT_CMD_MKENT(check, 2, 0, do_lcd1_check, "", ""),
|
|
U_BOOT_CMD_MKENT(cursor, 4, 0, do_lcd1_cursor, "", ""),
|
|
U_BOOT_CMD_MKENT(prbs, 2, 0, do_lcd1_prbs, "", ""),
|
|
U_BOOT_CMD_MKENT(panel_dump, 3, 0, do_lcd1_panel_dump, "", ""),
|
|
#ifdef CONFIG_AML_LCD_EXTERN
|
|
U_BOOT_CMD_MKENT(ext, 4, 0, do_lcd1_ext, "", ""),
|
|
#endif
|
|
U_BOOT_CMD_MKENT(bl, 4, 0, do_lcd1_bl, "", ""),
|
|
};
|
|
|
|
static cmd_tbl_t cmd_lcd2_sub[] = {
|
|
U_BOOT_CMD_MKENT(list, 2, 0, do_lcd_list, "", ""),
|
|
U_BOOT_CMD_MKENT(set, 2, 0, do_lcd2_set, "", ""),
|
|
U_BOOT_CMD_MKENT(probe, 2, 0, do_lcd2_probe, "", ""),
|
|
U_BOOT_CMD_MKENT(enable, 2, 0, do_lcd2_enable, "", ""),
|
|
U_BOOT_CMD_MKENT(disable, 2, 0, do_lcd2_disable, "", ""),
|
|
U_BOOT_CMD_MKENT(power, 3, 0, do_lcd2_power, "", ""),
|
|
U_BOOT_CMD_MKENT(ss, 4, 0, do_lcd2_ss, "", ""),
|
|
U_BOOT_CMD_MKENT(clk, 2, 0, do_lcd2_clk, "", ""),
|
|
U_BOOT_CMD_MKENT(print, 3, 0, do_lcd2_print, "", ""),
|
|
U_BOOT_CMD_MKENT(dump, 2, 0, do_lcd2_dump, "", ""),
|
|
U_BOOT_CMD_MKENT(info, 2, 0, do_lcd2_info, "", ""),
|
|
U_BOOT_CMD_MKENT(reg, 2, 0, do_lcd2_reg, "", ""),
|
|
U_BOOT_CMD_MKENT(test, 3, 0, do_lcd2_test, "", ""),
|
|
U_BOOT_CMD_MKENT(check, 2, 0, do_lcd2_check, "", ""),
|
|
U_BOOT_CMD_MKENT(prbs, 2, 0, do_lcd2_prbs, "", ""),
|
|
U_BOOT_CMD_MKENT(panel_dump, 3, 0, do_lcd2_panel_dump, "", ""),
|
|
#ifdef CONFIG_AML_LCD_EXTERN
|
|
U_BOOT_CMD_MKENT(ext, 4, 0, do_lcd2_ext, "", ""),
|
|
#endif
|
|
U_BOOT_CMD_MKENT(bl, 4, 0, do_lcd2_bl, "", ""),
|
|
};
|
|
|
|
static int do_lcd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
cmd_tbl_t *c;
|
|
|
|
/* Strip off leading 'bmp' command argument */
|
|
argc--;
|
|
argv++;
|
|
|
|
c = find_cmd_tbl(argv[0], &cmd_lcd_sub[0], ARRAY_SIZE(cmd_lcd_sub));
|
|
|
|
if (c)
|
|
return c->cmd(cmdtp, flag, argc, argv);
|
|
|
|
cmd_usage(cmdtp);
|
|
return 1;
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
lcd, 32, 0, do_lcd, "lcd sub-system",
|
|
"lcd probe - probe lcd parameters\n"
|
|
"lcd enable - enable lcd module\n"
|
|
"lcd disable - disable lcd module\n"
|
|
"lcd ss - lcd pll spread spectrum operation\n"
|
|
"lcd bl - lcd backlight operation\n"
|
|
"lcd clk - show lcd pll & clk parameters\n"
|
|
"lcd dump - show lcd parameters and registers\n"
|
|
"lcd info - show lcd parameters\n"
|
|
#ifdef CONFIG_AML_LCD_TCON
|
|
"lcd tcon - show lcd tcon debug\n"
|
|
#endif
|
|
"lcd vbyone - show lcd vbyone debug\n"
|
|
"lcd reg - dump lcd registers\n"
|
|
"lcd test - show lcd bist pattern\n"
|
|
"lcd check - show lcd bist pattern\n"
|
|
"lcd panel_dump - show lcd panel config\n"
|
|
"lcd mem - show lcd memory used\n"
|
|
#ifdef CONFIG_AML_LCD_EXTERN
|
|
"lcd ext - show lcd extern information\n"
|
|
#endif
|
|
);
|
|
|
|
static int do_lcd1(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
cmd_tbl_t *c;
|
|
|
|
/* Strip off leading 'bmp' command argument */
|
|
argc--;
|
|
argv++;
|
|
|
|
c = find_cmd_tbl(argv[0], &cmd_lcd1_sub[0], ARRAY_SIZE(cmd_lcd1_sub));
|
|
|
|
if (c)
|
|
return c->cmd(cmdtp, flag, argc, argv);
|
|
|
|
cmd_usage(cmdtp);
|
|
return 1;
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
lcd1, 32, 0, do_lcd1, "lcd1 sub-system",
|
|
"lcd1 probe - probe lcd parameters\n"
|
|
"lcd1 enable - enable lcd module\n"
|
|
"lcd1 disable - disable lcd module\n"
|
|
"lcd1 ss - lcd pll spread spectrum operation\n"
|
|
"lcd1 bl - lcd backlight operation\n"
|
|
"lcd1 clk - show lcd pll & clk parameters\n"
|
|
"lcd1 dump - show lcd parameters and registers\n"
|
|
"lcd1 info - show lcd parameters\n"
|
|
#ifdef CONFIG_AML_LCD_TCON
|
|
"lcd1 tcon - show lcd tcon debug\n"
|
|
#endif
|
|
"lcd1 vbyone - show lcd vbyone debug\n"
|
|
"lcd1 reg - dump lcd registers\n"
|
|
"lcd1 test - show lcd bist pattern\n"
|
|
"lcd1 panel_dump - show lcd panel config\n"
|
|
#ifdef CONFIG_AML_LCD_EXTERN
|
|
"lcd1 ext - show lcd extern information\n"
|
|
#endif
|
|
);
|
|
|
|
static int do_lcd2(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
cmd_tbl_t *c;
|
|
|
|
/* Strip off leading 'bmp' command argument */
|
|
argc--;
|
|
argv++;
|
|
|
|
c = find_cmd_tbl(argv[0], &cmd_lcd2_sub[0], ARRAY_SIZE(cmd_lcd2_sub));
|
|
|
|
if (c)
|
|
return c->cmd(cmdtp, flag, argc, argv);
|
|
|
|
cmd_usage(cmdtp);
|
|
return 1;
|
|
}
|
|
|
|
U_BOOT_CMD(
|
|
lcd2, 5, 0, do_lcd2, "lcd2 sub-system",
|
|
"lcd2 probe - probe lcd parameters\n"
|
|
"lcd2 enable - enable lcd module\n"
|
|
"lcd2 disable - disable lcd module\n"
|
|
"lcd2 ss - lcd pll spread spectrum operation\n"
|
|
"lcd2 bl - lcd backlight operation\n"
|
|
"lcd2 clk - show lcd pll & clk parameters\n"
|
|
"lcd2 dump - show lcd parameters and registers\n"
|
|
"lcd2 info - show lcd parameters\n"
|
|
"lcd2 reg - dump lcd registers\n"
|
|
"lcd2 test - show lcd bist pattern\n"
|
|
"lcd2 panel_dump - show lcd panel config\n"
|
|
#ifdef CONFIG_AML_LCD_EXTERN
|
|
"lcd2 ext - show lcd extern information\n"
|
|
#endif
|
|
);
|
|
|
|
#ifdef CONFIG_AML_LCD_TCON
|
|
#define DBG_TCON_REG_8_bit 1
|
|
#define DBG_TCON_REG_32_bit 0
|
|
|
|
static int do_aml_tcon_reg(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
struct aml_lcd_drv_s *pdrv = aml_lcd_get_driver(0);
|
|
unsigned int addr, mask, val, temp, bit_width, len;
|
|
int ret = 0, i;
|
|
|
|
if (!pdrv) {
|
|
printf("for_tool:ERROR\n");
|
|
printf("no lcd driver\n");
|
|
return 0;
|
|
}
|
|
if (!pdrv->tcon_reg_write) {
|
|
printf("for_tool:ERROR\n");
|
|
printf("tcon_reg_write is null\n");
|
|
return 0;
|
|
}
|
|
if (!pdrv->tcon_reg_read) {
|
|
printf("for_tool:ERROR\n");
|
|
printf("tcon_reg_read is null\n");
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[1], "wn") == 0) {
|
|
if (argc < 5) {
|
|
printf("for_tool:ERROR\n");
|
|
printf("argc is not enough\n");
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[2], "8") == 0) {
|
|
bit_width = DBG_TCON_REG_8_bit;
|
|
} else if (strcmp(argv[2], "32") == 0) {
|
|
bit_width = DBG_TCON_REG_32_bit;
|
|
} else {
|
|
printf("for_tool:ERROR\n");
|
|
printf("aml_tcon reg bit_width %s invalid\n", argv[2]);
|
|
return 0;
|
|
}
|
|
addr = (unsigned int)simple_strtoul(argv[3], NULL, 16);
|
|
len = (unsigned int)simple_strtoul(argv[4], NULL, 10);
|
|
if (len == 0 || len > 16) {
|
|
printf("for_tool:ERROR\n");
|
|
printf("aml_tcon reg len %d not support\n", len);
|
|
return 0;
|
|
}
|
|
if (argc < (len + 5)) {
|
|
printf("for_tool:ERROR\n");
|
|
printf("aml_tcon reg data cnt %d not enough\n", (argc - 5));
|
|
return 0;
|
|
}
|
|
for (i = 0; i < len; i++) {
|
|
val = (unsigned int)simple_strtoul(argv[5 + i], NULL, 16);
|
|
pdrv->tcon_reg_write(addr + i, val, bit_width);
|
|
}
|
|
printf("for_tool:");
|
|
if (bit_width == DBG_TCON_REG_8_bit) {
|
|
for (i = 0; i < len; i++) {
|
|
temp = pdrv->tcon_reg_read(addr + i, bit_width);
|
|
printf("0x%04x=0x%02x ", addr + i, temp);
|
|
}
|
|
} else {
|
|
for (i = 0; i < len; i++) {
|
|
temp = pdrv->tcon_reg_read(addr + i, bit_width);
|
|
printf("0x%04x=0x%08x ", addr + i, temp);
|
|
}
|
|
}
|
|
printf("\n");
|
|
} else if (strcmp(argv[1], "wm") == 0) {
|
|
if (argc < 6) {
|
|
printf("for_tool:ERROR\n");
|
|
printf("argc is not enough\n");
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[2], "8") == 0) {
|
|
bit_width = DBG_TCON_REG_8_bit;
|
|
} else if (strcmp(argv[2], "32") == 0) {
|
|
bit_width = DBG_TCON_REG_32_bit;
|
|
} else {
|
|
printf("for_tool:ERROR\n");
|
|
printf("aml_tcon reg bit_width %s invalid\n", argv[2]);
|
|
return 0;
|
|
}
|
|
addr = (unsigned int)simple_strtoul(argv[3], NULL, 16);
|
|
mask = (unsigned int)simple_strtoul(argv[4], NULL, 16);
|
|
val = (unsigned int)simple_strtoul(argv[5], NULL, 16);
|
|
|
|
temp = pdrv->tcon_reg_read(addr, bit_width);
|
|
temp &= ~mask;
|
|
temp |= val & mask;
|
|
pdrv->tcon_reg_write(addr, temp, bit_width);
|
|
printf("for_tool:");
|
|
temp = pdrv->tcon_reg_read(addr, bit_width);
|
|
if (bit_width == DBG_TCON_REG_8_bit)
|
|
printf("0x%04x=0x%02x\n", addr, temp);
|
|
else
|
|
printf("0x%04x=0x%08x\n", addr, temp);
|
|
} else if (strcmp(argv[1], "ws") == 0) {
|
|
if (argc < 5) {
|
|
printf("for_tool:ERROR\n");
|
|
printf("argc is not enough\n");
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[2], "8") == 0) {
|
|
bit_width = DBG_TCON_REG_8_bit;
|
|
} else if (strcmp(argv[2], "32") == 0) {
|
|
bit_width = DBG_TCON_REG_32_bit;
|
|
} else {
|
|
printf("for_tool:ERROR\n");
|
|
printf("aml_tcon reg bit_width %s invalid\n", argv[2]);
|
|
return 0;
|
|
}
|
|
addr = (unsigned int)simple_strtoul(argv[3], NULL, 16);
|
|
len = (unsigned int)simple_strtoul(argv[4], NULL, 10);
|
|
if (len == 0 || len > 16) {
|
|
printf("for_tool:ERROR\n");
|
|
printf("aml_tcon reg len %d not support\n", len);
|
|
return 0;
|
|
}
|
|
if (argc < (len + 5)) {
|
|
printf("for_tool:ERROR\n");
|
|
printf("aml_tcon reg data cnt %d not enough\n", (argc - 5));
|
|
return 0;
|
|
}
|
|
for (i = 0; i < len; i++) {
|
|
val = (unsigned int)simple_strtoul(argv[5 + i], NULL, 16);
|
|
pdrv->tcon_reg_write(addr, val, bit_width);
|
|
}
|
|
printf("for_tool:");
|
|
if (bit_width == DBG_TCON_REG_8_bit) {
|
|
for (i = 0; i < len; i++) {
|
|
temp = pdrv->tcon_reg_read(addr, bit_width);
|
|
printf("0x%04x=0x%02x ", addr, temp);
|
|
}
|
|
} else {
|
|
for (i = 0; i < len; i++) {
|
|
temp = pdrv->tcon_reg_read(addr, bit_width);
|
|
printf("0x%04x=0x%08x ", addr, temp);
|
|
}
|
|
}
|
|
printf("\n");
|
|
} else if (strcmp(argv[1], "rn") == 0) {
|
|
if (argc < 4) {
|
|
printf("for_tool:ERROR\n");
|
|
printf("argc is not enough\n");
|
|
return 0;
|
|
}
|
|
if (strcmp(argv[2], "8") == 0) {
|
|
bit_width = DBG_TCON_REG_8_bit;
|
|
} else if (strcmp(argv[2], "32") == 0) {
|
|
bit_width = DBG_TCON_REG_32_bit;
|
|
} else {
|
|
printf("for_tool:ERROR\n");
|
|
printf("aml_tcon reg bit_width %s invalid\n", argv[2]);
|
|
return 0;
|
|
}
|
|
addr = (unsigned int)simple_strtoul(argv[3], NULL, 16);
|
|
if (argc == 4)
|
|
len = 1;
|
|
else
|
|
len = (unsigned int)simple_strtoul(argv[4], NULL, 10);
|
|
if (len == 0 || len > 16) {
|
|
printf("for_tool:ERROR\n");
|
|
printf("aml_tcon reg len %d not support\n", len);
|
|
return 0;
|
|
}
|
|
printf("for_tool:");
|
|
if (bit_width == DBG_TCON_REG_8_bit) {
|
|
for (i = 0; i < len; i++) {
|
|
temp = pdrv->tcon_reg_read(addr + i, bit_width);
|
|
printf("0x%04x=0x%02x ", addr + i, temp);
|
|
}
|
|
} else {
|
|
for (i = 0; i < len; i++) {
|
|
temp = pdrv->tcon_reg_read(addr + i, bit_width);
|
|
printf("0x%04x=0x%08x ", addr + i, temp);
|
|
}
|
|
}
|
|
printf("\n");
|
|
} else {
|
|
printf("for_tool:ERROR\n");
|
|
ret = -1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static cmd_tbl_t cmd_aml_tcon_sub[] = {
|
|
U_BOOT_CMD_MKENT(reg, 32, 0, do_aml_tcon_reg, "", ""),
|
|
};
|
|
|
|
static int do_aml_tcon(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
{
|
|
cmd_tbl_t *c;
|
|
|
|
/* Strip off leading 'bmp' command argument */
|
|
argc--;
|
|
argv++;
|
|
|
|
c = find_cmd_tbl(argv[0], &cmd_aml_tcon_sub[0], ARRAY_SIZE(cmd_aml_tcon_sub));
|
|
|
|
if (c)
|
|
return c->cmd(cmdtp, flag, argc, argv);
|
|
|
|
cmd_usage(cmdtp);
|
|
return 1;
|
|
}
|
|
|
|
U_BOOT_CMD(aml_tcon, 32, 0, do_aml_tcon,
|
|
"aml_tcon sub-system",
|
|
"aml_tcon reg - aml_tcon reg access\n"
|
|
);
|
|
#endif
|