king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b394c2d4e7'
${ noResults }
v811_spc009/vendor/tools/board/huanglong/pdm/pdmtool.c

1392 lines
45 KiB
Raw Blame History

/*
* Copyright (c) Hisilicon Technologies Co., Ltd.. 2009-2020. All rights reserved.
* Description: pdm_tools
* Author: Hisilicon
* Create: 2009-03-17
*/
#include <fcntl.h>
#include <unistd.h>
#include <limits.h>
#include <regex.h>
#include "securec.h"
#include "uapi_pdm.h"
#define INPUT_PARAM_LEN 200
#define BUF_LEN 2048
#define INPUT_CMD_NUM_2 2
#define INPUT_CMD_NUM_3 3
#define INPUT_CMD_NUM_4 4
#define INPUT_CMD_NUM_5 5
#define ERRBUF_ARRAY_LEN 128
#define check_pdm_param_u32(p1, p2) \
do { \
if ((p1) != (p2)) { \
printf("set param is not the same, set: 0x%x, read:0x%x, line: %d\n", (p1), (p2), __LINE__); \
} \
} while (0) \
#define check_pdm_param_u64(p1, p2) \
do { \
if ((p1) != (p2)) { \
printf("set param is not the same, set: 0x%llx, read:0x%llx, line: %d\n", (p1), (p2), __LINE__); \
} \
} while (0) \
#define check_pdm_param_char(p1, p2) \
do { \
if ((p1) != (p2)) { \
printf("set param is not the same, set: %s, read:%s, line: %d\n", (p1), (p2), __LINE__); \
} \
} while (0) \
typedef struct {
td_char *str;
td_s32 flag;
} ext_disp_param_flag;
typedef struct {
td_char *str;
td_s32 key_id;
td_s32 key_len;
} ext_hdcp_key;
static ext_disp_param_flag g_format[] = {
{"NTSC", UAPI_VIDEO_FMT_NTSC},
{"NTSC_J", UAPI_VIDEO_FMT_NTSC_J},
{"NTSC_PAL_M", UAPI_VIDEO_FMT_NTSC_PAL_M},
{"SECAM_SIN", UAPI_VIDEO_FMT_SECAM_SIN},
{"SECAM_COS", UAPI_VIDEO_FMT_SECAM_COS},
{"PAL", UAPI_VIDEO_FMT_PAL},
{"PAL_N", UAPI_VIDEO_FMT_PAL_N},
{"PAL_NC", UAPI_VIDEO_FMT_PAL_NC},
{"480P60", UAPI_VIDEO_FMT_480P_60},
{"576P50", UAPI_VIDEO_FMT_576P_50},
{"720P50", UAPI_VIDEO_FMT_720P_50},
{"720P59_94", UAPI_VIDEO_FMT_720P_59_94},
{"720P60", UAPI_VIDEO_FMT_720P_60},
{"1080I50", UAPI_VIDEO_FMT_1080I_50},
{"1080I59_94", UAPI_VIDEO_FMT_1080I_59_94},
{"1080I60", UAPI_VIDEO_FMT_1080I_60},
{"1080P23_976", UAPI_VIDEO_FMT_1080P_23_976},
{"1080P24", UAPI_VIDEO_FMT_1080P_24},
{"1080P25", UAPI_VIDEO_FMT_1080P_25},
{"1080P29_97", UAPI_VIDEO_FMT_1080P_29_97},
{"1080P30", UAPI_VIDEO_FMT_1080P_30},
{"1080P50", UAPI_VIDEO_FMT_1080P_50},
{"1080P59_94", UAPI_VIDEO_FMT_1080P_59_94},
{"1080P60", UAPI_VIDEO_FMT_1080P_60},
{"1080P100", UAPI_VIDEO_FMT_1080P_100},
{"1080P119_88", UAPI_VIDEO_FMT_1080P_119_88},
{"1080P120", UAPI_VIDEO_FMT_1080P_120},
{"3840X2160_23_976", UAPI_VIDEO_FMT_3840X2160_23_976},
{"3840X2160_24", UAPI_VIDEO_FMT_3840X2160_24},
{"3840X2160_25", UAPI_VIDEO_FMT_3840X2160_25},
{"3840X2160_29_97", UAPI_VIDEO_FMT_3840X2160_29_97},
{"3840X2160_30", UAPI_VIDEO_FMT_3840X2160_30},
{"3840X2160_50", UAPI_VIDEO_FMT_3840X2160_50},
{"3840X2160_59_94", UAPI_VIDEO_FMT_3840X2160_59_94},
{"3840X2160_60", UAPI_VIDEO_FMT_3840X2160_60},
{"3840X2160_100", UAPI_VIDEO_FMT_3840X2160_100},
{"3840X2160_119_88", UAPI_VIDEO_FMT_3840X2160_119_88},
{"3840X2160_120", UAPI_VIDEO_FMT_3840X2160_120},
{"4096X2160_23_976", UAPI_VIDEO_FMT_4096X2160_23_976},
{"4096X2160_24", UAPI_VIDEO_FMT_4096X2160_24},
{"4096X2160_25", UAPI_VIDEO_FMT_4096X2160_25},
{"4096X2160_29_97", UAPI_VIDEO_FMT_4096X2160_29_97},
{"4096X2160_30", UAPI_VIDEO_FMT_4096X2160_30},
{"4096X2160_50", UAPI_VIDEO_FMT_4096X2160_50},
{"4096X2160_59_94", UAPI_VIDEO_FMT_4096X2160_59_94},
{"4096X2160_60", UAPI_VIDEO_FMT_4096X2160_60},
{"4096X2160_100", UAPI_VIDEO_FMT_4096X2160_100},
{"4096X2160_119_88", UAPI_VIDEO_FMT_4096X2160_119_88},
{"4096X2160_120", UAPI_VIDEO_FMT_4096X2160_120},
{"7680X4320_23_976", UAPI_VIDEO_FMT_7680X4320_23_976},
{"7680X4320_24", UAPI_VIDEO_FMT_7680X4320_24},
{"7680X4320_25", UAPI_VIDEO_FMT_7680X4320_25},
{"7680X4320_29_97", UAPI_VIDEO_FMT_7680X4320_29_97},
{"7680X4320_30", UAPI_VIDEO_FMT_7680X4320_30},
{"7680X4320_50", UAPI_VIDEO_FMT_7680X4320_50},
{"7680X4320_59_94", UAPI_VIDEO_FMT_7680X4320_59_94},
{"7680X4320_60", UAPI_VIDEO_FMT_7680X4320_60},
{"7680X4320_100", UAPI_VIDEO_FMT_7680X4320_100},
{"7680X4320_119_88", UAPI_VIDEO_FMT_7680X4320_119_88},
{"7680X4320_120", UAPI_VIDEO_FMT_7680X4320_120},
{"1080P_24_FRAME_PACKING", UAPI_VIDEO_FMT_1080P_24_FRAME_PACKING},
{"720P_60_FRAME_PACKING", UAPI_VIDEO_FMT_720P_60_FRAME_PACKING},
{"720P_50_FRAME_PACKING", UAPI_VIDEO_FMT_720P_50_FRAME_PACKING},
{"861D_640X480_60", UAPI_VIDEO_FMT_861D_640X480_60},
{"VESA_800X600_60", UAPI_VIDEO_FMT_VESA_800X600_60},
{"VESA_1024X768_60", UAPI_VIDEO_FMT_VESA_1024X768_60},
{"VESA_1280X720_60", UAPI_VIDEO_FMT_VESA_1280X720_60},
{"VESA_1280X1024_60", UAPI_VIDEO_FMT_VESA_1280X1024_60},
{"VESA_1280X1024_60", UAPI_VIDEO_FMT_VESA_1280X1024_60},
{"VESA_1360X768_60", UAPI_VIDEO_FMT_VESA_1360X768_60},
{"VESA_1366X768_60", UAPI_VIDEO_FMT_VESA_1366X768_60},
{"VESA_1400X1050_60", UAPI_VIDEO_FMT_VESA_1400X1050_60},
{"VESA_1440X900_60", UAPI_VIDEO_FMT_VESA_1440X900_60},
{"VESA_1440X900_60_RB", UAPI_VIDEO_FMT_VESA_1440X900_60_RB},
{"VESA_1600X900_60_RB", UAPI_VIDEO_FMT_VESA_1600X900_60_RB},
{"VESA_1600X1200_60", UAPI_VIDEO_FMT_VESA_1600X1200_60},
{"VESA_1680X1050_60", UAPI_VIDEO_FMT_VESA_1680X1050_60},
{"VESA_1680X1050_60_RB", UAPI_VIDEO_FMT_VESA_1680X1050_60_RB},
{"VESA_1920X1080_60", UAPI_VIDEO_FMT_VESA_1920X1080_60},
{"VESA_1920X1200_60", UAPI_VIDEO_FMT_VESA_1920X1200_60},
{"VESA_1920X1440_60", UAPI_VIDEO_FMT_VESA_1920X1440_60},
{"VESA_2048X1152_60", UAPI_VIDEO_FMT_VESA_2048X1152_60},
{"VESA_2560X1440_60_RB", UAPI_VIDEO_FMT_VESA_2560X1440_60_RB},
{"VESA_2560X1600_60_RB", UAPI_VIDEO_FMT_VESA_2560X1600_60_RB},
{"custom", UAPI_VIDEO_FMT_CUSTOM},
};
static ext_disp_param_flag g_pixel_format[] = {
{"RGB", UAPI_DISP_PIXEL_FORMAT_RGB},
{"YUV422", UAPI_DISP_PIXEL_FORMAT_YUV422},
{"YUV444", UAPI_DISP_PIXEL_FORMAT_YUV444},
{"YUV420", UAPI_DISP_PIXEL_FORMAT_YUV420}
};
static ext_disp_param_flag g_bitwidth[] = {
{"DEFAULT", UAPI_PIXEL_BIT_DEPTH_DEFAULT},
{"8BIT", UAPI_PIXEL_BIT_DEPTH_8BIT},
{"10BIT", UAPI_PIXEL_BIT_DEPTH_10BIT},
{"12BIT", UAPI_PIXEL_BIT_DEPTH_12BIT},
{"16BIT", UAPI_PIXEL_BIT_DEPTH_16BIT}
};
static ext_disp_param_flag g_hdr_type[] = {
{"NONE", UAPI_DISP_HDR_TYPE_NONE},
{"HDR10", UAPI_DISP_HDR_TYPE_HDR10},
{"HLG", UAPI_DISP_HDR_TYPE_HLG},
{"DOLBY", UAPI_DISP_HDR_TYPE_DOLBY},
{"DOLBY_LOWLATENCY", UAPI_DISP_HDR_TYPE_DOLBY_LOWLATENCY}
};
static ext_disp_param_flag g_aspect_ratio[] = {
{"AUTO", UAPI_DISP_DEVICE_ASPECT_RATIO_AUTO},
{"4TO3", UAPI_DISP_DEVICE_ASPECT_RATIO_4TO3},
{"16TO9", UAPI_DISP_DEVICE_ASPECT_RATIO_16TO9},
{"221TO100", UAPI_DISP_DEVICE_ASPECT_RATIO_221TO100},
{"CUSTOM", UAPI_DISP_DEVICE_ASPECT_RATIO_CUSTOM}
};
static ext_disp_param_flag g_color_space[] = {
{"BT709", UAPI_DISP_COLOR_SPACE_BT709},
{"BT601", UAPI_DISP_COLOR_SPACE_BT601},
{"BT2020", UAPI_DISP_COLOR_SPACE_BT2020}
};
static ext_hdcp_key g_hdcp_key[] = {
{"TX_14", UAPI_PDM_HDCP_KEY_ID_TX_14, 432},
{"RX_14", UAPI_PDM_HDCP_KEY_ID_RX_14, 432},
{"RX_23", UAPI_PDM_HDCP_KEY_ID_RX_23, 1136}
};
static td_void show_usage_info(td_void)
{
printf("usage: pdmtool [-s set] [-g get] [-u update] [[command] arg].\n");
printf("command as follows:\n");
printf("pdmtool -s disp_param --set disp param.\n");
printf("pdmtool -s panel_index [disp id] [panel id] --set panel index.\n");
printf("pdmtool -s serial_number [number] --set serial number.\n");
printf("pdmtool -g --get hdcp key.\n");
printf("pdmtool -g read_extend [extend_addr] [read_len]--read extend data.\n");
printf("pdmtool -u [key id] [file path] --update hdcp key.\n");
printf("pdmtool -v [disp id] [width] [height] --set virtual screen.\n");
printf("pdmtool -m [MAC address] --set MAC address.\n");
printf("Example:\n\t./pdmtool -s panel_index 0 1\n");
printf("\t./pdmtool -s serial_number xxxxxxxxxx\n");
printf("\t./pdmtool -u tx_14 xxx/xxx\n");
printf("\t./pdmtool -v 0 1920 1080\n");
printf("\t./pdmtool -m xx:xx:xx:xx:xx:xx\n");
return;
}
static td_s32 pdm_set_disp_enable_param(uapi_pdm_disp_param *disp_param)
{
td_s32 tmp;
td_s32 ret;
printf("Do you want set the now disp enable flag? old is: %u\n", disp_param->disp_enable);
tmp = getchar();
if (tmp != '\n') {
do {
printf("Please input new disp enable flag(on:1, off:0):\n");
ret = scanf_s("%u", &disp_param->disp_enable);
getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
} while (disp_param->disp_enable > 1);
}
printf("Do you want set the new source disp flag? old is: %d\n", disp_param->src_disp);
tmp = getchar();
if (tmp != '\n') {
do {
printf("Please input new source disp flag(0,1,2):\n");
ret = scanf_s("%d", &disp_param->src_disp);
getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
} while ((disp_param->src_disp < UAPI_DISPLAY0) ||
(disp_param->src_disp >= UAPI_DISPLAY_MAX));
}
return TD_SUCCESS;
}
static td_s32 pdm_set_disp_index_and_bg_color_param(uapi_pdm_disp_param *disp_param)
{
td_s32 tmp;
td_s32 ret;
printf("Do you want set the new logo index? old is: %d\n", disp_param->logo_index);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new logo index:\n");
ret = scanf_s("%d", &disp_param->logo_index);
getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
printf("Do you want set the new panel_index? old is: %d\n", disp_param->panel_index);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new panel_index:\n");
ret = scanf_s("%d", &disp_param->panel_index);
getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
printf("Do you want set the new bg_color(R/G/B)? old is: %d/%d/%d\n",
disp_param->bg_color.red, disp_param->bg_color.green, disp_param->bg_color.blue);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new bg_color(R/G/B):\n");
ret = scanf_s("%d %d %d", &disp_param->bg_color.red, &disp_param->bg_color.green, &disp_param->bg_color.blue);
getchar();
if (ret != 3) { /* 3 is scanf_s success return */
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
return TD_SUCCESS;
}
static td_s32 pdm_set_disp_light_param(uapi_pdm_disp_param *disp_param)
{
td_s32 tmp;
td_s32 ret;
printf("Do you want set the new brightness? old is: %d\n", disp_param->brightness);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new brightness:\n");
ret = scanf_s("%d", &disp_param->brightness);
getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
printf("Do you want set the new continue? old is: %d\n", disp_param->contrast);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new contrast:\n");
ret = scanf_s("%d", &disp_param->contrast);
getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
printf("Do you want set the new saturation? old is: %d\n", disp_param->saturation);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new saturation:\n");
ret = scanf_s("%d", &disp_param->saturation);
getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
printf("Do you want set the new hue_plus? old is: %d\n", disp_param->hue_plus);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new hue_plus:\n");
ret = scanf_s("%d", &disp_param->hue_plus);
getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
return TD_SUCCESS;
}
static td_s32 pdm_set_disp_format_param(uapi_pdm_disp_param *disp_param)
{
td_u32 i;
td_s32 tmp;
td_s32 ret;
td_char result[INPUT_PARAM_LEN];
printf("Do you want set the new format? old is: %d\n", disp_param->format);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new format:\n");
printf("format:720P50 720P60 1080I50 1080I60 1080P50 1080P60...\n");
ret = scanf_s("%s", result, INPUT_PARAM_LEN);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
getchar();
for (i = 0; i < (sizeof(g_format) / sizeof(g_format[0])); i++) {
if (!strcasecmp(g_format[i].str, result)) {
disp_param->format = g_format[i].flag;
break;
}
}
if (i >= (sizeof(g_format) / sizeof(g_format[0]))) {
printf("[ERROR] input format failed!\n");
return TD_FAILURE;
}
}
printf("Do you want set the new wcg_temperature? old is: %d\n", disp_param->wcg_temperature);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new wcg_temperature:\n");
ret = scanf_s("%d", &disp_param->wcg_temperature);
getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
return TD_SUCCESS;
}
static td_s32 pdm_set_disp_pixel_and_virt_param(uapi_pdm_disp_param *disp_param)
{
td_u32 i;
td_s32 tmp;
td_s32 ret;
td_char result[INPUT_PARAM_LEN];
printf("Do you want set the new pixel_format_out_mode? old is: %d\n", disp_param->pixel_format_out_mode);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new pixel_format_out_mode:\n");
printf("pixel format out mode:RGB YUV420 YUV422 YUV444\n");
ret = scanf_s("%s", result, INPUT_PARAM_LEN);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
getchar();
for (i = 0; i < (sizeof(g_pixel_format) / sizeof(g_format[0])); i++) {
if (!strcasecmp(g_pixel_format[i].str, result)) {
disp_param->pixel_format_out_mode = g_pixel_format[i].flag;
break;
}
}
if (i >= (sizeof(g_pixel_format) / sizeof(g_format[0]))) {
printf("[ERROR] input pixel format out mode failde!\n");
return TD_FAILURE;
}
}
printf("Do you want set the new virtual_screen(w/h)? old is: %d/%d\n",
disp_param->virt_screen_width, disp_param->virt_screen_height);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new virtual_screen(w/h), interval:[480,3840]:\n");
ret = scanf_s("%d %d", &disp_param->virt_screen_width, &disp_param->virt_screen_height);
getchar();
if (ret != 2) { /* 2 is scanf_s success return */
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
return TD_SUCCESS;
}
static td_s32 pdm_set_disp_bitwidth_and_offset_param(uapi_pdm_disp_param *disp_param)
{
td_u32 i;
td_s32 tmp;
td_s32 ret;
td_char result[INPUT_PARAM_LEN];
printf("Do you want set the new bitwidth_out_mode? old is: %d\n", disp_param->bitwidth_out_mode);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new bitwidth out mode:\n");
printf("bit width:8BIT 10BIT 12BIT 16BIT\n");
ret = scanf_s("%s", result, INPUT_PARAM_LEN);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
getchar();
for (i = 0; i < (sizeof(g_bitwidth) / sizeof(g_bitwidth[0])); i++) {
if (!strcasecmp(g_bitwidth[i].str, result)) {
disp_param->bitwidth_out_mode = g_bitwidth[i].flag;
disp_param->bg_color.bit_depth = disp_param->bitwidth_out_mode;
break;
}
}
if (i >= (sizeof(g_bitwidth) / sizeof(g_bitwidth[0]))) {
printf("[ERROR] input bitwidth out mode failed!\n");
return TD_FAILURE;
}
}
printf("Do you want set the new offset(L/R/Top/Bot)? old is: %d/%d/%d/%d\n",
disp_param->disp_offset.left, disp_param->disp_offset.right,
disp_param->disp_offset.top, disp_param->disp_offset.bottom);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new offset(L/R/Top/Bot)\nTop/Botinterval:[0,200] and multiple of 4:\n");
ret = scanf_s("%d %d %d %d", &disp_param->disp_offset.left, &disp_param->disp_offset.right,
&disp_param->disp_offset.top, &disp_param->disp_offset.bottom);
getchar();
if (ret != 4) { /* 4 is scanf_s success return */
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
return TD_SUCCESS;
}
static td_s32 pdm_set_disp_hdr_type_param(uapi_pdm_disp_param *disp_param)
{
td_u32 i;
td_s32 tmp;
td_s32 ret;
td_char result[INPUT_PARAM_LEN];
printf("Do you want set the new hdr_type? old is: %d\n", disp_param->hdr_type);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new hdr_type, hdr_type as follows:\n");
printf("SDR --Normal SDR signal output type\n");
printf("HDR10 --HDR10 signal output type\n");
printf("DOLBY_VISION --DolbyVision signal output type\n");
printf("DBVISION_LOWLATENCY --DolbyVision low latency signal output type\n");
ret = scanf_s("%s", result, INPUT_PARAM_LEN);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
getchar();
for (i = 0; i < (sizeof(g_hdr_type) / sizeof(g_hdr_type[0])); i++) {
if (!strcasecmp(g_hdr_type[i].str, result)) {
disp_param->hdr_type = g_hdr_type[i].flag;
break;
}
}
if (i >= (sizeof(g_hdr_type) / sizeof(g_hdr_type[0]))) {
printf("[ERROR] input hdr type failed!\n");
return TD_FAILURE;
}
}
return TD_SUCCESS;
}
static td_s32 pdm_set_disp_hmc_and_scenario_param(uapi_pdm_disp_param *disp_param)
{
td_s32 tmp;
td_s32 ret;
printf("Do you want set the new hdr_match_content? old is: %d\n", disp_param->hdr_match_content);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new hdr_match_content:\n");
ret = scanf_s("%d", &disp_param->hdr_match_content);
getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
printf("Do you want set the new scenario_mode? old is: %d\n", disp_param->scenario_mode);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new scenario_mode:\n");
ret = scanf_s("%d", &disp_param->scenario_mode);
getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
return TD_SUCCESS;
}
static td_s32 pdm_set_disp_aspect_ratio_param(uapi_pdm_disp_param *disp_param)
{
td_u32 i;
td_s32 tmp;
td_s32 ret;
td_char result[INPUT_PARAM_LEN];
printf("Do you want set the new aspect ratio? old is: %d\n", disp_param->aspect_ratio.ratio);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new aspect ratio, aspect ratio as follows:\n");
printf("auto --aspect ratio as device Resolution\n");
printf("4to3 --4:3\n");
printf("16to9 --16:9\n");
printf("221to100 --221:100\n");
printf("custom --user define\n");
ret = scanf_s("%s", result, INPUT_PARAM_LEN);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
getchar();
for (i = 0; i < (sizeof(g_aspect_ratio) / sizeof(g_aspect_ratio[0])); i++) {
if (!strcasecmp(g_aspect_ratio[i].str, result)) {
disp_param->aspect_ratio.ratio = g_aspect_ratio[i].flag;
break;
}
}
if (i >= (sizeof(g_aspect_ratio) / sizeof(g_aspect_ratio[0]))) {
printf("[ERROR] input aspect ratio failed!\n");
return TD_FAILURE;
}
if (i == UAPI_DISP_DEVICE_ASPECT_RATIO_CUSTOM) {
printf("Please input new aspect ratio(w/h):\n");
ret = scanf_s("%d %d", &disp_param->aspect_ratio.width,
&disp_param->aspect_ratio.height);
getchar();
if (ret != 2) { /* 2 is scanf_s success return */
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
}
return TD_SUCCESS;
}
static td_s32 pdm_set_disp_vic_and_ocg_param(uapi_pdm_disp_param *disp_param)
{
td_u32 i;
td_s32 tmp;
td_s32 ret;
td_char result[INPUT_PARAM_LEN];
printf("Do you want set the new vic? old is: %d\n", disp_param->vic);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new vic:\n");
ret = scanf_s("%d", &disp_param->vic);
getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
}
printf("Do you want set the new output_color_gamut? old is: %d\n", disp_param->output_color_gamut);
tmp = getchar();
if (tmp != '\n') {
printf("Please input new output_color_gamut:\n");
printf("output color space:BT709 BT601 BT2020\n");
ret = scanf_s("%s", result, INPUT_PARAM_LEN);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
getchar();
for (i = 0; i < (sizeof(g_color_space) / sizeof(g_color_space[0])); i++) {
if (!strcasecmp(g_color_space[i].str, result)) {
disp_param->output_color_gamut = g_color_space[i].flag;
break;
}
}
if (i >= (sizeof(g_color_space) / sizeof(g_color_space[0]))) {
printf("[ERROR] input output color gamut failed!\n");
return TD_FAILURE;
}
}
return TD_SUCCESS;
}
static td_s32 pdm_set_disp_intf_id_param(uapi_pdm_disp_param *disp_param)
{
td_s32 ret;
td_char tmp;
printf("Please input new intf_type:(HDMI:h, CVBS:c, PANEL:p)\n");
ret = scanf_s("%c", &tmp, sizeof(tmp));
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
if (tmp == 'c') {
printf("Please input new intf config of CVBS, old is: %d\n",
disp_param->intf[UAPI_DISP_INTF_TYPE_CVBS].intf.cvbs.dac);
disp_param->intf[UAPI_DISP_INTF_TYPE_CVBS].intf_type = UAPI_DISP_INTF_TYPE_CVBS;
ret = scanf_s("%d", &disp_param->intf[UAPI_DISP_INTF_TYPE_CVBS].intf.cvbs.dac);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
} else if (tmp == 'h') {
printf("Please input new HDMI ID, old is: %d\n", disp_param->intf[UAPI_DISP_INTF_TYPE_HDMITX].intf.hdmitx);
disp_param->intf[UAPI_DISP_INTF_TYPE_HDMITX].intf_type = UAPI_DISP_INTF_TYPE_HDMITX;
ret = scanf_s("%d", &disp_param->intf[UAPI_DISP_INTF_TYPE_HDMITX].intf.hdmitx);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
} else if (tmp == 'p') {
printf("Please input new PANEL ID, old is: %d\n", disp_param->intf[UAPI_DISP_INTF_TYPE_PANEL].intf.panel);
disp_param->intf[UAPI_DISP_INTF_TYPE_PANEL].intf_type = UAPI_DISP_INTF_TYPE_PANEL;
ret = scanf_s("%d", &disp_param->intf[UAPI_DISP_INTF_TYPE_PANEL].intf.panel);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
} else {
printf("[ERROR] intf_type input failed!\n");
return TD_FAILURE;
}
return TD_SUCCESS;
}
static td_s32 pdm_set_disp_intf_param(uapi_pdm_disp_param *disp_param)
{
td_s32 tmp1;
td_s32 ret;
td_u32 index = 0;
printf("Do you want set the new intf_type?\n");
tmp1 = getchar();
if (tmp1 != '\n') {
getchar();
for (index = 0; index < UAPI_DISP_INTF_TYPE_MAX; index++) {
ret = memset_s(&(disp_param->intf[index].intf_type), sizeof(disp_param->intf[index].intf_type), 0x18,
sizeof(disp_param->intf[index].intf_type)); /* 0x18 is invalid intf type */
if (ret != 0) {
printf("[ERROR] memset_s failed!\n");
return ret;
}
}
ret = pdm_set_disp_intf_id_param(disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
}
return TD_SUCCESS;
}
static td_s32 set_pdm_disp_param(uapi_pdm_disp_param *disp_param)
{
td_s32 ret;
ret = pdm_set_disp_enable_param(disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
ret = pdm_set_disp_index_and_bg_color_param(disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
ret = pdm_set_disp_light_param(disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
ret = pdm_set_disp_format_param(disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
ret = pdm_set_disp_pixel_and_virt_param(disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
ret = pdm_set_disp_bitwidth_and_offset_param(disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
ret = pdm_set_disp_hdr_type_param(disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
ret = pdm_set_disp_hmc_and_scenario_param(disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
ret = pdm_set_disp_aspect_ratio_param(disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
ret = pdm_set_disp_vic_and_ocg_param(disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
ret = pdm_set_disp_intf_param(disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
return ret;
}
static td_s32 pdm_set_disp_param(td_void)
{
td_s32 ret;
uapi_disp disp_index;
uapi_pdm_disp_param disp_param1 = {0};
do {
printf("set which display param(0,1,2)?\n");
ret = scanf_s("%d", &disp_index);
(void)getchar();
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
} while ((disp_index < UAPI_DISPLAY0) || (disp_index >= UAPI_DISPLAY_MAX));
ret = uapi_pdm_get_disp_param(disp_index, &disp_param1);
if (ret != TD_SUCCESS) {
printf("[ERROR] cannot read disp param!: 0x%x \n", ret);
return ret;
}
ret = set_pdm_disp_param(&disp_param1);
if (ret != TD_SUCCESS) {
printf("[ERROR] setting failed!\n");
return ret;
}
ret = uapi_pdm_update_disp_param(disp_index, &disp_param1);
if (ret != TD_SUCCESS) {
printf("[ERROR] cannot update pdm disp param : 0x%x\n", ret);
return ret;
}
return TD_SUCCESS;
}
static td_s32 updata_disp_param(uapi_disp disp_index, uapi_pdm_disp_param *param_data)
{
td_s32 ret;
ret = uapi_pdm_update_disp_param(disp_index, param_data);
if (ret != TD_SUCCESS) {
printf("[ERROR] cannot update pdm disp param : 0x%x\n", ret);
return TD_FAILURE;
}
ret = uapi_pdm_get_disp_param(disp_index, param_data);
if (ret != TD_SUCCESS) {
printf("[ERROR] cannot get pdm disp param : 0x%x\n", ret);
return TD_FAILURE;
}
if (ret == TD_SUCCESS) {
printf("set suncess panel_index : 0x%x\n", param_data->panel_index);
}
return TD_SUCCESS;
}
static td_s32 pdm_set_panel_index(td_s32 argc, td_char *argv[])
{
td_s32 ret;
uapi_pdm_disp_param disp_param1 = {0};
uapi_disp disp_index;
if (argc <= INPUT_CMD_NUM_4) {
printf("set which display panel index?(0,1,2)\n");
ret = scanf_s("%d", &disp_index);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
ret = uapi_pdm_get_disp_param(disp_index, &disp_param1);
if (ret != TD_SUCCESS) {
printf("[ERROR] cannot read disp param!: 0x%x \n", ret);
return ret;
}
printf("Please input new panel_index, old is: %d\n", disp_param1.panel_index);
ret = scanf_s("%d", &disp_param1.panel_index);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
} else {
if (!strcmp("0", argv[INPUT_CMD_NUM_3])) {
disp_index = UAPI_DISPLAY0;
} else if (!strcmp("1", argv[INPUT_CMD_NUM_3])) {
disp_index = UAPI_DISPLAY1;
} else if (!strcmp("2", argv[INPUT_CMD_NUM_3])) {
disp_index = UAPI_DISPLAY2;
} else {
printf("[ERROR] display index is invalid!\n");
return TD_FAILURE;
}
ret = uapi_pdm_get_disp_param(disp_index, &disp_param1);
if (ret != TD_SUCCESS) {
printf("[ERROR] cannot read disp param!: 0x%x \n", ret);
return ret;
}
printf("cur pane_index!: 0x%x \n", disp_param1.panel_index);
disp_param1.panel_index = (td_u32)atoi(argv[INPUT_CMD_NUM_4]);
}
ret = updata_disp_param(disp_index, &disp_param1);
return ret;
}
static td_s32 pdm_set_serial_number(td_s32 argc, td_char *argv[])
{
td_s32 ret;
uapi_pdm_basic_info basic_info1 = {0};
uapi_pdm_basic_info basic_info2 = {0};
ret = uapi_pdm_get_basic_info(&basic_info1);
if (ret != TD_SUCCESS) {
printf("[ERROR] cannot read basic info!: 0x%x \n", ret);
return ret;
}
if (argc <= INPUT_CMD_NUM_3) {
printf("Please input new serial number, old is %.*s:\n", UAPI_PDM_SERIAL_NUM_LEN, basic_info1.serial_number);
ret = scanf_s("%s", basic_info1.serial_number, UAPI_PDM_SERIAL_NUM_LEN);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
} else {
if (strlen(argv[INPUT_CMD_NUM_3]) >= UAPI_PDM_SERIAL_NUM_LEN) {
printf("serial number length:%zu out of bound:%d!\n",
strlen(argv[INPUT_CMD_NUM_3]), UAPI_PDM_SERIAL_NUM_LEN);
return TD_FAILURE;
}
memset_s(basic_info1.serial_number, UAPI_PDM_SERIAL_NUM_LEN, 0, UAPI_PDM_SERIAL_NUM_LEN);
ret = memcpy_s(basic_info1.serial_number, UAPI_PDM_SERIAL_NUM_LEN,
argv[INPUT_CMD_NUM_3], strlen(argv[INPUT_CMD_NUM_3]));
if (ret != EOK) {
printf("[ERROR] serial_number:%s memcpy_s fail!\n", argv[INPUT_CMD_NUM_3]);
return TD_FAILURE;
}
}
ret = uapi_pdm_update_basic_info(&basic_info1);
if (ret != TD_SUCCESS) {
printf("[ERROR] cannot update basic info : 0x%x\n", ret);
return ret;
}
ret = uapi_pdm_get_basic_info(&basic_info2);
if (ret != TD_SUCCESS) {
printf("[ERROR] cannot read basic info : 0x%x\n", ret);
return ret;
}
ret = memcmp(basic_info1.serial_number, basic_info2.serial_number, UAPI_PDM_SERIAL_NUM_LEN);
if (ret != 0) {
printf("[ERROR] set and read param is not same! set: %s, read:%s\n",
basic_info1.serial_number, basic_info2.serial_number);
return ret;
}
return TD_SUCCESS;
}
static td_s32 pdm_read_extend_data(td_s32 argc, td_char *argv[])
{
td_s32 ret;
td_u8 *read_buf = TD_NULL;
td_u32 offset_addr = 0;
td_u32 buf_len = 0;
td_u32 read_length;
td_u32 total_size;
if (argc == INPUT_CMD_NUM_5) {
offset_addr = (td_u32)atoi(argv[INPUT_CMD_NUM_3]);
buf_len = (td_u32)atoi(argv[INPUT_CMD_NUM_4]);
} else {
show_usage_info();
return TD_FAILURE;
}
ret = uapi_pdm_get_extend_total_size(&total_size);
if (ret != TD_SUCCESS) {
printf("[ERROR] cannot uapi_pdm_get_extend_total_size : 0x%x\n", ret);
return TD_FAILURE;
}
if (buf_len > total_size) {
printf("buf_len is out range\n");
return TD_FAILURE;
}
read_buf = (td_u8 *)malloc(buf_len);
if (read_buf == TD_NULL) {
printf("[ERROR] malloc failed!\n");
return TD_FAILURE;
}
ret = uapi_pdm_get_extend_data(offset_addr, read_buf, buf_len, &read_length);
if (ret != TD_SUCCESS) {
printf("[ERROR] cannot uapi_pdm_get_extend_data : 0x%x\n", ret);
free(read_buf);
return TD_FAILURE;
}
printf("[%s,%d]data_buf = %p, data_len = 0x%x\n", __FUNCTION__, __LINE__, read_buf, read_length);
for (td_u32 i = 0; i < read_length; i += 2) { // 2 s hop count
printf("%02x%02x ", read_buf[i], read_buf[i + 1]); // 1 is array index increments
if ((i + 2) % 16 == 0) { // 16 is need enter, 2 is hop count
printf("\n");
}
}
printf("\n");
free(read_buf);
return TD_SUCCESS;
}
static td_s32 get_hdcp_key(const uapi_pdm_hdcp_key_id id, const td_char *file)
{
td_s32 ret;
td_u8 *buf = TD_NULL;
td_s32 fd = -1;
td_s32 read_len;
buf = malloc(BUF_LEN);
if (buf == TD_NULL) {
printf("[ERROR] malloc failed!\n");
return TD_FAILURE;
}
ret = uapi_pdm_get_hdcp_key(id, BUF_LEN, buf, &read_len);
if (ret != TD_SUCCESS) {
free(buf);
return ret;
}
fd = open(file, O_RDWR | O_CREAT, 0755); /* 0755 for permission */
if (fd < 0) {
printf("[ERROR] fail to open %s!\n", file);
free(buf);
return TD_FAILURE;
}
if (read_len > 0 && read_len < BUF_LEN) {
ret = write(fd, buf, read_len);
if (ret != read_len) {
printf("[ERROR] write failed!\n");
close(fd);
free(buf);
return TD_FAILURE;
}
} else {
printf("read_len(%d) is invalid!\n", read_len);
close(fd);
free(buf);
return TD_FAILURE;
}
close(fd);
fd = -1;
free(buf);
return TD_SUCCESS;
}
static td_s32 pdm_get_hdcp_key(td_void)
{
td_u32 i;
td_s32 ret;
td_char result[INPUT_PARAM_LEN];
uapi_pdm_hdcp_key_id id = TD_NULL;
td_char file[INPUT_PARAM_LEN];
printf("Please input file name:\n");
ret = scanf_s("%s", file, INPUT_PARAM_LEN);
if (ret <= 0) {
printf("[ERROR] scanf_s failed!\n");
return TD_FAILURE;
}
printf("Please input hdcp key id:\n");
printf("id:[tx_14] [rx_14] [rx_23]\n");
ret = scanf_s("%s", result, INPUT_PARAM_LEN);
if (ret <= 0) {
printf("[ERROR] scanf_s failed!\n");
return TD_FAILURE;
}
for (i = 0; i < (sizeof(g_hdcp_key) / sizeof(g_hdcp_key[0])); i++) {
if (!strcasecmp(g_hdcp_key[i].str, result)) {
id = g_hdcp_key[i].key_id;
break;
}
}
if (i >= (sizeof(g_hdcp_key) / sizeof(g_hdcp_key[0]))) {
printf("[ERROR] input hdcp key id failed!\n");
return TD_FAILURE;
}
ret = get_hdcp_key(id, file);
if (ret != TD_SUCCESS) {
return ret;
}
return TD_SUCCESS;
}
static td_s32 update_hdcp_key(uapi_pdm_hdcp_key_id id, const td_char *file, td_u32 file_len, td_s32 len)
{
td_s32 ret;
td_u8 *buf = TD_NULL;
td_s32 fd = -1;
char path[PATH_MAX] = {0};
if (file_len > PATH_MAX || realpath(file, path) == TD_NULL) {
printf("input file is invalid!\n");
return TD_FAILURE;
}
fd = open(path, O_RDWR);
if (fd < 0) {
printf("[ERROR] Fail to open %s!\n", path);
return TD_FAILURE;
}
buf = malloc(BUF_LEN);
if (buf == TD_NULL) {
printf("[ERROR] malloc failed!\n");
close(fd);
fd = -1;
return TD_FAILURE;
}
if (len > 0 && len < BUF_LEN) {
ret = read(fd, buf, len);
if (ret != len) {
printf("[ERROR] read failed!\n");
ret = TD_FAILURE;
goto failed;
}
} else {
printf("len(%d) is invalid!\n", len);
ret = TD_FAILURE;
goto failed;
}
ret = uapi_pdm_update_hdcp_key(id, buf, len);
failed:
free(buf);
close(fd);
fd = -1;
return ret;
}
static td_s32 pdm_update_hdcp_key(td_s32 argc, td_char *argv[])
{
td_s32 len, ret;
td_u32 i;
td_char file[PATH_MAX] = {0};
uapi_pdm_hdcp_key_id id = 0;
td_char result[INPUT_PARAM_LEN] = {0};
if (argc <= INPUT_CMD_NUM_3) {
printf("Please input file name:\n");
if (scanf_s("%s", file, PATH_MAX) <= 0) {
printf("[ERROR] scanf_s failed!\n");
return TD_FAILURE;
}
printf("Please input hdcp key id:\nid:[tx_14] [rx_14] [rx_23]\n");
if (scanf_s("%s", result, INPUT_PARAM_LEN) <= 0) {
printf("[ERROR] scanf_s failed!\n");
return TD_FAILURE;
}
} else {
if (strlen(argv[INPUT_CMD_NUM_3]) > PATH_MAX || strlen(argv[INPUT_CMD_NUM_2]) > INPUT_PARAM_LEN) {
printf("file path length:%zu/id length:%zu out of bound:%d/%d!\n",
strlen(argv[INPUT_CMD_NUM_3]), strlen(argv[INPUT_CMD_NUM_2]), PATH_MAX, INPUT_PARAM_LEN);
return TD_FAILURE;
}
if (memcpy_s(result, INPUT_PARAM_LEN, argv[INPUT_CMD_NUM_2], strlen(argv[INPUT_CMD_NUM_2])) != EOK) {
printf("[ERROR] result:%s memcpy_s fail!\n", argv[INPUT_CMD_NUM_2]);
return TD_FAILURE;
}
if (memcpy_s(file, PATH_MAX, argv[INPUT_CMD_NUM_3], strlen(argv[INPUT_CMD_NUM_3])) != EOK) {
printf("[ERROR] file:%s memcpy_s fail!\n", argv[INPUT_CMD_NUM_3]);
return TD_FAILURE;
}
}
for (i = 0; i < (sizeof(g_hdcp_key) / sizeof(g_hdcp_key[0])); i++) {
if (!strcasecmp(g_hdcp_key[i].str, result)) {
id = g_hdcp_key[i].key_id;
len = g_hdcp_key[i].key_len;
break;
}
}
if (i >= (sizeof(g_hdcp_key) / sizeof(g_hdcp_key[0]))) {
printf("[ERROR] input hdcp key id failed!\n");
return TD_FAILURE;
}
ret = update_hdcp_key(id, file, strlen(file), len);
if (ret != TD_SUCCESS) {
printf("update_hdcp_key fail! ret : 0x%x\n", ret);
}
return ret;
}
static td_s32 pdm_set_virt_screen(td_s32 argc, td_char *argv[])
{
td_s32 ret;
uapi_pdm_disp_param disp_param = {0};
uapi_disp disp_index;
if (argc <= INPUT_CMD_NUM_4) {
printf("set which display panel index?(0,1,2)\n");
ret = scanf_s("%d", &disp_index);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
ret = uapi_pdm_get_disp_param(disp_index, &disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
printf("Please input new virt_screen_width, old is: %d\n", disp_param.virt_screen_width);
ret = scanf_s("%d", &disp_param.virt_screen_width);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
printf("Please input new virt_screen_height, old is: %d\n", disp_param.virt_screen_height);
ret = scanf_s("%d", &disp_param.virt_screen_height);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
} else {
if (!strcmp("0", argv[INPUT_CMD_NUM_2])) {
disp_index = UAPI_DISPLAY0;
} else if (!strcmp("1", argv[INPUT_CMD_NUM_2])) {
disp_index = UAPI_DISPLAY1;
} else if (!strcmp("2", argv[INPUT_CMD_NUM_2])) {
disp_index = UAPI_DISPLAY2;
} else {
printf("[ERROR] display index is invalid!\n");
return TD_FAILURE;
}
ret = uapi_pdm_get_disp_param(disp_index, &disp_param);
if (ret != TD_SUCCESS) {
return ret;
}
disp_param.virt_screen_width = (td_u32)atoi(argv[INPUT_CMD_NUM_3]);
disp_param.virt_screen_height = (td_u32)atoi(argv[INPUT_CMD_NUM_4]);
}
ret = uapi_pdm_update_disp_param(disp_index, &disp_param);
return ret;
}
static td_s32 pdm_check_mac_addr_valid(const td_char *mac)
{
td_s32 ret;
const td_char *pattern = "^([A-Fa-f0-9]{2}[-,:]){5}[A-Fa-f0-9]{2}$";
const td_s32 cflags = REG_EXTENDED | REG_NEWLINE;
td_char ebuf[ERRBUF_ARRAY_LEN];
regmatch_t pmatch;
const td_s32 nmatch = 1;
regex_t reg;
ret = regcomp(&reg, pattern, cflags);
if (ret != TD_SUCCESS) {
regerror(ret, &reg, ebuf, sizeof(ebuf));
fprintf(stderr, "regcomp fail: %s , pattern '%s' \n", ebuf, pattern);
goto failed;
}
ret = regexec(&reg, mac, nmatch, &pmatch, 0);
if (ret != TD_SUCCESS) {
regerror(ret, &reg, ebuf, sizeof(ebuf));
fprintf(stderr, "regexec fail: %s\n", ebuf);
goto failed;
}
failed:
regfree(&reg);
return ret;
}
static td_s32 pdm_set_mac_address(td_s32 argc, td_char *argv[])
{
uapi_pdm_config_info cfg_info;
if (memset_s(&cfg_info, sizeof(cfg_info), 0, sizeof(cfg_info)) != EOK) {
printf("cfg_info init failed!");
return TD_FAILURE;
}
td_s32 ret = uapi_pdm_get_cfg_info(&cfg_info);
if (ret != TD_SUCCESS) {
printf("[ERROR] get config info fail! ret:0x%x\n", ret);
return ret;
}
if (argc <= INPUT_CMD_NUM_2) {
printf("Please input new mac addr\n");
ret = scanf_s("%s", cfg_info.mac_addr, UAPI_PDM_MAC_ADDR_LEN);
if (ret <= 0) {
printf("[ERROR] scanf_s failed, err:0x%x\n", ret);
return TD_FAILURE;
}
ret = pdm_check_mac_addr_valid((td_char *)cfg_info.mac_addr);
if (ret != TD_SUCCESS) {
printf("[ERROR] mac addr invalid! ret:0x%x\n", ret);
return ret;
}
} else {
if (strlen(argv[INPUT_CMD_NUM_2]) >= UAPI_PDM_MAC_ADDR_LEN) {
printf("mac address length:%zu out of bound:%d!\n",
strlen(argv[INPUT_CMD_NUM_2]), UAPI_PDM_MAC_ADDR_LEN);
return TD_FAILURE;
}
ret = pdm_check_mac_addr_valid(argv[INPUT_CMD_NUM_2]);
if (ret != TD_SUCCESS) {
printf("[ERROR] mac addr invalid! ret:0x%x\n", ret);
return ret;
}
memset_s(cfg_info.mac_addr, UAPI_PDM_MAC_ADDR_LEN, 0, UAPI_PDM_MAC_ADDR_LEN);
ret = memcpy_s(cfg_info.mac_addr, UAPI_PDM_MAC_ADDR_LEN,
argv[INPUT_CMD_NUM_2], strlen(argv[INPUT_CMD_NUM_2]));
if (ret != EOK) {
printf("[ERROR] mac_addr:%s memcpy_s fail!\n", argv[INPUT_CMD_NUM_2]);
return TD_FAILURE;
}
}
ret = uapi_pdm_update_cfg_info(&cfg_info);
if (ret != TD_SUCCESS) {
printf("[ERROR] update config info fail!\n ret:0x%x\n", ret);
return ret;
}
return TD_SUCCESS;
}
static td_s32 get_flash_param(td_s32 argc, td_char *argv[])
{
td_s32 ret;
if (argc == INPUT_CMD_NUM_5) {
if (!strcasecmp("read_extend", argv[INPUT_CMD_NUM_2])) {
ret = pdm_read_extend_data(argc, argv);
if (ret != TD_SUCCESS) {
printf("[ERROR] setting failed! 0x%x\n", ret);
return TD_FAILURE;
}
}
}
if (argc == INPUT_CMD_NUM_2) {
ret = pdm_get_hdcp_key();
if (ret != TD_SUCCESS) {
printf("[ERROR] get hdcp key failed! 0x%x\n", ret);
return TD_FAILURE;
}
}
return TD_SUCCESS;
}
td_s32 main(td_s32 argc, td_char *argv[])
{
td_s32 ret;
td_s32 result;
result = getopt(argc, argv, "s:guvm");
if (result == 's') {
if (!strcasecmp("disp_param", optarg)) {
ret = pdm_set_disp_param();
if (ret != TD_SUCCESS) {
printf("[ERROR] disp_param setting failed! 0x%x\n", ret);
}
return ret;
} else if (!strcasecmp("panel_index", optarg)) {
ret = pdm_set_panel_index(argc, argv);
if (ret != TD_SUCCESS) {
printf("[ERROR] setting failed! 0x%x\n", ret);
}
return ret;
} else if (!strcasecmp("serial_number", optarg)) {
ret = pdm_set_serial_number(argc, argv);
if (ret != TD_SUCCESS) {
printf("[ERROR] setting failed! 0x%x\n", ret);
}
return ret;
}
} else if (result == 'g') {
ret = get_flash_param(argc, argv);
if (ret != TD_SUCCESS) {
printf("[ERROR] update hdcp key failed! 0x%x\n", ret);
}
return ret;
} else if (result == 'u') {
ret = pdm_update_hdcp_key(argc, argv);
if (ret != TD_SUCCESS) {
printf("[ERROR] update hdcp key failed! 0x%x\n", ret);
}
return ret;
} else if (result == 'v') {
ret = pdm_set_virt_screen(argc, argv);
if (ret != TD_SUCCESS) {
printf("[ERROR] set virtual screen fail! ret:0x%x\n", ret);
}
return ret;
} else if (result == 'm') {
pdm_set_mac_address(argc, argv);
return TD_SUCCESS;
}
show_usage_info();
}
Reference in new issue View Git Blame Copy Permalink