xiaoyu/project/app/aov_sample/common/aov/sample_comm_aov.c

// Copyright 2019 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "sample_comm_aov.h"
#include "sample_comm.h"
#include <net/if.h>   // must be included later than <net/if.h>
#include <linux/if.h> // must be included later than <net/if.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <pthread.h>
#include <sys/mman.h>
#include <sys/mount.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <linux/input.h>

#define MAX_CAMERA_NUM 3

#ifdef AOV_FASTBOOT_ENABLE

#include "rk_meta.h"
#include "rk_meta_wakeup_param.h"
#include "sensor_iq_info.h"

// Memory region definitions
#define META_PHY_ADDR 0x800000
// Meta region
#define META_SIZE (384 * 1024)

struct meta_para_vir {
	int mem_fd;
	void *mapped_base;
	void *meta_head;
	int meta_head_size;
	void *param_share2kernel_offset;
	int param_share2kernel_offset_size;
	void *sensor_init_offset;
	int sensor_init_offset_size;
	void *cmdline_offset;
	int cmdline_offset_size;
	void *ae_table_offset;
	int ae_table_offset_size;
	void *app_param_offset;
	int app_param_offset_size;
	void *secondary_sensor_init_offset;
	int secondary_sensor_init_offset_size;
	void *wakeup_param_offset;
	int wakeup_param_offset_size;
	void *reserve;
	int reserve_size;
	void *backup;
	int backup_size;
	void *sensor_iq_bin_offset;
	int sensor_iq_bin_offset_size;
	void *secondary_sensor_iq_bin_offset;
	int secondary_sensor_iq_bin_offset_size;

	void *wakeup_aov_param_offset;
	int wakeup_aov_param_max_size;
};

static struct meta_para_vir *g_meta_vir = NULL;
#endif // #ifdef AOV_FASTBOOT_ENABLE

#define MAX_NL_BUF_SIZE (1024 * 16)
#define MAX_SELECT_TIMEOUT (2 * 1000 * 1000)

static pthread_mutex_t g_wakeup_run_mutex = PTHREAD_MUTEX_INITIALIZER;

static RK_S32 g_input_device_fd = -1;

#ifdef AOV_FASTBOOT_ENABLE
static void SAMPLE_COMM_AOV_MetaDump() {
	if (!g_meta_vir) {
		printf("[%s()] empty meta!\n", __func__);
		return;
	}
	printf("g_meta_vir->mem_fd: %d\n", g_meta_vir->mem_fd);
	printf("g_meta_vir->mapped_base: %p\n", g_meta_vir->mapped_base);
	printf("g_meta_vir->meta_head: %p\n", g_meta_vir->meta_head);
	printf("g_meta_vir->meta_head_size: %d\n", g_meta_vir->meta_head_size);
	printf("g_meta_vir->param_share2kernel_offset: %p\n",
	       g_meta_vir->param_share2kernel_offset);
	printf("g_meta_vir->param_share2kernel_offset_size: %d\n",
	       g_meta_vir->param_share2kernel_offset_size);
	printf("g_meta_vir->sensor_init_offset: %p\n", g_meta_vir->sensor_init_offset);
	printf("g_meta_vir->sensor_init_offset_size: %d\n",
	       g_meta_vir->sensor_init_offset_size);
	printf("g_meta_vir->cmdline_offset: %p\n", g_meta_vir->cmdline_offset);
	printf("g_meta_vir->cmdline_offset_size: %d\n", g_meta_vir->cmdline_offset_size);
	printf("g_meta_vir->ae_table_offset: %p\n", g_meta_vir->ae_table_offset);
	printf("g_meta_vir->ae_table_offset_size: %d\n", g_meta_vir->ae_table_offset_size);
	printf("g_meta_vir->app_param_offset: %p\n", g_meta_vir->app_param_offset);
	printf("g_meta_vir->app_param_offset_size: %d\n", g_meta_vir->app_param_offset_size);
	printf("g_meta_vir->secondary_sensor_init_offset: %p\n",
	       g_meta_vir->secondary_sensor_init_offset);
	printf("g_meta_vir->secondary_sensor_init_offset_size: %d\n",
	       g_meta_vir->wakeup_param_offset_size);
	printf("g_meta_vir->wakeup_param_offset: %p\n", g_meta_vir->wakeup_param_offset);
	printf("g_meta_vir->wakeup_param_offset_size: %d\n",
	       g_meta_vir->secondary_sensor_init_offset_size);
	printf("g_meta_vir->reserve: %p\n", g_meta_vir->reserve);
	printf("g_meta_vir->reserve_size: %d\n", g_meta_vir->reserve_size);
	printf("g_meta_vir->backup: %p\n", g_meta_vir->backup);
	printf("g_meta_vir->backup_size: %d\n", g_meta_vir->backup_size);
	printf("g_meta_vir->sensor_iq_bin_offset: %p\n", g_meta_vir->sensor_iq_bin_offset);
	printf("g_meta_vir->sensor_iq_bin_offset_size: %d\n",
	       g_meta_vir->sensor_iq_bin_offset_size);
	printf("g_meta_vir->secondary_sensor_iq_bin_offset: %p\n",
	       g_meta_vir->secondary_sensor_iq_bin_offset);
	printf("g_meta_vir->secondary_sensor_iq_bin_offset_size: %d\n",
	       g_meta_vir->secondary_sensor_iq_bin_offset_size);
	printf("g_meta_vir->wakeup_aov_param_offset: %p\n",
	       g_meta_vir->wakeup_aov_param_offset);
	printf("g_meta_vir->wakeup_aov_param_max_size: %d\n",
	       g_meta_vir->wakeup_aov_param_max_size);
	// ... Print other fields ...
}

#define se32_to_be32(x)                                                                  \
	((0x000000FF & x) << 24) | ((0x0000FF00 & x) << 8) | ((0x00FF0000 & x) >> 8) |       \
	    ((0xFF000000 & x) >> 24)

static int SAMPLE_COMM_AOV_MetaMmap() {
	int mem_fd = -1;
	void *mapped_base, *virt_addr;
	uint32_t meta_addr, meta_size;
	int dts_fd;

	if (g_meta_vir != NULL) {
		printf("[%s()] g_meta_vir has been mapped!", __func__);
		return RK_FAILURE;
	}
	g_meta_vir = malloc(sizeof(struct meta_para_vir));
	if (g_meta_vir == NULL) {
		printf("[%s()] g_meta_vir malloc failed!", __func__);
		return RK_FAILURE;
	}
	memset(g_meta_vir, 0, sizeof(struct meta_para_vir));

	mem_fd = open("/dev/mem", O_RDWR | O_SYNC);
	if (mem_fd == -1) {
		perror("Error opening /dev/mem");
		return EXIT_FAILURE;
	}

	dts_fd =
	    open("/sys/firmware/devicetree/base/reserved-memory/meta@800000/reg", O_RDONLY);
	if (dts_fd > 0) {
		int read_bytes = read(dts_fd, &meta_addr, sizeof(meta_addr));
		read_bytes = read(dts_fd, &meta_size, sizeof(meta_size));
		if (read_bytes > 0) {
			meta_size = se32_to_be32(meta_size);
			meta_addr = se32_to_be32(meta_addr);
			printf("# read firmware meta addr 0X%08x size 0X%08x!\n", meta_addr,
			       meta_size);
		} else {
			meta_size = META_SIZE;
			meta_addr = META_PHY_ADDR;
			printf("# read dts reg failed!\n");
		}
		close(dts_fd);
	} else {
		meta_size = META_SIZE;
		meta_addr = META_PHY_ADDR;
		printf("# read dts failed!\n");
	}

	mapped_base =
	    mmap(0, meta_size, PROT_READ | PROT_WRITE, MAP_SHARED, mem_fd, meta_addr);
	if (mapped_base == MAP_FAILED) {
		perror("Error mapping physical address to virtual address");
		close(mem_fd);
		return EXIT_FAILURE;
	}

	g_meta_vir->mem_fd = mem_fd;
	g_meta_vir->mapped_base = mapped_base;
	g_meta_vir->meta_head = mapped_base + META_INFO_HEAD_OFFSET;
	g_meta_vir->meta_head_size = META_INFO_SIZE;
	g_meta_vir->param_share2kernel_offset = mapped_base + PARAM_SHARE2KERNEL_OFFSET;
	g_meta_vir->param_share2kernel_offset_size = PARAM_SHARE2KERNEL_SIZE;
	g_meta_vir->sensor_init_offset = mapped_base + SENSOR_INIT_OFFSET;
	g_meta_vir->sensor_init_offset_size = SENSOR_INIT_MAX_SIZE;
	g_meta_vir->cmdline_offset = mapped_base + CMDLINE_OFFSET;
	g_meta_vir->cmdline_offset_size = CMDLINE_MAX_SIZE;
	g_meta_vir->ae_table_offset = mapped_base + AE_TABLE_OFFSET;
	g_meta_vir->ae_table_offset_size = AE_TABLE_MAX_SIZE;
	g_meta_vir->app_param_offset = mapped_base + APP_PARAM_OFFSET;
	g_meta_vir->app_param_offset_size = APP_PARAM_MAX_SIZE;
	g_meta_vir->secondary_sensor_init_offset = mapped_base + SECONDARY_SENSOR_INIT_OFFSET;
	g_meta_vir->secondary_sensor_init_offset_size = SECONDARY_SENSOR_INIT_MAX_SIZE;
	g_meta_vir->wakeup_param_offset = mapped_base + WAKEUP_PARAM_OFFSET;
	g_meta_vir->wakeup_param_offset_size = WAKEUP_PARAM_MAX_SIZE;
	// g_meta_vir->reserve = mapped_base + RESERVE;
	// g_meta_vir->reserve_size = RESERVE_SIZE;
	// g_meta_vir->backup = mapped_base + BACKUP;
	// g_meta_vir->backup_size = BACKUP_SIZE;
	g_meta_vir->sensor_iq_bin_offset = mapped_base + SENSOR_IQ_BIN_OFFSET;
	g_meta_vir->sensor_iq_bin_offset_size = SENSOR_IQ_BIN_MAX_SIZE;
	g_meta_vir->secondary_sensor_iq_bin_offset =
	    mapped_base + SECONDARY_SENSOR_IQ_BIN_OFFSET;
	g_meta_vir->secondary_sensor_iq_bin_offset_size = SENSOR_IQ_BIN_MAX_SIZE;
	// g_meta_vir->secondary_sensor_iq_bin_offset_size = 0; // not support
	g_meta_vir->wakeup_aov_param_offset = mapped_base + WAKEUP_AOV_PARAM_OFFSET;
	g_meta_vir->wakeup_aov_param_max_size = WAKEUP_AOV_PARAM_MAX_SIZE;

	SAMPLE_COMM_AOV_MetaDump(g_meta_vir);

	// init mcu mode
	struct wakeup_param_info *wakeup_param =
	    (struct wakeup_param_info *)g_meta_vir->wakeup_param_offset;
	wakeup_param->wakeup_mode = 0;
	wakeup_param->ae_wakeup_mode = 0;
	wakeup_param->arm_run_count = 0;
	wakeup_param->arm_max_run_count = -1;
	wakeup_param->mcu_run_count = 0;
	wakeup_param->mcu_max_run_count = -1;

	return RK_SUCCESS;
}

static int SAMPLE_COMM_AOV_MetaMunmap() {
	if (g_meta_vir) {
		if (g_meta_vir->mapped_base)
			munmap(g_meta_vir->mapped_base, META_SIZE);
		if (g_meta_vir->mem_fd >= 0)
			close(g_meta_vir->mem_fd);
		free(g_meta_vir);
		g_meta_vir = NULL;
	} else {
		printf("[%s()] empty g_meta_vir!\n", __func__);
		return RK_FAILURE;
	}
	return RK_SUCCESS;
}

#endif // #ifdef AOV_FASTBOOT_ENABLE

#ifdef RK_ENABLE_RTT
int SAMPLE_COMM_Get_WakeupBin_Info(uint32_t *addr, uint32_t *size) {

#define RTT_BIN_PARAM "/proc/device-tree/reserved-memory/rtos@40000/reg"
#define uswap_32(x)                                                                      \
	((((x)&0xff000000) >> 24) | (((x)&0x00ff0000) >> 8) | (((x)&0x0000ff00) << 8) |      \
	 (((x)&0x000000ff) << 24))

	int rtt_bin_param_fd = -1;
	struct RttBinParam {
		unsigned int addr;
		unsigned int size;
	};

	struct RttBinParam bin_param = {0, 0};
	if ((rtt_bin_param_fd = open(RTT_BIN_PARAM, O_RDONLY)) < 0) {
		printf("cannot open [%s]\n", RTT_BIN_PARAM);
		return RK_FAILURE;
	}

	if (read(rtt_bin_param_fd, (void *)&bin_param, sizeof(bin_param)) == -1) {
		printf("read log param error.\n");
		if (rtt_bin_param_fd != -1)
			close(rtt_bin_param_fd);
		return RK_FAILURE;
	}

	if (rtt_bin_param_fd != -1)
		close(rtt_bin_param_fd);

	bin_param.addr = uswap_32(bin_param.addr);
	bin_param.size = uswap_32(bin_param.size);
	printf("rtt wakeup bin addr [%#x]\n", bin_param.addr);
	printf("rtt wakeup bin size [%#x]\n", bin_param.size);

	*addr = bin_param.addr;
	*size = bin_param.size;
	return RK_SUCCESS;
}

int SAMPLE_COMM_AOV_WakeupBinMmap(const char *rtthread_wakeup_bin_path) {
	int mem_fd = -1;
	uint32_t rtt_bin_addr, rtt_bin_max_size;
	void *mapped_base, *virt_addr;
	if (access(rtthread_wakeup_bin_path, F_OK) != 0) {
		perror("read ree wakeup bin info error");
		return EXIT_FAILURE;
	}

	if (SAMPLE_COMM_Get_WakeupBin_Info(&rtt_bin_addr, &rtt_bin_max_size) != 0) {
		return EXIT_FAILURE;
	}

	FILE *rtt_bin_file = fopen(rtthread_wakeup_bin_path, "r");
	if (rtt_bin_file == NULL) {
		perror("Error opening meta file");
		close(mem_fd);
		return EXIT_FAILURE;
	}
	mem_fd = open("/dev/mem", O_RDWR | O_SYNC);
	if (mem_fd == -1) {
		perror("Error opening /dev/mem");
		fclose(rtt_bin_file);
		return EXIT_FAILURE;
	}
	mapped_base = mmap(0, rtt_bin_max_size, PROT_READ | PROT_WRITE, MAP_SHARED, mem_fd,
	                   rtt_bin_addr);
	if (mapped_base == MAP_FAILED) {
		perror("Error mapping physical address to virtual address");
		fclose(rtt_bin_file);
		close(mem_fd);
		return EXIT_FAILURE;
	}

	memset(mapped_base, 0, rtt_bin_max_size);

	char buffer[1024];
	size_t read_bytes;
	while ((read_bytes = fread(buffer, 1, sizeof(buffer), rtt_bin_file)) > 0) {
		memcpy(mapped_base, buffer, read_bytes);
		mapped_base += read_bytes;
	}
	fclose(rtt_bin_file);
	munmap(mapped_base, rtt_bin_max_size);
	close(mem_fd);
	return RK_SUCCESS;
}
#endif // #ifdef RK_ENABLE_RTT

int SAMPLE_COMM_AOV_Init() {
#ifdef AOV_FASTBOOT_ENABLE
	SAMPLE_COMM_AOV_MetaMmap();
#endif
	// INFO:
	// Find event device path in /proc/bus/input/devices is a better way.
	g_input_device_fd = open("/dev/input/event0", O_RDONLY | O_NONBLOCK);
	if (g_input_device_fd < 0) {
		printf("Open failed /dev/input/event0: %s, you can ignore this"
		       " msg if you don't need gpio wakeup...\n",
		       strerror(errno));
	}

	pthread_mutex_init(&g_wakeup_run_mutex, NULL);
	return RK_SUCCESS;
}

int SAMPLE_COMM_AOV_Deinit() {
	pthread_mutex_lock(&g_wakeup_run_mutex);
#ifdef AOV_FASTBOOT_ENABLE
	SAMPLE_COMM_AOV_MetaMunmap();
#endif
	pthread_mutex_unlock(&g_wakeup_run_mutex);
	pthread_mutex_destroy(&g_wakeup_run_mutex);

	if (g_input_device_fd >= 0)
		close(g_input_device_fd);
}

void SAMPLE_COMM_AOV_EnterSleep() {
#if 0

	pthread_mutex_lock(&g_wakeup_run_mutex);
	writeReg(0x02000200, 8); // output
	// writeReg(0x02000000, 0); //low
	// usleep(50 * 1000);
	writeReg(0x02000200, 0); // high
#endif

	pthread_mutex_lock(&g_wakeup_run_mutex);

	FILE *file;
	// 打开文件
	file = fopen("/sys/power/state", "w");
	if (file == NULL) {
		perror("Failed to open /sys/power/state");
		pthread_mutex_unlock(&g_wakeup_run_mutex);
		exit(EXIT_FAILURE);
	}
	// 写入字符串
	const char *state = "mem";
	printf("start echo mem > /sys/power/state\n");
	// 进入休眠
	size_t bytes_written = fwrite(state, sizeof(char), strlen(state), file);
	if (bytes_written != strlen(state)) {
		perror("Failed to write to /sys/power/state");
		fclose(file);
		pthread_mutex_unlock(&g_wakeup_run_mutex);
		exit(EXIT_FAILURE);
	}
	fflush(file);
	// 关闭文件
	fclose(file);
#if 0
	writeReg(0x02000200, 8); // output
	writeReg(0x02000000, 0); // low
	// writeReg(0x02000200, 8); //output
	// writeReg(0x02000000, 0); //low
	// usleep(50 * 1000);
	// writeReg(0x02000200, 0); //high
	pthread_mutex_unlock(&g_wakeup_run_mutex);
#endif
	pthread_mutex_unlock(&g_wakeup_run_mutex);
}

int SAMPLE_COMM_AOV_SetSuspendTime(int wakeup_suspend_time) {
	char wakeup_cmd[256];
	sprintf(wakeup_cmd, "io -4 0xff300048 %d", wakeup_suspend_time * 32);
	system(wakeup_cmd);
	sleep(1);
	printf("wakeup suspend time = %d", wakeup_suspend_time);
	return RK_SUCCESS;
}

int SAMPLE_COMM_AOV_PreInitIsp(const char *sensor_name, const char *iq_file_dir,
                               int cam_index) {
	int ret = RK_SUCCESS;
	rk_aiq_tb_info_t tb_info;
	struct sensor_iq_info *sensor_iq = NULL;
	void *main_iq_offset = NULL;
	void *secondary_iq_offset = NULL;

	pthread_mutex_lock(&g_wakeup_run_mutex);
	memset(&tb_info, 0, sizeof(rk_aiq_tb_info_t));
	tb_info.magic = sizeof(rk_aiq_tb_info_t) - 2;

#ifdef AOV_FASTBOOT_ENABLE
	if (!g_meta_vir) {
		printf("[%s()] empty meta image!\n", __func__);
		pthread_mutex_unlock(&g_wakeup_run_mutex);
		return RK_FAILURE;
	}

	if (cam_index < MAX_CAMERA_NUM) {
		sensor_iq = (struct sensor_iq_info *)g_meta_vir->sensor_iq_bin_offset;
		main_iq_offset = (uint8_t *)g_meta_vir->mapped_base +
		                 (sensor_iq->main_sensor_iq_offset - META_PHY_ADDR);
		secondary_iq_offset = (uint8_t *)g_meta_vir->mapped_base +
		                      (sensor_iq->secondary_sensor_iq_offset - META_PHY_ADDR);
		printf("[%s()] main addr %p size %d, second addr %p size %d\n", __func__,
		       sensor_iq->main_sensor_iq_offset, sensor_iq->main_sensor_iq_size,
		       sensor_iq->secondary_sensor_iq_offset,
		       sensor_iq->secondary_sensor_iq_size);
	} else {
		printf("[%s()] error camera index %d!\n", __func__, cam_index);
		pthread_mutex_unlock(&g_wakeup_run_mutex);
		return RK_FAILURE;
	}

	tb_info.is_start_once = true;
	tb_info.is_pre_aiq = true;
	tb_info.prd_type = RK_AIQ_PRD_TYPE_TB_BATIPC;
	// tb_info.rtt_share_addr = g_meta_vir->wakeup_aov_param_offset;
	tb_info.rtt_share_addr = 0;
#else
	tb_info.is_start_once = false;
	tb_info.is_pre_aiq = false;
	tb_info.prd_type = RK_AIQ_PRD_TYPE_SINGLE_FRAME;
	tb_info.rtt_share_addr = 0;
	if (iq_file_dir != NULL) {
		printf("rkaiq use iqfiles from %s\n", iq_file_dir);
		tb_info.iq_bin_mode = RK_AIQ_META_NOT_FULL_IQ_BIN;
	}
#endif
	ret = rk_aiq_uapi2_sysctl_preInit_tb_info(sensor_name, &tb_info);
	if (ret != RK_SUCCESS)
		printf("[%s()] rk_aiq_uapi2_sysctl_preInit_tb_info failed %#X!\n", __func__, ret);

#ifdef AOV_FASTBOOT_ENABLE
	if (cam_index == 0)
		ret = rk_aiq_uapi2_sysctl_preInit_iq_addr(sensor_name, main_iq_offset,
		                                          sensor_iq->main_sensor_iq_size);
	else if (cam_index == 1)
		ret = rk_aiq_uapi2_sysctl_preInit_iq_addr(sensor_name, secondary_iq_offset,
		                                          sensor_iq->secondary_sensor_iq_size);
	else
		printf("[%s()] not support camera index %d now!\n", cam_index);
	if (ret != RK_SUCCESS)
		printf("[%s()] rk_aiq_uapi2_sysctl_preInit_iq_addr failed %#X!\n", __func__, ret);
#endif
	pthread_mutex_unlock(&g_wakeup_run_mutex);
	return ret;
}

#define ETHERNET_DEVICE "ffa80000.ethernet"
#define ETHERNET_DRIVER "/sys/bus/platform/drivers/rk_gmac-dwmac/"
// #define NIC_DEVICE "stmmac-0:02"
// #define NIC_DRIVER "/sys/bus/mdio_bus/drivers/RK630 PHY/"
#define ETHERNET_BIND_DONE "/sys/bus/platform/drivers/rk_gmac-dwmac/"
#define ETHERNET_UNBNID_DONE "/sys/bus/platform/drivers/rk_gmac-dwmac/"

int SAMPLE_COMM_AOV_BindEthernet() {
	char buf[MAX_NL_BUF_SIZE] = {'\0'};
	char name[256] = {'\0'};
	int ret = 0;
	int fd = -1;
	int len = MAX_NL_BUF_SIZE;
	fd_set read_set;
	struct ifreq ifr;
	struct timeval timeout;
	struct sockaddr_nl addr;
	struct nlmsghdr *nh = NULL;
	struct ifinfomsg *ifinfo = NULL;

	printf("[%s()] Enter\n", __func__);
	if (access(ETHERNET_DRIVER ETHERNET_DEVICE, F_OK) == 0) {
		printf("[%s()] ethernet device already bind!\n", __func__);
		goto __FAILED;
	}

	fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
	setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &len, sizeof(len));
	memset(&addr, 0, sizeof(addr));
	addr.nl_family = AF_NETLINK;
	addr.nl_groups = RTNLGRP_LINK;
	addr.nl_pid = getpid();
	if (fd < 0) {
		printf("[%s()] Failed to open network netlink because %s\n", __func__,
		       strerror(errno));
		goto __FAILED;
	} else if (bind(fd, (struct sockaddr *)(&addr), sizeof(addr)) != 0) {
		printf("[%s()] bind network netlink addr failed because %s\n", __func__,
		       strerror(errno));
		goto __FAILED;
	}

	FD_ZERO(&read_set);
	FD_SET(fd, &read_set);
	timeout.tv_sec = 0;
	timeout.tv_usec = MAX_SELECT_TIMEOUT;
	setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (void *)&timeout,
	           (socklen_t)sizeof(struct timeval));

	// bind ethernet driver
	SAMPLE_COMM_ECHO(ETHERNET_DRIVER "bind", ETHERNET_DEVICE, (strlen(ETHERNET_DEVICE)));

#if 1
	// open etherner device
	system("ifconfig eth0 up");
	// reset local ip, gateway and dns resolvation
	system("killall -9 udhcpc");                // restart udhcpc
	system("route del default gw 0.0.0.0");     // delete default gateway
	system("cat /dev/null > /etc/resolv.conf"); // reset DNS resolvation
	system("udhcpc -i eth0 -T 1 -A 0 -b -q");   // find a new ip address for eth0
#endif
	// wait for bind success
	// FIXME:
	// there has some bug for select()
	// ret = select(fd + 1, &read_set, NULL, NULL, &timeout);
	memset(&buf, 0, sizeof(buf));
	while ((ret = read(fd, buf, sizeof(buf))) > 0) {
		for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, ret); nh = NLMSG_NEXT(nh, ret)) {
			if (nh->nlmsg_type == NLMSG_DONE) {
				printf("[%s()] NLMSG_DONE\n", __func__);
				goto __FAILED;
			}
			if (nh->nlmsg_type == NLMSG_ERROR) {
				printf("[%s()] NLMSG_ERROR\n", __func__);
				goto __FAILED;
			}
			if (nh->nlmsg_type != RTM_NEWLINK) {
				printf("[%s()] not RTM_NEWLINK, ignore\n", __func__);
				continue;
			}
			ifinfo = NLMSG_DATA(nh);
			if_indextoname(ifinfo->ifi_index, name);

			// printf("[%s()] %s: up %s, lower up %s, running %s, value 0X%X\n", __func__
			// 	, name
			// 	, (ifinfo->ifi_flags & IFF_UP) ? "true" : "false"
			// 	, (ifinfo->ifi_flags & IFF_LOWER_UP) ? "true" : "false"
			// 	, (ifinfo->ifi_flags & IFF_RUNNING) ? "true" : "false"
			// 	, ifinfo->ifi_flags
			// );

			if ((ifinfo->ifi_flags & IFF_RUNNING) && (ifinfo->ifi_flags & IFF_LOWER_UP) &&
			    (ifinfo->ifi_flags & IFF_UP)) {
				printf("[%s()] ethernet bind success!\n", __func__);
				goto __SUCCESS;
			}
		}
	}
	if (ret < 0)
		goto __FAILED;

__SUCCESS:
	if (fd >= 0)
		close(fd);
	printf("[%s()] Exit\n", __func__);
	return RK_SUCCESS;
__FAILED:
	if (fd >= 0)
		close(fd);
	printf("[%s()] Exit Error\n", __func__);
	return RK_FAILURE;
}

int SAMPLE_COMM_AOV_UnbindEthernet() {
	char buf[MAX_NL_BUF_SIZE] = {'\0'};
	char name[256] = {'\0'};
	int ret = 0;
	int fd = -1;
	int len = MAX_NL_BUF_SIZE;
	fd_set read_set;
	struct sockaddr_nl addr;
	struct timeval timeout;
	struct nlmsghdr *nh = NULL;
	struct ifinfomsg *ifinfo = NULL;

	printf("[%s()] Enter\n", __func__);
	if (access(ETHERNET_DRIVER ETHERNET_DEVICE, F_OK) != 0) {
		printf("[%s()] ethernet device already unbind!\n", __func__);
		goto __FAILED;
	}

	fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
	setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &len, sizeof(len));
	memset(&addr, 0, sizeof(addr));
	addr.nl_family = AF_NETLINK;
	addr.nl_groups = RTNLGRP_LINK;
	addr.nl_pid = getpid();
	if (fd < 0) {
		printf("[%s()] Failed to open network netlink because %s\n", __func__,
		       strerror(errno));
		return RK_FAILURE;
	} else if (bind(fd, (struct sockaddr *)(&addr), sizeof(addr)) != 0) {
		printf("[%s()] bind network netlink addr failed because %s\n", __func__,
		       strerror(errno));
		goto __FAILED;
	}

	FD_ZERO(&read_set);
	FD_SET(fd, &read_set);
	timeout.tv_sec = 0;
	timeout.tv_usec = MAX_SELECT_TIMEOUT;

	// close ethernet device
	system("ifconfig eth0 0.0.0.0");
	system("ifconfig eth0 down");
	// unbind ethernet driver
	SAMPLE_COMM_ECHO(ETHERNET_DRIVER "unbind", ETHERNET_DEVICE,
	                 (strlen(ETHERNET_DEVICE)));
	// wait for unbind done
__RETRY:
	ret = select(fd + 1, &read_set, NULL, NULL, &timeout);
	if (ret > 0) {
		memset(&buf, 0, sizeof(buf));
		ret = read(fd, buf, sizeof(buf));
		for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, ret); nh = NLMSG_NEXT(nh, ret)) {
			if (nh->nlmsg_type == NLMSG_DONE) {
				printf("[%s()] NLMSG_DONE\n", __func__);
				goto __FAILED;
			}
			if (nh->nlmsg_type == NLMSG_ERROR) {
				printf("[%s()] NLMSG_ERROR\n", __func__);
				goto __FAILED;
			}
			ifinfo = NLMSG_DATA(nh);
			if_indextoname(ifinfo->ifi_index, name);

			// printf("[%s()] %s: up %s, lower up %s, running %s, value 0X%X\n", __func__
			// 	, name
			// 	, (ifinfo->ifi_flags & IFF_UP) ? "true" : "false"
			// 	, (ifinfo->ifi_flags & IFF_LOWER_UP) ? "true" : "false"
			// 	, (ifinfo->ifi_flags & IFF_RUNNING) ? "true" : "false"
			// 	, ifinfo->ifi_flags
			// );

			if (!(ifinfo->ifi_flags & IFF_RUNNING) &&
			    !(ifinfo->ifi_flags & IFF_LOWER_UP) && !(ifinfo->ifi_flags & IFF_UP)) {
				printf("[%s()] ethernet unbind success!\n", __func__);
				goto __SUCCESS;
			}
		}
		// printf("[%s()] Bind msg: %s\n", __func__, buf);
		goto __RETRY; // drop all message
	} else {
		printf("[%s()] select error: %s\n", __func__, strerror(errno));
		goto __FAILED;
	}
__SUCCESS:
	close(fd);
	// open etherner device
	printf("[%s()] Exit\n", __func__);
	return RK_SUCCESS;
__FAILED:
	close(fd);
	printf("[%s()] Exit Error\n", __func__);
	return RK_FAILURE;
}

#define SDCARD_ADDR_STR "ffaa0000.mmc"
#define SDCARD_NODE_BIND "/sys/bus/platform/drivers/dwmmc_rockchip/bind"
#define SDCARD_NODE_UNBIND "/sys/bus/platform/drivers/dwmmc_rockchip/unbind"
#define SDCARD_NODE_DEVICE "/sys/bus/platform/drivers/dwmmc_rockchip/ffaa0000.mmc"
#define SDCARD_BIND_DONE "bind@/devices/platform/ffaa0000.mmc/mmc_host/mmc1/mmc1"
#define SDCARD_UNBIND_DONE "unbind@/devices/platform/ffaa0000.mmc"

int SAMPLE_COMM_AOV_BindSdcard() {
	int ret = 0;
	int fd = -1;
	char buf[MAX_NL_BUF_SIZE] = {'\0'};
	fd_set read_set;
	struct timeval timeout;
	struct sockaddr_nl addr;

	if (access(SDCARD_NODE_DEVICE, F_OK) == 0) {
		printf("[%s()] sdcard device already bind!\n", __func__);
		return RK_SUCCESS;
	}

	memset(&addr, 0, sizeof(addr));
	addr.nl_family = AF_NETLINK;
	addr.nl_groups = NETLINK_KOBJECT_UEVENT;
	addr.nl_pid = 0;

	fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_KOBJECT_UEVENT);
	if (fd < 0) {
		printf("[%s()] Failed to open sdcard netlink because %s\n", __func__,
		       strerror(errno));
		return RK_FAILURE;
	} else if (bind(fd, (struct sockaddr *)(&addr), sizeof(addr)) != 0) {
		printf("[%s()] bind sdcard netlink addr failed because %s\n", __func__,
		       strerror(errno));
		goto __FAILED;
	}

	FD_ZERO(&read_set);
	FD_SET(fd, &read_set);
	timeout.tv_sec = 0;
	timeout.tv_usec = MAX_SELECT_TIMEOUT;

	// bind sdcard
	SAMPLE_COMM_ECHO(SDCARD_NODE_BIND, SDCARD_ADDR_STR, (sizeof(SDCARD_ADDR_STR)));
	// wait for bind success
__RETRY:
	ret = select(fd + 1, &read_set, NULL, NULL, &timeout);
	if (ret > 0) {
		memset(&buf, 0, sizeof(buf));
		read(fd, buf, sizeof(buf));
		buf[MAX_NL_BUF_SIZE - 1] = '\0';
		// printf("[%s()] bind msg: %s\n", __func__, buf);
		if (strncmp(buf, SDCARD_BIND_DONE, strlen(SDCARD_BIND_DONE)) == 0) {
			printf("[%s()] Bind success: %s\n", __func__, buf);
			goto __SUCCESS;
		}
		goto __RETRY; // drop all message
	} else {
		printf("[%s()] select error %s\n", __func__, strerror(errno));
		goto __FAILED;
	}
__SUCCESS:
	close(fd);
	return RK_SUCCESS;
__FAILED:
	close(fd);
	return RK_FAILURE;
}

int SAMPLE_COMM_AOV_UnbindSdcard() {
	int ret = 0;
	int fd = -1;
	char buf[MAX_NL_BUF_SIZE] = {'\0'};
	fd_set read_set;
	struct timeval timeout;
	struct sockaddr_nl addr;

	if (access(SDCARD_NODE_DEVICE, F_OK) != 0) {
		printf("[%s()] sdcard device already unbind!\n", __func__);
		return RK_SUCCESS;
	}

	memset(&addr, 0, sizeof(addr));
	addr.nl_family = AF_NETLINK;
	addr.nl_groups = NETLINK_KOBJECT_UEVENT;
	addr.nl_pid = 0;

	fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_KOBJECT_UEVENT);
	if (fd < 0) {
		printf("[%s()] Failed to open sdcard netlink because %s\n", __func__,
		       strerror(errno));
		return RK_FAILURE;
	} else if (bind(fd, (struct sockaddr *)(&addr), sizeof(addr)) != 0) {
		printf("[%s()] bind sdcard netlink addr failed because %s\n", __func__,
		       strerror(errno));
		goto __FAILED;
	}

	memset(&buf, 0, sizeof(buf));
	FD_ZERO(&read_set);
	FD_SET(fd, &read_set);
	timeout.tv_sec = 0;
	timeout.tv_usec = MAX_SELECT_TIMEOUT;

	// unbind sdcard
	SAMPLE_COMM_ECHO(SDCARD_NODE_UNBIND, SDCARD_ADDR_STR, (sizeof(SDCARD_ADDR_STR)));
	// wait for unbind success
__RETRY:
	ret = select(fd + 1, &read_set, NULL, NULL, &timeout);
	if (ret > 0) {
		memset(&buf, 0, sizeof(buf));
		read(fd, buf, sizeof(buf));
		buf[MAX_NL_BUF_SIZE - 1] = '\0';
		// printf("[%s()] unbind msg: %s\n", __func__, buf);
		if (strcmp(buf, SDCARD_UNBIND_DONE) == 0) {
			printf("[%s()] Unbind success: %s\n", __func__, buf);
			goto __SUCCESS;
		}
		goto __RETRY; // drop all message
	} else {
		printf("[%s()] select error %s\n", __func__, strerror(errno));
		goto __FAILED;
	}
__SUCCESS:
	close(fd);
	return RK_SUCCESS;
__FAILED:
	close(fd);
	return RK_FAILURE;
}

static int SAMPLE_COMM_AOV_CheckSDcardMount(void) {
	FILE *file = fopen("/proc/mounts", "r");
	int ret = RK_FAILURE;
	if (file == NULL) {
		printf("Failed to open file\n");
		return ret;
	}

	char line[256];
	while (fgets(line, sizeof(line), file)) {
		if (strstr(line, "/mnt/sdcard")) {
			printf("Found '/mnt/sdcard' in line: %s", line);
			ret = RK_SUCCESS;
		}
	}

	fclose(file);
	return ret;
} /* -----  end of function SAMPLE_COMM_AOV_CheckSDcardMount  ----- */

int SAMPLE_COMM_AOV_CopyStreamToSdcard(int venc_chn_id, char *data, int data_size,
                                       char *data2, int data2_size) {
	int ret = 0;
	pthread_mutex_lock(&g_wakeup_run_mutex);
	SAMPLE_COMM_AOV_BindSdcard();
	// mount sd
	if (access("/dev/mmcblk1p1", F_OK) == 0) {
		// system("mount -t vfat /dev/mmcblk1p1 /mnt/sdcard/");
		ret = mount("/dev/mmcblk1p1", "/mnt/sdcard", "vfat", 0, NULL);
		if (ret != 0)
			printf("[%s()] mount failed because %s\n", __func__, strerror(errno));
		else
			printf("[%s()] mount success\n", __func__);
	} else if (access("/dev/mmcblk1", F_OK) == 0) {
		// system("mount -t vfat /dev/mmcblk1 /mnt/sdcard/");
		ret = mount("/dev/mmcblk1", "/mnt/sdcard", "vfat", 0, NULL);
		if (ret != 0)
			printf("[%s()] mount failed because %s\n", __func__, strerror(errno));
		else
			printf("[%s()] mount success\n", __func__);
	} else {
		printf("[%s()] bad mount path!\n", __func__);
		goto SAMPLE_COMM_AOV_CopyStreamToSdcard_end;
	}

	if (0 != SAMPLE_COMM_AOV_CheckSDcardMount()) {
		printf("Not found mount sdcard on /mnt/sdcard\n");
		goto SAMPLE_COMM_AOV_CopyStreamToSdcard_end;
	}

	static int count_t = 0;
	static char dstPath[256];
	int s32fd = 0;
	char dst[256];
	// 首次进来存储，遍历目录是否可用，最多100个目录
	if (count_t == 0) {
		int i = 0;
		for (i = 0; i < 100; i++) {
			sprintf(dstPath, "/mnt/sdcard/wakeup_frame_%d", i);
			struct stat st;
			if (stat(dstPath, &st) == -1) {
				if (mkdir(dstPath, 0777) == -1)
					printf("mkdir %s failed\n", dstPath);
				break;
			}
		}
	}
	sprintf(dst, "%s/venc_chn%d_%d.h265", dstPath, venc_chn_id, count_t);
	FILE *fp = fopen(dst, "wb");
	if (fp != NULL) {
		fwrite(data, 1, data_size, fp);
		if (data2)
			fwrite(data2, 1, data2_size, fp);
		s32fd = fileno(fp);
		fsync(s32fd);
		fclose(fp);
		count_t++;
	}
	// unmount sdcard
	umount2("/mnt/sdcard", MNT_DETACH);

SAMPLE_COMM_AOV_CopyStreamToSdcard_end:
	SAMPLE_COMM_AOV_UnbindSdcard();
	pthread_mutex_unlock(&g_wakeup_run_mutex);

	return RK_SUCCESS;
}

void SAMPLE_COMM_AOV_DumpPtsToTMP(uint32_t seq, uint64_t pts, int max_dump_pts_count) {
	static int line_count = 0;
	static FILE *file;
	const char *file_path = "/tmp/pts.txt";

	if (line_count >= max_dump_pts_count) {
		return;
	}

	if (line_count == 0) {
		file = fopen(file_path, "w");
		if (file == NULL) {
			perror("Error opening file");
			return;
		}
	}

	if (file != NULL)
		fprintf(file, "seq: %u, pts: %llums\n", seq, (unsigned long long)pts / 1000);

	line_count++;

	if (line_count >= max_dump_pts_count) {
		printf("Closed file after writing %d lines.\n", max_dump_pts_count);
		fclose(file);
		file = NULL;
	}
}

// Return true is there has input event happened.
bool SAMPLE_COMM_AOV_GetGpioIrqStat() {
	bool input_event_happened = false;
	struct input_event event;

	if (g_input_device_fd < 0) {
		// printf("[%s()] unsupport input event detector\n", __func__);
		return input_event_happened;
	}

	// The read() operation is non-block, so the loop would
	// return EGAGIN if there has no any new input event.
	while (read(g_input_device_fd, &event, sizeof(event)) > 0) {
		// printf("[%s()] detect event type %d, code %d, value %d\n"
		// 		, __func__
		// 		, event.type
		// 		, event.code
		// 		, event.value
		// 		);
		// Translate ISP state if gpio-key is pressed between
		// sleeping time.
		if (event.type == EV_KEY && event.code == KEY_POWER && event.value == 1)
			input_event_happened = true;
	}
	return input_event_happened;
}

#define SOUND_BIND_DONE "bind@/devices/platform/acodec-sound"
#define SOUND_UNBIND_DONE "unbind@/devices/platform/ffae0000.i2s"
#define I2S_DRIVER "/sys/bus/platform/drivers/rockchip-i2s-tdm/"
#define ACODEC_DRIVER "/sys/bus/platform/drivers/rv1106-acodec/"
#define ASOC_DRIVER "/sys/bus/platform/drivers/asoc-simple-card/"
#define I2S_DEVICE "ffae0000.i2s"
#define ACODEC_DEVICE "ff480000.acodec"
#define ASOC_DEVICE "acodec-sound"

int SAMPLE_COMM_AOV_BindSoundcard() {
	int ret = 0;
	int fd = -1;
	char buf[MAX_NL_BUF_SIZE] = {'\0'};
	fd_set read_set;
	struct timeval timeout;
	struct sockaddr_nl addr;

	memset(&addr, 0, sizeof(addr));
	addr.nl_family = AF_NETLINK;
	addr.nl_groups = NETLINK_KOBJECT_UEVENT;
	addr.nl_pid = 0;

	fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_KOBJECT_UEVENT);
	if (fd < 0) {
		printf("[%s()] Failed to open netlink because %s\n", __func__, strerror(errno));
		return RK_FAILURE;
	} else if (bind(fd, (struct sockaddr *)(&addr), sizeof(addr)) != 0) {
		printf("[%s()] bind netlink addr failed because %s\n", __func__, strerror(errno));
		goto __FAILED;
	}

	memset(&buf, 0, sizeof(buf));
	FD_ZERO(&read_set);
	FD_SET(fd, &read_set);
	timeout.tv_sec = 0;
	timeout.tv_usec = MAX_SELECT_TIMEOUT;

	SAMPLE_COMM_ECHO(I2S_DRIVER "bind", I2S_DEVICE, (sizeof(I2S_DEVICE)));
	SAMPLE_COMM_ECHO(ACODEC_DRIVER "bind", ACODEC_DEVICE, (sizeof(ACODEC_DEVICE)));
	SAMPLE_COMM_ECHO(ASOC_DRIVER "bind", ASOC_DEVICE, (sizeof(ASOC_DEVICE)));
__RETRY:
	ret = select(fd + 1, &read_set, NULL, NULL, &timeout);
	if (ret > 0) {
		memset(&buf, 0, sizeof(buf));
		read(fd, buf, sizeof(buf));
		buf[MAX_NL_BUF_SIZE - 1] = '\0';
		// printf("[%s()] msg: %s\n", __func__, buf);
		if (strncmp(buf, SOUND_BIND_DONE, strlen(SOUND_BIND_DONE)) == 0) {
			printf("[%s()] Bind success: %s\n", __func__, buf);
			goto __SUCCESS;
		}
		goto __RETRY; // drop all message
	} else {
		printf("[%s()] select error %s\n", __func__, strerror(errno));
		goto __FAILED;
	}

__SUCCESS:
	close(fd);
	return RK_SUCCESS;
__FAILED:
	close(fd);
	return RK_FAILURE;
}

int SAMPLE_COMM_AOV_UnbindSoundcard() {
	int ret = 0;
	int fd = -1;
	char buf[MAX_NL_BUF_SIZE] = {'\0'};
	fd_set read_set;
	struct timeval timeout;
	struct sockaddr_nl addr;

	memset(&addr, 0, sizeof(addr));
	addr.nl_family = AF_NETLINK;
	addr.nl_groups = NETLINK_KOBJECT_UEVENT;
	addr.nl_pid = 0;

	fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_KOBJECT_UEVENT);
	if (fd < 0) {
		printf("[%s()] Failed to open netlink because %s\n", __func__, strerror(errno));
		return RK_FAILURE;
	} else if (bind(fd, (struct sockaddr *)(&addr), sizeof(addr)) != 0) {
		printf("[%s()] bind netlink addr failed because %s\n", __func__, strerror(errno));
		goto __FAILED;
	}

	memset(&buf, 0, sizeof(buf));
	FD_ZERO(&read_set);
	FD_SET(fd, &read_set);
	timeout.tv_sec = 0;
	timeout.tv_usec = MAX_SELECT_TIMEOUT;

	SAMPLE_COMM_ECHO(ASOC_DRIVER "unbind", ASOC_DEVICE, (sizeof(ASOC_DEVICE)));
	SAMPLE_COMM_ECHO(ACODEC_DRIVER "unbind", ACODEC_DEVICE, (sizeof(ACODEC_DEVICE)));
	SAMPLE_COMM_ECHO(I2S_DRIVER "unbind", I2S_DEVICE, (sizeof(I2S_DEVICE)));
__RETRY:
	ret = select(fd + 1, &read_set, NULL, NULL, &timeout);
	if (ret > 0) {
		memset(&buf, 0, sizeof(buf));
		read(fd, buf, sizeof(buf));
		buf[MAX_NL_BUF_SIZE - 1] = '\0';
		// printf("[%s()] msg: %s\n", __func__, buf);
		if (strncmp(buf, SOUND_UNBIND_DONE, strlen(SOUND_UNBIND_DONE)) == 0) {
			printf("[%s()] Unbind success: %s\n", __func__, buf);
			goto __SUCCESS;
		}
		goto __RETRY; // drop all message
	} else {
		printf("[%s()] select error %s\n", __func__, strerror(errno));
		goto __FAILED;
	}

__SUCCESS:
	close(fd);
	return RK_SUCCESS;
__FAILED:
	close(fd);
	return RK_FAILURE;
}