GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)
This commit is contained in:
@@ -0,0 +1,60 @@
|
||||
SDK_DIR := $(shell cd $(shell pwd)/../.. && /bin/pwd)
|
||||
include $(SDK_DIR)/build/base.mk
|
||||
|
||||
###############################################################################
|
||||
#
|
||||
#
|
||||
#Copyright (c) XMEDIA. All rights reserved.
|
||||
#
|
||||
#
|
||||
###############################################################################
|
||||
|
||||
CROSS_COMPILE := $(CONFIG_XMEDIA_USR_ARM_TOOLCHAINS)
|
||||
STRIP := $(CROSS_COMPILE)-strip
|
||||
ROOTFS_PREFIX := $(XMEDIA_ROOTFS_DIR)
|
||||
ROOTFS_BUILDDIR ?= $(shell pwd)/.build
|
||||
ROOTFS_SRCDIR := $(if $(ROOTFS_DIR),$(ROOTFS_DIR),$(shell pwd))
|
||||
|
||||
MKFLAGS := PREFIX=$(ROOTFS_PREFIX) \
|
||||
CROSS_COMPILE=$(CROSS_COMPILE)- \
|
||||
CONFIG_LIBCPP_SUPPORT=$(CONFIG_XMEDIA_LIBCPP_SUPPORT) \
|
||||
CONFIG_ETH_SUPPORT=y
|
||||
|
||||
.PHONY: all clean
|
||||
|
||||
all: rootfs_strip_$(CONFIG_XMEDIA_ROOTFS_STRIP)
|
||||
@echo;
|
||||
@echo 'File system is ready at "$(ROOTFS_PREFIX)"'
|
||||
@echo;
|
||||
|
||||
clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)
|
||||
rm -rf $(ROOTFS_PREFIX)
|
||||
|
||||
.PHONY: rootfs_strip_y
|
||||
rootfs_strip_y: rootfs_unstrip
|
||||
@set -e; for ix in $$(find $(ROOTFS_PREFIX)/ -type f -a ! -name "*.ko"); \
|
||||
do ( \
|
||||
FILEINFO=$$(file -b $${ix}); \
|
||||
if [ "s$$(echo $${FILEINFO} | \
|
||||
grep '^ELF ..-bit LSB ')" != "s" ]; \
|
||||
then ( \
|
||||
$(STRIP) $${ix}; \
|
||||
) fi; \
|
||||
) done
|
||||
|
||||
.PHONY: rootfs_strip_ rootfs_strip_n rootfs_unstrip
|
||||
rootfs_strip_ rootfs_strip_n: rootfs_unstrip
|
||||
|
||||
TOOLS.y = scripts busybox
|
||||
TOOLS.$(CONFIG_XMEDIA_UDEV_SUPPORT) += eudev
|
||||
TOOLS.$(CONFIG_XMEDIA_E2FSPROGS_SUPPORT) += e2fsprogs
|
||||
TOOLS.$(CONFIG_XMEDIA_GDB_SUPPORT) += gdb
|
||||
TOOLS.$(CONFIG_XMEDIA_REG_SUPPORT) += regtools
|
||||
TOOLS.$(CONFIG_XMEDIA_MIITOOLS_SUPPORT) += ethtools
|
||||
TOOLS.$(CONFIG_XMEDIA_DOSFS_SUPPORT) += dosfstools
|
||||
TOOLS.$(CONFIG_XMEDIA_MTDUTILS_SUPPORT) += mtd-utils
|
||||
TOOLS.$(CONFIG_XMEDIA_CANTOOLS_SUPPORT) += can-utils canutils
|
||||
TOOLS.$(CONFIG_XMEDIA_QUICK_START) += uboot_env
|
||||
|
||||
include $(foreach utils,$(TOOLS.y),$(ROOTFS_SRCDIR)/$(utils)/Makefile)
|
||||
@@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env make
|
||||
###############################################################################
|
||||
#
|
||||
#
|
||||
#Copyright (c) XMEDIA. All rights reserved.
|
||||
#
|
||||
#
|
||||
###############################################################################
|
||||
|
||||
BUSYBOX := busybox-1.36.1
|
||||
|
||||
BUSYBOX_PREFIX = $(ROOTFS_BUILDDIR)/$(BUSYBOX)/.install
|
||||
|
||||
MKFLAGS_BUSYBOX = $(MKFLAGS) V=1
|
||||
MKFLAGS_BUSYBOX += CROSS_COMPILE=$(CONFIG_XMEDIA_USR_ARM_TOOLCHAINS)-
|
||||
MKFLAGS_BUSYBOX += CONFIG_PREFIX=$(BUSYBOX_PREFIX)
|
||||
MKFLAGS_BUSYBOX += CFLAGS="$(filter-out -Werror,$(SDK_USR_CFLAGS)) $(if $(CONFIG_XMEDIA_ARM-GCC7.3-LINUX-MUSLEABI),-Ouserspace,)"
|
||||
|
||||
rootfs_unstrip: $(ROOTFS_PREFIX)/bin/busybox
|
||||
|
||||
clean: $(BUSYBOX).clean
|
||||
|
||||
$(BUSYBOX).clean:
|
||||
$(AT)rm -rf $(ROOTFS_BUILDDIR)/$(BUSYBOX)
|
||||
|
||||
$(ROOTFS_PREFIX)/bin/busybox: $(ROOTFS_BUILDDIR)/$(BUSYBOX)/.built
|
||||
$(call mkdir,$(@D))
|
||||
cp -arf $(BUSYBOX_PREFIX)/. $(ROOTFS_PREFIX)
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(BUSYBOX)/.built: $(ROOTFS_BUILDDIR)/$(BUSYBOX)/.extracted
|
||||
make -C $(<D) $(MKFLAGS_BUSYBOX) all
|
||||
make -C $(<D) $(MKFLAGS_BUSYBOX) install
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(BUSYBOX)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
tar -xf $(OPEN_SOURCE_DIR)/busybox/$(BUSYBOX).tar.bz2 -C $(ROOTFS_BUILDDIR)
|
||||
cp -f $(ROOTFS_SRCDIR)/busybox/$(CONFIG_XMEDIA_BUSYBOX_CFG_NAME).config $(@D)/.config
|
||||
touch $@
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,36 @@
|
||||
#!/usr/bin/env make
|
||||
###############################################################################
|
||||
#
|
||||
#Copyright (c) XMEDIA. All rights reserved.
|
||||
#
|
||||
#
|
||||
###############################################################################
|
||||
CAN_UTILS := can-utils-v2023.03
|
||||
CAN_UTILS_BUILDDIR := $(ROOTFS_BUILDDIR)/$(CAN_UTILS)
|
||||
CAN_UTILS_PREFIX := $(ROOTFS_BUILDDIR)/$(CAN_UTILS)/.install
|
||||
MKFLAG_CAN_UTILS := CFLAGS=-static LDFLAGS=-static
|
||||
|
||||
CC := $(CROSS_COMPILE)-gcc
|
||||
|
||||
rootfs_unstrip: $(ROOTFS_PREFIX)/bin/cangen
|
||||
|
||||
clean: $(CAN_UTILS).clean
|
||||
|
||||
$(CAN_UTILS).clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)/$(CAN_UTILS)
|
||||
|
||||
$(ROOTFS_PREFIX)/bin/cangen: $(CAN_UTILS_BUILDDIR)/.built
|
||||
$(call mkdir,$(@D))
|
||||
cp -arf $(CAN_UTILS_PREFIX)/bin/cangen $(ROOTFS_PREFIX)/bin
|
||||
cp -arf $(CAN_UTILS_PREFIX)/bin/candump $(ROOTFS_PREFIX)/bin
|
||||
touch $@
|
||||
|
||||
$(CAN_UTILS_BUILDDIR)/.built: $(CAN_UTILS_BUILDDIR)/.extracted
|
||||
make -C $(<D) PREFIX=$(CAN_UTILS_PREFIX) CC=$(CC) $(MKFLAG_CAN_UTILS)
|
||||
make -C $(<D) install PREFIX=$(CAN_UTILS_PREFIX) CC=$(CC) $(MKFLAG_CAN_UTILS)
|
||||
touch $@
|
||||
|
||||
$(CAN_UTILS_BUILDDIR)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
unzip -q $(OPEN_SOURCE_DIR)/can/$(CAN_UTILS).zip -d $(ROOTFS_BUILDDIR)/
|
||||
touch $@
|
||||
@@ -0,0 +1,51 @@
|
||||
#!/usr/bin/env make
|
||||
###############################################################################
|
||||
#
|
||||
#Copyright (c) XMEDIA. All rights reserved.
|
||||
#
|
||||
#
|
||||
###############################################################################
|
||||
CANTOOL := canutils
|
||||
CANUTILS := canutils-4.0.6
|
||||
CANLIBSOCKET := libsocketcan-0.0.12
|
||||
CANTOOL_BUILDDIR := $(ROOTFS_BUILDDIR)/$(CANUTILS)
|
||||
LIBSOCKET_PREFIX := $(CANTOOL_BUILDDIR)/$(CANLIBSOCKET)/.install
|
||||
LIBSOCKET_INC_OUT:= $(CANTOOL_BUILDDIR)/$(CANLIBSOCKET)/.install/include
|
||||
LIBSOCKET_LIB_OUT:= $(CANTOOL_BUILDDIR)/$(CANLIBSOCKET)/.install/lib
|
||||
CANTOOL_PREFIX := $(CANTOOL_BUILDDIR)/.install
|
||||
|
||||
rootfs_unstrip: $(ROOTFS_PREFIX)/bin/canconfig
|
||||
|
||||
clean: $(CANTOOL).clean
|
||||
|
||||
$(CANTOOL).clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)/$(CANTOOL)
|
||||
|
||||
$(ROOTFS_PREFIX)/bin/canconfig: $(CANTOOL_BUILDDIR)/.built
|
||||
$(call mkdir,$(@D))
|
||||
cp -arf $(LIBSOCKET_LIB_OUT)/libsocketcan.so.2.3.1 $(ROOTFS_PREFIX)/lib
|
||||
cp -arf $(LIBSOCKET_LIB_OUT)/libsocketcan.so $(ROOTFS_PREFIX)/lib
|
||||
cp -arf $(LIBSOCKET_LIB_OUT)/libsocketcan.so.2 $(ROOTFS_PREFIX)/lib
|
||||
cp -arf $(CANTOOL_PREFIX)/sbin/canconfig $(ROOTFS_PREFIX)/bin
|
||||
touch $@
|
||||
|
||||
$(CANTOOL_BUILDDIR)/.built: $(CANTOOL_BUILDDIR)/.extracted
|
||||
$(call mkdir,$(@D))
|
||||
make -C $(CANTOOL_BUILDDIR)/$(CANLIBSOCKET)
|
||||
make install -C $(CANTOOL_BUILDDIR)/$(CANLIBSOCKET)
|
||||
cd $(CANTOOL_BUILDDIR)/$(CANUTILS); sh autogen.sh;\
|
||||
./configure --prefix=$(CANTOOL_PREFIX) --host=$(CROSS_COMPILE) LDFLAGS=-L$(LIBSOCKET_LIB_OUT) \
|
||||
CFLAGS=-I$(LIBSOCKET_INC_OUT) libsocketcan_LIBS=-lsocketcan libsocketcan_CFLAGS=-I$(LIBSOCKET_INC_OUT)
|
||||
make -C $(CANTOOL_BUILDDIR)/$(CANUTILS)
|
||||
make install -C $(CANTOOL_BUILDDIR)/$(CANUTILS)
|
||||
touch $@
|
||||
|
||||
$(CANTOOL_BUILDDIR)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
tar -xf $(OPEN_SOURCE_DIR)/can/$(CANLIBSOCKET).tar.bz2 -C $(CANTOOL_BUILDDIR)
|
||||
cp -arf $(ROOTFS_SRCDIR)/$(CANTOOL)/$(CANLIBSOCKET).patch/. $(@D)/$(CANLIBSOCKET)
|
||||
cd $(CANTOOL_BUILDDIR)/$(CANLIBSOCKET); sh autogen.sh;\
|
||||
./configure --prefix=$(LIBSOCKET_PREFIX) --host=$(CROSS_COMPILE)
|
||||
tar -xf $(OPEN_SOURCE_DIR)/can/$(CANUTILS).tar.bz2 -C $(CANTOOL_BUILDDIR);
|
||||
cp -arf $(ROOTFS_SRCDIR)/$(CANTOOL)/$(CANUTILS).patch/. $(@D)/$(CANUTILS)
|
||||
touch $@
|
||||
@@ -0,0 +1,617 @@
|
||||
/*
|
||||
* canutils/canconfig.c
|
||||
*
|
||||
* Copyright (C) 2005, 2008 Marc Kleine-Budde <mkl@pengutronix.de>, Pengutronix
|
||||
* Copyright (C) 2007 Juergen Beisert <jbe@pengutronix.de>, Pengutronix
|
||||
* Copyright (C) 2009 Luotao Fu <l.fu@pengutronix.de>, Pengutronix
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the version 2 of the GNU General Public License
|
||||
* as published by the Free Software Foundation
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <limits.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <sys/socket.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <libsocketcan.h>
|
||||
#include <can_config.h>
|
||||
|
||||
#ifndef MIN
|
||||
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
||||
#endif
|
||||
|
||||
const char *can_states[CAN_STATE_MAX] = {
|
||||
"ERROR-ACTIVE",
|
||||
"ERROR-WARNING",
|
||||
"ERROR-PASSIVE",
|
||||
"BUS-OFF",
|
||||
"STOPPED",
|
||||
"SLEEPING"
|
||||
};
|
||||
|
||||
const char *config_keywords[] = {
|
||||
"baudrate", "nbitrate", "dbitrate", "bittiming", "ctrlmode", "restart",
|
||||
"start", "stop", "restart-ms", "state", "clockfreq",
|
||||
"bittiming-const", "berr-counter"};
|
||||
|
||||
/* this is shamelessly stolen from iproute and slightly modified */
|
||||
#define NEXT_ARG() \
|
||||
do { \
|
||||
argv++; \
|
||||
if (--argc < 0) { \
|
||||
fprintf(stderr, "missing parameter for %s\n", *argv); \
|
||||
exit(EXIT_FAILURE);\
|
||||
}\
|
||||
} while(0)
|
||||
|
||||
static inline int find_str(const char** haystack, unsigned int stack_size,
|
||||
const char* needle)
|
||||
{
|
||||
int i, found = 0;
|
||||
|
||||
for (i = 0; i < stack_size; i++) {
|
||||
if (!strcmp(needle, haystack[i])) {
|
||||
found = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return found;
|
||||
}
|
||||
|
||||
static void help(void)
|
||||
{
|
||||
fprintf(stderr, "usage:\n\t"
|
||||
"canconfig <dev> nbitrate { nominal BR } [sample-point { SP }]\n\t"
|
||||
"canconfig <dev> dbitrate { nominal BR data BR} [sample-point { SP }]\n\t\t"
|
||||
"BR := <bitrate in Hz>\n\t\t"
|
||||
"SP := <sample-point {0...0.999}> (optional)\n\t"
|
||||
"canconfig <dev> bittiming [ VALs ]\n\t\t"
|
||||
"VALs := <tq | prop-seg | phase-seg1 | phase-seg2 | sjw>\n\t\t"
|
||||
"tq <time quantum in ns>\n\t\t"
|
||||
"prop-seg <no. in tq>\n\t\t"
|
||||
"phase-seg1 <no. in tq>\n\t\t"
|
||||
"phase-seg2 <no. in tq\n\t\t"
|
||||
"sjw <no. in tq> (optional)\n\t"
|
||||
"canconfig <dev> restart-ms { RESTART-MS }\n\t\t"
|
||||
"RESTART-MS := <autorestart interval in ms>\n\t"
|
||||
"canconfig <dev> ctrlmode { CTRLMODE }\n\t\t"
|
||||
"CTRLMODE := <[loopback | listen-only | triple-sampling | berr-reporting] | fd | presume-ack | fd-non-iso [on|off]>\n\t"
|
||||
"canconfig <dev> {ACTION}\n\t\t"
|
||||
"ACTION := <[start|stop|restart]>\n\t"
|
||||
"canconfig <dev> clockfreq\n\t"
|
||||
"canconfig <dev> bittiming-constants\n\t"
|
||||
"canconfig <dev> berr-counter\n"
|
||||
);
|
||||
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
static void do_show_bitrate(const char *name)
|
||||
{
|
||||
struct can_bittiming bt;
|
||||
|
||||
if (can_get_bittiming(name, &bt) < 0) {
|
||||
fprintf(stderr, "%s: failed to get bitrate\n", name);
|
||||
exit(EXIT_FAILURE);
|
||||
} else
|
||||
fprintf(stdout,
|
||||
"%s bitrate: %u, sample-point: %0.3f\n",
|
||||
name, bt.bitrate,
|
||||
(float)((float)bt.sample_point / 1000));
|
||||
}
|
||||
|
||||
static void do_set_bitrate(int argc, char *argv[], const char *name)
|
||||
{
|
||||
__u32 nominal_bitrate = 0;
|
||||
__u32 data_bitrate = 0;
|
||||
__u32 sample_point = 0;
|
||||
int err;
|
||||
|
||||
while (argc > 0) {
|
||||
if (!strcmp(*argv, "nbitrate")) {
|
||||
NEXT_ARG();
|
||||
nominal_bitrate = (__u32)strtoul(*argv, NULL, 0);
|
||||
} else if (!strcmp(*argv, "dbitrate")) {
|
||||
NEXT_ARG();
|
||||
nominal_bitrate = (__u32)strtoul(*argv, NULL, 0);
|
||||
argc--, argv++;
|
||||
data_bitrate = (__u32)strtoul(*argv, NULL, 0);
|
||||
} else if (!strcmp(*argv, "sample-point")) {
|
||||
NEXT_ARG();
|
||||
sample_point = (__u32)(strtod(*argv, NULL) * 1000);
|
||||
}
|
||||
argc--, argv++;
|
||||
}
|
||||
|
||||
if (sample_point)
|
||||
err = can_set_bitrate_samplepoint(name, nominal_bitrate, sample_point);
|
||||
else {
|
||||
if (data_bitrate == 0)
|
||||
err = can_set_bitrate(name, nominal_bitrate);
|
||||
else
|
||||
err = can_set_data_bitrate(name, nominal_bitrate, data_bitrate);
|
||||
}
|
||||
|
||||
if (err < 0) {
|
||||
if (data_bitrate == 0)
|
||||
fprintf(stderr, "failed to set %s nominal bitrate to %u\n",
|
||||
name, nominal_bitrate);
|
||||
else
|
||||
fprintf(stderr, "failed to set %s nominal bitrate to %u and data bitrate to %u\n",
|
||||
name, nominal_bitrate, data_bitrate);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
|
||||
static void cmd_bitrate(int argc, char *argv[], const char *name)
|
||||
{
|
||||
int show_only = 1;
|
||||
|
||||
if (argc > 0)
|
||||
show_only = find_str(config_keywords,
|
||||
sizeof(config_keywords) / sizeof(char*),
|
||||
argv[1]);
|
||||
|
||||
if (! show_only)
|
||||
do_set_bitrate(argc, argv, name);
|
||||
|
||||
do_show_bitrate(name);
|
||||
}
|
||||
|
||||
static void do_set_bittiming(int argc, char *argv[], const char *name)
|
||||
{
|
||||
struct can_bittiming bt;
|
||||
int bt_par_count = 0;
|
||||
|
||||
memset(&bt, 0, sizeof(bt));
|
||||
|
||||
while (argc > 0) {
|
||||
if (!strcmp(*argv, "tq")) {
|
||||
NEXT_ARG();
|
||||
bt.tq = (__u32)strtoul(*argv, NULL, 0);
|
||||
bt_par_count++;
|
||||
continue;
|
||||
}
|
||||
if (!strcmp(*argv, "prop-seg")) {
|
||||
NEXT_ARG();
|
||||
bt.prop_seg = (__u32)strtoul(*argv, NULL, 0);
|
||||
bt_par_count++;
|
||||
continue;
|
||||
}
|
||||
if (!strcmp(*argv, "phase-seg1")) {
|
||||
NEXT_ARG();
|
||||
bt.phase_seg1 = (__u32)strtoul(*argv, NULL, 0);
|
||||
bt_par_count++;
|
||||
continue;
|
||||
}
|
||||
if (!strcmp(*argv, "phase-seg2")) {
|
||||
NEXT_ARG();
|
||||
bt.phase_seg2 =
|
||||
(__u32)strtoul(*argv, NULL, 0);
|
||||
bt_par_count++;
|
||||
continue;
|
||||
}
|
||||
if (!strcmp(*argv, "sjw")) {
|
||||
NEXT_ARG();
|
||||
bt.sjw =
|
||||
(__u32)strtoul(*argv, NULL, 0);
|
||||
continue;
|
||||
}
|
||||
argc--, argv++;
|
||||
}
|
||||
/* kernel will take a default sjw value if it's zero. all other
|
||||
* parameters have to be set */
|
||||
if (bt_par_count < 4) {
|
||||
fprintf(stderr, "%s: missing bittiming parameters, "
|
||||
"try help to figure out the correct format\n",
|
||||
name);
|
||||
exit(1);
|
||||
}
|
||||
if (can_set_bittiming(name, &bt) < 0) {
|
||||
fprintf(stderr, "%s: unable to set bittiming\n", name);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
|
||||
static void do_show_bittiming(const char *name)
|
||||
{
|
||||
struct can_bittiming bt;
|
||||
|
||||
if (can_get_bittiming(name, &bt) < 0) {
|
||||
fprintf(stderr, "%s: failed to get bittiming\n", name);
|
||||
exit(EXIT_FAILURE);
|
||||
} else
|
||||
fprintf(stdout, "%s bittiming:\n\t"
|
||||
"tq: %u, prop-seq: %u phase-seq1: %u phase-seq2: %u "
|
||||
"sjw: %u, brp: %u\n",
|
||||
name, bt.tq, bt.prop_seg, bt.phase_seg1, bt.phase_seg2,
|
||||
bt.sjw, bt.brp);
|
||||
}
|
||||
|
||||
static void cmd_bittiming(int argc, char *argv[], const char *name)
|
||||
{
|
||||
int show_only = 1;
|
||||
|
||||
if (argc > 0)
|
||||
show_only = find_str(config_keywords,
|
||||
sizeof(config_keywords) / sizeof(char*),
|
||||
argv[1]);
|
||||
|
||||
if (! show_only)
|
||||
do_set_bittiming(argc, argv, name);
|
||||
|
||||
do_show_bittiming(name);
|
||||
do_show_bitrate(name);
|
||||
}
|
||||
|
||||
static void do_show_bittiming_const(const char *name)
|
||||
{
|
||||
struct can_bittiming_const btc;
|
||||
|
||||
if (can_get_bittiming_const(name, &btc) < 0) {
|
||||
fprintf(stderr, "%s: failed to get bittiming_const\n", name);
|
||||
exit(EXIT_FAILURE);
|
||||
} else
|
||||
fprintf(stdout, "%s bittiming-constants: name %s,\n\t"
|
||||
"tseg1-min: %u, tseg1-max: %u, "
|
||||
"tseg2-min: %u, tseg2-max: %u,\n\t"
|
||||
"sjw-max %u, brp-min: %u, brp-max: %u, brp-inc: %u,\n",
|
||||
name, btc.name, btc.tseg1_min, btc.tseg1_max,
|
||||
btc.tseg2_min, btc.tseg2_max, btc.sjw_max,
|
||||
btc.brp_min, btc.brp_max, btc.brp_inc);
|
||||
}
|
||||
|
||||
static void cmd_bittiming_const(int argc, char *argv[], const char *name)
|
||||
{
|
||||
do_show_bittiming_const(name);
|
||||
}
|
||||
|
||||
static void do_show_state(const char *name)
|
||||
{
|
||||
int state;
|
||||
|
||||
if (can_get_state(name, &state) < 0) {
|
||||
fprintf(stderr, "%s: failed to get state \n", name);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (state >= 0 && state < CAN_STATE_MAX)
|
||||
fprintf(stdout, "%s state: %s\n", name, can_states[state]);
|
||||
else
|
||||
fprintf(stderr, "%s: unknown state\n", name);
|
||||
}
|
||||
|
||||
static void cmd_state(int argc, char *argv[], const char *name)
|
||||
{
|
||||
do_show_state(name);
|
||||
}
|
||||
|
||||
static void do_show_clockfreq(const char *name)
|
||||
{
|
||||
struct can_clock clock;
|
||||
|
||||
memset(&clock, 0, sizeof(struct can_clock));
|
||||
if (can_get_clock(name, &clock) < 0) {
|
||||
fprintf(stderr, "%s: failed to get clock parameters\n",
|
||||
name);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
fprintf(stdout, "%s clock freq: %u\n", name, clock.freq);
|
||||
}
|
||||
|
||||
static void cmd_clockfreq(int argc, char *argv[], const char *name)
|
||||
{
|
||||
do_show_clockfreq(name);
|
||||
}
|
||||
|
||||
static void do_restart(const char *name)
|
||||
{
|
||||
if (can_do_restart(name) < 0) {
|
||||
fprintf(stderr, "%s: failed to restart\n", name);
|
||||
exit(EXIT_FAILURE);
|
||||
} else {
|
||||
fprintf(stdout, "%s restarted\n", name);
|
||||
}
|
||||
}
|
||||
|
||||
static void cmd_restart(int argc, char *argv[], const char *name)
|
||||
{
|
||||
do_restart(name);
|
||||
}
|
||||
|
||||
static void do_start(const char *name)
|
||||
{
|
||||
if (can_do_start(name) < 0) {
|
||||
fprintf(stderr, "%s: failed to start\n", name);
|
||||
exit(EXIT_FAILURE);
|
||||
} else {
|
||||
do_show_state(name);
|
||||
}
|
||||
}
|
||||
|
||||
static void cmd_start(int argc, char *argv[], const char *name)
|
||||
{
|
||||
do_start(name);
|
||||
}
|
||||
|
||||
static void do_stop(const char *name)
|
||||
{
|
||||
if (can_do_stop(name) < 0) {
|
||||
fprintf(stderr, "%s: failed to stop\n", name);
|
||||
exit(EXIT_FAILURE);
|
||||
} else {
|
||||
do_show_state(name);
|
||||
}
|
||||
}
|
||||
|
||||
static void cmd_stop(int argc, char *argv[], const char *name)
|
||||
{
|
||||
do_stop(name);
|
||||
}
|
||||
|
||||
static inline void print_ctrlmode(__u32 cm_flags)
|
||||
{
|
||||
fprintf(stdout,
|
||||
"loopback[%s], listen-only[%s], tripple-sampling[%s],"
|
||||
"one-shot[%s], berr-reporting[%s], fd[%s], presume-ack[%s],"
|
||||
"fd-non-iso[%s]\n",
|
||||
(cm_flags & CAN_CTRLMODE_LOOPBACK) ? "ON" : "OFF",
|
||||
(cm_flags & CAN_CTRLMODE_LISTENONLY) ? "ON" : "OFF",
|
||||
(cm_flags & CAN_CTRLMODE_3_SAMPLES) ? "ON" : "OFF",
|
||||
(cm_flags & CAN_CTRLMODE_ONE_SHOT) ? "ON" : "OFF",
|
||||
(cm_flags & CAN_CTRLMODE_BERR_REPORTING) ? "ON" : "OFF",
|
||||
(cm_flags & CAN_CTRLMODE_FD) ? "ON" : "OFF",
|
||||
(cm_flags & CAN_CTRLMODE_PRESUME_ACK) ? "ON" : "OFF",
|
||||
(cm_flags & CAN_CTRLMODE_FD_NON_ISO) ? "ON" : "OFF");
|
||||
}
|
||||
|
||||
static void do_show_ctrlmode(const char *name)
|
||||
{
|
||||
struct can_ctrlmode cm;
|
||||
|
||||
if (can_get_ctrlmode(name, &cm) < 0) {
|
||||
fprintf(stderr, "%s: failed to get controlmode\n", name);
|
||||
exit(EXIT_FAILURE);
|
||||
} else {
|
||||
fprintf(stdout, "%s ctrlmode: ", name);
|
||||
print_ctrlmode(cm.flags);
|
||||
}
|
||||
}
|
||||
|
||||
/* this is shamelessly stolen from iproute and slightly modified */
|
||||
static inline void set_ctrlmode(char* name, char *arg,
|
||||
struct can_ctrlmode *cm, __u32 flags)
|
||||
{
|
||||
if (strcmp(arg, "on") == 0) {
|
||||
cm->flags |= flags;
|
||||
} else if (strcmp(arg, "off") != 0) {
|
||||
fprintf(stderr,
|
||||
"Error: argument of \"%s\" must be \"on\" or \"off\" %s\n",
|
||||
name, arg);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
cm->mask |= flags;
|
||||
}
|
||||
|
||||
static void do_set_ctrlmode(int argc, char* argv[], const char *name)
|
||||
{
|
||||
struct can_ctrlmode cm;
|
||||
|
||||
memset(&cm, 0, sizeof(cm));
|
||||
|
||||
while (argc > 0) {
|
||||
if (!strcmp(*argv, "loopback")) {
|
||||
NEXT_ARG();
|
||||
set_ctrlmode("loopback", *argv, &cm,
|
||||
CAN_CTRLMODE_LOOPBACK);
|
||||
} else if (!strcmp(*argv, "listen-only")) {
|
||||
NEXT_ARG();
|
||||
set_ctrlmode("listen-only", *argv, &cm,
|
||||
CAN_CTRLMODE_LISTENONLY);
|
||||
} else if (!strcmp(*argv, "triple-sampling")) {
|
||||
NEXT_ARG();
|
||||
set_ctrlmode("triple-sampling", *argv, &cm,
|
||||
CAN_CTRLMODE_3_SAMPLES);
|
||||
} else if (!strcmp(*argv, "one-shot")) {
|
||||
NEXT_ARG();
|
||||
set_ctrlmode("one-shot", *argv, &cm,
|
||||
CAN_CTRLMODE_ONE_SHOT);
|
||||
} else if (!strcmp(*argv, "berr-reporting")) {
|
||||
NEXT_ARG();
|
||||
set_ctrlmode("berr-reporting", *argv, &cm,
|
||||
CAN_CTRLMODE_BERR_REPORTING);
|
||||
} else if (!strcmp(*argv, "fd")) {
|
||||
NEXT_ARG();
|
||||
set_ctrlmode("fd", *argv, &cm,
|
||||
CAN_CTRLMODE_FD);
|
||||
} else if (!strcmp(*argv, "presume-ack")) {
|
||||
NEXT_ARG();
|
||||
set_ctrlmode("presume-ack", *argv, &cm,
|
||||
CAN_CTRLMODE_PRESUME_ACK);
|
||||
} else if (!strcmp(*argv, "fd-non-iso")) {
|
||||
NEXT_ARG();
|
||||
set_ctrlmode("fd-non-iso", *argv, &cm,
|
||||
CAN_CTRLMODE_FD_NON_ISO);
|
||||
}
|
||||
|
||||
argc--, argv++;
|
||||
}
|
||||
|
||||
fprintf(stderr, "cm->mask :%x\n", cm.mask);
|
||||
|
||||
if (can_set_ctrlmode(name, &cm) < 0) {
|
||||
fprintf(stderr, "%s: failed to set ctrlmode\n", name);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
|
||||
static void cmd_ctrlmode(int argc, char *argv[], const char *name)
|
||||
{
|
||||
int show_only = 1;
|
||||
|
||||
if (argc > 0)
|
||||
show_only = find_str(config_keywords,
|
||||
sizeof(config_keywords) / sizeof(char*),
|
||||
argv[1]);
|
||||
|
||||
if (! show_only)
|
||||
do_set_ctrlmode(argc, argv, name);
|
||||
|
||||
do_show_ctrlmode(name);
|
||||
}
|
||||
|
||||
static void do_show_restart_ms(const char *name)
|
||||
{
|
||||
__u32 restart_ms;
|
||||
|
||||
if (can_get_restart_ms(name, &restart_ms) < 0) {
|
||||
fprintf(stderr, "%s: failed to get restart_ms\n", name);
|
||||
exit(EXIT_FAILURE);
|
||||
} else
|
||||
fprintf(stdout,
|
||||
"%s restart-ms: %u\n", name, restart_ms);
|
||||
}
|
||||
|
||||
static void do_set_restart_ms(int argc, char* argv[], const char *name)
|
||||
{
|
||||
if (can_set_restart_ms(name,
|
||||
(__u32)strtoul(argv[1], NULL, 10)) < 0) {
|
||||
fprintf(stderr, "failed to set restart_ms of %s to %lu\n",
|
||||
name, strtoul(argv[1], NULL, 10));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
|
||||
static void cmd_restart_ms(int argc, char *argv[], const char *name)
|
||||
{
|
||||
int show_only = 1;
|
||||
|
||||
if (argc > 0)
|
||||
show_only = find_str(config_keywords,
|
||||
sizeof(config_keywords) / sizeof(char*),
|
||||
argv[1]);
|
||||
|
||||
if (! show_only)
|
||||
do_set_restart_ms(argc, argv, name);
|
||||
|
||||
do_show_restart_ms(name);
|
||||
}
|
||||
|
||||
static void do_show_berr_counter(const char *name)
|
||||
{
|
||||
struct can_berr_counter bc;
|
||||
struct can_ctrlmode cm;
|
||||
|
||||
if (can_get_ctrlmode(name, &cm) < 0) {
|
||||
fprintf(stderr, "%s: failed to get controlmode\n", name);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (cm.flags & CAN_CTRLMODE_BERR_REPORTING) {
|
||||
memset(&bc, 0, sizeof(struct can_berr_counter));
|
||||
|
||||
if (can_get_berr_counter(name, &bc) < 0) {
|
||||
fprintf(stderr, "%s: failed to get berr counters\n",
|
||||
name);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
fprintf(stdout, "%s txerr: %u rxerr: %u\n",
|
||||
name, bc.txerr, bc.rxerr);
|
||||
}
|
||||
}
|
||||
|
||||
static void cmd_berr_counter(int argc, char *argv[], const char *name)
|
||||
{
|
||||
do_show_berr_counter(name);
|
||||
}
|
||||
|
||||
static void cmd_baudrate(int argc, char *argv[], const char *name)
|
||||
{
|
||||
fprintf(stderr, "%s: baudrate is deprecated, pleae use bitrate\n",
|
||||
name);
|
||||
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
static void cmd_show_interface(const char *name)
|
||||
{
|
||||
do_show_bitrate(name);
|
||||
do_show_bittiming(name);
|
||||
do_show_state(name);
|
||||
do_show_restart_ms(name);
|
||||
do_show_ctrlmode(name);
|
||||
do_show_clockfreq(name);
|
||||
do_show_bittiming_const(name);
|
||||
do_show_berr_counter(name);
|
||||
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
const char* name = argv[1];
|
||||
|
||||
if ((argc < 2) || !strcmp(argv[1], "--help"))
|
||||
help();
|
||||
|
||||
if (!strcmp(argv[1], "--version")) {
|
||||
printf("Version: %s\n", VERSION);
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
if (argc < 3)
|
||||
cmd_show_interface(name);
|
||||
|
||||
while (argc-- > 0) {
|
||||
if (!strcmp(argv[0], "baudrate"))
|
||||
cmd_baudrate(argc, argv, name);
|
||||
if (!strcmp(argv[0], "nbitrate"))
|
||||
cmd_bitrate(argc, argv, name);
|
||||
if (!strcmp(argv[0], "dbitrate"))
|
||||
cmd_bitrate(argc, argv, name);
|
||||
if (!strcmp(argv[0], "bittiming"))
|
||||
cmd_bittiming(argc, argv, name);
|
||||
if (!strcmp(argv[0], "ctrlmode"))
|
||||
cmd_ctrlmode(argc, argv, name);
|
||||
if (!strcmp(argv[0], "restart"))
|
||||
cmd_restart(argc, argv, name);
|
||||
if (!strcmp(argv[0], "start"))
|
||||
cmd_start(argc, argv, name);
|
||||
if (!strcmp(argv[0], "stop"))
|
||||
cmd_stop(argc, argv, name);
|
||||
if (!strcmp(argv[0], "restart-ms"))
|
||||
cmd_restart_ms(argc, argv, name);
|
||||
if (!strcmp(argv[0], "state"))
|
||||
cmd_state(argc, argv, name);
|
||||
if (!strcmp(argv[0], "clockfreq"))
|
||||
cmd_clockfreq(argc, argv, name);
|
||||
if (!strcmp(argv[0], "bittiming-constants"))
|
||||
cmd_bittiming_const(argc, argv, name);
|
||||
if (!strcmp(argv[0], "berr-counter"))
|
||||
cmd_berr_counter(argc, argv, name);
|
||||
argv++;
|
||||
}
|
||||
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
/*
|
||||
* linux/can/netlink.h
|
||||
*
|
||||
* Definitions for the CAN netlink interface
|
||||
*
|
||||
* Copyright (c) 2009 Wolfgang Grandegger <wg@grandegger.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the version 2 of the GNU General Public License
|
||||
* as published by the Free Software Foundation
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*/
|
||||
|
||||
#ifndef _UAPI_CAN_NETLINK_H
|
||||
#define _UAPI_CAN_NETLINK_H
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
/*
|
||||
* CAN bit-timing parameters
|
||||
*
|
||||
* For further information, please read chapter "8 BIT TIMING
|
||||
* REQUIREMENTS" of the "Bosch CAN Specification version 2.0"
|
||||
* at http://www.semiconductors.bosch.de/pdf/can2spec.pdf.
|
||||
*/
|
||||
struct can_bittiming {
|
||||
__u32 bitrate; /* Bit-rate in bits/second */
|
||||
__u32 sample_point; /* Sample point in one-tenth of a percent */
|
||||
__u32 tq; /* Time quanta (TQ) in nanoseconds */
|
||||
__u32 prop_seg; /* Propagation segment in TQs */
|
||||
__u32 phase_seg1; /* Phase buffer segment 1 in TQs */
|
||||
__u32 phase_seg2; /* Phase buffer segment 2 in TQs */
|
||||
__u32 sjw; /* Synchronisation jump width in TQs */
|
||||
__u32 brp; /* Bit-rate prescaler */
|
||||
};
|
||||
|
||||
/*
|
||||
* CAN harware-dependent bit-timing constant
|
||||
*
|
||||
* Used for calculating and checking bit-timing parameters
|
||||
*/
|
||||
struct can_bittiming_const {
|
||||
char name[16]; /* Name of the CAN controller hardware */
|
||||
__u32 tseg1_min; /* Time segement 1 = prop_seg + phase_seg1 */
|
||||
__u32 tseg1_max;
|
||||
__u32 tseg2_min; /* Time segement 2 = phase_seg2 */
|
||||
__u32 tseg2_max;
|
||||
__u32 sjw_max; /* Synchronisation jump width */
|
||||
__u32 brp_min; /* Bit-rate prescaler */
|
||||
__u32 brp_max;
|
||||
__u32 brp_inc;
|
||||
};
|
||||
|
||||
/*
|
||||
* CAN clock parameters
|
||||
*/
|
||||
struct can_clock {
|
||||
__u32 freq; /* CAN system clock frequency in Hz */
|
||||
};
|
||||
|
||||
/*
|
||||
* CAN operational and error states
|
||||
*/
|
||||
enum can_state {
|
||||
CAN_STATE_ERROR_ACTIVE = 0, /* RX/TX error count < 96 */
|
||||
CAN_STATE_ERROR_WARNING, /* RX/TX error count < 128 */
|
||||
CAN_STATE_ERROR_PASSIVE, /* RX/TX error count < 256 */
|
||||
CAN_STATE_BUS_OFF, /* RX/TX error count >= 256 */
|
||||
CAN_STATE_STOPPED, /* Device is stopped */
|
||||
CAN_STATE_SLEEPING, /* Device is sleeping */
|
||||
CAN_STATE_MAX
|
||||
};
|
||||
|
||||
/*
|
||||
* CAN bus error counters
|
||||
*/
|
||||
struct can_berr_counter {
|
||||
__u16 txerr;
|
||||
__u16 rxerr;
|
||||
};
|
||||
|
||||
/*
|
||||
* CAN controller mode
|
||||
*/
|
||||
struct can_ctrlmode {
|
||||
__u32 mask;
|
||||
__u32 flags;
|
||||
};
|
||||
|
||||
#define CAN_CTRLMODE_LOOPBACK 0x01 /* Loopback mode */
|
||||
#define CAN_CTRLMODE_LISTENONLY 0x02 /* Listen-only mode */
|
||||
#define CAN_CTRLMODE_3_SAMPLES 0x04 /* Triple sampling mode */
|
||||
#define CAN_CTRLMODE_ONE_SHOT 0x08 /* One-Shot mode */
|
||||
#define CAN_CTRLMODE_BERR_REPORTING 0x10 /* Bus-error reporting */
|
||||
#define CAN_CTRLMODE_FD 0x20 /* CAN FD mode */
|
||||
#define CAN_CTRLMODE_PRESUME_ACK 0x40 /* Ignore missing CAN ACKs */
|
||||
#define CAN_CTRLMODE_FD_NON_ISO 0x80 /* CAN FD in non-ISO mode */
|
||||
|
||||
/*
|
||||
* CAN device statistics
|
||||
*/
|
||||
struct can_device_stats {
|
||||
__u32 bus_error; /* Bus errors */
|
||||
__u32 error_warning; /* Changes to error warning state */
|
||||
__u32 error_passive; /* Changes to error passive state */
|
||||
__u32 bus_off; /* Changes to bus off state */
|
||||
__u32 arbitration_lost; /* Arbitration lost errors */
|
||||
__u32 restarts; /* CAN controller re-starts */
|
||||
};
|
||||
|
||||
/*
|
||||
* CAN netlink interface
|
||||
*/
|
||||
enum {
|
||||
IFLA_CAN_UNSPEC,
|
||||
IFLA_CAN_BITTIMING,
|
||||
IFLA_CAN_BITTIMING_CONST,
|
||||
IFLA_CAN_CLOCK,
|
||||
IFLA_CAN_STATE,
|
||||
IFLA_CAN_CTRLMODE,
|
||||
IFLA_CAN_RESTART_MS,
|
||||
IFLA_CAN_RESTART,
|
||||
IFLA_CAN_BERR_COUNTER,
|
||||
IFLA_CAN_DATA_BITTIMING,
|
||||
IFLA_CAN_DATA_BITTIMING_CONST,
|
||||
__IFLA_CAN_MAX
|
||||
};
|
||||
|
||||
#define IFLA_CAN_MAX (__IFLA_CAN_MAX - 1)
|
||||
|
||||
#endif /* !_UAPI_CAN_NETLINK_H */
|
||||
@@ -0,0 +1,63 @@
|
||||
/*
|
||||
* libsocketcan.h
|
||||
*
|
||||
* (C) 2009 Luotao Fu <l.fu@pengutronix.de>
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or modify it under
|
||||
* the terms of the GNU Lesser General Public License as published by the Free
|
||||
* Software Foundation; either version 2.1 of the License, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful, but without
|
||||
* any warranty; without even the implied warranty of merchantability or fitness
|
||||
* for a particular purpose. see the gnu lesser general public license for more
|
||||
* details.
|
||||
*
|
||||
* you should have received a copy of the gnu lesser general public license
|
||||
* along with this library; if not, write to the free software foundation, inc.,
|
||||
* 59 temple place, suite 330, boston, ma 02111-1307 usa
|
||||
*/
|
||||
|
||||
#ifndef _socketcan_netlink_h
|
||||
#define _socketcan_netlink_h
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @brief API overview
|
||||
*/
|
||||
|
||||
#include <can_netlink.h>
|
||||
|
||||
struct rtnl_link_stats64; /* from <linux/if_link.h> */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
int can_do_restart(const char *name);
|
||||
int can_do_stop(const char *name);
|
||||
int can_do_start(const char *name);
|
||||
|
||||
int can_set_restart_ms(const char *name, __u32 restart_ms);
|
||||
int can_set_bittiming(const char *name, struct can_bittiming *bt);
|
||||
int can_set_ctrlmode(const char *name, struct can_ctrlmode *cm);
|
||||
int can_set_bitrate(const char *name, __u32 bitrate);
|
||||
int can_set_data_bitrate(const char *name, __u32 nominal_bitrate, __u32 data_bitrate);
|
||||
|
||||
int can_set_bitrate_samplepoint(const char *name, __u32 bitrate, __u32 sample_point);
|
||||
|
||||
int can_get_restart_ms(const char *name, __u32 *restart_ms);
|
||||
int can_get_bittiming(const char *name, struct can_bittiming *bt);
|
||||
int can_get_ctrlmode(const char *name, struct can_ctrlmode *cm);
|
||||
int can_get_state(const char *name, int *state);
|
||||
int can_get_clock(const char *name, struct can_clock *clock);
|
||||
int can_get_bittiming_const(const char *name, struct can_bittiming_const *btc);
|
||||
int can_get_berr_counter(const char *name, struct can_berr_counter *bc);
|
||||
int can_get_device_stats(const char *name, struct can_device_stats *cds);
|
||||
int can_get_link_stats(const char *name, struct rtnl_link_stats64 *rls);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,46 @@
|
||||
#!/usr/bin/env make
|
||||
###############################################################################
|
||||
#
|
||||
#
|
||||
#Copyright (c) XMEDIA. All rights reserved.
|
||||
#
|
||||
#
|
||||
###############################################################################
|
||||
DOSFS := dosfstools-4.2
|
||||
|
||||
DOSFS_PREFIX = $(ROOTFS_BUILDDIR)/$(DOSFS)/.install
|
||||
|
||||
CC := $(CROSS_COMPILE)-gcc
|
||||
|
||||
rootfs_unstrip: $(ROOTFS_PREFIX)/sbin/fsck.fat
|
||||
|
||||
clean: $(DOSFS).clean
|
||||
|
||||
$(DOSFS).clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)/$(DOSFS)
|
||||
|
||||
$(ROOTFS_PREFIX)/sbin/fsck.fat: $(ROOTFS_BUILDDIR)/$(DOSFS)/.built
|
||||
$(call mkdir,$(@D))
|
||||
cp -arf $(DOSFS_PREFIX)/sbin/dosfsck $(ROOTFS_PREFIX)/sbin
|
||||
cp -arf $(DOSFS_PREFIX)/sbin/fsck.fat $(ROOTFS_PREFIX)/sbin
|
||||
cp -arf $(DOSFS_PREFIX)/sbin/fsck.vfat $(ROOTFS_PREFIX)/sbin
|
||||
cp -arf $(DOSFS_PREFIX)/sbin/mkfs.fat $(ROOTFS_PREFIX)/sbin
|
||||
cp -arf $(DOSFS_PREFIX)/sbin/mkfs.vfat $(ROOTFS_PREFIX)/sbin
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(DOSFS)/.built: $(ROOTFS_BUILDDIR)/$(DOSFS)/.extracted
|
||||
cd $(<D); \
|
||||
CC=$(CC) ./configure \
|
||||
--prefix=$(DOSFS_PREFIX) \
|
||||
--host=$(CROSS_COMPILE) \
|
||||
--enable-compat-symlinks \
|
||||
--without-iconv
|
||||
make -C $(<D)
|
||||
make -C $(<D) install
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(DOSFS)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
tar xf $(OPEN_SOURCE_DIR)/dosfstools/$(DOSFS).tar.gz -C $(ROOTFS_BUILDDIR)
|
||||
touch $@
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
#!/usr/bin/env make
|
||||
###############################################################################
|
||||
#
|
||||
#
|
||||
#Copyright (c) XMEDIA. All rights reserved.
|
||||
#
|
||||
#
|
||||
###############################################################################
|
||||
|
||||
E2FSPROGS := e2fsprogs-1.47.0
|
||||
|
||||
E2FSPROGS_PREFIX = $(ROOTFS_BUILDDIR)/$(E2FSPROGS)/.install
|
||||
|
||||
rootfs_unstrip: $(ROOTFS_PREFIX)/sbin/mke2fs
|
||||
|
||||
clean: $(E2FSPROGS).clean
|
||||
|
||||
$(E2FSPROGS).clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)/$(E2FSPROGS)
|
||||
|
||||
$(ROOTFS_PREFIX)/sbin/mke2fs: $(ROOTFS_BUILDDIR)/$(E2FSPROGS)/.built
|
||||
$(call mkdir,$(@D))
|
||||
for x in mkfs.ext4 mke2fs fsck.ext4 e2fsck; do ( \
|
||||
test -L $(ROOTFS_PREFIX)/sbin/$$x && unlink $(ROOTFS_PREFIX)/sbin/$$x; \
|
||||
cp -af $(E2FSPROGS_PREFIX)/sbin/$$x $(ROOTFS_PREFIX)/sbin; \
|
||||
) done
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(E2FSPROGS)/.built: $(ROOTFS_BUILDDIR)/$(E2FSPROGS)/.extracted
|
||||
cd $(<D); CC=$(CROSS_COMPILE)-gcc ./configure \
|
||||
--prefix=$(E2FSPROGS_PREFIX) \
|
||||
--with-udev-rules-dir=$(E2FSPROGS_PREFIX)/etc/udev/rules.d \
|
||||
--with-crond-dir=$(E2FSPROGS_PREFIX)/etc/cron.d \
|
||||
--with-systemd-unit-dir=$(E2FSPROGS_PREFIX)/lib/systemd/system \
|
||||
--host=$(CROSS_COMPILE) \
|
||||
--disable-tls \
|
||||
--disable-defrag
|
||||
make -C $(<D)
|
||||
make -C $(<D) install
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(E2FSPROGS)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
tar xf $(OPEN_SOURCE_DIR)/e2fsprogs/$(E2FSPROGS).tar.gz -C $(ROOTFS_BUILDDIR)
|
||||
touch $@
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
#!/usr/bin/env make
|
||||
###############################################################################
|
||||
#
|
||||
#
|
||||
#Copyright (c) Lotus. All rights reserved.
|
||||
#
|
||||
#
|
||||
###############################################################################
|
||||
|
||||
ETHTOOL := ethtool-6
|
||||
|
||||
ETHTOOL_PREFIX = $(ROOTFS_BUILDDIR)/$(ETHTOOL)/.install
|
||||
|
||||
rootfs_unstrip: $(ROOTFS_PREFIX)/sbin/ethtool
|
||||
|
||||
clean: $(ETHTOOL).clean
|
||||
|
||||
$(ETHTOOL).clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)/$(ETHTOOL)
|
||||
|
||||
$(ROOTFS_PREFIX)/sbin/ethtool: $(ROOTFS_BUILDDIR)/$(ETHTOOL)/.built
|
||||
$(call mkdir,$(@D))
|
||||
cp -arf $(ETHTOOL_PREFIX)/sbin/ethtool $(ROOTFS_PREFIX)/sbin
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(ETHTOOL)/.built: $(ROOTFS_BUILDDIR)/$(ETHTOOL)/.extracted
|
||||
cd $(<D); CC=$(CROSS_COMPILE)-gcc ./configure \
|
||||
--prefix=$(ETHTOOL_PREFIX) --host=$(CROSS_COMPILE) \
|
||||
CFLAGS="$(filter-out -Werror,$(SDK_USR_CFLAGS))" \
|
||||
--enable-static --disable-shared
|
||||
make -C $(<D)
|
||||
make -C $(<D) install
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(ETHTOOL)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
tar xf $(OPEN_SOURCE_DIR)/ethtool/$(ETHTOOL).tar.gz -C $(ROOTFS_BUILDDIR)
|
||||
cp -arf $(ROOTFS_SRCDIR)/ethtools/$(ETHTOOL).patch/* $(@D)
|
||||
touch $@
|
||||
@@ -0,0 +1,72 @@
|
||||
/* Portions Copyright 2001 Sun Microsystems (thockin@sun.com) */
|
||||
/* Portions Copyright 2002 Intel (scott.feldman@intel.com) */
|
||||
#ifndef ETHTOOL_UTIL_H__
|
||||
#define ETHTOOL_UTIL_H__
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
/* hack, so we may include kernel's ethtool.h */
|
||||
typedef unsigned long long __u64;
|
||||
typedef unsigned int __u32; /* ditto */
|
||||
typedef unsigned short __u16; /* ditto */
|
||||
typedef unsigned char __u8; /* ditto */
|
||||
|
||||
/* historical: we used to use kernel-like types; remove these once cleaned */
|
||||
typedef unsigned long long u64;
|
||||
typedef unsigned int u32; /* ditto */
|
||||
typedef unsigned short u16; /* ditto */
|
||||
typedef unsigned char u8; /* ditto */
|
||||
|
||||
#include "ethtool-copy.h"
|
||||
|
||||
/* National Semiconductor DP83815, DP83816 */
|
||||
int natsemi_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
int natsemi_dump_eeprom(struct ethtool_drvinfo *info,
|
||||
struct ethtool_eeprom *ee);
|
||||
|
||||
/* Digital/Intel 21040 and 21041 */
|
||||
int de2104x_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* Intel(R) PRO/1000 Gigabit Adapter Family */
|
||||
int e1000_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* RealTek PCI */
|
||||
int realtek_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* Intel(R) PRO/100 Fast Ethernet Adapter Family */
|
||||
int e100_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* Tigon3 */
|
||||
int tg3_dump_eeprom(struct ethtool_drvinfo *info, struct ethtool_eeprom *ee);
|
||||
|
||||
/* Advanced Micro Devices AMD8111 based Adapter */
|
||||
int amd8111e_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* Advanced Micro Devices PCnet32 Adapter */
|
||||
int pcnet32_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* Motorola 8xx FEC Ethernet controller */
|
||||
int fec_8xx_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* PowerPC 4xx on-chip Ethernet controller */
|
||||
int ibm_emac_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* Intel(R) PRO/10GBe Gigabit Adapter Family */
|
||||
int ixgb_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* Broadcom Tigon3 Ethernet controller */
|
||||
int tg3_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* SysKonnect Gigabit (Genesis and Yukon) */
|
||||
int skge_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* SysKonnect Gigabit (Yukon2) */
|
||||
int sky2_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* Fabric7 VIOC */
|
||||
int vioc_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
/* SMSC LAN911x/LAN921x embedded ethernet controller */
|
||||
int smsc911x_dump_regs(struct ethtool_drvinfo *info, struct ethtool_regs *regs);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,37 @@
|
||||
#!/usr/bin/env make
|
||||
###############################################################################
|
||||
#
|
||||
# Copyright (c) XMEDIA. All rights reserved.
|
||||
#
|
||||
###############################################################################
|
||||
|
||||
EUDEV := eudev-3.2.14
|
||||
|
||||
EUDEV_PREFIX = $(ROOTFS_BUILDDIR)/$(EUDEV)/.install
|
||||
|
||||
rootfs_unstrip: $(ROOTFS_PREFIX)/sbin/udevd
|
||||
|
||||
clean: $(EUDEV).clean
|
||||
|
||||
$(EUDEV).clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)/$(EUDEV)
|
||||
|
||||
$(ROOTFS_PREFIX)/sbin/udevd: $(ROOTFS_BUILDDIR)/$(EUDEV)/.built
|
||||
$(call mkdir,$(@D))
|
||||
cp -af $(ROOTFS_BUILDDIR)/$(EUDEV)/src/udev/udevd $(ROOTFS_PREFIX)/sbin
|
||||
cp -af $(ROOTFS_BUILDDIR)/$(EUDEV)/src/udev/udevadm $(ROOTFS_PREFIX)/bin
|
||||
tar -xf $(ROOTFS_SRCDIR)/eudev/rootfs.tar.bz2 -C $(ROOTFS_PREFIX)/..
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(EUDEV)/.built: $(ROOTFS_BUILDDIR)/$(EUDEV)/.extracted
|
||||
cd $(<D); CC=$(CROSS_COMPILE)-gcc CFLAGS="$(filter-out -Werror,$(SDK_USR_CFLAGS))" ./configure \
|
||||
--prefix=/ \
|
||||
--host=$(CROSS_COMPILE)
|
||||
make -C $(<D) USE_STATIC=false
|
||||
touch $@
|
||||
|
||||
#cp -arf $(ROOTFS_SRCDIR)/eudev/$(EUDEV).patch/. $(@D)
|
||||
$(ROOTFS_BUILDDIR)/$(EUDEV)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
tar xf $(OPEN_SOURCE_DIR)/eudev/$(EUDEV).tar.gz -C $(ROOTFS_BUILDDIR)
|
||||
touch $@
|
||||
@@ -0,0 +1,379 @@
|
||||
/*
|
||||
* Copyright (C) 2003-2013 Kay Sievers <kay@vrfy.org>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <grp.h>
|
||||
#include <dirent.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/sysmacros.h>
|
||||
|
||||
#include "udev.h"
|
||||
#include "smack-util.h"
|
||||
|
||||
static int node_symlink(struct udev_device *dev, const char *node, const char *slink) {
|
||||
struct stat stats;
|
||||
char target[UTIL_PATH_SIZE];
|
||||
char *s;
|
||||
size_t l;
|
||||
char slink_tmp[UTIL_PATH_SIZE + 32];
|
||||
int i = 0;
|
||||
int tail = 0;
|
||||
int err = 0;
|
||||
|
||||
/* use relative link */
|
||||
target[0] = '\0';
|
||||
while (node[i] && (node[i] == slink[i])) {
|
||||
if (node[i] == '/')
|
||||
tail = i+1;
|
||||
i++;
|
||||
}
|
||||
s = target;
|
||||
l = sizeof(target);
|
||||
while (slink[i] != '\0') {
|
||||
if (slink[i] == '/')
|
||||
l = strpcpy(&s, l, "../");
|
||||
i++;
|
||||
}
|
||||
l = strscpy(s, l, &node[tail]);
|
||||
if (l == 0) {
|
||||
err = -EINVAL;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
/* preserve link with correct target, do not replace node of other device */
|
||||
if (lstat(slink, &stats) == 0) {
|
||||
if (S_ISBLK(stats.st_mode) || S_ISCHR(stats.st_mode)) {
|
||||
log_error("conflicting device node '%s' found, link to '%s' will not be created", slink, node);
|
||||
goto exit;
|
||||
} else if (S_ISLNK(stats.st_mode)) {
|
||||
char buf[UTIL_PATH_SIZE];
|
||||
int len;
|
||||
|
||||
len = readlink(slink, buf, sizeof(buf));
|
||||
if (len > 0 && len < (int)sizeof(buf)) {
|
||||
buf[len] = '\0';
|
||||
if (streq(target, buf)) {
|
||||
log_debug("preserve already existing symlink '%s' to '%s'", slink, target);
|
||||
label_fix(slink, true, false);
|
||||
utimensat(AT_FDCWD, slink, NULL, AT_SYMLINK_NOFOLLOW);
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
log_debug("creating symlink '%s' to '%s'", slink, target);
|
||||
do {
|
||||
err = mkdir_parents_label(slink, 0755);
|
||||
if (err != 0 && err != -ENOENT)
|
||||
break;
|
||||
mac_selinux_create_file_prepare(slink, S_IFLNK);
|
||||
err = symlink(target, slink);
|
||||
if (err != 0)
|
||||
err = -errno;
|
||||
mac_selinux_create_file_clear();
|
||||
} while (err == -ENOENT);
|
||||
if (err == 0)
|
||||
goto exit;
|
||||
}
|
||||
|
||||
log_debug("atomically replace '%s'", slink);
|
||||
strscpyl(slink_tmp, sizeof(slink_tmp), slink, ".tmp-", udev_device_get_id_filename(dev), NULL);
|
||||
unlink(slink_tmp);
|
||||
do {
|
||||
err = mkdir_parents_label(slink_tmp, 0755);
|
||||
if (err != 0 && err != -ENOENT)
|
||||
break;
|
||||
mac_selinux_create_file_prepare(slink_tmp, S_IFLNK);
|
||||
err = symlink(target, slink_tmp);
|
||||
if (err != 0)
|
||||
err = -errno;
|
||||
mac_selinux_create_file_clear();
|
||||
} while (err == -ENOENT);
|
||||
if (err != 0) {
|
||||
log_error_errno(errno, "symlink '%s' '%s' failed: %m", target, slink_tmp);
|
||||
goto exit;
|
||||
}
|
||||
err = rename(slink_tmp, slink);
|
||||
if (err != 0) {
|
||||
log_error_errno(errno, "rename '%s' '%s' failed: %m", slink_tmp, slink);
|
||||
unlink(slink_tmp);
|
||||
}
|
||||
exit:
|
||||
return err;
|
||||
}
|
||||
|
||||
/* find device node of device with highest priority */
|
||||
static const char *link_find_prioritized(struct udev_device *dev, bool add, const char *stackdir, char *buf, size_t bufsize) {
|
||||
struct udev *udev = udev_device_get_udev(dev);
|
||||
DIR *dir;
|
||||
int priority = 0;
|
||||
const char *target = NULL;
|
||||
|
||||
if (add) {
|
||||
priority = udev_device_get_devlink_priority(dev);
|
||||
strscpy(buf, bufsize, udev_device_get_devnode(dev));
|
||||
target = buf;
|
||||
}
|
||||
|
||||
dir = opendir(stackdir);
|
||||
if (dir == NULL)
|
||||
return target;
|
||||
for (;;) {
|
||||
struct udev_device *dev_db;
|
||||
struct dirent *dent;
|
||||
|
||||
dent = readdir(dir);
|
||||
if (dent == NULL || dent->d_name[0] == '\0')
|
||||
break;
|
||||
if (dent->d_name[0] == '.')
|
||||
continue;
|
||||
|
||||
log_debug("found '%s' claiming '%s'", dent->d_name, stackdir);
|
||||
|
||||
/* did we find ourself? */
|
||||
if (streq(dent->d_name, udev_device_get_id_filename(dev)))
|
||||
continue;
|
||||
|
||||
dev_db = udev_device_new_from_device_id(udev, dent->d_name);
|
||||
if (dev_db != NULL) {
|
||||
const char *devnode;
|
||||
|
||||
devnode = udev_device_get_devnode(dev_db);
|
||||
if (devnode != NULL) {
|
||||
if (target == NULL || udev_device_get_devlink_priority(dev_db) > priority) {
|
||||
log_debug("'%s' claims priority %i for '%s'",
|
||||
udev_device_get_syspath(dev_db), udev_device_get_devlink_priority(dev_db), stackdir);
|
||||
priority = udev_device_get_devlink_priority(dev_db);
|
||||
strscpy(buf, bufsize, devnode);
|
||||
target = buf;
|
||||
}
|
||||
}
|
||||
udev_device_unref(dev_db);
|
||||
}
|
||||
}
|
||||
closedir(dir);
|
||||
return target;
|
||||
}
|
||||
|
||||
/* manage "stack of names" with possibly specified device priorities */
|
||||
static void link_update(struct udev_device *dev, const char *slink, bool add) {
|
||||
char name_enc[UTIL_PATH_SIZE];
|
||||
char filename[UTIL_PATH_SIZE * 2];
|
||||
char dirname[UTIL_PATH_SIZE];
|
||||
const char *target;
|
||||
char buf[UTIL_PATH_SIZE];
|
||||
|
||||
util_path_encode(slink + strlen("/dev"), name_enc, sizeof(name_enc));
|
||||
strscpyl(dirname, sizeof(dirname), UDEV_ROOT_RUN "/udev/links/", name_enc, NULL);
|
||||
strscpyl(filename, sizeof(filename), dirname, "/", udev_device_get_id_filename(dev), NULL);
|
||||
|
||||
if (!add && unlink(filename) == 0)
|
||||
rmdir(dirname);
|
||||
|
||||
target = link_find_prioritized(dev, add, dirname, buf, sizeof(buf));
|
||||
if (target == NULL) {
|
||||
log_debug("no reference left, remove '%s'", slink);
|
||||
if (unlink(slink) == 0)
|
||||
rmdir_parents(slink, "/");
|
||||
} else {
|
||||
log_debug("creating link '%s' to '%s'", slink, target);
|
||||
node_symlink(dev, target, slink);
|
||||
}
|
||||
|
||||
if (add) {
|
||||
int err;
|
||||
|
||||
do {
|
||||
int fd;
|
||||
|
||||
err = mkdir_parents(filename, 0755);
|
||||
if (err != 0 && err != -ENOENT)
|
||||
break;
|
||||
fd = open(filename, O_WRONLY|O_CREAT|O_CLOEXEC|O_TRUNC|O_NOFOLLOW, 0444);
|
||||
if (fd >= 0)
|
||||
close(fd);
|
||||
else
|
||||
err = -errno;
|
||||
} while (err == -ENOENT);
|
||||
}
|
||||
}
|
||||
|
||||
void udev_node_update_old_links(struct udev_device *dev, struct udev_device *dev_old) {
|
||||
struct udev_list_entry *list_entry;
|
||||
|
||||
/* update possible left-over symlinks */
|
||||
udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev_old)) {
|
||||
const char *name = udev_list_entry_get_name(list_entry);
|
||||
struct udev_list_entry *list_entry_current;
|
||||
int found;
|
||||
|
||||
/* check if old link name still belongs to this device */
|
||||
found = 0;
|
||||
udev_list_entry_foreach(list_entry_current, udev_device_get_devlinks_list_entry(dev)) {
|
||||
const char *name_current = udev_list_entry_get_name(list_entry_current);
|
||||
|
||||
if (streq(name, name_current)) {
|
||||
found = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (found)
|
||||
continue;
|
||||
|
||||
log_debug("update old name, '%s' no longer belonging to '%s'",
|
||||
name, udev_device_get_devpath(dev));
|
||||
link_update(dev, name, false);
|
||||
}
|
||||
}
|
||||
|
||||
static int node_permissions_apply(struct udev_device *dev, bool apply,
|
||||
mode_t mode, uid_t uid, gid_t gid,
|
||||
struct udev_list *seclabel_list) {
|
||||
const char *devnode = udev_device_get_devnode(dev);
|
||||
dev_t devnum = udev_device_get_devnum(dev);
|
||||
struct stat stats;
|
||||
struct udev_list_entry *entry;
|
||||
int err = 0;
|
||||
|
||||
if (streq(udev_device_get_subsystem(dev), "block"))
|
||||
mode |= S_IFBLK;
|
||||
else
|
||||
mode |= S_IFCHR;
|
||||
|
||||
if (lstat(devnode, &stats) != 0) {
|
||||
err = -errno;
|
||||
log_debug_errno(errno, "can not stat() node '%s' (%m)", devnode);
|
||||
err = mknod(devnode, mode, devnum);
|
||||
if (err != 0)
|
||||
err = -errno;
|
||||
chmod(devnode, mode);
|
||||
chown(devnode, uid, gid);
|
||||
log_info("mknod %s %u:%u %#o' ok\n",devnode,major(devnum), minor(devnum), mode);
|
||||
}
|
||||
|
||||
if (((stats.st_mode & S_IFMT) != (mode & S_IFMT)) || (stats.st_rdev != devnum)) {
|
||||
err = -EEXIST;
|
||||
log_debug("found node '%s' with non-matching devnum %s, skip handling",
|
||||
udev_device_get_devnode(dev), udev_device_get_id_filename(dev));
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (apply) {
|
||||
bool selinux = false;
|
||||
bool smack = false;
|
||||
|
||||
if ((stats.st_mode & 0777) != (mode & 0777) || stats.st_uid != uid || stats.st_gid != gid) {
|
||||
log_debug("set permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);
|
||||
err = chmod(devnode, mode);
|
||||
if (err < 0)
|
||||
log_warning_errno(errno, "setting mode of %s to %#o failed: %m", devnode, mode);
|
||||
err = chown(devnode, uid, gid);
|
||||
if (err < 0)
|
||||
log_warning_errno(errno, "setting owner of %s to uid=%u, gid=%u failed: %m", devnode, uid, gid);
|
||||
} else {
|
||||
log_debug("preserve permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);
|
||||
}
|
||||
|
||||
/* apply SECLABEL{$module}=$label */
|
||||
udev_list_entry_foreach(entry, udev_list_get_entry(seclabel_list)) {
|
||||
const char *name, *label;
|
||||
int r;
|
||||
|
||||
name = udev_list_entry_get_name(entry);
|
||||
label = udev_list_entry_get_value(entry);
|
||||
|
||||
if (streq(name, "selinux")) {
|
||||
selinux = true;
|
||||
|
||||
r = mac_selinux_apply(devnode, label);
|
||||
if (r < 0)
|
||||
log_error_errno(r, "SECLABEL: failed to set SELinux label '%s': %m", label);
|
||||
else
|
||||
log_debug("SECLABEL: set SELinux label '%s'", label);
|
||||
|
||||
} else if (streq(name, "smack")) {
|
||||
smack = true;
|
||||
|
||||
r = mac_smack_apply(devnode, label);
|
||||
if (r < 0)
|
||||
log_error_errno(r, "SECLABEL: failed to set SMACK label '%s': %m", label);
|
||||
else
|
||||
log_debug("SECLABEL: set SMACK label '%s'", label);
|
||||
|
||||
} else
|
||||
log_error("SECLABEL: unknown subsystem, ignoring '%s'='%s'", name, label);
|
||||
}
|
||||
|
||||
/* set the defaults */
|
||||
if (!selinux)
|
||||
mac_selinux_fix(devnode, true, false);
|
||||
if (!smack)
|
||||
mac_smack_apply(devnode, NULL);
|
||||
}
|
||||
|
||||
/* always update timestamp when we re-use the node, like on media change events */
|
||||
utimensat(AT_FDCWD, devnode, NULL, 0);
|
||||
out:
|
||||
return err;
|
||||
}
|
||||
|
||||
void udev_node_add(struct udev_device *dev, bool apply,
|
||||
mode_t mode, uid_t uid, gid_t gid,
|
||||
struct udev_list *seclabel_list) {
|
||||
char filename[UTIL_PATH_SIZE];
|
||||
struct udev_list_entry *list_entry;
|
||||
|
||||
log_debug("handling device node '%s', devnum=%s, mode=%#o, uid="UID_FMT", gid="GID_FMT,
|
||||
udev_device_get_devnode(dev), udev_device_get_id_filename(dev), mode, uid, gid);
|
||||
|
||||
if (node_permissions_apply(dev, apply, mode, uid, gid, seclabel_list) < 0)
|
||||
return;
|
||||
|
||||
/* always add /dev/{block,char}/$major:$minor */
|
||||
snprintf(filename, sizeof(filename), "/dev/%s/%u:%u",
|
||||
streq(udev_device_get_subsystem(dev), "block") ? "block" : "char",
|
||||
major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev)));
|
||||
node_symlink(dev, udev_device_get_devnode(dev), filename);
|
||||
|
||||
/* create/update symlinks, add symlinks to name index */
|
||||
udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev))
|
||||
link_update(dev, udev_list_entry_get_name(list_entry), true);
|
||||
}
|
||||
|
||||
void udev_node_remove(struct udev_device *dev) {
|
||||
struct udev_list_entry *list_entry;
|
||||
char filename[UTIL_PATH_SIZE];
|
||||
|
||||
/* remove/update symlinks, remove symlinks from name index */
|
||||
udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev))
|
||||
link_update(dev, udev_list_entry_get_name(list_entry), false);
|
||||
|
||||
/* remove /dev/{block,char}/$major:$minor */
|
||||
snprintf(filename, sizeof(filename), "/dev/%s/%u:%u",
|
||||
streq(udev_device_get_subsystem(dev), "block") ? "block" : "char",
|
||||
major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev)));
|
||||
unlink(filename);
|
||||
}
|
||||
Binary file not shown.
@@ -0,0 +1,90 @@
|
||||
#!/usr/bin/env make
|
||||
###################################################################################
|
||||
#
|
||||
#
|
||||
#Copyright (c) XMEDIA. All rights reserved.
|
||||
#
|
||||
#
|
||||
###################################################################################
|
||||
GDB := gdb-13.2
|
||||
|
||||
NCURSES := ncurses-6.4
|
||||
|
||||
GMP := gmp-6.3.0
|
||||
|
||||
GDB_PREFIX := $(ROOTFS_BUILDDIR)/$(GDB)/.install
|
||||
|
||||
NCURSES_PREFIX := $(ROOTFS_BUILDDIR)/$(NCURSES)/.install
|
||||
|
||||
GMP_PREFIX := $(ROOTFS_BUILDDIR)/$(GMP)/.install
|
||||
|
||||
|
||||
###################################################################################
|
||||
rootfs_unstrip: $(ROOTFS_PREFIX)/bin/gdb
|
||||
|
||||
clean: $(GDB).clean $(NCURSES).clean $(GMP).clean
|
||||
|
||||
$(GDB).clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)/$(GDB)
|
||||
|
||||
$(ROOTFS_PREFIX)/bin/gdb: $(ROOTFS_BUILDDIR)/$(GDB)/.built
|
||||
$(call mkdir,$(@D))
|
||||
cp -arf $(GDB_PREFIX)/bin/gdb $(ROOTFS_PREFIX)/bin
|
||||
cp -arf $(GDB_PREFIX)/bin/gdbserver $(ROOTFS_PREFIX)/bin
|
||||
cp -arf $(GMP_PREFIX)/lib/libgmp.so* $(ROOTFS_PREFIX)/usr/lib/
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(GDB)/.built: $(ROOTFS_BUILDDIR)/$(GDB)/.extracted \
|
||||
$(ROOTFS_BUILDDIR)/$(NCURSES)/.built $(ROOTFS_BUILDDIR)/$(GMP)/.built
|
||||
cd $(<D); CC=$(CROSS_COMPILE)-gcc ./configure \
|
||||
--prefix=$(GDB_PREFIX) \
|
||||
--host=$(CROSS_COMPILE) \
|
||||
CFLAGS='-lm'\
|
||||
--disable-tui\
|
||||
--with-gmp=$(GMP_PREFIX) \
|
||||
LDFLAGS="-static-libstdc++ -static-libgcc -L$(NCURSES_PREFIX)/lib" \
|
||||
gdb_cv_prfpregset_t_broken=no \
|
||||
host_configargs="--disable-tui CFLAGS='-lm' --with-libgmp-prefix=$(GMP_PREFIX)"
|
||||
make -C $(<D)
|
||||
make -C $(<D) install
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(GDB)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
tar xf $(OPEN_SOURCE_DIR)/gdb/$(GDB).tar.xz -C $(ROOTFS_BUILDDIR)
|
||||
touch $@
|
||||
|
||||
#cp -arf $(ROOTFS_SRCDIR)/gdb/$(GDB).patch/* $(@D)
|
||||
###################################################################################
|
||||
$(NCURSES).clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)/$(NCURSES)
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(NCURSES)/.built: $(ROOTFS_BUILDDIR)/$(NCURSES)/.extracted
|
||||
cd $(<D); CC=$(CROSS_COMPILE)-gcc ./configure \
|
||||
CPPFLAGS="-P" \
|
||||
--prefix=$(NCURSES_PREFIX) \
|
||||
--host=$(CROSS_COMPILE) --disable-stripping --disable-db-install
|
||||
make -C $(<D)
|
||||
make -C $(<D) install
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(NCURSES)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
tar xf $(OPEN_SOURCE_DIR)/ncurses/$(NCURSES).tar.gz -C $(ROOTFS_BUILDDIR)
|
||||
touch $@
|
||||
###################################################################################
|
||||
$(GMP).clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)/$(GMP)
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(GMP)/.built: $(ROOTFS_BUILDDIR)/$(GMP)/.extracted
|
||||
cd $(<D); CC=$(CROSS_COMPILE)-gcc ./configure \
|
||||
--prefix=$(GMP_PREFIX) \
|
||||
--host=$(CROSS_COMPILE)
|
||||
make -C $(<D)
|
||||
make -C $(<D) install
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(GMP)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
tar xf $(OPEN_SOURCE_DIR)/gdb/$(GMP).tar.xz -C $(ROOTFS_BUILDDIR)
|
||||
touch $@
|
||||
@@ -0,0 +1,84 @@
|
||||
#!/usr/bin/env make
|
||||
###################################################################################
|
||||
#
|
||||
#Copyright (c) Lotus. All rights reserved.
|
||||
#
|
||||
###################################################################################
|
||||
MTDUTILS := mtd-utils-2.0.2
|
||||
|
||||
ZLIB :=zlib-1.2.11
|
||||
|
||||
UUIDLIB :=libuuid-1.0.3
|
||||
|
||||
MTDUTILS_PREFIX = $(ROOTFS_BUILDDIR)/$(MTDUTILS)/.install
|
||||
|
||||
ZLIB_PREFIX = $(ROOTFS_BUILDDIR)/$(ZLIB)/.install
|
||||
|
||||
UUIDLIB_PREFIX = $(ROOTFS_BUILDDIR)/$(UUIDLIB)/.install
|
||||
|
||||
###################################################################################
|
||||
rootfs_unstrip: $(ROOTFS_PREFIX)/bin/mkfs.ubifs
|
||||
|
||||
clean: $(MTDUTILS).clean $(UUIDLIB).clean $(ZLIB).clean
|
||||
|
||||
$(MTDUTILS).clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)/$(MTDUTILS)
|
||||
|
||||
$(ROOTFS_PREFIX)/bin/mkfs.ubifs: $(ROOTFS_BUILDDIR)/$(MTDUTILS)/.built
|
||||
$(call mkdir,$(@D))
|
||||
cp -arf $(MTDUTILS_PREFIX)/sbin/* $(ROOTFS_PREFIX)/bin
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(MTDUTILS)/.built: $(ROOTFS_BUILDDIR)/$(MTDUTILS)/.extracted \
|
||||
$(ROOTFS_BUILDDIR)/$(UUIDLIB)/.built \
|
||||
$(ROOTFS_BUILDDIR)/$(ZLIB)/.built
|
||||
cd $(<D); CC=$(CROSS_COMPILE)-gcc ./configure \
|
||||
--prefix=$(MTDUTILS_PREFIX) \
|
||||
--host=$(CROSS_COMPILE) \
|
||||
CFLAGS='--static -I$(ZLIB_PREFIX)/include' \
|
||||
ZLIB_LIBS=$(ZLIB_PREFIX)/lib/libz.a \
|
||||
UUID_LIBS=$(UUIDLIB_PREFIX)/lib/libuuid.a \
|
||||
PKG_CONFIG_PATH=$(UUIDLIB_PREFIX)/lib/pkgconfig \
|
||||
--without-lzo \
|
||||
--disable-tests
|
||||
make -C $(<D)
|
||||
make -C $(<D) install
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(MTDUTILS)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
tar xf $(OPEN_SOURCE_DIR)/mtd-utils/$(MTDUTILS).tar.bz2 -C $(ROOTFS_BUILDDIR)
|
||||
touch $@
|
||||
|
||||
###################################################################################
|
||||
$(UUIDLIB).clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)/$(UUIDLIB)
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(UUIDLIB)/.built: $(ROOTFS_BUILDDIR)/$(UUIDLIB)/.extracted
|
||||
cd $(<D); CC=$(CROSS_COMPILE)-gcc ./configure \
|
||||
--prefix=$(UUIDLIB_PREFIX) \
|
||||
--host=$(CROSS_COMPILE)
|
||||
make -C $(<D)
|
||||
make -C $(<D) install
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(UUIDLIB)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
tar xf $(OPEN_SOURCE_DIR)/libuuid/$(UUIDLIB).tar.gz -C $(ROOTFS_BUILDDIR)
|
||||
touch $@
|
||||
|
||||
###################################################################################
|
||||
$(ZLIB).clean:
|
||||
rm -rf $(ROOTFS_BUILDDIR)/$(ZLIB)
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(ZLIB)/.built: $(ROOTFS_BUILDDIR)/$(ZLIB)/.extracted
|
||||
cd $(<D); CC=$(CROSS_COMPILE)-gcc ./configure \
|
||||
--prefix=$(ZLIB_PREFIX)
|
||||
make -C $(<D)
|
||||
make -C $(<D) install
|
||||
touch $@
|
||||
|
||||
$(ROOTFS_BUILDDIR)/$(ZLIB)/.extracted:
|
||||
$(call mkdir,$(@D))
|
||||
tar xf $(OPEN_SOURCE_DIR)/zlib/$(ZLIB).tar.gz -C $(ROOTFS_BUILDDIR)
|
||||
touch $@
|
||||
@@ -0,0 +1,83 @@
|
||||
#!/usr/bin/env make
|
||||
###############################################################################
|
||||
#
|
||||
#Copyright (c) XMEDIA. All rights reserved.
|
||||
#
|
||||
#
|
||||
###############################################################################
|
||||
REGTOOLS := regtools
|
||||
|
||||
REGTOOLS_BUILD := $(ROOTFS_BUILDDIR)/regtools
|
||||
|
||||
CROSS_STRIP := $(CONFIG_XMEDIA_USR_ARM_TOOLCHAINS)-strip
|
||||
|
||||
CFG_FLAGS := -DVENDOR_I2C
|
||||
CFG_FLAGS += -g3
|
||||
CFG_FLAGS += -Wall -Wunused
|
||||
CFG_FLAGS += -D__LINUX_ARM_ARCH__=7
|
||||
CFG_FLAGS += -mtune=arm9tdmi
|
||||
CFG_FLAGS += -DTARGET_ARM
|
||||
CFG_FLAGS += -mlittle-endian
|
||||
CFG_FLAGS += $(filter-out -Werror,$(SDK_USR_CFLAGS))
|
||||
CFG_FLAGS += -I$(ROOTFS_SRCDIR)/$(REGTOOLS)/include/common
|
||||
CFG_FLAGS += -I$(ROOTFS_SRCDIR)/$(REGTOOLS)/include/utils
|
||||
|
||||
|
||||
COMMON_SRC=$(wildcard $(addprefix $(ROOTFS_SRCDIR)/$(REGTOOLS)/source/,common/*.c) )
|
||||
COMMON_OBJ=$(patsubst %.c,$(REGTOOLS_BUILD)/source/common/%.o, $(notdir $(COMMON_SRC)))
|
||||
|
||||
TOOLS_SRC=$(wildcard $(addprefix $(ROOTFS_SRCDIR)/$(REGTOOLS)/source/,tools/*.c) )
|
||||
TOOLS_OBJ=$(patsubst %.c,$(REGTOOLS_BUILD)/source/tools/%.o, $(notdir $(TOOLS_SRC)))
|
||||
|
||||
UITILS_SRC=$(wildcard $(addprefix $(ROOTFS_SRCDIR)/$(REGTOOLS)/source/,utils/*.c) )
|
||||
UITILS_OBJ=$(patsubst %.c,$(REGTOOLS_BUILD)/source/utils/%.o, $(notdir $(UITILS_SRC)))
|
||||
|
||||
LINK_OBJ=$(wildcard $(REGTOOLS_BUILD)/*.o)
|
||||
COMPILE=$(CROSS_COMPILE)-gcc $(CFG_FLAGS) -c -w -o "$(REGTOOLS_BUILD)/$(*F).o" "$<"
|
||||
|
||||
###############################################################################
|
||||
rootfs_unstrip: $(ROOTFS_PREFIX)/bin/regtools
|
||||
|
||||
clean: $(REGTOOLS).clean
|
||||
|
||||
$(REGTOOLS).clean:
|
||||
rm -rf $(REGTOOLS_BUILD)
|
||||
|
||||
install_regtools = cd $(REGTOOLS_BUILD); ln -sf regtools $1; \
|
||||
cp -rf $(REGTOOLS_BUILD)/$1 $(ROOTFS_PREFIX)/bin
|
||||
|
||||
install_ddr_stat_tools = cd $(REGTOOLS_BUILD);\
|
||||
echo "\#!/bin/sh" >$1;\
|
||||
echo "" >>$1;\
|
||||
echo "while true; do (cat /proc/ddr_bandwidth;sleep 1) done | grep \"Bandwidth Util:\"" >>$1;\
|
||||
echo "" >>$1; \
|
||||
chmod +x $(REGTOOLS_BUILD)/$1;\
|
||||
cp -f $(REGTOOLS_BUILD)/$1 $(ROOTFS_PREFIX)/bin
|
||||
|
||||
$(ROOTFS_PREFIX)/bin/regtools: $(REGTOOLS_BUILD)/.built
|
||||
$(call mkdir,$(@D))
|
||||
$(call install_regtools,xmmd)
|
||||
$(call install_regtools,xmmd.l)
|
||||
$(call install_regtools,xmmm)
|
||||
$(call install_regtools,xmmc)
|
||||
$(call install_regtools,i2c_read)
|
||||
$(call install_regtools,i2c_write)
|
||||
$(call install_regtools,ssp_read)
|
||||
$(call install_regtools,ssp_write)
|
||||
$(call install_ddr_stat_tools,xmddrs)
|
||||
cp -rf $(REGTOOLS_BUILD)/regtools $(ROOTFS_PREFIX)/bin
|
||||
touch $@
|
||||
|
||||
$(REGTOOLS_BUILD)/.built: $(COMMON_OBJ) $(TOOLS_OBJ) $(UITILS_OBJ) prepare
|
||||
$(CROSS_COMPILE)-gcc -o $(REGTOOLS_BUILD)/regtools -lpthread -lrt $(filter-out -Werror,$(SDK_USR_CFLAGS)) $(LINK_OBJ)
|
||||
$(CROSS_STRIP) $(REGTOOLS_BUILD)/regtools
|
||||
touch $@
|
||||
|
||||
$(REGTOOLS_BUILD)/%.o : $(ROOTFS_SRCDIR)/$(REGTOOLS)/%.c
|
||||
$(call mkdir,$(@D))
|
||||
$(COMPILE)
|
||||
touch $@
|
||||
|
||||
prepare:
|
||||
@$(call mkdir,$(REGTOOLS_BUILD))
|
||||
(test ! -f $(ROOTFS_SRCDIR)/$(REGTOOLS)/*.o) || cp -af $(ROOTFS_SRCDIR)/$(REGTOOLS)/*.o $(REGTOOLS_BUILD)/
|
||||
@@ -0,0 +1,35 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __XMEDIA_H__
|
||||
#define __XMEDIA_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
#include "bsp_config.h"
|
||||
#include "bsp_defs.h"
|
||||
#include "bsp_type.h"
|
||||
|
||||
#include "bsp_version.h"
|
||||
|
||||
#include "bsp_os.h"
|
||||
#include "bsp_module.h"
|
||||
#include "bsp_error.h"
|
||||
#include "bsp_dbg.h"
|
||||
#include "bsp_bits.h"
|
||||
#include "bsp_utils.h"
|
||||
#include "bsp_help_en.h"
|
||||
#include "bsp_thread.h"
|
||||
#include <errno.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __XMEDIA_H__ */
|
||||
@@ -0,0 +1,66 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __XMEDIA_BITS_H__
|
||||
#define __XMEDIA_BITS_H__
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
|
||||
/*** High 8 bits of 16 ***/
|
||||
#define GET_0Byte_32(ul) ((U32)ul & 0x000000FF)
|
||||
#define GET_1Byte_32(ul) ((U32)ul & 0x0000FF00) >> 8
|
||||
#define GET_2Byte_32(ul) ((U32)ul & 0x00FF0000) >> 16
|
||||
#define GET_3Byte_32(ul) ((U32)ul & 0xFF000000) >> 24
|
||||
|
||||
#define GET_HI8_16(us) ((U16)us >> 8)
|
||||
#define GET_LO8_16(us) ((U16)us & 0x00FF)
|
||||
|
||||
#define SET_HI8_16(us, v) (((U16)us & 0x00FF) | (v << 8))
|
||||
#define SET_LO8_16(us, v) (((U16)us & 0xFF00) | (v))
|
||||
|
||||
/**/
|
||||
#define GET_HI16_32(dw) ((dw) >> 16)
|
||||
#define GET_LO16_32(dw) ((dw) & 0x0000FFFF)
|
||||
|
||||
#define SET_HI16_32(dw, v) ((dw & 0x0000FFFF) | (v << 16))
|
||||
#define SET_LO16_32(dw, v) ((dw & 0xFFFF0000) | (v))
|
||||
|
||||
#define GET_LO32_64(dw) ((dw) & 0x00000000FFFFFFFF)
|
||||
|
||||
/*15...3 2 1 0*/
|
||||
#define SET_BIT0_16(us, v) ((us & 0xFFFE) | v)
|
||||
#define SET_BIT1_16(us, v) ((us & 0xFFFD) | (v << 1))
|
||||
#define SET_BIT2_16(us, v) ((us & 0xFFFB) | (v << 2))
|
||||
#define SET_BIT3_16(us, v) ((us & 0xFFF7) | (v << 3))
|
||||
|
||||
#define SET_BIT4_16(us, v) ((us & 0xFFEF) | (v << 4))
|
||||
#define SET_BIT5_16(us, v) ((us & 0xFFDF) | (v << 5))
|
||||
#define SET_BIT6_16(us, v) ((us & 0xFFBF) | (v << 6))
|
||||
#define SET_BIT7_16(us, v) ((us & 0xFF7F) | (v << 7))
|
||||
|
||||
#define SET_BIT8_16(us, v) ((us & 0xFEFF) | (v << 8))
|
||||
#define SET_BIT9_16(us, v) ((us & 0xFDFF) | (v << 9))
|
||||
#define SET_BIT10_16(us, v) ((us & 0xFBFF) | (v << 10))
|
||||
#define SET_BIT11_16(us, v) ((us & 0xF7FF) | (v << 11))
|
||||
|
||||
#define SET_BIT12_16(us, v) ((us & 0xEFFF) | (v << 12))
|
||||
#define SET_BIT13_16(us, v) ((us & 0xDFFF) | (v << 13))
|
||||
#define SET_BIT14_16(us, v) ((us & 0xBFFF) | (v << 14))
|
||||
#define SET_BIT15_16(us, v) ((us & 0x7FFF) | (v << 15))
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#endif /* __XMEDIA_BITS_H__ */
|
||||
@@ -0,0 +1,93 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __XMEDIA_CONFIG_H__
|
||||
#define __XMEDIA_CONFIG_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#if defined(TARGET_X86)
|
||||
|
||||
//#define PC_EMULATOR
|
||||
/*#undefine PC_EMULATOR*/
|
||||
|
||||
/* Whether to use the BTRACE debug library */
|
||||
/*#define USE_BTRACE*/
|
||||
/*#undefine USE_BTRACE*/
|
||||
#endif
|
||||
|
||||
/* DEBUG MODE */
|
||||
#define DEBUG
|
||||
/*#define RELEASE*/
|
||||
|
||||
#define OS_LINUX
|
||||
|
||||
/**/
|
||||
|
||||
/************ -D in Makefile ******/
|
||||
/* Simulate the program on ARM, Use -DARM_CPU*/
|
||||
/*#define ARM_CPU*/
|
||||
|
||||
/*Simulate the program on ZSP, Use -DZSP_CPU*/
|
||||
/*#define ZSP_CPU*/
|
||||
|
||||
/* Whether to perform the print function */
|
||||
#define LOGQUEUE
|
||||
|
||||
/* Whether to do Arm and ZSP communication statistics */
|
||||
#define AZ_STAT
|
||||
|
||||
/* multi-task logqueue*/
|
||||
#define MULTI_TASK_LOGQUEUE
|
||||
|
||||
/* Using inerrupt mode on ARM and ZSP communication */
|
||||
#define USE_AZ_INT
|
||||
|
||||
#define STAT
|
||||
|
||||
#if 0
|
||||
/*Turn on both when test video */
|
||||
#define AZ_POOL_LOW
|
||||
#define AZ_MAGIC_LOW
|
||||
#endif
|
||||
|
||||
//#define H264STREAM_CORRECT
|
||||
/*RingBuffer count */
|
||||
#define RBSTAT
|
||||
|
||||
#define BITSTREAM_ENC_CHECKSUM
|
||||
#define BITSTREAM_DEC_CHECKSUM
|
||||
|
||||
#define RTSP_VOD
|
||||
|
||||
#define SAVE_VOICE 1
|
||||
|
||||
/* Support network on-demand */
|
||||
#define MPLAYER_NETWORK
|
||||
|
||||
#define DEMO_MEDIA
|
||||
|
||||
#define DEMO_VOICE
|
||||
#define DEMO_VIDEO_ENC
|
||||
#define DEMO_VIDEO_DEC
|
||||
|
||||
//#define SYNC_USE_COND
|
||||
|
||||
#define AZPOOLS_X
|
||||
|
||||
#if defined(IMAGESIZE_CIF)
|
||||
#define CONFIG_VIU_CAPTURE_DOWNSCALING //CIF
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __XMEDIA_CONFIG_H__ */
|
||||
+238
@@ -0,0 +1,238 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __XMEDIA_DBG_H__
|
||||
#define __XMEDIA_DBG_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#if defined(DEBUG)
|
||||
#include <assert.h>
|
||||
#endif
|
||||
|
||||
#ifdef LOGQUEUE
|
||||
#include "bsp_message.h"
|
||||
USE_GLOBALVAR LOG_QUEUE gLogQueue;
|
||||
#endif
|
||||
|
||||
#if defined(DEBUG)
|
||||
#define DBG_ASSERT(expression) assert(expression)
|
||||
#define DBG_ASSERT_STR(expression, str) \
|
||||
do \
|
||||
{ \
|
||||
if (!(expression)) \
|
||||
{ \
|
||||
WRITE_LOG_DEBUG(str); \
|
||||
assert(expression); \
|
||||
} \
|
||||
}while(0);
|
||||
|
||||
|
||||
#define DBG_LOG WRITE_LOG_DEBUG
|
||||
#define DBG_LOG1 WRITE_LOG_DEBUG1
|
||||
#define DBG_LOG2 WRITE_LOG_DEBUG2
|
||||
|
||||
#else
|
||||
#define DBG_ASSERT(expression) ((void)0)
|
||||
#define DBG_ASSERT_STR(expression, str)
|
||||
|
||||
#define DBG_LOG(args...)
|
||||
#define DBG_LOG1 WRITE_LOG_DEBUG1
|
||||
#define DBG_LOG2 WRITE_LOG_DEBUG2
|
||||
|
||||
#endif
|
||||
#define LOG_LEVEL_NORMAL 0
|
||||
#define LOG_LEVEL_FATAL 1
|
||||
#define LOG_LEVEL_ERROR 2
|
||||
#define LOG_LEVEL_WARN 3
|
||||
#define LOG_LEVEL_INFO 4
|
||||
|
||||
#define LOG_LEVEL_DEBUG 5
|
||||
#define LOG_LEVEL_DEBUG1 6
|
||||
#define LOG_LEVEL_DEBUG2 7
|
||||
|
||||
#define LOG_LEVEL_ALL 10
|
||||
#define LOG_LEVEL_NONE 0
|
||||
|
||||
#define LOG_LEVEL_DEFAULT LOG_LEVEL_INFO
|
||||
#define LOG_LEVEL_MINI LOG_LEVEL_ERROR
|
||||
#define LOG_LEVEL_MAX LOG_LEVEL_ALL
|
||||
|
||||
/* LOG */
|
||||
/*
|
||||
*WRITE_LOG_FATAL("Memory is too much , total: %u M, it's waste, please save people's money , 1024");
|
||||
*WRITE_LOG ( LOG_LEVEL_WARN, "after VIU device analyse: you are a handsome pig." );
|
||||
*/
|
||||
|
||||
/*gLogQueue is a Global Var, now defined at bsp_message.c and
|
||||
declare at bsp_dbg.h, it you use this log functions outside,
|
||||
you can declare your owner "gLogQueue"*/
|
||||
/*Call this first , and only call it once*/
|
||||
|
||||
/*level = LOG_LEVEL_ERROR .....*/
|
||||
|
||||
#ifdef LOGQUEUE
|
||||
#define LOG_CREATE(level, msglen) Log_Create(&gLogQueue, level, msglen)
|
||||
|
||||
#define LOG_SETLEVEL(level) (gLogQueue.ucMinLevel = level)
|
||||
|
||||
#define LOG_GETLEVEL() (gLogQueue.ucMinLevel)
|
||||
|
||||
#define LOG_DESTROY() Log_Destroy(&gLogQueue)
|
||||
|
||||
#if 0
|
||||
#define WRITE_LOG_NORMAL(psz_format, args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_NORMAL, psz_format, ##args )
|
||||
|
||||
#define WRITE_LOG_INFO(psz_format, args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_INFO, psz_format, ##args )
|
||||
|
||||
#define WRITE_LOG_FATAL(psz_format, args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_FATAL, psz_format, ##args )
|
||||
|
||||
#define WRITE_LOG_ERROR(psz_format, args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_ERROR, psz_format, ##args )
|
||||
|
||||
#define WRITE_LOG_WARN(psz_format, args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_WARN, psz_format, ##args )
|
||||
|
||||
#define WRITE_LOG_DEBUG(psz_format, args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_DEBUG, "{%s:%i}:"psz_format, \
|
||||
__FILE__, __LINE__ ,##args)
|
||||
|
||||
#define WRITE_LOG_DEBUG1(psz_format, args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_DEBUG1, "{%s:%i}:"psz_format, \
|
||||
__FILE__, __LINE__ ,##args)
|
||||
|
||||
#define WRITE_LOG_DEBUG2(psz_format, args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_DEBUG2, "{%s:%i}:"psz_format, \
|
||||
__FILE__, __LINE__ ,##args)
|
||||
|
||||
#define WRITE_LOG(iLevel, psz_format, args... ) \
|
||||
Log_Msg(&gLogQueue, iLevel, psz_format, ##args )
|
||||
#endif /* End of #if 0 */
|
||||
|
||||
#define MKSTR(exp) # exp
|
||||
#define MKMARCOTOSTR(exp) MKSTR(exp)
|
||||
#define LINENUMBER MKMARCOTOSTR(__LINE__)
|
||||
|
||||
#define ATTACHINFO ""
|
||||
|
||||
#define WRITE_LOG_NORMAL(args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_NORMAL, args )
|
||||
|
||||
#define WRITE_LOG_INFO(args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_INFO, args)
|
||||
|
||||
#define WRITE_LOG_FATAL(args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_FATAL, args )
|
||||
|
||||
#define WRITE_LOG_ERROR(args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_ERROR, args )
|
||||
|
||||
#define WRITE_LOG_WARN(args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_WARN, args )
|
||||
|
||||
#define WRITE_LOG_DEBUG(args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_DEBUG, ATTACHINFO args)
|
||||
|
||||
#define WRITE_LOG_DEBUG1(args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_DEBUG1, ATTACHINFO args)
|
||||
|
||||
#define WRITE_LOG_DEBUG2(args... ) \
|
||||
Log_Msg(&gLogQueue, LOG_LEVEL_DEBUG2, ATTACHINFO args)
|
||||
|
||||
#define WRITE_LOG(iLevel, args... ) \
|
||||
Log_Msg(&gLogQueue, iLevel, args )
|
||||
|
||||
#else
|
||||
|
||||
#define LOG_CREATE(level, msglen)
|
||||
|
||||
#define LOG_SETLEVEL(level)
|
||||
|
||||
#define LOG_GETLEVEL() (0)
|
||||
|
||||
#define LOG_DESTROY()
|
||||
|
||||
#define WRITE_LOG_NORMAL(args...)
|
||||
|
||||
#define WRITE_LOG_INFO(args...)
|
||||
|
||||
#define WRITE_LOG_FATAL(args...)
|
||||
|
||||
#define WRITE_LOG_ERROR(args...)
|
||||
|
||||
#define WRITE_LOG_WARN(args...)
|
||||
|
||||
#define WRITE_LOG_DEBUG(args...)
|
||||
|
||||
#define WRITE_LOG_DEBUG1(args...)
|
||||
|
||||
#define WRITE_LOG_DEBUG2(args...)
|
||||
|
||||
#define WRITE_LOG(args...)
|
||||
|
||||
#endif
|
||||
|
||||
#if defined(OS_LINUX) && defined(USE_BTRACE) && defined(DEBUG)
|
||||
#if !defined(BTRACE_ENABLE)
|
||||
#define BTRACE_ENABLE
|
||||
#endif
|
||||
#else
|
||||
#if defined(BTRACE_ENABLE)
|
||||
#undef BTRACE_ENABLE
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(BTRACE_ENABLE)
|
||||
#define BTRACE_INIT() btrace()
|
||||
#define BTRACE_PRINT btrace_print
|
||||
#define BTRACE_PRINT_FUNC() btrace_print_str(__func__)
|
||||
#define BTRACE_PRINT_STR(str) btrace_print_str(str)
|
||||
|
||||
#else
|
||||
#define BTRACE_INIT()
|
||||
#define BTRACE_PRINT
|
||||
#define BTRACE_PRINT_FUNC()
|
||||
#define BTRACE_PRINT_STR(str)
|
||||
#endif
|
||||
|
||||
EXTERNFUNC XMEDIA_RET bsp_md(IN VOID* pStart,IN U32 ulLen,IN FD fd);
|
||||
/*Memory Dump 2 file*/
|
||||
EXTERNFUNC XMEDIA_RET bsp_md2file(IN VOID* pStart,IN U32 ulLen,
|
||||
IN const char* strLabel,
|
||||
IN char* fn);
|
||||
|
||||
EXTERNFUNC void bsp_hexdump(OUT FILE *stream,
|
||||
IN const void *src, IN size_t len,
|
||||
IN size_t width);
|
||||
|
||||
EXTERNFUNC VOID bsp_hexdump_log(IN const void *src, IN size_t len,
|
||||
IN size_t width);
|
||||
|
||||
VOID bsp_hexdump2(OUT FILE *stream,
|
||||
IN const void *src, IN size_t len, IN size_t width);
|
||||
|
||||
#if defined(DEBUG)
|
||||
#define MEM_DUMP bsp_md
|
||||
#define MEM_DUMP2FILE bsp_md2file
|
||||
#else
|
||||
#define MEM_DUMP
|
||||
#define MEM_DUMP2FILE
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __XMEDIA_DBG_H__ */
|
||||
@@ -0,0 +1,90 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __XMEDIA_DEFS_H__
|
||||
#define __XMEDIA_DEFS_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#ifndef __GNUC__
|
||||
#define __asm__ asm
|
||||
#define __inline__ inline
|
||||
#endif
|
||||
|
||||
#define DO_NOTHING
|
||||
|
||||
#define INLINE inline
|
||||
|
||||
/*use for parameter INPUT, *DO NOT Modify the value* */
|
||||
#define IN
|
||||
/* use for parameter OUTPUT, the value maybe change when return from the function
|
||||
* the init value is ingore in the function.*/
|
||||
#define OUT
|
||||
/*use for parameter INPUT and OUTPUT*/
|
||||
#define IO
|
||||
|
||||
/* -------------------------------- */
|
||||
#define EXTERN extern
|
||||
#define STATIC static
|
||||
|
||||
#define LOCALVAR static
|
||||
#define GLOBALVAR extern
|
||||
|
||||
#define DECLARE_GLOBALVAR
|
||||
|
||||
#define USE_GLOBALVAR extern
|
||||
|
||||
#define LOCALFUNC static
|
||||
#define EXTERNFUNC extern
|
||||
|
||||
#define LAPI
|
||||
#define HAPI
|
||||
/*Multimedia Frame API*/
|
||||
#define MMFAPI
|
||||
|
||||
/* -------- Standard input/output/err *****/
|
||||
#define STDIN stdin
|
||||
#define STDOUT stdout
|
||||
#define STDERR stderr
|
||||
|
||||
#define MIN(x,y) ((x) < (y) ? (x) : (y))
|
||||
#define MAX(x,y) ((x) > (y) ? (x) : (y))
|
||||
|
||||
#define ALIGN_START(v,a) (((v)) & (~((a)-1)))
|
||||
|
||||
#define ALIGN_END(v,a) (((v) & ~((a)-1)) + ((a)-1) )
|
||||
|
||||
#define ALIGN_NEXT(v,a) ((((v) + ((a)-1)) & (~((a)-1))))
|
||||
|
||||
#define ALIGN_LENGTH(l, a) ALIGN_NEXT(l, a)
|
||||
|
||||
#define ALIGNTYPE_1BYTE 1
|
||||
/*zsp*/
|
||||
#define ALIGNTYPE_2BYTE 2
|
||||
/*x86... default*/
|
||||
#define ALIGNTYPE_4BYTE 4
|
||||
|
||||
#define ALIGNTYPE_8BYTE 8
|
||||
/*1 Page*/
|
||||
#define ALIGNTYPE_4K 4096
|
||||
|
||||
#define ALIGNTYPE_ZSP ALIGNTYPE_2BYTE
|
||||
|
||||
#define ALIGNTYPE_VIDEO ALIGNTYPE_8BYTE
|
||||
|
||||
#define PRINT_OUT(args...) printf(##args)
|
||||
|
||||
#define PACK_ONE_BYTE __attribute__((__packed__))
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __XMEDIA_DEFS_H__ */
|
||||
+246
@@ -0,0 +1,246 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __XMEDIA_ERROR_H__
|
||||
#define __XMEDIA_ERROR_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/*
|
||||
*/
|
||||
|
||||
#define ERR_SUB_MODULE_BASE(module, submodule) \
|
||||
(( module << 24 ) | ( submodule << 16 ))
|
||||
|
||||
#define ERR_NUMBER(err, base) ( (base) | (err) )
|
||||
|
||||
/*****************************************************************************
|
||||
****************************************************************************/
|
||||
|
||||
/*0x00XX*/
|
||||
#define ERR_GENERAL_BASE ERR_SUB_MODULE_BASE(MODULE_GENERAL, 0)
|
||||
|
||||
#define ERR_GEN_NOT_ENOUGH_MEMORY ERR_NUMBER(2, ERR_GENERAL_BASE) /*0x0002*/
|
||||
#define ERR_GEN_INVALID_POINTER ERR_NUMBER(3, ERR_GENERAL_BASE) /*0x0003*/
|
||||
#define ERR_GEN_OVERFLOW ERR_NUMBER(4, ERR_GENERAL_BASE) /*0x0004*/
|
||||
#define ERR_GEN_OUT_OF_BOUND ERR_NUMBER(5, ERR_GENERAL_BASE) /*0x0004*/
|
||||
#define ERR_GEN_INVALID_FP ERR_NUMBER(6, ERR_GENERAL_BASE) /*0x0004*/
|
||||
|
||||
#define ERR_GEN_TIMEOUT ERR_NUMBER(7, ERR_GENERAL_BASE) /*0x0007*/
|
||||
#define ERR_GEN_INVALID_PARAMETER ERR_NUMBER(8, ERR_GENERAL_BASE) /*0x0008*/
|
||||
|
||||
/*****************************************************************************
|
||||
****************************************************************************/
|
||||
#define ERR_DRV_VIU_BASE ERR_SUB_MODULE_BASE(MODULE_DRV, DRV_SUB_MODULE_VIU)
|
||||
#define ERR_DRV_VOU_BASE ERR_SUB_MODULE_BASE(MODULE_DRV, DRV_SUB_MODULE_VOU)
|
||||
#define ERR_DRV_DSU_BASE ERR_SUB_MODULE_BASE(MODULE_DRV, DRV_SUB_MODULE_DSU)
|
||||
#define ERR_DRV_USB_BASE ERR_SUB_MODULE_BASE(MODULE_DRV, DRV_SUB_MODULE_USB)
|
||||
#define ERR_DRV_SF_BASE ERR_SUB_MODULE_BASE(MODULE_DRV, DRV_SUB_MODULE_SF)
|
||||
#define ERR_DRV_TDE_BASE ERR_SUB_MODULE_BASE(MODULE_DRV, DRV_SUB_MODULE_TDE)
|
||||
|
||||
/* ERR_DRV_VOU_BASE */
|
||||
#define ERR_DRV_VOU_ERROR ERR_NUMBER(0, ERR_DRV_VOU_BASE)
|
||||
#define ERR_DRV_VOU_NOT_INITED ERR_NUMBER(1, ERR_DRV_VOU_BASE)
|
||||
#define ERR_DRV_VOU_INIT_FAILED ERR_NUMBER(2, ERR_DRV_VOU_BASE)
|
||||
#define ERR_DRV_VOU_OUTPUT_MODE_NOT_SUPPORT ERR_NUMBER(3, ERR_DRV_VOU_BASE)
|
||||
#define ERR_DRV_VOU_LAYER_INVALID ERR_NUMBER(4, ERR_DRV_VOU_BASE)
|
||||
|
||||
/* ERR_DRV_VIU_BASE */
|
||||
#define ERR_DRV_VIU_ERROR ERR_NUMBER(0, ERR_DRV_VIU_BASE)
|
||||
#define ERR_DRV_VIU_NOT_INITED ERR_NUMBER(1, ERR_DRV_VIU_BASE)
|
||||
#define ERR_DRV_VIU_INIT_FAILED ERR_NUMBER(2, ERR_DRV_VIU_BASE)
|
||||
#define ERR_DRV_VIU_MODE_NOT_SUPPORT ERR_NUMBER(3, ERR_DRV_VIU_BASE)
|
||||
|
||||
/* ERR_DRV_DSU_BASE */
|
||||
#define ERR_DRV_DSU_ERROR ERR_NUMBER(0, ERR_DRV_DSU_BASE)
|
||||
#define ERR_DRV_DSU_NOT_INITED ERR_NUMBER(1, ERR_DRV_DSU_BASE)
|
||||
#define ERR_DRV_DSU_INIT_FAILED ERR_NUMBER(2, ERR_DRV_DSU_BASE)
|
||||
#define ERR_DRV_DSU_FILTER_NOT_SUPPORT ERR_NUMBER(3, ERR_DRV_DSU_BASE)
|
||||
|
||||
/* ERR_DRV_TDE_BASE */
|
||||
#define ERR_DRV_TDE_ERROR ERR_NUMBER(0, ERR_DRV_TDE_BASE)
|
||||
#define ERR_DRV_TDE_NOT_INITED ERR_NUMBER(1, ERR_DRV_TDE_BASE)
|
||||
#define ERR_DRV_TDE_INIT_FAILED ERR_NUMBER(2, ERR_DRV_TDE_BASE)
|
||||
#define ERR_DRV_TDE_FIFO_TIMEOUT ERR_NUMBER(3, ERR_DRV_TDE_BASE)
|
||||
|
||||
/*
|
||||
Add By You , man
|
||||
......
|
||||
.....
|
||||
*/
|
||||
|
||||
/*00000001-00000001-xxxxxxxx-xxxxxxxx 0x11XX*/
|
||||
#define ERR_SYS_AZ_BASE ERR_SUB_MODULE_BASE(MODULE_SYS, SYS_SUB_MODULE_AZ)
|
||||
|
||||
#define ERR_AZMSG_INVALID_MSGPOOLS ERR_NUMBER(1, ERR_SYS_AZ_BASE) /*0x1101*/
|
||||
#define ERR_AZMSG_INVALID_MSG ERR_NUMBER(2, ERR_SYS_AZ_BASE) /*0x1102*/
|
||||
#define ERR_AZMSG_NO_SPACE_TOSEND ERR_NUMBER(3, ERR_SYS_AZ_BASE) /*0x1103*/
|
||||
#define ERR_AZMSG_NO_MSG_TORECV ERR_NUMBER(4, ERR_SYS_AZ_BASE)
|
||||
#define ERR_AZMSG_INVALID_MSGDATA ERR_NUMBER(5, ERR_SYS_AZ_BASE) /*0x1105*/
|
||||
|
||||
#define ERR_AZMSG_OVERFLOW ERR_NUMBER(6, ERR_SYS_AZ_BASE) /*0x1106*/
|
||||
#define ERR_AZMSG_EMPTY ERR_NUMBER(7, ERR_SYS_AZ_BASE) /*0x1107*/
|
||||
#define ERR_AZMSG_READY_TIMEOUT ERR_NUMBER(8, ERR_SYS_AZ_BASE) /*0x1108*/
|
||||
#define ERR_AZMSG_POOL_OFFREAD ERR_NUMBER(9, ERR_SYS_AZ_BASE) /*0x1109*/
|
||||
#define ERR_AZMSG_POOL_OFFWRITE ERR_NUMBER(10, ERR_SYS_AZ_BASE) /*0x1110*/
|
||||
|
||||
#define ERR_AZMSG_MSG_MAGIC ERR_NUMBER(11, ERR_SYS_AZ_BASE) /*0x1111*/
|
||||
#define ERR_AZMSG_MSG_LENGTH ERR_NUMBER(12, ERR_SYS_AZ_BASE) /*0x1112*/
|
||||
#define ERR_AZMSG_MSG_PID ERR_NUMBER(13, ERR_SYS_AZ_BASE) /*0x1113*/
|
||||
/*Ring Buffer*/
|
||||
/*00000001-00000002-xxxxxxxx-xxxxxxxx 0x12XX*/
|
||||
#define ERR_SYS_RB_BASE ERR_SUB_MODULE_BASE(MODULE_SYS, SYS_SUB_MODULE_RB)
|
||||
|
||||
#define ERR_RB_ERROR ERR_NUMBER(0, ERR_SYS_RB_BASE) /*0x1201*/
|
||||
#define ERR_RB_INIT ERR_NUMBER(1, ERR_SYS_RB_BASE) /*0x1201*/
|
||||
#define ERR_RB_OVERFLOW ERR_NUMBER(2, ERR_SYS_RB_BASE) /*0x1202*/
|
||||
#define ERR_RB_READ_NOTENOGH ERR_NUMBER(3, ERR_SYS_RB_BASE) /*0x1203*/
|
||||
#define ERR_RB_WRITE_NOTENOGH ERR_NUMBER(4, ERR_SYS_RB_BASE) /*0x1204*/
|
||||
#define ERR_RB_NULL_BUF ERR_NUMBER(5, ERR_SYS_RB_BASE) /*0x1205*/
|
||||
#define ERR_RB_DAMAGE ERR_NUMBER(6, ERR_SYS_RB_BASE) /*0x1206*/
|
||||
|
||||
/*Buffer Manager*/
|
||||
/*00000001-00000003-xxxxxxxx-xxxxxxxx 0x13XX*/
|
||||
#define ERR_SYS_BM_BASE ERR_SUB_MODULE_BASE(MODULE_SYS, SYS_SUB_MODULE_BM)
|
||||
|
||||
#define ERR_BM_ERROR ERR_NUMBER(0, ERR_SYS_BM_BASE) /*0x1301*/
|
||||
#define ERR_BM_INIT ERR_NUMBER(1, ERR_SYS_BM_BASE) /*0x1301*/
|
||||
#define ERR_BM_OVERFLOW ERR_NUMBER(2, ERR_SYS_BM_BASE) /*0x1302*/
|
||||
#define ERR_BM_READ_NOTENOGH ERR_NUMBER(3, ERR_SYS_BM_BASE) /*0x1303*/
|
||||
#define ERR_BM_WRITE_NOTENOGH ERR_NUMBER(4, ERR_SYS_BM_BASE) /*0x1304*/
|
||||
#define ERR_BM_INVALIDLEN ERR_NUMBER(5, ERR_SYS_BM_BASE) /*0x1304*/
|
||||
|
||||
/*Message Queue*/
|
||||
/*00000001-00000004-xxxxxxxx-xxxxxxxx 0x14XX*/
|
||||
#define ERR_SYS_MQ_BASE ERR_SUB_MODULE_BASE(MODULE_SYS, SYS_SUB_MODULE_MQ)
|
||||
/*Message Queue's Normal Error*/
|
||||
#define ERR_MQ_ERROR ERR_NUMBER(0, ERR_SYS_MQ_BASE)
|
||||
/*the Queue is invalid*/
|
||||
#define ERR_MQ_QUEUE_INVALUD ERR_NUMBER(1, ERR_SYS_MQ_BASE)
|
||||
/*no enough space to write to queue*/
|
||||
#define ERR_MQ_QUEUE_OVERFLOW ERR_NUMBER(2, ERR_SYS_MQ_BASE)
|
||||
/*the queue is empty to read */
|
||||
#define ERR_MQ_QUEUE_EMPTY ERR_NUMBER(3, ERR_SYS_MQ_BASE)
|
||||
/*the message is invalid*/
|
||||
#define ERR_MQ_MSG_INVALID ERR_NUMBER(4, ERR_SYS_MQ_BASE)
|
||||
/*the message length is null*/
|
||||
#define ERR_MQ_MSG_LEN_INVALID ERR_NUMBER(5, ERR_SYS_MQ_BASE)
|
||||
/*the buffer is invalid*/
|
||||
#define ERR_MQ_BUFFER_INVALID ERR_NUMBER(6, ERR_SYS_MQ_BASE)
|
||||
|
||||
/*thread manager*/
|
||||
#define ERR_SYS_THREAD_BASE ERR_SUB_MODULE_BASE(MODULE_SYS, SYS_SUB_MODULE_THREAD)
|
||||
|
||||
#define ERR_SYS_THREAD_MUTEX_ERROR ERR_NUMBER(0, ERR_SYS_THREAD_BASE)
|
||||
|
||||
/*------------- MMF Module Error Number Define ---------------0x31xx----------*/
|
||||
#define ERR_MMF_INPUT_BASE \
|
||||
ERR_SUB_MODULE_BASE(MODULE_MMF, MMF_SUB_MODULE_INPUT)
|
||||
|
||||
#define ERR_INPUT_STREAM_ERROR \
|
||||
ERR_NUMBER(1, ERR_MMF_INPUT_BASE) /*0x3102*/
|
||||
#define ERR_INPUT_STREAM_NOTSUPPORT \
|
||||
ERR_NUMBER(2, ERR_MMF_INPUT_BASE) /*0x3102*/
|
||||
#define ERR_INPUT_FILE_OPEN_ERROR \
|
||||
ERR_NUMBER(3, ERR_MMF_INPUT_BASE) /*0x3102*/
|
||||
|
||||
/*------------- DEMUX Module Error Number Define ---------------0x35xx--------*/
|
||||
#define ERR_MMF_DEMUX_BASE \
|
||||
ERR_SUB_MODULE_BASE(MODULE_MMF, MMF_SUB_MODULE_DEMUX)
|
||||
|
||||
#define ERR_DEMUX_STREAM_END \
|
||||
ERR_NUMBER(1, ERR_MMF_DEMUX_BASE)
|
||||
#define ERR_DEMUX_STREAM_SEEK_FAILED \
|
||||
ERR_NUMBER(2, ERR_MMF_DEMUX_BASE)
|
||||
#define ERR_DEMUX_STREAM_SEEK_NOSUPPORT \
|
||||
ERR_NUMBER(3, ERR_MMF_DEMUX_BASE)
|
||||
#define ERR_DEMUX_NO_DEMUX_INFO \
|
||||
ERR_NUMBER(4, ERR_MMF_DEMUX_BASE)
|
||||
|
||||
#define ERR_MMF_STREAM_BASE \
|
||||
ERR_SUB_MODULE_BASE(MODULE_MMF, MMF_SUB_MODULE_STREAM)
|
||||
|
||||
#define ERR_STREAM_EMPTY \
|
||||
ERR_NUMBER(1, MMF_SUB_MODULE_STREAM) /*0x3601*/
|
||||
|
||||
/*************** video decode error code define *******************/
|
||||
#define ERR_MMF_VDEC_BASE \
|
||||
ERR_SUB_MODULE_BASE(MODULE_MMF, MMF_SUB_MODULE_VDEC)
|
||||
|
||||
#define ERR_MMF_VDEC_ERROR \
|
||||
ERR_NUMBER(0, ERR_MMF_VDEC_BASE) /*0x3701*/
|
||||
|
||||
#define ERR_MMF_VDEC_HANDLE_INVALID \
|
||||
ERR_NUMBER(1, ERR_MMF_VDEC_BASE)
|
||||
|
||||
#define ERR_MMF_VDEC_DATA_INVALID \
|
||||
ERR_NUMBER(2, ERR_MMF_VDEC_BASE)
|
||||
|
||||
#define ERR_MMF_VDEC_DATATYPE_INVALID \
|
||||
ERR_NUMBER(3, ERR_MMF_VDEC_BASE)
|
||||
|
||||
#define ERR_MMF_VDEC_PAYTYPE_INVALID \
|
||||
ERR_NUMBER(4, ERR_MMF_VDEC_BASE)
|
||||
|
||||
#define ERR_MMF_VDEC_FIRST_NALU_INVALID \
|
||||
ERR_NUMBER(5, ERR_MMF_VDEC_BASE)
|
||||
|
||||
/*************** jitter buffer error code define *******************/
|
||||
#define ERR_MMF_JB_BASE \
|
||||
ERR_SUB_MODULE_BASE(MODULE_MMF, MMF_SUB_MODULE_JB)
|
||||
|
||||
|
||||
#define ERR_APP_VPAI_BASE ERR_SUB_MODULE_BASE(MODULE_APP, APP_SUB_MODULE_VAPI)
|
||||
|
||||
/* ERR_APP_VPAI_BASE */
|
||||
#define ERR_APP_VAPI_ERROR ERR_NUMBER(0, ERR_APP_VPAI_BASE)
|
||||
#define ERR_APP_VAPI_NOT_INITED ERR_NUMBER(1, ERR_APP_VPAI_BASE)
|
||||
#define ERR_APP_VAPI_INIT_FAILED ERR_NUMBER(2, ERR_APP_VPAI_BASE)
|
||||
|
||||
#define STRFMT_ERRCODE "%#010lX"
|
||||
|
||||
#ifdef DEBUG
|
||||
|
||||
#define XMEDIA_ERRNO(err) \
|
||||
do{ \
|
||||
(err) \
|
||||
? WRITE_LOG_DEBUG("<ERROR>%s:"STRFMT_ERRCODE"\n", #err, err ) \
|
||||
: (void)0 ; \
|
||||
return (err); \
|
||||
}while(0)
|
||||
|
||||
#else
|
||||
#define XMEDIA_ERRNO(err) return (err)
|
||||
#endif
|
||||
|
||||
#ifdef DEBUG
|
||||
#define EXIT(msg, errno) \
|
||||
WRITE_LOG_ERROR("%s exit:"STRFMT_ERRCODE"\n", msg, errno); \
|
||||
printf("[END]\n"); \
|
||||
exit(errno)
|
||||
|
||||
#else
|
||||
#define EXIT(msg, errno) \
|
||||
printf("[END]\n"); \
|
||||
(exit(errno))
|
||||
#endif
|
||||
#define XMEDIA_RETCHECK(err) \
|
||||
do{\
|
||||
(err) \
|
||||
? WRITE_LOG_DEBUG("<ERROR>%s:"STRFMT_ERRCODE"\n", #err, err ) \
|
||||
: (void)0 ; \
|
||||
exit(err);\
|
||||
}while(0)
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __XMEDIA_ERROR_H__ */
|
||||
@@ -0,0 +1,36 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __XMEDIA_HELP_EN_H__
|
||||
#define __XMEDIA_HELP_EN_H__
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#define MSG_CR "\n"
|
||||
|
||||
#define MSG_NEWLINE(msg) (msg MSG_CR)
|
||||
|
||||
#define MSG_FILE_NotFound "File '%s' not found."
|
||||
#define MSG_FILE_Open_Error "File '%s' open error."
|
||||
#define MSG_FILE_Open_Success "File '%s' open success."
|
||||
#define MSG_FILE_Filename_Error "File name error."
|
||||
#define MSG_THREAD_CREATE_INFO "Create Thread. name:%s, threadid:%i "
|
||||
|
||||
#define AZ_WAITREADY_TIMEOUT "Waitting for pools ready is timeout."
|
||||
#define AZ_POOLS_NOTREADY "Pools is not ready."
|
||||
|
||||
#define MSG_COMMON_NOTSUPPORT "Not support now."
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __XMEDIA_HELP_EN_H__ */
|
||||
@@ -0,0 +1,88 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#ifndef __XMEDIA_I2C_H__
|
||||
#define __XMEDIA_I2C_H__
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
typedef struct I2C_DATA_S
|
||||
{
|
||||
unsigned char dev_addr;
|
||||
unsigned int reg_addr;
|
||||
unsigned int addr_byte_num;
|
||||
unsigned int data;
|
||||
unsigned int data_byte_num;
|
||||
|
||||
}I2C_DATA_S ;
|
||||
|
||||
#define READ_OPERATION (1)
|
||||
#define WRITE_OPERATION 0xfe
|
||||
#define CMD_I2C_WRITE 0x01
|
||||
#define CMD_I2C_READ 0x03
|
||||
|
||||
|
||||
/* I2C_CTRL_REG */
|
||||
#define I2C_ENABLE (1 << 8)
|
||||
#define I2C_UNMASK_TOTAL (1 << 7)
|
||||
#define I2C_UNMASK_START (1 << 6)
|
||||
#define I2C_UNMASK_END (1 << 5)
|
||||
#define I2C_UNMASK_SEND (1 << 4)
|
||||
#define I2C_UNMASK_RECEIVE (1 << 3)
|
||||
#define I2C_UNMASK_ACK (1 << 2)
|
||||
#define I2C_UNMASK_ARBITRATE (1<< 1)
|
||||
#define I2C_UNMASK_OVER (1 << 0)
|
||||
#define I2C_UNMASK_ALL (I2C_UNMASK_START | I2C_UNMASK_END | \
|
||||
I2C_UNMASK_SEND | I2C_UNMASK_RECEIVE | \
|
||||
I2C_UNMASK_ACK | I2C_UNMASK_ARBITRATE | \
|
||||
I2C_UNMASK_OVER)
|
||||
|
||||
/* I2C_COM_REB */
|
||||
#define I2C_SEND_ACK (~(1 << 4))
|
||||
#define I2C_START (1 << 3)
|
||||
#define I2C_READ (1 << 2)
|
||||
#define I2C_WRITE (1 << 1)
|
||||
#define I2C_STOP (1 << 0)
|
||||
|
||||
/* I2C_ICR_REG */
|
||||
#define I2C_CLEAR_START (1 << 6)
|
||||
#define I2C_CLEAR_END (1 << 5)
|
||||
#define I2C_CLEAR_SEND (1 << 4)
|
||||
#define I2C_CLEAR_RECEIVE (1 << 3)
|
||||
#define I2C_CLEAR_ACK (1 << 2)
|
||||
#define I2C_CLEAR_ARBITRATE (1 << 1)
|
||||
#define I2C_CLEAR_OVER (1 << 0)
|
||||
#define I2C_CLEAR_ALL (I2C_CLEAR_START | I2C_CLEAR_END | \
|
||||
I2C_CLEAR_SEND | I2C_CLEAR_RECEIVE | \
|
||||
I2C_CLEAR_ACK | I2C_CLEAR_ARBITRATE | \
|
||||
I2C_CLEAR_OVER)
|
||||
|
||||
/* I2C_SR_REG */
|
||||
#define I2C_BUSY (1 << 7)
|
||||
#define I2C_START_INTR (1 << 6)
|
||||
#define I2C_END_INTR (1 << 5)
|
||||
#define I2C_SEND_INTR (1 << 4)
|
||||
#define I2C_RECEIVE_INTR (1 << 3)
|
||||
#define I2C_ACK_INTR (1 << 2)
|
||||
#define I2C_ARBITRATE_INTR (1 << 1)
|
||||
#define I2C_OVER_INTR (1 << 0)
|
||||
|
||||
int XMEDIA_I2C_WriteConfig(unsigned char dev_addr);
|
||||
int XMEDIA_I2C_Write(unsigned char dev_addr, unsigned int reg_addr,
|
||||
unsigned int addr_byte_num, unsigned int data, unsigned int data_byte_num);
|
||||
int XMEDIA_I2C_Read (unsigned char dev_addr, unsigned int reg_addr,
|
||||
unsigned int addr_byte_num, unsigned int data_byte_num);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,60 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
/*----------------------------------------------*
|
||||
* external variables *
|
||||
*----------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------*
|
||||
* external routine prototypes *
|
||||
*----------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------*
|
||||
* internal routine prototypes *
|
||||
*----------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------*
|
||||
* project-wide global variables *
|
||||
*----------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------*
|
||||
* module-wide global variables *
|
||||
*----------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------*
|
||||
* constants *
|
||||
*----------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------*
|
||||
* macros *
|
||||
*----------------------------------------------*/
|
||||
|
||||
/*----------------------------------------------*
|
||||
* routines' implementations *
|
||||
*----------------------------------------------*/
|
||||
|
||||
#ifndef XMEDIA_LIMIT_H__
|
||||
#define XMEDIA_LIMIT_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#define INT_MAX ((int)(~0U>>1))
|
||||
#define MAXINT INT_MAX
|
||||
#define INT_MIN (-INT_MAX - 1)
|
||||
#define UINT_MAX (~0U)
|
||||
#define LONG_MAX ((long)(~0UL>>1))
|
||||
#define LONG_MIN (-LONG_MAX - 1)
|
||||
#define ULONG_MAX (~0UL)
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* XMEDIA_LIMIT_H__ */
|
||||
@@ -0,0 +1,57 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#if !defined( XMEDIA_MESSAGE_H__ )
|
||||
#define XMEDIA_MESSAGE_H__
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#if defined(MULTI_TASK_LOGQUEUE)
|
||||
#ifdef OS_LINUX
|
||||
#include <pthread.h>
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define MAX_MESSAG_STRLEN 512
|
||||
typedef struct LOG_QUEUE_STRU
|
||||
{
|
||||
/** Message queue lock */
|
||||
#if defined(MULTI_TASK_LOGQUEUE)
|
||||
pthread_mutex_t mutex_lock;
|
||||
#endif
|
||||
U8 ucMinLevel;
|
||||
|
||||
LENGTH_T lenMsg;
|
||||
CHAR *pMsg;
|
||||
}LOG_QUEUE;
|
||||
|
||||
XMEDIA_RET Log_Create (IO LOG_QUEUE *pLogQueue, IN U8 minLevel, IN LENGTH_T lenMsg);
|
||||
|
||||
VOID Log_Destroy(IO LOG_QUEUE *pLogQueue );
|
||||
|
||||
|
||||
VOID Log_Msg (IO LOG_QUEUE *pLogQueue,
|
||||
IN U32 ucLogLevel,
|
||||
IN char *psz_format, ... );
|
||||
|
||||
VOID Log_MsgVa( IO LOG_QUEUE* pLogQueue,
|
||||
IN U32 ucLogLevel,
|
||||
IN const char *psz_format,IN va_list args );
|
||||
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,75 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __XMEDIA_MODULE_H__
|
||||
#define __XMEDIA_MODULE_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
typedef enum tag_MODULE
|
||||
{
|
||||
MODULE_GENERAL = 0,
|
||||
MODULE_SYS = 1 ,
|
||||
MODULE_DRV = 2 ,
|
||||
MODULE_MMF = 3, /*MultiMedia Frame*/
|
||||
MODULE_APP = 4,
|
||||
|
||||
MODULE_BUTT
|
||||
}MODULE_E;
|
||||
|
||||
typedef enum tag_SYS_SUB_MODULE
|
||||
{
|
||||
SYS_SUB_MODULE_AZ = 1, /*Arm ZSP Message Communication*/
|
||||
SYS_SUB_MODULE_RB = 2, /*Ring Buffer */
|
||||
SYS_SUB_MODULE_BM = 3, /*Buffer Manager*/
|
||||
SYS_SUB_MODULE_MQ = 4, /*Message Queue*/
|
||||
SYS_SUB_MODULE_THREAD = 5,
|
||||
SYS_SUB_MODULE_BUTT
|
||||
}SYS_SUB_MODULE;
|
||||
|
||||
typedef enum tag_DRV_SUB_MODULE
|
||||
{
|
||||
DRV_SUB_MODULE_VIU = 1, /*Video In Unit*/
|
||||
DRV_SUB_MODULE_VOU = 2, /*Video Out Unit*/
|
||||
DRV_SUB_MODULE_DSU = 3, /*DS Unit*/
|
||||
DRV_SUB_MODULE_USB = 4, /*USB*/
|
||||
DRV_SUB_MODULE_SF = 5, /*Soft Switch*/
|
||||
DRV_SUB_MODULE_TDE = 6, /*2d accelarate */
|
||||
|
||||
DRV_SUB_MODULE_BUTT
|
||||
}DRV_SUB_MODULE;
|
||||
|
||||
typedef enum tag_MMF_SUB_MODULE
|
||||
{
|
||||
MMF_SUB_MODULE_INPUT = 1,
|
||||
MMF_SUB_MODULE_DEMUX = 2,
|
||||
MMF_SUB_MODULE_MUX = 3,
|
||||
MMF_SUB_MODULE_AO = 4,
|
||||
MMF_SUB_MODULE_VO = 5,
|
||||
MMF_SUB_MODULE_STREAM = 6,
|
||||
MMF_SUB_MODULE_VDEC = 7,
|
||||
MMF_SUB_MODULE_JB = 8,
|
||||
|
||||
MMF_SUB_MODULE_BUTT
|
||||
}MMF_SUB_MODULE;
|
||||
|
||||
typedef enum tag_APP_SUB_MODULE
|
||||
{
|
||||
APP_SUB_MODULE_VAPI = 1,
|
||||
|
||||
APP_SUB_MODULE_BUTT
|
||||
}APP_SUB_MODULE;
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __XMEDIA_MODULE_H__ */
|
||||
@@ -0,0 +1,51 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __XMEDIA_OS_H__
|
||||
#define __XMEDIA_OS_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#if defined(OS_LINUX)
|
||||
|
||||
#endif
|
||||
|
||||
#if defined(OS_WINCE)
|
||||
|
||||
#endif
|
||||
|
||||
#if defined(OS_WIN32)
|
||||
|
||||
#endif
|
||||
|
||||
#if defined(OS_LINUX)
|
||||
#define _UNUSED_FUNC __attribute__ ((unused))
|
||||
#define _UNUSED_VAR __attribute__ ((unused))
|
||||
|
||||
/*
|
||||
int xxx() _NOWARN_UNUSED;
|
||||
|
||||
int _NOWARN_UNUSED YYY()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
#define _NOWARN_UNUSED _UNUSED_FUNC
|
||||
#endif
|
||||
|
||||
#if defined(OS_VXWORKS)
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __XMEDIA_OS_H__ */
|
||||
@@ -0,0 +1,113 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#ifndef __XMEDIA_SPI_H__
|
||||
#define __XMEDIA_SPI_H__
|
||||
|
||||
#include <linux/ioctl.h>
|
||||
|
||||
/* User space versions of kernel symbols for SPI clocking modes,
|
||||
* matching <linux/spi/spi.h>
|
||||
*/
|
||||
|
||||
#define SPI_CPHA 0x01
|
||||
#define SPI_CPOL 0x02
|
||||
|
||||
#define SPI_MODE_0 (0|0)
|
||||
#define SPI_MODE_1 (0|SPI_CPHA)
|
||||
#define SPI_MODE_2 (SPI_CPOL|0)
|
||||
#define SPI_MODE_3 (SPI_CPOL|SPI_CPHA)
|
||||
|
||||
#define SPI_CS_HIGH 0x04
|
||||
#define SPI_LSB_FIRST 0x08
|
||||
#define SPI_3WIRE 0x10
|
||||
#define SPI_LOOP 0x20
|
||||
#define SPI_NO_CS 0x40
|
||||
#define SPI_READY 0x80
|
||||
|
||||
/*---------------------------------------------------------------------------*/
|
||||
|
||||
/* IOCTL commands */
|
||||
|
||||
#define SPI_IOC_MAGIC 'k'
|
||||
|
||||
/**
|
||||
* struct spi_ioc_transfer - describes a single SPI transfer
|
||||
* @tx_buf: Holds pointer to userspace buffer with transmit data, or null.
|
||||
* If no data is provided, zeroes are shifted out.
|
||||
* @rx_buf: Holds pointer to userspace buffer for receive data, or null.
|
||||
* @len: Length of tx and rx buffers, in bytes.
|
||||
* @speed_hz: Temporary override of the device's bitrate.
|
||||
* @bits_per_word: Temporary override of the device's wordsize.
|
||||
* @delay_usecs: If nonzero, how long to delay after the last bit transfer
|
||||
* before optionally deselecting the device before the next transfer.
|
||||
* @cs_change: True to deselect device before starting the next transfer.
|
||||
*
|
||||
* This structure is mapped directly to the kernel spi_transfer structure;
|
||||
* the fields have the same meanings, except of course that the pointers
|
||||
* are in a different address space (and may be of different sizes in some
|
||||
* cases, such as 32-bit i386 userspace over a 64-bit x86_64 kernel).
|
||||
* Zero-initialize the structure, including currently unused fields, to
|
||||
* accommodate potential future updates.
|
||||
*
|
||||
* SPI_IOC_MESSAGE gives userspace the equivalent of kernel spi_sync().
|
||||
* Pass it an array of related transfers, they'll execute together.
|
||||
* Each transfer may be half duplex (either direction) or full duplex.
|
||||
*
|
||||
* struct spi_ioc_transfer mesg[4];
|
||||
* ...
|
||||
* status = ioctl(fd, SPI_IOC_MESSAGE(4), mesg);
|
||||
*
|
||||
* So for example one transfer might send a nine bit command (right aligned
|
||||
* in a 16-bit word), the next could read a block of 8-bit data before
|
||||
* terminating that command by temporarily deselecting the chip; the next
|
||||
* could send a different nine bit command (re-selecting the chip), and the
|
||||
* last transfer might write some register values.
|
||||
*/
|
||||
struct spi_ioc_transfer {
|
||||
__u64 tx_buf;
|
||||
__u64 rx_buf;
|
||||
|
||||
__u32 len;
|
||||
__u32 speed_hz;
|
||||
|
||||
__u16 delay_usecs;
|
||||
__u8 bits_per_word;
|
||||
__u8 cs_change;
|
||||
__u32 pad;
|
||||
|
||||
/* If the contents of 'struct spi_ioc_transfer' ever change
|
||||
* incompatibly, then the ioctl number (currently 0) must change;
|
||||
* ioctls with constant size fields get a bit more in the way of
|
||||
* error checking than ones (like this) where that field varies.
|
||||
*
|
||||
* NOTE: struct layout is the same in 64bit and 32bit userspace.
|
||||
*/
|
||||
};
|
||||
|
||||
/* not all platforms use <asm-generic/ioctl.h> or _IOC_TYPECHECK() ... */
|
||||
#define SPI_MSGSIZE(N) \
|
||||
((((N)*(sizeof (struct spi_ioc_transfer))) < (1 << _IOC_SIZEBITS)) \
|
||||
? ((N)*(sizeof (struct spi_ioc_transfer))) : 0)
|
||||
#define SPI_IOC_MESSAGE(N) _IOW(SPI_IOC_MAGIC, 0, char[SPI_MSGSIZE(N)])
|
||||
|
||||
|
||||
/* Read / Write of SPI mode (SPI_MODE_0..SPI_MODE_3) */
|
||||
#define SPI_IOC_RD_MODE _IOR(SPI_IOC_MAGIC, 1, __u8)
|
||||
#define SPI_IOC_WR_MODE _IOW(SPI_IOC_MAGIC, 1, __u8)
|
||||
|
||||
/* Read / Write SPI bit justification */
|
||||
#define SPI_IOC_RD_LSB_FIRST _IOR(SPI_IOC_MAGIC, 2, __u8)
|
||||
#define SPI_IOC_WR_LSB_FIRST _IOW(SPI_IOC_MAGIC, 2, __u8)
|
||||
|
||||
/* Read / Write SPI device word length (1..N) */
|
||||
#define SPI_IOC_RD_BITS_PER_WORD _IOR(SPI_IOC_MAGIC, 3, __u8)
|
||||
#define SPI_IOC_WR_BITS_PER_WORD _IOW(SPI_IOC_MAGIC, 3, __u8)
|
||||
|
||||
/* Read / Write SPI device default max speed hz */
|
||||
#define SPI_IOC_RD_MAX_SPEED_HZ _IOR(SPI_IOC_MAGIC, 4, __u32)
|
||||
#define SPI_IOC_WR_MAX_SPEED_HZ _IOW(SPI_IOC_MAGIC, 4, __u32)
|
||||
|
||||
|
||||
|
||||
#endif /* __XMEDIA_SPI_H__ */
|
||||
@@ -0,0 +1,159 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __XMEDIA_THREAD_H__
|
||||
#define __XMEDIA_THREAD_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
#include <pthread.h>
|
||||
#include <semaphore.h>
|
||||
#include <bsp_defs.h>
|
||||
#include <stdio.h>
|
||||
|
||||
typedef pthread_mutex_t XMEDIA_THREAD_MUTEX ;
|
||||
typedef pthread_mutexattr_t XMEDIA_THREAD_MUTEXATTR;
|
||||
|
||||
typedef pthread_cond_t XMEDIA_THREAD_COND;
|
||||
typedef pthread_condattr_t XMEDIA_THREAD_CONDATTR;
|
||||
|
||||
typedef struct XMEDIA_SYNC_STRU
|
||||
{
|
||||
#if defined(SYNC_USE_COND)
|
||||
XMEDIA_THREAD_MUTEX _mutex;
|
||||
XMEDIA_THREAD_COND _cond;
|
||||
#else
|
||||
sem_t _sem;
|
||||
#endif
|
||||
}XMEDIA_SYNC_T;
|
||||
|
||||
#define MAX_THREAD_NAME_LEN 16
|
||||
|
||||
typedef int XMEDIA_PRIORITY_T;
|
||||
|
||||
typedef char THREAD_NAME[MAX_THREAD_NAME_LEN];
|
||||
|
||||
typedef VOID* (*THREAD_RUN)(VOID* );
|
||||
|
||||
typedef struct XMEDIA_THREAD_STRU
|
||||
{
|
||||
THREAD_NAME szThreadName;
|
||||
/**/
|
||||
pthread_t threadid;
|
||||
|
||||
pid_t pid;
|
||||
|
||||
XMEDIA_PRIORITY_T priority;
|
||||
|
||||
THREAD_RUN pf_run;
|
||||
|
||||
BOOL bStart;
|
||||
|
||||
XMEDIA_THREAD_COND cond_start;
|
||||
XMEDIA_THREAD_MUTEX mutex_cond_start;
|
||||
|
||||
VOID* args;
|
||||
}XMEDIA_THREAD_T;
|
||||
|
||||
EXTERNFUNC XMEDIA_RET bsp_thread_init(XMEDIA_THREAD_T *pThread, const char* szName,
|
||||
THREAD_RUN pf, INT32 priority, BOOL bStart);
|
||||
|
||||
VOID* bsp_thread_run_handle(VOID* arg);
|
||||
|
||||
EXTERNFUNC void bsp_delay(U32 ulUsDelay);
|
||||
|
||||
/*__wait is TRUE, not run when create , wait cond_start to run*/
|
||||
EXTERNFUNC INT32 bsp_thread_create(XMEDIA_THREAD_T *pThread,const pthread_attr_t*__attr,
|
||||
void*__arg);
|
||||
|
||||
EXTERNFUNC INT32 bsp_thread_join(XMEDIA_THREAD_T *pThread, void **thread_return);
|
||||
|
||||
EXTERNFUNC INT32 XMEDIA_THREAD_Start(XMEDIA_THREAD_T *pThread);
|
||||
|
||||
EXTERNFUNC INT32 bsp_thread_pause(XMEDIA_THREAD_T *pThread);
|
||||
|
||||
EXTERNFUNC INT32 bsp_thread_cancel(XMEDIA_THREAD_T *pThread);
|
||||
EXTERNFUNC VOID bsp_thread_setid(XMEDIA_THREAD_T *pThread);
|
||||
|
||||
EXTERNFUNC VOID bsp_thread_setpriority(XMEDIA_THREAD_T *pThread, XMEDIA_PRIORITY_T prio);
|
||||
|
||||
/*** ------------------------------------ ***/
|
||||
EXTERNFUNC INT32 bsp_thread_mutex_init(XMEDIA_THREAD_MUTEX* pMutex, XMEDIA_THREAD_MUTEXATTR* pMutexattr);
|
||||
|
||||
EXTERNFUNC INT32 bsp_thread_mutex_lock(XMEDIA_THREAD_MUTEX* pMutex);
|
||||
|
||||
EXTERNFUNC INT32 bsp_thread_mutex_trylock(XMEDIA_THREAD_MUTEX* pMutex);
|
||||
|
||||
EXTERNFUNC INT32 bsp_thread_mutex_unlock(XMEDIA_THREAD_MUTEX* pMutex);
|
||||
|
||||
EXTERNFUNC INT32 bsp_thread_mutex_destroy(XMEDIA_THREAD_MUTEX* pMutex);
|
||||
|
||||
/*** ------------------------------------ ***/
|
||||
EXTERNFUNC INT32 bsp_thread_cond_init(XMEDIA_THREAD_COND* pCond, XMEDIA_THREAD_CONDATTR* pCondattr);
|
||||
EXTERNFUNC INT32 bsp_thread_cond_signal(XMEDIA_THREAD_COND* pCond);
|
||||
EXTERNFUNC INT32 bsp_thread_cond_broadcast(XMEDIA_THREAD_COND* pCond);
|
||||
EXTERNFUNC INT32 bsp_thread_cond_wait(XMEDIA_THREAD_COND* pCond, XMEDIA_THREAD_MUTEX *pMutex, U32 msecs);
|
||||
EXTERNFUNC INT32 bsp_thread_cond_destroy(XMEDIA_THREAD_COND* pCond);
|
||||
|
||||
#define DEFAULT_PRIORITY 0
|
||||
#define THREAD_PRIORITY_AUDIO 0
|
||||
#define THREAD_PRIORITY_AZ 10
|
||||
|
||||
#define THREAD_SLEEP(msec) usleep(msec * 1000)
|
||||
/*#define THREAD_SLEEP(msec) */
|
||||
|
||||
/*** -------------------------------------***/
|
||||
EXTERNFUNC XMEDIA_RET bsp_sync_create(IO XMEDIA_SYNC_T *pWait);
|
||||
EXTERNFUNC XMEDIA_RET bsp_sync_wait(IO XMEDIA_SYNC_T *pWait, IN U32 msec);
|
||||
EXTERNFUNC XMEDIA_RET bsp_sync_notify(IO XMEDIA_SYNC_T *pWait);
|
||||
EXTERNFUNC XMEDIA_RET bsp_sync_destroy(IO XMEDIA_SYNC_T *pWait);
|
||||
|
||||
#if defined(DEBUG)
|
||||
#define SYNC_WAIT(pSync, msec, pStr) \
|
||||
if (pStr) \
|
||||
WRITE_LOG_DEBUG(pStr); \
|
||||
bsp_sync_wait(pSync, msec)
|
||||
|
||||
#define SYNC_NOTIFY(pSync, msec, pStr) \
|
||||
if (pStr) \
|
||||
WRITE_LOG_DEBUG(pStr); \
|
||||
bsp_sync_notify(pSync)
|
||||
#else
|
||||
#define SYNC_WAIT(pSync, msec, pStr) \
|
||||
bsp_sync_wait(pSync, msec)
|
||||
|
||||
#define SYNC_NOTIFY(pSync, msec, pStr) \
|
||||
bsp_sync_notify(pSync)
|
||||
#endif
|
||||
|
||||
/*__wait is TRUE, not run when create , wait cond_start to run*/
|
||||
#define XMEDIA_THREAD_CREATE (pThread, __attr, __arg)\
|
||||
bsp_thread_create(pThread, __attr, __arg)
|
||||
|
||||
#define XMEDIA_THREAD_JOIN(pThread, ppthread_return) \
|
||||
bsp_thread_join(pThread, ppthread_return)
|
||||
|
||||
#define XMEDIA_THREAD_START(pThread) \
|
||||
XMEDIA_THREAD_Start(pThread)
|
||||
|
||||
#define XMEDIA_THREAD_PAUSE(pThread) \
|
||||
bsp_thread_pause(pThread)
|
||||
|
||||
#define XMEDIA_THREAD_SETID(pThread) \
|
||||
bsp_thread_setid(pThread)
|
||||
|
||||
#define XMEDIA_THREAD_SETPRIORITY(pThread ,prio) \
|
||||
bsp_thread_setpriority(pThread ,prio)
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __XMEDIA_THREAD_H__ */
|
||||
|
||||
@@ -0,0 +1,157 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
/*
|
||||
*/
|
||||
#ifndef __XMEDIA_TYPE_H__
|
||||
#define __XMEDIA_TYPE_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#if !defined( OS_VXWORKS) /* there is a same typedef in vxworks for U8 */
|
||||
typedef unsigned char U8;
|
||||
#endif
|
||||
typedef unsigned short U16;
|
||||
typedef unsigned long U32;
|
||||
typedef unsigned long long U64;
|
||||
|
||||
typedef char S8;
|
||||
typedef short S16;
|
||||
typedef long S32;
|
||||
typedef long long S64;
|
||||
|
||||
typedef char INT8;
|
||||
typedef short INT16;
|
||||
typedef int INT32;
|
||||
typedef char CHAR;
|
||||
typedef char* PCHAR;
|
||||
#if 0
|
||||
typedef U8 B8;
|
||||
typedef U16 B16;
|
||||
typedef U32 B32;
|
||||
#endif
|
||||
|
||||
typedef float FLOAT;
|
||||
typedef double DOUBLE;
|
||||
typedef void VOID;
|
||||
typedef unsigned char UCHAR;
|
||||
typedef unsigned char UINT8;
|
||||
typedef unsigned short UINT16;
|
||||
typedef unsigned long UINT32;
|
||||
typedef unsigned long ULONG;
|
||||
|
||||
typedef U16 ZWORD;
|
||||
typedef U32 ZDWORD;
|
||||
typedef U32 ZLENGTH;
|
||||
typedef U32 ZSIZE;
|
||||
|
||||
#define LEN_Z2C(len) (len+len)
|
||||
|
||||
#define LEN_C2Z(len) (len >> 1)
|
||||
typedef unsigned long PHY_ADDR;
|
||||
typedef unsigned long VADDR;
|
||||
|
||||
typedef void* PVOID;
|
||||
typedef void* PTR;
|
||||
|
||||
#define INVALID_ADDR 0
|
||||
/*File descriptor*/
|
||||
typedef int FD;
|
||||
|
||||
typedef unsigned long LENGTH_T;
|
||||
typedef unsigned long size_type;
|
||||
typedef unsigned long SIZE_T;
|
||||
typedef unsigned long COUNT_T;
|
||||
|
||||
#if !defined(OFF_T)
|
||||
typedef unsigned long OFF_T ;
|
||||
#endif
|
||||
|
||||
typedef long SOFF_T;//by hhm
|
||||
|
||||
typedef unsigned long XMEDIA_RET;
|
||||
|
||||
#define MAX_FILENAME_LENGTH 128
|
||||
typedef char FILENAME_T[MAX_FILENAME_LENGTH];
|
||||
|
||||
typedef char CHECKNAME_T[32];
|
||||
typedef char IPADDRESS_T[32]; //add by ququ
|
||||
|
||||
/*#define EMPTY_VAR U32 null_var*/
|
||||
#define EMPTY_VAR unsigned int xyz
|
||||
|
||||
/* Vxworks defined BOOL type */
|
||||
#if !defined(BOOL) && !defined(OS_VXWORKS)
|
||||
#define BOOL U8
|
||||
#endif
|
||||
|
||||
#ifdef TRUE
|
||||
#undef TRUE
|
||||
#endif
|
||||
#define TRUE 0x1
|
||||
|
||||
#ifdef FALSE
|
||||
#undef FALSE
|
||||
#endif
|
||||
#define FALSE 0x0L
|
||||
|
||||
#define YES 0x1
|
||||
#define NO 0x0L
|
||||
|
||||
#ifndef NULL
|
||||
#define NULL (U32)0x0L
|
||||
#endif
|
||||
|
||||
/* *DO NOT* type like : if(XMEDIA_OK)*/
|
||||
#define XMEDIA_OK 0
|
||||
#define XMEDIA_ERROR (1)
|
||||
|
||||
#define XMEDIA_SUCCESS 0
|
||||
#define XMEDIA_FAILURE 1
|
||||
|
||||
#define XMEDIA_RET_NOT_DEFINED 0
|
||||
|
||||
#define AV_MALLOC(sizeLen) malloc(sizeLen)
|
||||
#define AV_MALLOC_ALIGN(ucAlign, sizeLen) malloc(sizeLen)
|
||||
|
||||
typedef void* AV_PTR;
|
||||
typedef void* VIDEO_PTR;
|
||||
typedef void* AUDIO_PTR;
|
||||
|
||||
#ifndef MAXPATHLEN
|
||||
#define MAXPATHLEN 1024
|
||||
#endif
|
||||
|
||||
/*typedef char[MAXPATHLEN] FILENAME_T;*/
|
||||
|
||||
#define MAX_POOL_NAME_LEN 16
|
||||
typedef char POOL_NAME[MAX_POOL_NAME_LEN];
|
||||
|
||||
typedef unsigned long long PTS_TIME;
|
||||
|
||||
typedef struct PVADDR_STRU
|
||||
{
|
||||
VOID* pvAddr;/*point of virtual address*/
|
||||
PHY_ADDR phyAddr; /*phy address*/
|
||||
}PVADDR_T;
|
||||
|
||||
typedef struct ADDRINFO_STRU
|
||||
{
|
||||
PHY_ADDR phyAddrStart;
|
||||
SIZE_T sizeAddr;
|
||||
}ADDRINFO_T;
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __XMEDIA_TYPE_H__ */
|
||||
@@ -0,0 +1,22 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef XMEDIA_LIMIT_H__
|
||||
#define XMEDIA_LIMIT_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
#include <unistd.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* XMEDIA_LIMIT_H__ */
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __XMEDIA_VERSION_H__
|
||||
#define __XMEDIA_VERSION_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#include <stdio.h>
|
||||
typedef unsigned long XMEDIA_VERSION_T;
|
||||
|
||||
/*
|
||||
Version define
|
||||
31 24 23 16 15 0
|
||||
-----------------------------------------------
|
||||
| major | minor | build number |
|
||||
-----------------------------------------------
|
||||
*/
|
||||
|
||||
#define VERSION_CODE(major, minor, build) \
|
||||
( ((major) << 24) | ((minor) << 16) | (build) )
|
||||
|
||||
#define VERSION_CODE_MAJOR(v) ((v) >> 24)
|
||||
#define VERSION_CODE_MINOR(v) (((v) >> 16) & 0xFF)
|
||||
#define VERSION_CODE_BUILD(v) ((v) & 0xFFFF )
|
||||
|
||||
#define MMPLIB_VER_MAJOR 0L
|
||||
#define MMPLIB_VER_MINOR 6L
|
||||
#define MMPLIB_VER_BUILD 0106L
|
||||
#define MMPLIB_BUILD_DATE "20060415-V100ITr1"
|
||||
|
||||
#define MMPLIB_VER_EXTFLAG 0
|
||||
|
||||
#define GET_MMPLIB_VER VERSION_CODE(MMPLIB_VER_MAJOR, MMPLIB_VER_MINOR,MMPLIB_VER_BUILD )
|
||||
|
||||
#define VERSTF_SIZE 64
|
||||
static inline const char* MMPLIB_VER_STR()
|
||||
{
|
||||
static char verstr[VERSTF_SIZE];
|
||||
sprintf(verstr, "%02lu.%02lu.%04lu build:%s",
|
||||
MMPLIB_VER_MAJOR,
|
||||
MMPLIB_VER_MINOR,
|
||||
MMPLIB_VER_BUILD,
|
||||
MMPLIB_BUILD_DATE
|
||||
);
|
||||
return ( (char*)verstr );
|
||||
}
|
||||
|
||||
static inline const char* bsp_version_str(XMEDIA_VERSION_T v)
|
||||
{
|
||||
static char verstr[VERSTF_SIZE];
|
||||
sprintf(verstr, "%02lu.%02lu.%04lu ",
|
||||
VERSION_CODE_MAJOR(v),
|
||||
VERSION_CODE_MINOR(v),
|
||||
VERSION_CODE_BUILD(v)
|
||||
);
|
||||
return verstr;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __XMEDIA_VERSION_H__ */
|
||||
@@ -0,0 +1,19 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef _GPIO_I2C_H
|
||||
#define _GPIO_I2C_H
|
||||
|
||||
|
||||
#define GPIO_I2C_READ 0x01
|
||||
#define GPIO_I2C_WRITE 0x03
|
||||
typedef unsigned char byte;
|
||||
|
||||
unsigned char gpio_i2c_read(unsigned char devaddress, unsigned char address);
|
||||
void gpio_i2c_write(unsigned char devaddress, unsigned char address, unsigned char value);
|
||||
byte siiReadSegmentBlockEDID(byte SlaveAddr, byte Segment, byte Offset, byte *Buffer, byte Length);
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef _UAPI_LINUX_I2C_DEV_H
|
||||
#define _UAPI_LINUX_I2C_DEV_H
|
||||
|
||||
/* /dev/i2c-X ioctl commands. The ioctl's parameter is always an
|
||||
* unsigned long, except for:
|
||||
* - I2C_FUNCS, takes pointer to an unsigned long
|
||||
* - I2C_RDWR, takes pointer to struct i2c_rdwr_ioctl_data
|
||||
* - I2C_SMBUS, takes pointer to struct i2c_smbus_ioctl_data
|
||||
*/
|
||||
#define I2C_RETRIES 0x0701 /* number of times a device address should
|
||||
be polled when not acknowledging */
|
||||
#define I2C_TIMEOUT 0x0702 /* set timeout in units of 10 ms */
|
||||
|
||||
/* NOTE: Slave address is 7 or 10 bits, but 10-bit addresses
|
||||
* are NOT supported! (due to code brokenness)
|
||||
*/
|
||||
#define I2C_SLAVE 0x0703 /* Use this slave address */
|
||||
#define I2C_SLAVE_FORCE 0x0706 /* Use this slave address, even if it
|
||||
is already in use by a driver! */
|
||||
#define I2C_TENBIT 0x0704 /* 0 for 7 bit addrs, != 0 for 10 bit */
|
||||
|
||||
#define I2C_FUNCS 0x0705 /* Get the adapter functionality mask */
|
||||
|
||||
#define I2C_RDWR 0x0707 /* Combined R/W transfer (one STOP only) */
|
||||
|
||||
#define I2C_PEC 0x0708 /* != 0 to use PEC with SMBus */
|
||||
#define I2C_SMBUS 0x0720 /* SMBus transfer */
|
||||
#define I2C_16BIT_REG 0x0709 /* 16BIT REG WIDTH */
|
||||
#define I2C_16BIT_DATA 0x070a /* 16BIT DATA WIDTH */
|
||||
|
||||
/* This is the structure as used in the I2C_RDWR ioctl call */
|
||||
struct i2c_rdwr_ioctl_data {
|
||||
struct i2c_msg *msgs; /* pointers to i2c_msgs */
|
||||
__u32 nmsgs; /* number of i2c_msgs */
|
||||
};
|
||||
|
||||
#define I2C_RDRW_IOCTL_MAX_MSGS 42
|
||||
|
||||
|
||||
#endif /* _UAPI_LINUX_I2C_DEV_H */
|
||||
@@ -0,0 +1,22 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __MMPVER_H__
|
||||
#define __MMPVER_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
USE_GLOBALVAR XMEDIA_VERSION_T g_mmplib_ver;
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __MMPVER_H__ */
|
||||
@@ -0,0 +1,56 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef ARGPARSER_H__
|
||||
#define ARGPARSER_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#define ERR_ARG_WRONG_FMT 2 /* format error */
|
||||
#define ERR_ARG_UNKOWN_ARG 3 /* Undefined arg*/
|
||||
#define ERR_ARG_NOT_DEFINE_NO_OPT 4/* Undefined NO_OPT Type */
|
||||
#define ERR_ARG_MULTI_NO_OPT 5/* Undefined NO_OPT Type */
|
||||
|
||||
enum ARG_TYPE
|
||||
{
|
||||
ARG_TYPE_NO_OPT = 0, /* lack of opt, only single one arg */
|
||||
ARG_TYPE_CHAR = 1, /* char */
|
||||
ARG_TYPE_STRING = 2, /* string */
|
||||
ARG_TYPE_INT = 3, /* integer */
|
||||
ARG_TYPE_FLOAT = 4, /* float */
|
||||
ARG_TYPE_SINGLE = 5, /* single, no parm */
|
||||
ARG_TYPE_HELP = 6,
|
||||
ARG_TYPE_END
|
||||
};
|
||||
|
||||
typedef struct ARGOpt_stru
|
||||
{
|
||||
//CHAR opt;
|
||||
CHAR* sz_opt;
|
||||
CHAR type;
|
||||
CHAR isSet; /*1: be set, 0 not set*/
|
||||
CHAR resv;
|
||||
CHAR *pHelpMsg;
|
||||
void *pValue;
|
||||
}ARGOpt_t;
|
||||
|
||||
EXTERNFUNC XMEDIA_RET ARGParser(int argc, char **argv, ARGOpt_t *opts);
|
||||
EXTERNFUNC VOID ARGPrintOpt(ARGOpt_t *pOpt);
|
||||
|
||||
EXTERNFUNC VOID StrToArg(CHAR* pSrc, int* argc, CHAR** argv);
|
||||
EXTERNFUNC VOID ARGClearOpts(ARGOpt_t *opts);
|
||||
EXTERNFUNC VOID ARGPrintHelp(ARGOpt_t *opts);
|
||||
|
||||
#define ARGHelpStrHead "\t"
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* ARGPARSER_H__ */
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __BTOOLS_H__
|
||||
#define __BTOOLS_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
XMEDIA_RET xmmc(int argc , char* argv[]);
|
||||
|
||||
XMEDIA_RET xmmd_l(int argc , char* argv[]);
|
||||
|
||||
XMEDIA_RET xmmd(int argc , char* argv[]);
|
||||
|
||||
XMEDIA_RET xmmm(int argc , char* argv[]);
|
||||
|
||||
XMEDIA_RET bsper(int argc , char* argv[]);
|
||||
|
||||
XMEDIA_RET bspew(int argc , char* argv[]);
|
||||
|
||||
XMEDIA_RET i2c_read(int argc , char* argv[]);
|
||||
|
||||
XMEDIA_RET i2c_write(int argc , char* argv[]);
|
||||
|
||||
XMEDIA_RET ssp_read(int argc , char* argv[]);
|
||||
|
||||
XMEDIA_RET ssp_write(int argc , char* argv[]);
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __BTOOLS_H__ */
|
||||
@@ -0,0 +1,79 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef CMDSHELL_H__
|
||||
#define CMDSHELL_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
/*///////////////////////////////////////*/
|
||||
/*main function style*/
|
||||
|
||||
#define ERR_CMD_SHELL_NULL_CMD 2
|
||||
#define ERR_CMD_SHELL_NULL_FP 3
|
||||
|
||||
#define MAX_CMDSHELL_STRING_LEN 16
|
||||
typedef XMEDIA_RET (*cmd_func)(int , char **);
|
||||
|
||||
#define CMD_ENABLE 1
|
||||
#define CMD_DISABLE 0
|
||||
|
||||
typedef char CMDSHELL_STR[MAX_CMDSHELL_STRING_LEN] ;
|
||||
|
||||
typedef struct CMDSHELL_STRU
|
||||
{
|
||||
char *cmdstr;
|
||||
U32 isEnable;
|
||||
cmd_func pFunc;
|
||||
char *helpstr;
|
||||
}CMD_SHELL_T;
|
||||
|
||||
#define CMD_SHELL_DEF(cmdstr,isEnable, pf, helpmsg) {cmdstr,isEnable, pf, helpmsg},
|
||||
|
||||
/*
|
||||
cmdstrs : Whole
|
||||
*/
|
||||
/*
|
||||
CMD_SHELL_T *CMD_SHELL_Search(IN char* cmdstr,
|
||||
IN CMD_SHELL_T* pCmds,
|
||||
IN COUNT_T max_cmds
|
||||
);
|
||||
*/
|
||||
|
||||
CMD_SHELL_T *CMD_SHELL_Search(IN char* cmdstr,
|
||||
IN CMD_SHELL_T* pCmds
|
||||
);
|
||||
|
||||
int CMD_SHELL_Run(CMD_SHELL_T* pCmd, int argc, char** argv);
|
||||
|
||||
/* Enter the whole series of commands */
|
||||
int CMD_SHELL_RUN(char* cmdstrs, const CMD_SHELL_T *pCmds);
|
||||
|
||||
/* If input parm is command line, transfer Parm from mian immediatly */
|
||||
int CMD_SHELL_RUN_2(int argc, char* argv[], const CMD_SHELL_T *pCmds);
|
||||
|
||||
#define CMD_SHELL_PRINT_CMDSTRS(xargc, xargv) \
|
||||
do \
|
||||
{ \
|
||||
int i = 0; \
|
||||
char x[128]; \
|
||||
memset(x, 0, 128); \
|
||||
for (i = 0; i< xargc;i++) \
|
||||
{ \
|
||||
sprintf(x, "%s %s ",x, xargv[i]); \
|
||||
} \
|
||||
printf(" argc: %d, argv:<%s>\n", xargc, x); \
|
||||
}while(0)
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* CMDSHELL_H__ */
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
/* linux /dev/mem mmap support head file */
|
||||
/* */
|
||||
/* */
|
||||
/* Copyright 2021 CJiang com. */
|
||||
/* Create date: 2021-01-07 */
|
||||
/* Modify bspstory */
|
||||
/* */
|
||||
|
||||
#ifndef __MEM_MAP_H__
|
||||
#define __MEM_MAP_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
extern void * memmap(unsigned long phy_addr, unsigned long size);
|
||||
extern int memunmap(void * addr_mapped);
|
||||
extern void * mmapfile(char* fn, unsigned int size);
|
||||
extern void * mmapfile_r(char* fn, unsigned int size);
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __STAT_H__
|
||||
#define __STAT_H__
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#ifdef STAT
|
||||
|
||||
typedef struct
|
||||
{
|
||||
time_t StartTime;
|
||||
time_t EndTime;
|
||||
}TimeVal_t;
|
||||
|
||||
typedef enum STAT_ITEM_ENUM
|
||||
{
|
||||
E_VEnc_SendFrames,
|
||||
E_VEnc_RecvPackets,
|
||||
E_VEnc_RecvEncdata,
|
||||
E_VEnc_Rtp_SendPackets,
|
||||
E_VEnc_Rtp_SendBytes,
|
||||
|
||||
E_VDec_SendPackets,
|
||||
E_VDec_RecvFrames,
|
||||
E_VDec_RecvDecdata,
|
||||
E_VDec_Rtp_RecvPackets,
|
||||
E_VDec_Rtp_RecvBytes,
|
||||
E_VDec_Rtp_Discarded,
|
||||
|
||||
E_Voice_SendPackets,
|
||||
E_Voice_RecvFrames,
|
||||
E_Voice_ResendTimes,
|
||||
E_Voice_Rtp_SendPackets,
|
||||
E_Voice_Rtp_SendBytes,
|
||||
E_Voice_Rtp_RecvPackets,
|
||||
E_Voice_Rtp_RecvBytes,
|
||||
E_Voice_Rtp_Discarded,
|
||||
|
||||
E_STAT_ITEM_END
|
||||
}STAT_ITEM_E;
|
||||
|
||||
typedef enum STAT_TYPE_ENUM
|
||||
{
|
||||
STAT_AUDIODEC = 1,
|
||||
STAT_AUDIOENC = 2,
|
||||
STAT_VIDEODEC = 3,
|
||||
STAT_VIDEOENC = 4,
|
||||
STAT_VOICE = 5,
|
||||
|
||||
STAT_TYPE_MAX
|
||||
}STAT_TYPE_E;
|
||||
|
||||
|
||||
|
||||
extern VOID stat_init();
|
||||
extern VOID stat_rtp_discarded(STAT_ITEM_E t, U16 seq, U16 prev_seq);
|
||||
extern VOID stat_calc(STAT_ITEM_E t, U32 value);
|
||||
extern VOID stat_time_start(STAT_TYPE_E t);
|
||||
extern VOID stat_print(STAT_TYPE_E t);
|
||||
|
||||
extern VOID stat_print_venc(int argc, char* argv[]);
|
||||
extern VOID stat_print_vdec(int argc, char* argv[]);
|
||||
extern VOID stat_print_voice(int argc, char* argv[]);
|
||||
|
||||
#define STAT_CALC(t, value) stat_calc(t, value)
|
||||
#define STAT_INIT() stat_init()
|
||||
#define STAT_TIME_STAT(t) stat_time_start(t)
|
||||
#define STAT_RTP_DISCARDED(t, seq, prev_seq) stat_rtp_discarded(t, seq, prev_seq)
|
||||
#define STAT_PRINT_VENC(argc, argv ) stat_print_venc(argc, argv )
|
||||
#define STAT_PRINT_VDEC(argc, argv ) stat_print_vdec(argc, argv )
|
||||
#define STAT_PRINT_VOICE(argc, argv ) stat_print_voice(argc, argv )
|
||||
#else
|
||||
|
||||
#define STAT_CALC(t, value)
|
||||
#define STAT_INIT()
|
||||
#define STAT_TIME_STAT(t)
|
||||
#define STAT_RTP_DISCARDED(t, seq, prev_seq)
|
||||
#define STAT_PRINT_VENC(argc, argv )
|
||||
#define STAT_PRINT_VDEC(argc, argv )
|
||||
#define STAT_PRINT_VOICE(argc, argv )
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
|
||||
#endif /* __STAT_H__ */
|
||||
@@ -0,0 +1,25 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef __STRFUNC_H__
|
||||
#define __STRFUNC_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#define STRFMT_ADDR32 "%#010lX"
|
||||
#define STRFMT_ADDR32_2 "0x%08lX"
|
||||
|
||||
EXTERNFUNC XMEDIA_RET StrToNumber(IN CHAR *str , OUT U32 * ulValue);
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif /* __STRFUNC_H__ */
|
||||
@@ -0,0 +1,191 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <limits.h>
|
||||
#include <stdlib.h>
|
||||
#include "bsp.h"
|
||||
#include "memmap.h"
|
||||
|
||||
#define MAX_ROW (0x8000000) /* =max_len/16 */
|
||||
|
||||
/*memory dump*/
|
||||
XMEDIA_RET bsp_md(IN VOID* pStart, IN U32 ulLen, IN FD fd)
|
||||
{
|
||||
if (NULL == pStart) {
|
||||
return ERR_GEN_INVALID_POINTER;
|
||||
}
|
||||
|
||||
size_t wl = write(fd, pStart, ulLen);
|
||||
if (wl != ulLen) {
|
||||
WRITE_LOG_DEBUG("Dump memory error!wish len: %u, dump len:%u\n", ulLen, wl);
|
||||
}
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
/*Memory Dump 2 file*/
|
||||
XMEDIA_RET bsp_md2file(IN VOID* pStart, IN U32 ulLen, IN const char* strLabel, IN char* fn)
|
||||
{
|
||||
char path[PATH_MAX + 1] = {0x00};
|
||||
|
||||
if (NULL == fn || NULL == pStart) {
|
||||
return ERR_GEN_INVALID_POINTER;
|
||||
}
|
||||
|
||||
if ((strlen(fn) > PATH_MAX) || (NULL == realpath(fn, path))) {
|
||||
printf("error: input path error.\n");
|
||||
return ERR_GEN_INVALID_POINTER;
|
||||
}
|
||||
|
||||
FILE* fMd = fopen(path, "a");
|
||||
if (NULL == fMd) {
|
||||
WRITE_LOG_DEBUG("Open File %s to dump memory error.\n", fn);
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
if (strLabel) {
|
||||
fwrite(strLabel, strlen(strLabel), 1, fMd);
|
||||
}
|
||||
fwrite(pStart, ulLen, 1, fMd);
|
||||
fclose(fMd);
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
VOID bsp_hexdump(OUT FILE* stream, IN const void* src, IN size_t len, IN size_t width)
|
||||
{
|
||||
unsigned int rows, pos, c, i;
|
||||
const unsigned char* start = NULL;
|
||||
const unsigned char* rowpos = NULL;
|
||||
const unsigned char* data = NULL;
|
||||
|
||||
if (width == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
data = src;
|
||||
start = data;
|
||||
pos = 0;
|
||||
rows = (len % width) == 0 ? len / width : len / width + 1;
|
||||
for (i = 0; i < rows; i++) {
|
||||
rowpos = data;
|
||||
fprintf(stream, "%05x: ", pos);
|
||||
do {
|
||||
c = *data++ & 0xff;
|
||||
if ((size_t)(data - start) <= len) {
|
||||
fprintf(stream, " %02x", c);
|
||||
} else {
|
||||
fprintf(stream, " ");
|
||||
}
|
||||
} while (((data - rowpos) % width) != 0);
|
||||
|
||||
fprintf(stream, " |");
|
||||
data -= width;
|
||||
do {
|
||||
c = *data++;
|
||||
if (isprint(c) == 0 || c == '\t') {
|
||||
c = '.';
|
||||
}
|
||||
if ((size_t)(data - start) <= len) {
|
||||
fprintf(stream, "%c", c);
|
||||
} else {
|
||||
fprintf(stream, " ");
|
||||
}
|
||||
} while (((data - rowpos) % width) != 0);
|
||||
fprintf(stream, "|\n");
|
||||
pos += width;
|
||||
}
|
||||
fflush(stream);
|
||||
}
|
||||
|
||||
VOID bsp_hexdump2(OUT FILE* stream, IN const void* src, IN size_t len, IN size_t width)
|
||||
{
|
||||
unsigned int c, i, rows;
|
||||
const unsigned int* rowpos = NULL;
|
||||
const unsigned int* data = NULL;
|
||||
|
||||
if (width == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
data = src;
|
||||
rows = (len % width) == 0 ? len / width : len / width + 1;
|
||||
|
||||
if (MAX_ROW < rows) {
|
||||
printf("error:Input param(len) is greater than 2GB!\n");
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < rows; i++) {
|
||||
rowpos = data;
|
||||
fprintf(stream, "%04x: ", i * 0x10);
|
||||
do {
|
||||
c = *data++;
|
||||
fprintf(stream, " %08x", c);
|
||||
} while (((data - rowpos) % 4) != 0);
|
||||
fprintf(stream, "\n");
|
||||
}
|
||||
fflush(stream);
|
||||
}
|
||||
|
||||
VOID bsp_hexdump_log(IN const void* src, IN size_t len, IN size_t width)
|
||||
{
|
||||
if (LOG_GETLEVEL() < LOG_LEVEL_DEBUG2)
|
||||
return;
|
||||
|
||||
unsigned int rows, pos, c, i;
|
||||
const unsigned char* start = NULL;
|
||||
const unsigned char* rowpos = NULL;
|
||||
const unsigned char* data = NULL;
|
||||
|
||||
if (width == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
data = src;
|
||||
start = data;
|
||||
pos = 0;
|
||||
rows = (len % width) == 0 ? len / width : len / width + 1;
|
||||
for (i = 0; i < rows; i++) {
|
||||
rowpos = data;
|
||||
WRITE_LOG_NORMAL("%05x: ", pos);
|
||||
do {
|
||||
c = *data++ & 0xff;
|
||||
if ((size_t)(data - start) <= len) {
|
||||
WRITE_LOG_NORMAL(" %02x", c);
|
||||
} else {
|
||||
WRITE_LOG_NORMAL(" ");
|
||||
}
|
||||
} while (((data - rowpos) % width) != 0);
|
||||
|
||||
WRITE_LOG_NORMAL(" |");
|
||||
data -= width;
|
||||
do {
|
||||
c = *data++;
|
||||
if (isprint(c) == 0 || c == '\t') {
|
||||
c = '.';
|
||||
}
|
||||
if ((size_t)(data - start) <= len) {
|
||||
WRITE_LOG_NORMAL("%c", c);
|
||||
} else {
|
||||
WRITE_LOG_NORMAL(" ");
|
||||
}
|
||||
} while (((data - rowpos) % width) != 0);
|
||||
WRITE_LOG_NORMAL("|\n");
|
||||
pos += width;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
@@ -0,0 +1,164 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
extern "C"{
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <unistd.h>
|
||||
#include <pthread.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "bsp.h"
|
||||
#include "bsp_message.h"
|
||||
|
||||
|
||||
DECLARE_GLOBALVAR LOG_QUEUE gLogQueue;
|
||||
static const char *gppsz_type[] =
|
||||
{
|
||||
" ","[fatal]:", "[error]:", "[warn]:",
|
||||
"[info]:", "[debug]:" , "[debug1]:", "[debug2]:"
|
||||
};
|
||||
|
||||
LOCALFUNC VOID Log_PrintMsg (IO LOG_QUEUE* pLogQueue,IN U32 ucLogLevel,
|
||||
IN const char *psz_format,IN va_list _args );
|
||||
|
||||
#if defined(MULTI_TASK_LOGQUEUE)
|
||||
LOCALFUNC VOID Log_InitLock(IO LOG_QUEUE* pLogQueue);
|
||||
LOCALFUNC S32 Log_Lock(IO LOG_QUEUE* pLogQueue);
|
||||
LOCALFUNC S32 Log_Unlock(IO LOG_QUEUE* pLogQueue);
|
||||
LOCALFUNC VOID Log_DestroyLock(IO LOG_QUEUE* pLogQueue);
|
||||
|
||||
/*-------- Lock Function , Maybe Replace later ---*/
|
||||
|
||||
|
||||
LOCALFUNC S32 Log_Lock(IO LOG_QUEUE* pLogQueue)
|
||||
{
|
||||
#if defined(OS_LINUX)
|
||||
return pthread_mutex_lock(&(pLogQueue->mutex_lock));
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
LOCALFUNC S32 Log_Unlock(IO LOG_QUEUE* pLogQueue)
|
||||
{
|
||||
#if defined(OS_LINUX)
|
||||
return pthread_mutex_unlock(&(pLogQueue->mutex_lock));
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
LOCALFUNC VOID Log_InitLock(IO LOG_QUEUE* pLogQueue)
|
||||
{
|
||||
#if defined(OS_LINUX)
|
||||
pthread_mutex_init(&pLogQueue->mutex_lock, NULL);
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
LOCALFUNC VOID Log_DestroyLock(IO LOG_QUEUE* pLogQueue)
|
||||
{
|
||||
Log_Unlock(pLogQueue);
|
||||
#if defined(OS_LINUX)
|
||||
pthread_mutex_destroy( &pLogQueue->mutex_lock );
|
||||
#else
|
||||
#endif
|
||||
}
|
||||
|
||||
#else
|
||||
#define Log_Lock(p)
|
||||
#define Log_Unlock(p)
|
||||
#define Log_InitLock(p)
|
||||
#define Log_DestroyLock(p)
|
||||
#endif
|
||||
|
||||
/* --------- Message Functions -----*/
|
||||
XMEDIA_RET Log_Create(IO LOG_QUEUE* pLogQueue, IN U8 minLevel , IN LENGTH_T lenMsg)
|
||||
{
|
||||
DBG_ASSERT(pLogQueue);
|
||||
Log_InitLock(pLogQueue);
|
||||
pLogQueue->ucMinLevel = minLevel;
|
||||
pLogQueue->lenMsg = lenMsg;
|
||||
if (lenMsg <= 0)
|
||||
{
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
pLogQueue->pMsg = malloc(lenMsg);
|
||||
if (NULL == pLogQueue->pMsg)
|
||||
{
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
VOID Log_Destroy(IO LOG_QUEUE* pLogQueue )
|
||||
{
|
||||
DBG_ASSERT(pLogQueue);
|
||||
free(pLogQueue->pMsg);
|
||||
Log_DestroyLock(pLogQueue);
|
||||
pLogQueue->pMsg = NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
VOID Log_Msg(IO LOG_QUEUE* pLogQueue,IN U32 ucLogLevel,
|
||||
IN char *psz_format, ... )
|
||||
{
|
||||
DBG_ASSERT(pLogQueue);
|
||||
|
||||
if (pLogQueue->ucMinLevel < ucLogLevel)
|
||||
{
|
||||
return;
|
||||
}
|
||||
va_list args;
|
||||
|
||||
va_start( args, psz_format );
|
||||
Log_PrintMsg( pLogQueue, ucLogLevel, psz_format, args );
|
||||
va_end( args );
|
||||
}
|
||||
|
||||
VOID Log_MsgVa(IO LOG_QUEUE* pLogQueue,IN U32 ucLogLevel,
|
||||
IN const char *psz_format, IN va_list args )
|
||||
{
|
||||
Log_PrintMsg( pLogQueue, ucLogLevel, psz_format, args );
|
||||
}
|
||||
|
||||
/* following functions are local */
|
||||
|
||||
static VOID Log_PrintMsg (IO LOG_QUEUE* pLogQueue,IN U32 ucLogLevel,
|
||||
IN const char *psz_format,IN va_list _args )
|
||||
{
|
||||
|
||||
va_list args;
|
||||
Log_Lock(pLogQueue);
|
||||
va_copy( args, _args );
|
||||
vsnprintf(pLogQueue->pMsg, pLogQueue->lenMsg, psz_format, args);
|
||||
va_end( args );
|
||||
pLogQueue->pMsg[ pLogQueue->lenMsg - 1 ] = 0;
|
||||
|
||||
if (ucLogLevel)
|
||||
fprintf( STDOUT, "%s %s", gppsz_type[ucLogLevel], pLogQueue->pMsg);
|
||||
else
|
||||
fprintf( STDOUT, "%s", pLogQueue->pMsg);
|
||||
|
||||
Log_Unlock(pLogQueue);
|
||||
|
||||
fflush(STDOUT);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* __cplusplus */
|
||||
@@ -0,0 +1,237 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
#include <sys/time.h>
|
||||
#include <time.h>
|
||||
#include <pthread.h>
|
||||
#include <string.h>
|
||||
#include "bsp.h"
|
||||
|
||||
#include "bsp_thread.h"
|
||||
|
||||
/*** Mutex Port Begin **/
|
||||
|
||||
INT32 bsp_thread_mutex_init(XMEDIA_THREAD_MUTEX* pMutex, XMEDIA_THREAD_MUTEXATTR* pMutexattr)
|
||||
{
|
||||
return (pthread_mutex_init(pMutex, pMutexattr));
|
||||
}
|
||||
|
||||
INT32 bsp_thread_mutex_lock(XMEDIA_THREAD_MUTEX* pMutex)
|
||||
{
|
||||
return (pthread_mutex_lock(pMutex));
|
||||
}
|
||||
|
||||
INT32 bsp_thread_mutex_trylock(XMEDIA_THREAD_MUTEX* pMutex)
|
||||
{
|
||||
return (pthread_mutex_trylock(pMutex));
|
||||
}
|
||||
|
||||
INT32 bsp_thread_mutex_unlock(XMEDIA_THREAD_MUTEX* pMutex)
|
||||
{
|
||||
return (pthread_mutex_unlock(pMutex));
|
||||
}
|
||||
|
||||
INT32 bsp_thread_mutex_destroy(XMEDIA_THREAD_MUTEX* pMutex)
|
||||
{
|
||||
return (pthread_mutex_destroy(pMutex));
|
||||
}
|
||||
|
||||
INT32 bsp_thread_cond_init(XMEDIA_THREAD_COND* pCond, XMEDIA_THREAD_CONDATTR* pCondattr)
|
||||
{
|
||||
return pthread_cond_init(pCond, pCondattr);
|
||||
}
|
||||
|
||||
INT32 bsp_thread_cond_destroy(XMEDIA_THREAD_COND* pCond)
|
||||
{
|
||||
return pthread_cond_destroy(pCond);
|
||||
}
|
||||
INT32 bsp_thread_cond_broadcast(XMEDIA_THREAD_COND* pCond)
|
||||
{
|
||||
return pthread_cond_broadcast(pCond);
|
||||
}
|
||||
|
||||
INT32 bsp_thread_cond_wait(XMEDIA_THREAD_COND* pCond, XMEDIA_THREAD_MUTEX *pMutex, U32 msecs)
|
||||
{
|
||||
struct timeval now;
|
||||
struct timespec timeout;
|
||||
|
||||
if (msecs == 0)
|
||||
{
|
||||
return pthread_cond_wait(pCond, pMutex);
|
||||
}
|
||||
else
|
||||
{
|
||||
gettimeofday(&now, NULL);
|
||||
timeout.tv_sec = now.tv_sec;
|
||||
timeout.tv_nsec = ( now.tv_usec + (msecs * 1000 )) * 1000;
|
||||
return pthread_cond_timedwait(pCond, pMutex, &timeout);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/*** Mutex Port END **/
|
||||
|
||||
INT32 bsp_thread_join(XMEDIA_THREAD_T *pThread, void **thread_return)
|
||||
{
|
||||
return (pthread_join(pThread->threadid, thread_return));
|
||||
}
|
||||
INT32 bsp_thread_create(XMEDIA_THREAD_T *pThread,const pthread_attr_t*__attr,
|
||||
void*__arg)
|
||||
{
|
||||
if (NULL == pThread)
|
||||
{
|
||||
WRITE_LOG_ERROR("No routine to be run for create thread. \n");
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
if (NULL == pThread->pf_run)
|
||||
{
|
||||
WRITE_LOG_ERROR("No routine to be run for create thread. \n");
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
#if 0
|
||||
if (0 == pthread_create(&(pThread->threadid), __attr, pThread->pf_run, __arg))
|
||||
{
|
||||
WRITE_LOG_DEBUG("thread %s create, id:%u\n", pThread->szThreadName, pThread->threadid);
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
else
|
||||
{
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
#endif
|
||||
|
||||
pThread->args = __arg;
|
||||
|
||||
if (0 == pthread_create(&(pThread->threadid), __attr,
|
||||
bsp_thread_run_handle,
|
||||
(void*)(pThread))
|
||||
)
|
||||
{
|
||||
WRITE_LOG_DEBUG("thread %s create, threadid:%u.\n", pThread->szThreadName, pThread->threadid);
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
else
|
||||
{
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
INT32 bsp_thread_cancel(XMEDIA_THREAD_T *pThread)
|
||||
{
|
||||
if (pThread == NULL)
|
||||
{
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
WRITE_LOG_DEBUG("cancel thread %s. pid:%d,tid:%d.\n",
|
||||
pThread->szThreadName, pThread->pid, pThread->threadid);
|
||||
|
||||
return pthread_cancel(pThread->threadid);
|
||||
}
|
||||
|
||||
VOID* bsp_thread_run_handle(VOID* arg)
|
||||
{
|
||||
if (NULL == arg)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
XMEDIA_THREAD_T *pThread = (XMEDIA_THREAD_T*)arg;
|
||||
|
||||
pThread->pid = getpid();
|
||||
pThread->threadid = pthread_self();
|
||||
|
||||
WRITE_LOG_DEBUG("thread %s run, pid:%u, threadid:%u\n",
|
||||
pThread->szThreadName,
|
||||
pThread->pid,
|
||||
pThread->threadid);
|
||||
|
||||
if (pThread->pf_run)
|
||||
{
|
||||
return pThread->pf_run(pThread->args);
|
||||
}
|
||||
else
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
EXTERNFUNC XMEDIA_RET bsp_thread_init(XMEDIA_THREAD_T *pThread, const char* szName,
|
||||
THREAD_RUN pf, INT32 priority, BOOL bStart)
|
||||
{
|
||||
pThread->pf_run = pf;
|
||||
pThread->priority = priority;
|
||||
pThread->bStart = bStart;
|
||||
if(strlen(szName) >= MAX_THREAD_NAME_LEN)
|
||||
{
|
||||
printf("The len of szName is more than MAX_THREAD_NAME_LEN\n");
|
||||
return XMEDIA_FAILURE;
|
||||
}else{
|
||||
strcpy(pThread->szThreadName, szName);
|
||||
}
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
/* work at 100MHz */
|
||||
EXTERNFUNC void bsp_delay(U32 ulUsDelay)
|
||||
{
|
||||
U32 ulLoop = 0;
|
||||
|
||||
while(ulLoop<ulUsDelay * 10)
|
||||
{
|
||||
ulLoop++;
|
||||
}
|
||||
//return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
#if defined(SYNC_USE_COND)
|
||||
EXTERNFUNC XMEDIA_RET bsp_sync_create(IO XMEDIA_SYNC_T *pWait)
|
||||
{
|
||||
bsp_thread_cond_init(&pWait->_cond, NULL);
|
||||
bsp_thread_mutex_init(&pWait->_mutex, NULL);
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
EXTERNFUNC XMEDIA_RET bsp_sync_wait(IO XMEDIA_SYNC_T *pWait,IN U32 msec)
|
||||
{
|
||||
return bsp_thread_cond_wait(&pWait->_cond, &pWait->_mutex, msec);
|
||||
}
|
||||
|
||||
EXTERNFUNC XMEDIA_RET bsp_sync_notify(IO XMEDIA_SYNC_T *pWait)
|
||||
{
|
||||
return bsp_thread_cond_broadcast(&pWait->_cond);
|
||||
}
|
||||
|
||||
EXTERNFUNC XMEDIA_RET bsp_sync_destroy(IO XMEDIA_SYNC_T *pWait)
|
||||
{
|
||||
bsp_thread_cond_init(&pWait->_cond, NULL);
|
||||
bsp_thread_mutex_init(&pWait->_mutex, NULL);
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
#else
|
||||
EXTERNFUNC XMEDIA_RET bsp_sync_create(IO XMEDIA_SYNC_T *pWait)
|
||||
{
|
||||
sem_init(&pWait->_sem, 0, 0);
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
EXTERNFUNC XMEDIA_RET bsp_sync_wait(IO XMEDIA_SYNC_T *pWait,IN U32 msec)
|
||||
{
|
||||
(void)msec;
|
||||
sem_wait(&pWait->_sem);
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
EXTERNFUNC XMEDIA_RET bsp_sync_notify(IO XMEDIA_SYNC_T *pWait)
|
||||
{
|
||||
sem_post(&pWait->_sem);
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
EXTERNFUNC XMEDIA_RET bsp_sync_destroy(IO XMEDIA_SYNC_T *pWait)
|
||||
{
|
||||
sem_destroy(&pWait->_sem);
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,329 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "bsp.h"
|
||||
#include "argparser.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cpluscplus */
|
||||
|
||||
char ARG_TYPE_STR[ARG_TYPE_END + 1][8] =
|
||||
{
|
||||
{"NO_OPT"},
|
||||
{"CHAR"},
|
||||
{"STRING"},
|
||||
{"INT"},
|
||||
{"FLOAT"},
|
||||
{"SINGLE"},
|
||||
{"HELP"},
|
||||
{"END"}
|
||||
};
|
||||
#if 0
|
||||
XMEDIA_RET _NOWARN_UNUSED ARG_CheckType(ARGOpt_t *pOpt, char* szArgv)
|
||||
{
|
||||
(void) szArgv;
|
||||
switch (pOpt->type)
|
||||
{
|
||||
case ARG_TYPE_INT:
|
||||
break;
|
||||
case ARG_TYPE_FLOAT:
|
||||
break;
|
||||
case ARG_TYPE_CHAR:
|
||||
break;
|
||||
case ARG_TYPE_NO_OPT:
|
||||
case ARG_TYPE_STRING:
|
||||
break;
|
||||
case ARG_TYPE_END:
|
||||
break;
|
||||
default:
|
||||
return ERR_ARG_UNKOWN_ARG;
|
||||
}
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
#endif
|
||||
XMEDIA_RET ARG_SetValue(ARGOpt_t *pOpt, const char* szArgv, int num)
|
||||
{
|
||||
switch (pOpt->type)
|
||||
{
|
||||
case ARG_TYPE_INT:
|
||||
*((INT32*)pOpt->pValue) = atoi(szArgv);
|
||||
pOpt->isSet = TRUE;
|
||||
break;
|
||||
case ARG_TYPE_FLOAT:
|
||||
*((float*)pOpt->pValue) = (float)atof(szArgv);
|
||||
pOpt->isSet = TRUE;
|
||||
break;
|
||||
case ARG_TYPE_CHAR:
|
||||
*((CHAR*)pOpt->pValue) = szArgv[0];
|
||||
pOpt->isSet = TRUE;
|
||||
break;
|
||||
case ARG_TYPE_NO_OPT:
|
||||
case ARG_TYPE_STRING:
|
||||
strcpy((char*)pOpt->pValue, szArgv);
|
||||
pOpt->isSet = TRUE;
|
||||
break;
|
||||
case ARG_TYPE_END:
|
||||
pOpt->isSet = FALSE;
|
||||
break;
|
||||
default:
|
||||
pOpt->isSet = FALSE;
|
||||
WRITE_LOG_ERROR("error opt type: %u\n",pOpt->type );
|
||||
return ERR_ARG_UNKOWN_ARG;
|
||||
}
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
/*
|
||||
cmd -i 1003 xyz
|
||||
^-------------
|
||||
-i 1003
|
||||
^ ^ 1003 arg
|
||||
^
|
||||
^------ i opt
|
||||
*/
|
||||
|
||||
/*****************************************************************************
|
||||
Prototype : StrToArg
|
||||
Description : Convert string to [argc, argv] pair, the INPUT str had chan-
|
||||
ged in this function
|
||||
Input : CHAR* pSrc
|
||||
int* argc
|
||||
CHAR** argv
|
||||
Output : None
|
||||
Return Value :
|
||||
Calls :
|
||||
Called By :
|
||||
|
||||
History :
|
||||
1.Date : 2005/7/27
|
||||
Modification : Created function
|
||||
|
||||
*****************************************************************************/
|
||||
VOID StrToArg(CHAR* pSrc, int* argc, CHAR** argv)
|
||||
{
|
||||
INT32 iNum = 0;
|
||||
BOOL bNewWord = FALSE;
|
||||
while(*pSrc)
|
||||
{
|
||||
if (*pSrc == ' ')
|
||||
{
|
||||
if (bNewWord == TRUE)
|
||||
{
|
||||
|
||||
*pSrc = 0;
|
||||
bNewWord = FALSE;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (bNewWord == FALSE)
|
||||
{
|
||||
bNewWord = TRUE;
|
||||
argv[iNum] = pSrc;
|
||||
iNum++;
|
||||
}
|
||||
}
|
||||
pSrc++;
|
||||
|
||||
}
|
||||
*argc = iNum;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
Prototype : ARGFindOptStr
|
||||
Description : Find option string in option lists, if not find, return
|
||||
NULL
|
||||
Input : ARGOpt_t * opts
|
||||
CHAR* strOpt
|
||||
Output : None
|
||||
Return Value :
|
||||
Calls :
|
||||
Called By :
|
||||
|
||||
History :
|
||||
1.Date : 2005/7/27
|
||||
Modification : Created function
|
||||
|
||||
*****************************************************************************/
|
||||
static ARGOpt_t *ARGFindOptStr(ARGOpt_t * opts, CHAR* strOpt)
|
||||
{
|
||||
INT32 i = 0;
|
||||
while (opts[i].type < ARG_TYPE_END)
|
||||
{
|
||||
if (strcmp(opts[i].sz_opt, strOpt) == 0 )
|
||||
{
|
||||
return &opts[i];
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static ARGOpt_t *ARGFindOpt_NoArg(ARGOpt_t * opts)
|
||||
{
|
||||
INT32 i = 0;
|
||||
while (opts[i].type < ARG_TYPE_END)
|
||||
{
|
||||
if (opts[i].type == ARG_TYPE_NO_OPT)
|
||||
{
|
||||
return &opts[i];
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
VOID ARGClearOpts(ARGOpt_t *opts)
|
||||
{
|
||||
INT32 i = 0;
|
||||
while (opts[i].type < ARG_TYPE_END)
|
||||
{
|
||||
opts[i].isSet = 0;
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
XMEDIA_RET ARGParser(int argc, char **argv, ARGOpt_t *opts)
|
||||
{
|
||||
XMEDIA_RET ret;
|
||||
INT32 iArgIdx = 0;
|
||||
CHAR* pCurrArg = NULL;
|
||||
ARGOpt_t* pCurrOpt = NULL;
|
||||
|
||||
BOOL bHasParseArg = FALSE;
|
||||
INT32 iNO_OPT_Cnt = 0;
|
||||
|
||||
if (argc == 1)
|
||||
{
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
//argv[0] is execute command
|
||||
for (iArgIdx = 1; iArgIdx < argc ; iArgIdx++)
|
||||
{
|
||||
pCurrArg = argv[iArgIdx];
|
||||
|
||||
if (*pCurrArg == '/' || *pCurrArg == '-')
|
||||
{
|
||||
pCurrArg++;
|
||||
|
||||
/*the argv[n] as '-' */
|
||||
if (*pCurrArg == 0)
|
||||
{
|
||||
WRITE_LOG_DEBUG("Wrong Args x: %s\n", argv[iArgIdx]);
|
||||
return ERR_ARG_WRONG_FMT;
|
||||
}
|
||||
|
||||
pCurrOpt = ARGFindOptStr(opts, pCurrArg);
|
||||
if (pCurrOpt == NULL)
|
||||
{
|
||||
WRITE_LOG_DEBUG("Wrong Args y: %s\n", argv[iArgIdx]);
|
||||
return ERR_ARG_WRONG_FMT;
|
||||
}
|
||||
if (pCurrOpt->type == ARG_TYPE_SINGLE)
|
||||
{
|
||||
bHasParseArg = FALSE;
|
||||
pCurrOpt->isSet = TRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
bHasParseArg = TRUE;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else if (bHasParseArg == FALSE)
|
||||
{
|
||||
pCurrOpt = ARGFindOpt_NoArg(opts);
|
||||
if (pCurrOpt == NULL)
|
||||
{
|
||||
WRITE_LOG_DEBUG("Wrong Args z: %s\n", argv[iArgIdx]);
|
||||
return ERR_ARG_NOT_DEFINE_NO_OPT;
|
||||
}
|
||||
bHasParseArg = TRUE;
|
||||
iNO_OPT_Cnt++;
|
||||
if (iNO_OPT_Cnt >1)
|
||||
{
|
||||
return ERR_ARG_MULTI_NO_OPT;
|
||||
}
|
||||
}
|
||||
|
||||
if (TRUE == bHasParseArg )
|
||||
{
|
||||
ret = ARG_SetValue(pCurrOpt, argv[iArgIdx], iArgIdx);
|
||||
if ( ret != XMEDIA_SUCCESS)
|
||||
{
|
||||
return ret;
|
||||
}
|
||||
|
||||
bHasParseArg = FALSE;
|
||||
}
|
||||
|
||||
}
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
/*return opts[]*/
|
||||
VOID ARGPrintHelp(ARGOpt_t *opts)
|
||||
{
|
||||
INT32 i = 0;
|
||||
while (opts[i].type < ARG_TYPE_END)
|
||||
{
|
||||
//fprintf(stdout, "-%s\n%s", opts[i].sz_opt,opts[i].pHelpMsg);
|
||||
WRITE_LOG_NORMAL("-%s\n%s", opts[i].sz_opt,opts[i].pHelpMsg);
|
||||
fflush(stdout);
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
VOID ARGPrintOpt(ARGOpt_t *pOpt)
|
||||
{
|
||||
switch (pOpt->type)
|
||||
{
|
||||
case ARG_TYPE_INT:
|
||||
WRITE_LOG_DEBUG("opt:%s, argtype:%s, Set:%i, argValue:%i. hlp:%s\n",
|
||||
pOpt->sz_opt, ARG_TYPE_STR[(int)pOpt->type],
|
||||
pOpt->isSet, *((INT32*)pOpt->pValue),
|
||||
(char*)pOpt->pHelpMsg);
|
||||
break;
|
||||
case ARG_TYPE_FLOAT:
|
||||
WRITE_LOG_DEBUG("opt:%s, argtype:%s, Set:%u, argValue:%f. hlp:%s\n",
|
||||
pOpt->sz_opt, ARG_TYPE_STR[(int)pOpt->type],
|
||||
pOpt->isSet, *((float*)pOpt->pValue),
|
||||
pOpt->pHelpMsg);
|
||||
break;
|
||||
case ARG_TYPE_CHAR:
|
||||
WRITE_LOG_DEBUG("opt:%s, argtype:%s, Set:%u, argValue:%c. hlp:%s\n",
|
||||
pOpt->sz_opt, ARG_TYPE_STR[(int)pOpt->type],
|
||||
pOpt->isSet, *((char*)pOpt->pValue),
|
||||
pOpt->pHelpMsg);
|
||||
break;
|
||||
case ARG_TYPE_NO_OPT:
|
||||
case ARG_TYPE_STRING:
|
||||
WRITE_LOG_DEBUG("opt:%s, argtype:%s, Set:%u, argValue:%s. hlp:%s\n",
|
||||
pOpt->sz_opt, ARG_TYPE_STR[(int)pOpt->type],
|
||||
pOpt->isSet, (char*)pOpt->pValue,
|
||||
pOpt->pHelpMsg);
|
||||
break;
|
||||
case ARG_TYPE_SINGLE:
|
||||
WRITE_LOG_DEBUG("opt:%s, argtype:%s, Set:%u, hlp:%s\n",
|
||||
pOpt->sz_opt,
|
||||
ARG_TYPE_STR[(int)pOpt->type],
|
||||
pOpt->isSet,
|
||||
pOpt->pHelpMsg);
|
||||
break;
|
||||
case ARG_TYPE_END:
|
||||
WRITE_LOG_DEBUG("END\n");
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cpluscplus */
|
||||
|
||||
@@ -0,0 +1,167 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "bsp.h"
|
||||
#include "argparser.h"
|
||||
#include "cmdshell.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cpluscplus */
|
||||
|
||||
CMD_SHELL_T *CMD_SHELL_Search(IN char* cmdstr,
|
||||
IN CMD_SHELL_T* pCmds
|
||||
)
|
||||
{
|
||||
if (NULL == pCmds || NULL == cmdstr)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
LENGTH_T lenCmdStr = strlen(cmdstr);
|
||||
if ( 0 == lenCmdStr )
|
||||
{
|
||||
WRITE_LOG_DEBUG1("cmdstr is zero length string \n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**/
|
||||
int i = 0;
|
||||
while(pCmds[i].cmdstr)
|
||||
{
|
||||
if (strcmp(pCmds[i].cmdstr, cmdstr) == 0)
|
||||
{
|
||||
return (&pCmds[i]);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
WRITE_LOG_DEBUG1("cann't find cmd: %s \n", cmdstr);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int CMD_SHELL_Run(CMD_SHELL_T* pCmd, int argc, char** argv)
|
||||
{
|
||||
if (NULL == pCmd)
|
||||
{
|
||||
return ERR_CMD_SHELL_NULL_CMD;
|
||||
}
|
||||
if (NULL == pCmd->pFunc)
|
||||
{
|
||||
return ERR_CMD_SHELL_NULL_FP;
|
||||
}
|
||||
else
|
||||
{
|
||||
//CMD_SHELL_PRINT_CMDSTRS(argc, argv);
|
||||
return ((int)pCmd->pFunc(argc, argv));
|
||||
}
|
||||
|
||||
}
|
||||
#if 0
|
||||
impl in file argparser.c
|
||||
static void StrToArg(CHAR* pSrc, int* argc, CHAR** argv)
|
||||
{
|
||||
U32 iNum = 0;
|
||||
BOOL bNewWord = FALSE;
|
||||
while(*pSrc)
|
||||
{
|
||||
if (*pSrc == ' ')
|
||||
{
|
||||
if (bNewWord == TRUE)
|
||||
{
|
||||
|
||||
*pSrc = 0;
|
||||
bNewWord = FALSE;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (bNewWord == FALSE)
|
||||
{
|
||||
bNewWord = TRUE;
|
||||
argv[iNum] = pSrc;
|
||||
iNum++;
|
||||
}
|
||||
}
|
||||
pSrc++;
|
||||
|
||||
}
|
||||
*argc = iNum;
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
#define MAX_CMD_LEN 128
|
||||
int CMD_SHELL_RUN(char* cmdstrs, const CMD_SHELL_T *pCmds)
|
||||
{
|
||||
char xcmdstr[MAX_CMD_LEN];
|
||||
int xargc;
|
||||
char* xargv[16] = {0};
|
||||
|
||||
if (NULL == cmdstrs)
|
||||
{
|
||||
printf("null\n");
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
|
||||
if (cmdstrs[0] == 0)
|
||||
{
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
if (strlen(cmdstrs) >= MAX_CMD_LEN)
|
||||
{
|
||||
printf("cmdstrs's length is %ld, wbsp.h should less than %d\n",
|
||||
strlen(cmdstrs), MAX_CMD_LEN);
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
memset(xcmdstr, 0, MAX_CMD_LEN);
|
||||
|
||||
strncpy(xcmdstr, cmdstrs, MAX_CMD_LEN - 1);
|
||||
|
||||
StrToArg(xcmdstr, &xargc, xargv);
|
||||
|
||||
//CMD_SHELL_PRINT_CMDSTRS(xargc, xargv);
|
||||
|
||||
CMD_SHELL_T* pCmd = CMD_SHELL_Search(xargv[0], (CMD_SHELL_T*)pCmds);
|
||||
if (pCmd == NULL)
|
||||
{
|
||||
WRITE_LOG_DEBUG("cann't find cmdstr:%s\n", cmdstrs);
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
else
|
||||
{
|
||||
return CMD_SHELL_Run(pCmd, xargc, xargv);
|
||||
}
|
||||
}
|
||||
|
||||
int CMD_SHELL_RUN_2(int argc, char* argv[], const CMD_SHELL_T *pCmds)
|
||||
{
|
||||
CMD_SHELL_T* pCmd = NULL;
|
||||
|
||||
char* pCmdStr = argv[0];
|
||||
char* pTmp = NULL;
|
||||
|
||||
for (pTmp = pCmdStr; *pTmp != '\0';)
|
||||
{
|
||||
if (*pTmp++ == '/')
|
||||
pCmdStr = pTmp;
|
||||
}
|
||||
WRITE_LOG_DEBUG1("cmdstr:%s\n", pCmdStr);
|
||||
|
||||
pCmd = CMD_SHELL_Search(pCmdStr, (CMD_SHELL_T*)pCmds);
|
||||
if (pCmd == NULL)
|
||||
{
|
||||
WRITE_LOG_DEBUG("cann't find cmdstr:%s\n", argv[0]);
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
else
|
||||
{
|
||||
return CMD_SHELL_Run(pCmd, argc, argv);
|
||||
}
|
||||
|
||||
}
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
@@ -0,0 +1,298 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
/* file name : memmap.c */
|
||||
/* linux /dev/mem mmap support func */
|
||||
/* */
|
||||
/* Copyright 2021 CJiang com. */
|
||||
/* Create date: 2021-01-07 */
|
||||
/************************************************************/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <linux/limits.h>
|
||||
|
||||
#include "bsp.h"
|
||||
|
||||
#ifdef OS_LINUX
|
||||
#include <fcntl.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/mman.h>
|
||||
#include <string.h>
|
||||
|
||||
typedef struct tag_MMAP_Node
|
||||
{
|
||||
unsigned long Start_P;
|
||||
unsigned long Start_V;
|
||||
unsigned long length;
|
||||
unsigned long refcount;
|
||||
struct tag_MMAP_Node * next;
|
||||
}TMMAP_Node_t;
|
||||
|
||||
TMMAP_Node_t * pTMMAPNode = NULL;
|
||||
|
||||
#define PAGE_SIZE 0x1000
|
||||
#define PAGE_SIZE_MASK (~(0xfff))
|
||||
|
||||
static int fd = -1;
|
||||
static const char dev[]="/dev/mem";
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/* no need considering page_size of 4K */
|
||||
void * memmap(unsigned long phy_addr, unsigned long size)
|
||||
{
|
||||
#ifndef OS_LINUX
|
||||
return (void *)phy_addr;
|
||||
#else
|
||||
unsigned long phy_addr_in_page;
|
||||
unsigned long page_diff;
|
||||
|
||||
unsigned long size_in_page;
|
||||
|
||||
TMMAP_Node_t *pTmp = NULL;
|
||||
TMMAP_Node_t *pNew = NULL;
|
||||
|
||||
void *addr=NULL;
|
||||
|
||||
if(size == 0)
|
||||
{
|
||||
WRITE_LOG_ERROR("memmap():size can't be zero!\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* check if the physical memory space have been mmaped */
|
||||
pTmp = pTMMAPNode;
|
||||
while(pTmp != NULL)
|
||||
{
|
||||
if( (phy_addr >= pTmp->Start_P) &&
|
||||
( (phy_addr + size) <= (pTmp->Start_P + pTmp->length) ) )
|
||||
{
|
||||
pTmp->refcount++; /* referrence count increase by 1 */
|
||||
return (void *)(uintptr_t)(pTmp->Start_V + phy_addr - pTmp->Start_P);
|
||||
}
|
||||
|
||||
pTmp = pTmp->next;
|
||||
}
|
||||
|
||||
/* not mmaped yet */
|
||||
if(fd < 0)
|
||||
{
|
||||
/* dev not opened yet, so open it */
|
||||
fd = open (dev, O_RDWR | O_SYNC);
|
||||
if (fd < 0)
|
||||
{
|
||||
WRITE_LOG_ERROR("memmap():open %s error!\n", dev);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* addr align in page_size(4K) */
|
||||
phy_addr_in_page = phy_addr & PAGE_SIZE_MASK;
|
||||
page_diff = phy_addr - phy_addr_in_page;
|
||||
|
||||
/* size in page_size */
|
||||
size_in_page =((size + page_diff - 1) & PAGE_SIZE_MASK) + PAGE_SIZE;
|
||||
|
||||
addr = mmap((void *)0, size_in_page, PROT_READ|PROT_WRITE, MAP_SHARED, fd, phy_addr_in_page);
|
||||
if (addr == MAP_FAILED)
|
||||
{
|
||||
WRITE_LOG_ERROR("memmap():mmap @ 0x%x error!\n", phy_addr_in_page);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* add this mmap to MMAP Node */
|
||||
pNew = (TMMAP_Node_t *)malloc(sizeof(TMMAP_Node_t));
|
||||
if(NULL == pNew)
|
||||
{
|
||||
WRITE_LOG_ERROR("memmap():malloc new node failed!\n");
|
||||
munmap(addr, size_in_page);
|
||||
return NULL;
|
||||
}
|
||||
pNew->Start_P = phy_addr_in_page;
|
||||
pNew->Start_V = (unsigned long)(uintptr_t)addr;
|
||||
pNew->length = size_in_page;
|
||||
pNew->refcount = 1;
|
||||
pNew->next = NULL;
|
||||
|
||||
if(pTMMAPNode == NULL)
|
||||
{
|
||||
pTMMAPNode = pNew;
|
||||
}
|
||||
else
|
||||
{
|
||||
pTmp = pTMMAPNode;
|
||||
while(pTmp->next != NULL)
|
||||
{
|
||||
pTmp = pTmp->next;
|
||||
}
|
||||
|
||||
pTmp->next = pNew;
|
||||
}
|
||||
|
||||
return (void *)(addr+page_diff);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
Prototype : memunmap
|
||||
Description :
|
||||
Input : void * addr_mapped
|
||||
Output : None
|
||||
Return Value : On success, returns 0, on failure -1
|
||||
Calls :
|
||||
Called By :
|
||||
|
||||
History :
|
||||
1.Date : 2005/12/21
|
||||
Author : Z42136
|
||||
Modification : Created function
|
||||
|
||||
*****************************************************************************/
|
||||
int memunmap(const void * addr_mapped)
|
||||
{
|
||||
TMMAP_Node_t *pPre = NULL;
|
||||
TMMAP_Node_t *pTmp = NULL;
|
||||
|
||||
if(pTMMAPNode == NULL)
|
||||
{
|
||||
WRITE_LOG_ERROR("memunmap(): address have not been mmaped!\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* check if the physical memory space have been mmaped */
|
||||
pTmp = pTMMAPNode;
|
||||
pPre = pTMMAPNode;
|
||||
|
||||
do
|
||||
{
|
||||
if( ((unsigned long)(uintptr_t)addr_mapped >= pTmp->Start_V) &&
|
||||
((unsigned long)(uintptr_t)addr_mapped <= (pTmp->Start_V + pTmp->length)) )
|
||||
{
|
||||
pTmp->refcount--; /* referrence count decrease by 1 */
|
||||
if(0 == pTmp->refcount)
|
||||
{
|
||||
|
||||
WRITE_LOG_INFO("memunmap(): map node will be remove!\n");
|
||||
|
||||
/* delete this map node from pMMAPNode */
|
||||
if(pTmp == pTMMAPNode)
|
||||
{
|
||||
pTMMAPNode = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
pPre->next = pTmp->next;
|
||||
}
|
||||
|
||||
/* munmap */
|
||||
if(munmap((void *)(uintptr_t)pTmp->Start_V, pTmp->length) != 0 )
|
||||
{
|
||||
WRITE_LOG_INFO("memunmap(): munmap failed!\n");
|
||||
}
|
||||
|
||||
free(pTmp);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
pPre = pTmp;
|
||||
pTmp = pTmp->next;
|
||||
}while(pTmp != NULL);
|
||||
|
||||
WRITE_LOG_ERROR("memunmap(): address have not been mmaped!\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
void * mmapfile(char* fn, unsigned long size)
|
||||
{
|
||||
int fd =-1;
|
||||
void * pShm = NULL;
|
||||
char path[PATH_MAX + 1] = {0x00};
|
||||
|
||||
if(fn == NULL)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if((strlen(fn) > PATH_MAX) || (NULL == realpath(fn, path)))
|
||||
{
|
||||
printf("error: mmapfile_r input path error.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if(size == 0)
|
||||
{
|
||||
printf("error:size is 0, error.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Open the file. */
|
||||
fd = open(path, O_RDWR | O_CREAT, S_IRWXU | S_IRWXG | O_SYNC);
|
||||
if (fd == -1)
|
||||
{
|
||||
WRITE_LOG_DEBUG("Open file %s error: %i.\n",fn, errno );
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Create the memory-mapping. */
|
||||
pShm = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
||||
close (fd);
|
||||
if (pShm != NULL)
|
||||
{
|
||||
WRITE_LOG_DEBUG("Memory Map OK. Map File: %s, length:%#X, addr:0x%08lX",
|
||||
fn, size, (unsigned long)(uintptr_t)pShm);
|
||||
}
|
||||
else
|
||||
{
|
||||
WRITE_LOG_DEBUG("Memory Map Failure. Map File %s, length:0x%08lX",
|
||||
fn, size);
|
||||
}
|
||||
return pShm;
|
||||
}
|
||||
|
||||
void * mmapfile_r(char* fn, unsigned long size)
|
||||
{
|
||||
int fd = -1;
|
||||
void * pShm = NULL;
|
||||
char path[PATH_MAX + 1] = {0x00};
|
||||
|
||||
if (fn == NULL || size == 0)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if((strlen(fn) > PATH_MAX) || (NULL == realpath(fn, path)))
|
||||
{
|
||||
printf("error: mmapfile_r input path error.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Open the file. */
|
||||
fd = open (path, O_RDONLY | O_SYNC);
|
||||
|
||||
if (fd == -1)
|
||||
{
|
||||
WRITE_LOG_INFO("Open file %s error: %d.\n",fn, errno );
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Create the memory-mapping. */
|
||||
pShm = mmap(0, size, PROT_READ, MAP_SHARED, fd, 0);
|
||||
close (fd);
|
||||
if (pShm != NULL)
|
||||
{
|
||||
WRITE_LOG_DEBUG("Memory Map OK. Map File: %s, length:%#X, addr:0x%08lX\n",
|
||||
fn, size, (unsigned long)(uintptr_t)pShm);
|
||||
}
|
||||
else
|
||||
{
|
||||
WRITE_LOG_DEBUG("Memory Map Failure. Map File %s, length:0x%08lX\n",
|
||||
fn, size);
|
||||
}
|
||||
return pShm;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,123 @@
|
||||
/*
|
||||
* Copyright (c) XMEDIA. All rights reserved.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include "bsp.h"
|
||||
#include "strfunc.h"
|
||||
|
||||
LOCALFUNC XMEDIA_RET atoul(IN CHAR *str,OUT unsigned long * pulValue);
|
||||
LOCALFUNC XMEDIA_RET atoulx(IN CHAR *str,OUT unsigned long * pulValue);
|
||||
|
||||
/*****************************************************************************
|
||||
Prototype : StrToNumber
|
||||
Calls : isdigit
|
||||
|
||||
Called By :
|
||||
|
||||
History :
|
||||
Modification : Created function
|
||||
*****************************************************************************/
|
||||
|
||||
XMEDIA_RET StrToNumber(IN CHAR *str , OUT unsigned long * pulValue)
|
||||
{
|
||||
if ( *str == '0' && (*(str+1) == 'x' || *(str+1) == 'X') )
|
||||
{
|
||||
if (*(str+2) == '\0')
|
||||
{
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
else
|
||||
{
|
||||
return atoulx(str+2,pulValue);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
return atoul(str,pulValue);
|
||||
}
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
Prototype : atoul
|
||||
Calls : isdigit
|
||||
|
||||
Called By :
|
||||
|
||||
History :
|
||||
Modification : Created function
|
||||
*****************************************************************************/
|
||||
XMEDIA_RET atoul(IN CHAR *str,OUT unsigned long * pulValue)
|
||||
{
|
||||
unsigned long ulResult=0;
|
||||
|
||||
while (*str)
|
||||
{
|
||||
if (isdigit((int)*str))
|
||||
{
|
||||
if ((ulResult<429496729) || ((ulResult==429496729) && (*str<'6')))
|
||||
{
|
||||
ulResult = ulResult*10 + (*str)-48;
|
||||
}
|
||||
else
|
||||
{
|
||||
*pulValue = ulResult;
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
*pulValue=ulResult;
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
str++;
|
||||
}
|
||||
*pulValue=ulResult;
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
Prototype : atoulx
|
||||
Calls : toupper
|
||||
isdigit
|
||||
|
||||
Called By :
|
||||
|
||||
History :
|
||||
Modification : Created function
|
||||
*****************************************************************************/
|
||||
#define ASC2NUM(ch) (ch - '0')
|
||||
#define HEXASC2NUM(ch) (ch - 'A' + 10)
|
||||
|
||||
XMEDIA_RET atoulx(IN CHAR *str,OUT unsigned long * pulValue)
|
||||
{
|
||||
unsigned long ulResult=0;
|
||||
UCHAR ch;
|
||||
|
||||
while (*str)
|
||||
{
|
||||
ch=toupper(*str);
|
||||
if (isdigit(ch) || ((ch >= 'A') && (ch <= 'F' )))
|
||||
{
|
||||
if (ulResult < 0x200000000)
|
||||
{
|
||||
ulResult = (ulResult << 4) + ((ch<='9')?(ASC2NUM(ch)):(HEXASC2NUM(ch)));
|
||||
}
|
||||
else
|
||||
{
|
||||
*pulValue=ulResult;
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
*pulValue=ulResult;
|
||||
return XMEDIA_FAILURE;
|
||||
}
|
||||
str++;
|
||||
}
|
||||
|
||||
*pulValue=ulResult;
|
||||
return XMEDIA_SUCCESS;
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
#!/usr/bin/env make
|
||||
###############################################################################
|
||||
#
|
||||
#
|
||||
#Copyright (c) XMEDIA. All rights reserved.
|
||||
#
|
||||
#
|
||||
###############################################################################
|
||||
|
||||
# $(call _rt_file,<libc>)
|
||||
_rt_file = $(shell $(CONFIG_XMEDIA_USR_ARM_TOOLCHAINS)-gcc \
|
||||
$(filter-out -Werror,$(SDK_USR_CFLAGS)) -print-file-name=$(1))
|
||||
|
||||
# $(call rt_file,<libc1, libc2, ...>)
|
||||
rt_file = $(foreach lib,$(1),$(shell if [ -f "$(call _rt_file,$(lib))" ]; \
|
||||
then ( echo "$(call _rt_file,$(lib))"; ) else ( echo ""; ) fi ))
|
||||
|
||||
# $(call rt_notdir,<libc1, libc2, ...>)
|
||||
rt_notdir = $(if $(strip $(call rt_file,$(1))),\
|
||||
$(notdir $(call rt_file,$(1))),\
|
||||
$(info *** $(CONFIG_XMEDIA_USR_ARM_TOOLCHAINS)-gcc $(SDK_USR_CFLAGS)) \
|
||||
$(error not found $(1), please check compiler and cflags))
|
||||
|
||||
# 兼容 uclibc(libc.so.0), glibc(libc.so.6), musllibc(libc.so)
|
||||
MUSL_LIBC=$(findstring musl, $(shell $(CONFIG_XMEDIA_USR_ARM_TOOLCHAINS)-gcc --version))
|
||||
RT-LIBS = $(if $(MUSL_LIBC),$(call rt_notdir,libc.so),\
|
||||
$(call rt_notdir,libc.so.0 libc.so.6))
|
||||
RT-LIBS += $(call rt_notdir,libgcc_s.so)
|
||||
ifeq ($(CONFIG_XMEDIA_LIBCPP_SUPPORT),y)
|
||||
RT-LIBS += $(call rt_notdir,libstdc++.so)
|
||||
endif
|
||||
|
||||
rootfs_unstrip: $(ROOTFS_PREFIX)/etc/inittab \
|
||||
$(addprefix $(ROOTFS_PREFIX)/lib/,$(RT-LIBS))
|
||||
|
||||
$(ROOTFS_PREFIX)/etc/inittab:
|
||||
$(call mkdir,$(@D))
|
||||
tar xzf $(ROOTFS_SRCDIR)/scripts/rootfs.tgz -C $(ROOTFS_PREFIX)/..
|
||||
touch $@
|
||||
|
||||
# To compatible with old dynamic lib linked with uClibc, create a link ld-uClibc.so.0.
|
||||
$(ROOTFS_PREFIX)/lib/libc.so:
|
||||
@$(call mkdir,$(@D))
|
||||
DIR=$(dir $(call rt_file,$(@F))); \
|
||||
cp -avf $${DIR}/*.so $(@D)
|
||||
cd $(@D);ln -s $(notdir $@) ld-musl-arm.so.1;chmod +x $@;cd -
|
||||
cd $(@D);ln -s $(notdir $@) ld-uClibc.so.0;chmod +x $@;cd -
|
||||
|
||||
$(ROOTFS_PREFIX)/lib/libc.so.0 $(ROOTFS_PREFIX)/lib/libc.so.6:
|
||||
@$(call mkdir,$(@D))
|
||||
DIR=$(dir $(call rt_file,$(@F))); \
|
||||
cp -avf $${DIR}/{*.so,*.so.*} $(@D)
|
||||
|
||||
$(ROOTFS_PREFIX)/lib/libgcc_s.so:
|
||||
@$(call mkdir,$(@D))
|
||||
DIR=$(dir $(call rt_file,$(@F))); \
|
||||
cp -avf $${DIR}/libgcc_s.s* $(@D)
|
||||
|
||||
$(ROOTFS_PREFIX)/lib/libstdc++.so:
|
||||
@$(call mkdir,$(@D))
|
||||
DIR=$(dir $(call rt_file,$(@F))); \
|
||||
cp -avf $${DIR}/{libstdc++.so,libstdc++.so.*[0-9]} $(@D)
|
||||
Binary file not shown.
@@ -0,0 +1,51 @@
|
||||
CROSS_COMPILE_PREFIX ?= $(CONFIG_XMEDIA_USR_ARM_TOOLCHAINS)
|
||||
CC := $(CROSS_COMPILE_PREFIX)-gcc
|
||||
CROSS_STRIP := $(CROSS_COMPILE_PREFIX)-strip
|
||||
|
||||
|
||||
UBOOT_ENV_TOOL := fw_printenv
|
||||
UBOOTENV_BUILD := $(ROOTFS_BUILDDIR)/uboot_env
|
||||
|
||||
UBOOTENV_INCDIR := $(ROOTFS_SRCDIR)/uboot_env/include
|
||||
UBOOTENV_SRCDIR := $(ROOTFS_SRCDIR)/uboot_env/source
|
||||
|
||||
UBOOTENV_SRC_OBJ_DIR := $(ROOTFS_SRCDIR)/uboot_env
|
||||
|
||||
CFLAGS := -Wall -O2 -I$(UBOOTENV_INCDIR)
|
||||
|
||||
|
||||
|
||||
SRCS := \
|
||||
$(UBOOTENV_SRCDIR)/crc32.c \
|
||||
$(UBOOTENV_SRCDIR)/fw_env.c \
|
||||
$(UBOOTENV_SRCDIR)/fw_env_main.c
|
||||
OBJS := $(patsubst $(UBOOTENV_SRCDIR)/%.c, $(UBOOTENV_BUILD)/%.o, $(SRCS))
|
||||
|
||||
rootfs_unstrip: $(ROOTFS_PREFIX)/bin/$(UBOOT_ENV_TOOL)
|
||||
|
||||
|
||||
$(ROOTFS_PREFIX)/bin/$(UBOOT_ENV_TOOL): $(UBOOTENV_BUILD)/.built
|
||||
@mkdir -p $(@D)
|
||||
cp -f $(UBOOTENV_BUILD)/$(UBOOT_ENV_TOOL) $(ROOTFS_PREFIX)/bin/
|
||||
cd $(@D) && ln -sf $(UBOOT_ENV_TOOL) fw_setenv
|
||||
touch $@
|
||||
|
||||
$(UBOOTENV_BUILD)/.built: $(OBJS) uboot_env_prepare
|
||||
$(CC) $(OBJS) -o $(UBOOTENV_BUILD)/$(UBOOT_ENV_TOOL)
|
||||
$(CROSS_STRIP) $(UBOOTENV_BUILD)/$(UBOOT_ENV_TOOL)
|
||||
@echo "Link and strip $(UBOOT_ENV_TOOL) to $(UBOOTENV_BUILD)"
|
||||
touch $@
|
||||
|
||||
uboot_env_prepare:
|
||||
mkdir -p $(UBOOTENV_BUILD) >/dev/null 2>&1
|
||||
if [ -e $(UBOOTENV_SRC_OBJ_DIR)/*.o ]; then \
|
||||
cp -af $(UBOOTENV_SRC_OBJ_DIR)/*.o $(UBOOTENV_BUILD)/; \
|
||||
fi
|
||||
@echo "Prepare uboot_env build dir: $(UBOOTENV_BUILD)"
|
||||
|
||||
$(UBOOTENV_BUILD)/%.o: $(UBOOTENV_SRCDIR)/%.c
|
||||
@mkdir -p $(@D)
|
||||
$(CC) $(CFLAGS) -c $< -o $@
|
||||
@echo "Compiled: $< -> $@"
|
||||
|
||||
.PHONY: rootfs_unstrip uboot_env_prepare
|
||||
@@ -0,0 +1,9 @@
|
||||
#ifndef __CRC32_H__
|
||||
#define __CRC32_H__
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
// U-Boot标准CRC32计算函数
|
||||
uint32_t crc32(uint32_t crc, const unsigned char *buf, unsigned int len);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,83 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
#ifndef __FW_ENV_H__
|
||||
#define __FW_ENV_H__
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include <sys/types.h> // 引入标准类型头文件
|
||||
|
||||
// 基础类型定义
|
||||
typedef uint32_t u32;
|
||||
typedef uint8_t u8;
|
||||
typedef int32_t s32;
|
||||
typedef unsigned long ulong; // 关键：显式定义ulong类型
|
||||
|
||||
// 环境变量核心宏
|
||||
#define MAX_REDUND 2
|
||||
#define ENV_CRC_SIZE sizeof(uint32_t)
|
||||
#define ENV_HEADER_SIZE ENV_CRC_SIZE
|
||||
#define CONFIG_ENV_SIZE 0x10000
|
||||
|
||||
// 环境变量操作选项
|
||||
struct env_opts {
|
||||
#ifdef CONFIG_FILE
|
||||
char *config_file;
|
||||
#endif
|
||||
char *lockname;
|
||||
char *part;
|
||||
ulong offset;
|
||||
ulong size;
|
||||
ulong esize;
|
||||
};
|
||||
|
||||
// 环境变量设备配置
|
||||
struct env_device {
|
||||
char *devname; // /dev/mtdX
|
||||
ulong offset; // 偏移
|
||||
ulong size; // 环境变量总大小
|
||||
ulong erasesize; // 擦除块大小
|
||||
int type; // 设备类型（MTD）
|
||||
int ubi_volume; // UBI卷标识
|
||||
};
|
||||
|
||||
// 环境变量上下文
|
||||
struct environment {
|
||||
void *image; // 环境变量缓冲区
|
||||
uint32_t *crc; // CRC指针（前4字节）
|
||||
uint8_t *flags; // 冗余标志
|
||||
char *data; // 数据区指针
|
||||
ulong usable_envsize; // 数据区有效长度
|
||||
int dirty; // 是否需要刷写
|
||||
int dev_current; // 当前激活设备
|
||||
int flag_scheme; // 标志方案
|
||||
};
|
||||
|
||||
// 快捷宏
|
||||
#define DEVNAME(idx) envdevices[idx].devname
|
||||
#define DEVOFFSET(idx) envdevices[idx].offset
|
||||
#define ENVSIZE(idx) envdevices[idx].size
|
||||
#define DEVESIZE(idx) envdevices[idx].erasesize
|
||||
#define DEVTYPE(idx) envdevices[idx].type
|
||||
#define IS_UBI(idx) envdevices[idx].ubi_volume
|
||||
#define CUR_DEVNAME DEVNAME(environment.dev_current)
|
||||
#define CUR_DEVOFFSET DEVOFFSET(environment.dev_current)
|
||||
#define CUR_ENVSIZE ENVSIZE(environment.dev_current)
|
||||
#define CUR_DEVESIZE DEVESIZE(environment.dev_current)
|
||||
|
||||
// 全局变量声明
|
||||
extern struct env_device envdevices[MAX_REDUND];
|
||||
extern struct environment environment;
|
||||
extern int have_redund_env;
|
||||
|
||||
// 函数声明
|
||||
int fw_printenv(int argc, char *argv[], int value_only, struct env_opts *opts);
|
||||
int fw_env_set(int argc, char *argv[], struct env_opts *opts);
|
||||
int fw_parse_script(char *fname, struct env_opts *opts);
|
||||
int fw_env_open(struct env_opts *opts);
|
||||
char *fw_getenv(char *name);
|
||||
int fw_env_write(char *name, char *value);
|
||||
int fw_env_flush(struct env_opts *opts);
|
||||
int fw_env_close(struct env_opts *opts);
|
||||
char *fw_env_version(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,82 @@
|
||||
#include "crc32.h"
|
||||
|
||||
#define tole(x) (x)
|
||||
|
||||
static const uint32_t crc_table[256] = {
|
||||
tole(0x00000000L), tole(0x77073096L), tole(0xee0e612cL), tole(0x990951baL),
|
||||
tole(0x076dc419L), tole(0x706af48fL), tole(0xe963a535L), tole(0x9e6495a3L),
|
||||
tole(0x0edb8832L), tole(0x79dcb8a4L), tole(0xe0d5e91eL), tole(0x97d2d988L),
|
||||
tole(0x09b64c2bL), tole(0x7eb17cbdL), tole(0xe7b82d07L), tole(0x90bf1d91L),
|
||||
tole(0x1db71064L), tole(0x6ab020f2L), tole(0xf3b97148L), tole(0x84be41deL),
|
||||
tole(0x1adad47dL), tole(0x6ddde4ebL), tole(0xf4d4b551L), tole(0x83d385c7L),
|
||||
tole(0x136c9856L), tole(0x646ba8c0L), tole(0xfd62f97aL), tole(0x8a65c9ecL),
|
||||
tole(0x14015c4fL), tole(0x63066cd9L), tole(0xfa0f3d63L), tole(0x8d080df5L),
|
||||
tole(0x3b6e20c8L), tole(0x4c69105eL), tole(0xd56041e4L), tole(0xa2677172L),
|
||||
tole(0x3c03e4d1L), tole(0x4b04d447L), tole(0xd20d85fdL), tole(0xa50ab56bL),
|
||||
tole(0x35b5a8faL), tole(0x42b2986cL), tole(0xdbbbc9d6L), tole(0xacbcf940L),
|
||||
tole(0x32d86ce3L), tole(0x45df5c75L), tole(0xdcd60dcfL), tole(0xabd13d59L),
|
||||
tole(0x26d930acL), tole(0x51de003aL), tole(0xc8d75180L), tole(0xbfd06116L),
|
||||
tole(0x21b4f4b5L), tole(0x56b3c423L), tole(0xcfba9599L), tole(0xb8bda50fL),
|
||||
tole(0x2802b89eL), tole(0x5f058808L), tole(0xc60cd9b2L), tole(0xb10be924L),
|
||||
tole(0x2f6f7c87L), tole(0x58684c11L), tole(0xc1611dabL), tole(0xb6662d3dL),
|
||||
tole(0x76dc4190L), tole(0x01db7106L), tole(0x98d220bcL), tole(0xefd5102aL),
|
||||
tole(0x71b18589L), tole(0x06b6b51fL), tole(0x9fbfe4a5L), tole(0xe8b8d433L),
|
||||
tole(0x7807c9a2L), tole(0x0f00f934L), tole(0x9609a88eL), tole(0xe10e9818L),
|
||||
tole(0x7f6a0dbbL), tole(0x086d3d2dL), tole(0x91646c97L), tole(0xe6635c01L),
|
||||
tole(0x6b6b51f4L), tole(0x1c6c6162L), tole(0x856530d8L), tole(0xf262004eL),
|
||||
tole(0x6c0695edL), tole(0x1b01a57bL), tole(0x8208f4c1L), tole(0xf50fc457L),
|
||||
tole(0x65b0d9c6L), tole(0x12b7e950L), tole(0x8bbeb8eaL), tole(0xfcb9887cL),
|
||||
tole(0x62dd1ddfL), tole(0x15da2d49L), tole(0x8cd37cf3L), tole(0xfbd44c65L),
|
||||
tole(0x4db26158L), tole(0x3ab551ceL), tole(0xa3bc0074L), tole(0xd4bb30e2L),
|
||||
tole(0x4adfa541L), tole(0x3dd895d7L), tole(0xa4d1c46dL), tole(0xd3d6f4fbL),
|
||||
tole(0x4369e96aL), tole(0x346ed9fcL), tole(0xad678846L), tole(0xda60b8d0L),
|
||||
tole(0x44042d73L), tole(0x33031de5L), tole(0xaa0a4c5fL), tole(0xdd0d7cc9L),
|
||||
tole(0x5005713cL), tole(0x270241aaL), tole(0xbe0b1010L), tole(0xc90c2086L),
|
||||
tole(0x5768b525L), tole(0x206f85b3L), tole(0xb966d409L), tole(0xce61e49fL),
|
||||
tole(0x5edef90eL), tole(0x29d9c998L), tole(0xb0d09822L), tole(0xc7d7a8b4L),
|
||||
tole(0x59b33d17L), tole(0x2eb40d81L), tole(0xb7bd5c3bL), tole(0xc0ba6cadL),
|
||||
tole(0xedb88320L), tole(0x9abfb3b6L), tole(0x03b6e20cL), tole(0x74b1d29aL),
|
||||
tole(0xead54739L), tole(0x9dd277afL), tole(0x04db2615L), tole(0x73dc1683L),
|
||||
tole(0xe3630b12L), tole(0x94643b84L), tole(0x0d6d6a3eL), tole(0x7a6a5aa8L),
|
||||
tole(0xe40ecf0bL), tole(0x9309ff9dL), tole(0x0a00ae27L), tole(0x7d079eb1L),
|
||||
tole(0xf00f9344L), tole(0x8708a3d2L), tole(0x1e01f268L), tole(0x6906c2feL),
|
||||
tole(0xf762575dL), tole(0x806567cbL), tole(0x196c3671L), tole(0x6e6b06e7L),
|
||||
tole(0xfed41b76L), tole(0x89d32be0L), tole(0x10da7a5aL), tole(0x67dd4accL),
|
||||
tole(0xf9b9df6fL), tole(0x8ebeeff9L), tole(0x17b7be43L), tole(0x60b08ed5L),
|
||||
tole(0xd6d6a3e8L), tole(0xa1d1937eL), tole(0x38d8c2c4L), tole(0x4fdff252L),
|
||||
tole(0xd1bb67f1L), tole(0xa6bc5767L), tole(0x3fb506ddL), tole(0x48b2364bL),
|
||||
tole(0xd80d2bdaL), tole(0xaf0a1b4cL), tole(0x36034af6L), tole(0x41047a60L),
|
||||
tole(0xdf60efc3L), tole(0xa867df55L), tole(0x316e8eefL), tole(0x4669be79L),
|
||||
tole(0xcb61b38cL), tole(0xbc66831aL), tole(0x256fd2a0L), tole(0x5268e236L),
|
||||
tole(0xcc0c7795L), tole(0xbb0b4703L), tole(0x220216b9L), tole(0x5505262fL),
|
||||
tole(0xc5ba3bbeL), tole(0xb2bd0b28L), tole(0x2bb45a92L), tole(0x5cb36a04L),
|
||||
tole(0xc2d7ffa7L), tole(0xb5d0cf31L), tole(0x2cd99e8bL), tole(0x5bdeae1dL),
|
||||
tole(0x9b64c2b0L), tole(0xec63f226L), tole(0x756aa39cL), tole(0x026d930aL),
|
||||
tole(0x9c0906a9L), tole(0xeb0e363fL), tole(0x72076785L), tole(0x05005713L),
|
||||
tole(0x95bf4a82L), tole(0xe2b87a14L), tole(0x7bb12baeL), tole(0x0cb61b38L),
|
||||
tole(0x92d28e9bL), tole(0xe5d5be0dL), tole(0x7cdcefb7L), tole(0x0bdbdf21L),
|
||||
tole(0x86d3d2d4L), tole(0xf1d4e242L), tole(0x68ddb3f8L), tole(0x1fda836eL),
|
||||
tole(0x81be16cdL), tole(0xf6b9265bL), tole(0x6fb077e1L), tole(0x18b74777L),
|
||||
tole(0x88085ae6L), tole(0xff0f6a70L), tole(0x66063bcaL), tole(0x11010b5cL),
|
||||
tole(0x8f659effL), tole(0xf862ae69L), tole(0x616bffd3L), tole(0x166ccf45L),
|
||||
tole(0xa00ae278L), tole(0xd70dd2eeL), tole(0x4e048354L), tole(0x3903b3c2L),
|
||||
tole(0xa7672661L), tole(0xd06016f7L), tole(0x4969474dL), tole(0x3e6e77dbL),
|
||||
tole(0xaed16a4aL), tole(0xd9d65adcL), tole(0x40df0b66L), tole(0x37d83bf0L),
|
||||
tole(0xa9bcae53L), tole(0xdebb9ec5L), tole(0x47b2cf7fL), tole(0x30b5ffe9L),
|
||||
tole(0xbdbdf21cL), tole(0xcabac28aL), tole(0x53b39330L), tole(0x24b4a3a6L),
|
||||
tole(0xbad03605L), tole(0xcdd70693L), tole(0x54de5729L), tole(0x23d967bfL),
|
||||
tole(0xb3667a2eL), tole(0xc4614ab8L), tole(0x5d681b02L), tole(0x2a6f2b94L),
|
||||
tole(0xb40bbe37L), tole(0xc30c8ea1L), tole(0x5a05df1bL), tole(0x2d02ef8dL)
|
||||
};
|
||||
|
||||
uint32_t crc32(uint32_t crc, const unsigned char *buf, unsigned int len)
|
||||
{
|
||||
if (crc == 0)
|
||||
crc = 0xFFFFFFFF;
|
||||
|
||||
while (len--) {
|
||||
crc = crc_table[(crc ^ *buf++) & 0xFF] ^ (crc >> 8);
|
||||
}
|
||||
|
||||
return ~crc;
|
||||
}
|
||||
@@ -0,0 +1,466 @@
|
||||
#include "fw_env.h"
|
||||
#include "crc32.h"
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <mtd/mtd-user.h>
|
||||
#include <errno.h>
|
||||
|
||||
// 全局变量定义
|
||||
struct env_device envdevices[MAX_REDUND] = {0};
|
||||
struct environment environment = {0};
|
||||
int have_redund_env;
|
||||
|
||||
// 默认参数
|
||||
static struct env_opts default_opts = {
|
||||
#ifdef CONFIG_FILE
|
||||
.config_file = NULL,
|
||||
#endif
|
||||
.lockname = NULL,
|
||||
.part = "bootargs",
|
||||
.offset = 0x0,
|
||||
.size = 0x0,
|
||||
.esize = 0x0,
|
||||
};
|
||||
|
||||
// 解析/proc/mtd获取分区信息
|
||||
static int find_mtd_by_name(const char *name, char *devpath, unsigned long *size, unsigned long *erase)
|
||||
{
|
||||
FILE *fp;
|
||||
char line[128];
|
||||
int mtdnum;
|
||||
char mtdname[64];
|
||||
|
||||
fp = fopen("/proc/mtd", "r");
|
||||
if (!fp)
|
||||
return -1;
|
||||
|
||||
fgets(line, sizeof(line), fp);
|
||||
while (fgets(line, sizeof(line), fp)) {
|
||||
if (sscanf(line, "mtd%d: %lx %lx \"%63[^\"]\"", &mtdnum, size, erase, mtdname) == 4) {
|
||||
if (!strcmp(mtdname, name)) {
|
||||
sprintf(devpath, "/dev/mtd%d", mtdnum);
|
||||
fclose(fp);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fclose(fp);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int check_device_config(int index)
|
||||
{
|
||||
if (CUR_DEVOFFSET + CUR_ENVSIZE > (1ULL << 32)) {
|
||||
fprintf(stderr, "Error: ENV range exceeds 32-bit address space\n");
|
||||
return -1;
|
||||
}
|
||||
if (CUR_ENVSIZE == 0 || CUR_DEVESIZE == 0) {
|
||||
fprintf(stderr, "Error: ENV size or erase size is zero\n");
|
||||
return -1;
|
||||
}
|
||||
if (environment.usable_envsize < 8) {
|
||||
fprintf(stderr, "Error: Usable ENV size too small (%lu bytes)\n", environment.usable_envsize);
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int parse_config(struct env_opts *opts)
|
||||
{
|
||||
int rc;
|
||||
char devname[32];
|
||||
unsigned long part_size = 0, part_erase = 0;
|
||||
|
||||
if (!opts) {
|
||||
fprintf(stderr, "env_opts is NULL\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
const char *part_name = opts->part ? opts->part : "bootargs";
|
||||
if (find_mtd_by_name(part_name, devname, &part_size, &part_erase) < 0) {
|
||||
fprintf(stderr, "Cannot find mtd partition '%s'\n", part_name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
DEVNAME(0) = strdup(devname);
|
||||
if (!DEVNAME(0)) {
|
||||
fprintf(stderr, "No memory for DEVNAME\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
DEVOFFSET(0) = (opts->offset != 0) ? opts->offset : 0x0;
|
||||
ENVSIZE(0) = (opts->size != 0) ? opts->size : part_erase;
|
||||
DEVESIZE(0) = (opts->esize != 0) ? opts->esize : part_erase;
|
||||
environment.usable_envsize = CUR_ENVSIZE - ENV_CRC_SIZE;
|
||||
|
||||
have_redund_env = 0;
|
||||
rc = check_device_config(0);
|
||||
if (rc < 0) {
|
||||
free(DEVNAME(0));
|
||||
DEVNAME(0) = NULL;
|
||||
return rc;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int env_check_crc(void)
|
||||
{
|
||||
uint32_t stored_crc, calc_crc;
|
||||
|
||||
if (!environment.image || environment.usable_envsize == 0)
|
||||
return -1;
|
||||
|
||||
memcpy(&stored_crc, environment.image, ENV_CRC_SIZE);
|
||||
calc_crc = crc32(0, (unsigned char *)environment.data, environment.usable_envsize);
|
||||
|
||||
if (stored_crc != calc_crc) {
|
||||
fprintf(stderr, "U-Boot CRC Check Failed: stored=0x%08x, calc=0x%08x\n", stored_crc, calc_crc);
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int get_mtd_info(int fd, struct mtd_info_user *info)
|
||||
{
|
||||
if (ioctl(fd, MEMGETINFO, info) < 0) {
|
||||
perror("MEMGETINFO");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Flash读写封装
|
||||
static int flash_io(int mode)
|
||||
{
|
||||
int fd;
|
||||
ssize_t ret;
|
||||
struct mtd_info_user mtd;
|
||||
size_t rw_len = CUR_ENVSIZE;
|
||||
off_t offset = CUR_DEVOFFSET;
|
||||
|
||||
fd = open(CUR_DEVNAME, (mode == O_RDONLY) ? O_RDONLY : O_RDWR);
|
||||
if (fd < 0) {
|
||||
perror(CUR_DEVNAME);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (get_mtd_info(fd, &mtd)) {
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (offset + rw_len > mtd.size) {
|
||||
fprintf(stderr, "ENV exceeds MTD size (off=0x%lx size=0x%lx mtd=0x%x)\n", offset, rw_len, mtd.size);
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (offset) {
|
||||
char dummy[4096];
|
||||
size_t skip = offset;
|
||||
while (skip) {
|
||||
size_t n = skip > sizeof(dummy) ? sizeof(dummy) : skip;
|
||||
ret = read(fd, dummy, n);
|
||||
if (ret <= 0)
|
||||
goto err;
|
||||
skip -= ret;
|
||||
}
|
||||
}
|
||||
|
||||
if (mode == O_RDONLY) {
|
||||
ret = read(fd, environment.image, rw_len);
|
||||
} else {
|
||||
ret = write(fd, environment.image, rw_len);
|
||||
fsync(fd);
|
||||
}
|
||||
|
||||
if (ret != (ssize_t)rw_len)
|
||||
goto err;
|
||||
|
||||
close(fd);
|
||||
return 0;
|
||||
|
||||
err:
|
||||
perror("flash_io");
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
|
||||
// 擦除Flash
|
||||
static int flash_erase(void)
|
||||
{
|
||||
int fd;
|
||||
struct erase_info_user ei;
|
||||
struct mtd_info_user mtd;
|
||||
|
||||
fd = open(CUR_DEVNAME, O_RDWR);
|
||||
if (fd < 0) {
|
||||
perror(CUR_DEVNAME);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (get_mtd_info(fd, &mtd)) {
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (ulong off = CUR_DEVOFFSET; off < CUR_DEVOFFSET + CUR_ENVSIZE; off += mtd.erasesize) {
|
||||
ei.start = off;
|
||||
ei.length = mtd.erasesize;
|
||||
if (ioctl(fd, MEMERASE, &ei) < 0) {
|
||||
perror("MEMERASE");
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
// 打开环境变量
|
||||
int fw_env_open(struct env_opts *opts)
|
||||
{
|
||||
int ret;
|
||||
void *addr = NULL;
|
||||
|
||||
if (!opts) {
|
||||
printf("==== Error no opts ==== \n");
|
||||
opts = &default_opts;
|
||||
}
|
||||
|
||||
if (parse_config(opts))
|
||||
return -1;
|
||||
|
||||
addr = calloc(1, CUR_ENVSIZE);
|
||||
if (!addr) {
|
||||
fprintf(stderr, "Not enough memory for environment (%lu bytes)\n", CUR_ENVSIZE);
|
||||
free(CUR_DEVNAME);
|
||||
CUR_DEVNAME = NULL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
environment.image = addr;
|
||||
environment.crc = (uint32_t *)addr;
|
||||
environment.data = (char *)addr + ENV_HEADER_SIZE;
|
||||
environment.dev_current = 0;
|
||||
environment.dirty = 0;
|
||||
|
||||
if (flash_io(O_RDONLY)) {
|
||||
free(addr);
|
||||
free(CUR_DEVNAME);
|
||||
CUR_DEVNAME = NULL;
|
||||
return -1;
|
||||
}
|
||||
|
||||
ret = env_check_crc();
|
||||
if (ret < 0) {
|
||||
free(addr);
|
||||
free(CUR_DEVNAME);
|
||||
CUR_DEVNAME = NULL;
|
||||
return ret;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// 获取环境变量
|
||||
char *fw_getenv(char *name)
|
||||
{
|
||||
char *ptr = environment.data;
|
||||
char *end = environment.data + environment.usable_envsize;
|
||||
int name_len = strlen(name);
|
||||
|
||||
if (!environment.image || environment.usable_envsize == 0)
|
||||
return NULL;
|
||||
|
||||
while (ptr < end && *ptr) {
|
||||
if (strncmp(ptr, name, name_len) == 0 && ptr[name_len] == '=') {
|
||||
return ptr + name_len + 1;
|
||||
}
|
||||
ptr += strlen(ptr) + 1;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// 打印环境变量
|
||||
int fw_printenv(int argc, char *argv[], int value_only, struct env_opts *opts)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
if (fw_env_open(opts))
|
||||
return -1;
|
||||
|
||||
if (argc == 0) {
|
||||
// 打印所有变量
|
||||
char *ptr = environment.data;
|
||||
char *end = environment.data + environment.usable_envsize;
|
||||
while (ptr < end && *ptr) {
|
||||
printf("%s\n", ptr);
|
||||
ptr += strlen(ptr) + 1;
|
||||
}
|
||||
} else {
|
||||
for (int i = 0; i < argc; i++) {
|
||||
char *val = fw_getenv(argv[i]);
|
||||
if (val) {
|
||||
if (value_only) {
|
||||
printf("%s\n", val);
|
||||
} else {
|
||||
printf("%s=%s\n", argv[i], val);
|
||||
}
|
||||
} else {
|
||||
fprintf(stderr, "%s: Not found\n", argv[i]);
|
||||
ret = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fw_env_close(opts);
|
||||
return ret;
|
||||
}
|
||||
|
||||
// 拼接环境变量值
|
||||
static char *concat_env_value(int argc, char *argv[])
|
||||
{
|
||||
int total_len = 0;
|
||||
char *val, *ptr;
|
||||
|
||||
for (int i = 1; i < argc; i++) {
|
||||
total_len += strlen(argv[i]) + 1;
|
||||
}
|
||||
if (total_len == 0)
|
||||
return NULL;
|
||||
|
||||
val = malloc(total_len);
|
||||
if (!val)
|
||||
return NULL;
|
||||
|
||||
ptr = val;
|
||||
for (int i = 1; i < argc; i++) {
|
||||
strcpy(ptr, argv[i]);
|
||||
ptr += strlen(argv[i]);
|
||||
if (i < argc - 1) {
|
||||
*ptr++ = ' ';
|
||||
}
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
// 写入环境变量
|
||||
int fw_env_write(char *name, char *value)
|
||||
{
|
||||
char *new_env, *ptr, *old_ptr;
|
||||
int name_len = strlen(name);
|
||||
uint32_t new_crc;
|
||||
|
||||
if (!environment.image || environment.usable_envsize == 0)
|
||||
return -1;
|
||||
|
||||
new_env = calloc(1, CUR_ENVSIZE);
|
||||
if (!new_env)
|
||||
return -1;
|
||||
|
||||
ptr = new_env + ENV_HEADER_SIZE;
|
||||
old_ptr = environment.data;
|
||||
char *end = environment.data + environment.usable_envsize;
|
||||
|
||||
while (old_ptr < end && *old_ptr) {
|
||||
if (strncmp(old_ptr, name, name_len) != 0 || old_ptr[name_len] != '=') {
|
||||
int len = strlen(old_ptr) + 1;
|
||||
if (ptr + len > new_env + ENV_HEADER_SIZE + environment.usable_envsize) {
|
||||
fprintf(stderr, "Error: ENV data overflow\n");
|
||||
free(new_env);
|
||||
return -1;
|
||||
}
|
||||
memcpy(ptr, old_ptr, len);
|
||||
ptr += len;
|
||||
}
|
||||
old_ptr += strlen(old_ptr) + 1;
|
||||
}
|
||||
|
||||
if (value) {
|
||||
int entry_len = snprintf(ptr, new_env + ENV_HEADER_SIZE + environment.usable_envsize - ptr, "%s=%s", name, value) + 1;
|
||||
if (ptr + entry_len > new_env + ENV_HEADER_SIZE + environment.usable_envsize) {
|
||||
fprintf(stderr, "Error: New variable exceeds usable ENV size\n");
|
||||
free(new_env);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
new_crc = crc32(0, (unsigned char *)new_env + ENV_HEADER_SIZE, environment.usable_envsize);
|
||||
memcpy(new_env, &new_crc, ENV_CRC_SIZE);
|
||||
|
||||
memcpy(environment.image, new_env, CUR_ENVSIZE);
|
||||
free(new_env);
|
||||
|
||||
environment.dirty = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// 设置环境变量
|
||||
int fw_env_set(int argc, char *argv[], struct env_opts *opts)
|
||||
{
|
||||
char *name, *value;
|
||||
int ret = 0;
|
||||
|
||||
if (argc < 1) {
|
||||
fprintf(stderr, "Error: No variable name specified\n");
|
||||
return -1;
|
||||
}
|
||||
name = argv[0];
|
||||
|
||||
if (fw_env_open(opts))
|
||||
return -1;
|
||||
|
||||
value = concat_env_value(argc, argv);
|
||||
if (fw_env_write(name, value)) {
|
||||
ret = -1;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (flash_erase() || flash_io(O_WRONLY)) {
|
||||
ret = -1;
|
||||
goto out;
|
||||
}
|
||||
|
||||
fprintf(stderr, "Success: set %s=%s (ENV size: %lu bytes, usable: %lu bytes)\n",
|
||||
name, value ? value : "", CUR_ENVSIZE, environment.usable_envsize);
|
||||
|
||||
out:
|
||||
free(value);
|
||||
fw_env_close(opts);
|
||||
return ret;
|
||||
}
|
||||
|
||||
// 关闭环境变量
|
||||
int fw_env_close(struct env_opts *opts)
|
||||
{
|
||||
(void)opts;
|
||||
|
||||
if (environment.image) {
|
||||
free(environment.image);
|
||||
environment.image = NULL;
|
||||
}
|
||||
if (CUR_DEVNAME) {
|
||||
free(CUR_DEVNAME);
|
||||
CUR_DEVNAME = NULL;
|
||||
}
|
||||
|
||||
memset(&environment, 0, sizeof(environment));
|
||||
memset(envdevices, 0, sizeof(envdevices));
|
||||
return 0;
|
||||
}
|
||||
|
||||
// 版本信息
|
||||
char *fw_env_version(void)
|
||||
{
|
||||
static char version[] = "fw_env v1.0 (U-Boot compatible, no mmap, dynamic ENV size)";
|
||||
return version;
|
||||
}
|
||||
@@ -0,0 +1,185 @@
|
||||
// SPDX-License-Identifier: GPL-2.0+
|
||||
#include "fw_env.h"
|
||||
#include <fcntl.h>
|
||||
#include <getopt.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/file.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#define CMD_PRINTENV "fw_printenv"
|
||||
#define CMD_SETENV "fw_setenv"
|
||||
|
||||
static int do_printenv = 0;
|
||||
static char *script_file = NULL;
|
||||
static int noheader = 0;
|
||||
static struct env_opts env_opts = {
|
||||
#ifdef CONFIG_FILE
|
||||
.config_file = NULL,
|
||||
#endif
|
||||
.lockname = NULL,
|
||||
.part = NULL,
|
||||
.offset = 0x0,
|
||||
.size = 0x0,
|
||||
.esize = 0x0,
|
||||
};
|
||||
|
||||
static const struct option long_options[] = {
|
||||
{"config", required_argument, NULL, 'c'},
|
||||
{"help", no_argument, NULL, 'h'},
|
||||
{"script", required_argument, NULL, 'S'},
|
||||
{"noheader", no_argument, NULL, 'n'},
|
||||
{"lock", required_argument, NULL, 'l'},
|
||||
{"version", no_argument, NULL, 'v'},
|
||||
{"part", required_argument, NULL, 'p'},
|
||||
{"offset", required_argument, NULL, 'o'},
|
||||
{"size", required_argument, NULL, 's'},
|
||||
{"esize", required_argument, NULL, 'e'},
|
||||
{NULL, 0, NULL, 0}
|
||||
};
|
||||
|
||||
static void usage(int is_printenv)
|
||||
{
|
||||
if (is_printenv) {
|
||||
fprintf(stderr,
|
||||
"Usage: %s [OPTIONS]... [VARIABLE]...\n"
|
||||
"Print variables from U-Boot environment\n\n"
|
||||
"Options:\n"
|
||||
" -h, --help Print this help message\n"
|
||||
" -v, --version Display version information\n"
|
||||
#ifdef CONFIG_FILE
|
||||
" -c, --config FILE Use specified configuration file\n"
|
||||
#endif
|
||||
" -n, --noheader Only print variable values\n"
|
||||
" -l, --lock FILE Use specified lock file\n"
|
||||
" -p, --part NAME Specify partition name\n"
|
||||
" -o, --offset NUM Specify environment offset\n"
|
||||
" -s, --size NUM Specify environment size\n"
|
||||
" -e, --esize NUM Specify environment effective size\n\n",
|
||||
CMD_PRINTENV);
|
||||
} else {
|
||||
fprintf(stderr,
|
||||
"Usage: %s [OPTIONS]... [VARIABLE]... [VALUE]...\n"
|
||||
"Modify variables in U-Boot environment\n\n"
|
||||
"Options:\n"
|
||||
" -h, --help Print this help message\n"
|
||||
" -v, --version Display version information\n"
|
||||
#ifdef CONFIG_FILE
|
||||
" -c, --config FILE Use specified configuration file\n"
|
||||
#endif
|
||||
" -l, --lock FILE Use specified lock file\n"
|
||||
" -S, --script FILE Batch modify variables via script\n"
|
||||
" -p, --part NAME Specify partition name\n"
|
||||
" -o, --offset NUM Specify environment offset\n"
|
||||
" -s, --size NUM Specify environment size\n"
|
||||
" -e, --esize NUM Specify environment effective size\n\n"
|
||||
"Examples:\n"
|
||||
" %s foo bar Set variable 'foo' to 'bar'\n"
|
||||
" %s foo Delete variable 'foo'\n\n",
|
||||
CMD_SETENV, CMD_SETENV, CMD_SETENV);
|
||||
}
|
||||
}
|
||||
|
||||
static int parse_env_args(int argc, char *argv[], int is_printenv)
|
||||
{
|
||||
int c;
|
||||
opterr = 0;
|
||||
|
||||
#ifdef CONFIG_FILE
|
||||
env_opts.config_file = CONFIG_FILE;
|
||||
#endif
|
||||
|
||||
while ((c = getopt_long(argc, argv, "a:c:nl:h:vS:p:o:s:e:", long_options, NULL)) != EOF) {
|
||||
switch (c) {
|
||||
case 'c':
|
||||
#ifdef CONFIG_FILE
|
||||
env_opts.config_file = optarg;
|
||||
#endif
|
||||
break;
|
||||
case 'l':
|
||||
env_opts.lockname = optarg;
|
||||
break;
|
||||
case 'n':
|
||||
noheader = 1;
|
||||
break;
|
||||
case 'S':
|
||||
script_file = optarg;
|
||||
break;
|
||||
case 'p':
|
||||
env_opts.part = optarg;
|
||||
break;
|
||||
case 'o':
|
||||
env_opts.offset = strtoul(optarg, NULL, 0);
|
||||
break;
|
||||
case 's':
|
||||
env_opts.size = strtoul(optarg, NULL, 0);
|
||||
break;
|
||||
case 'e':
|
||||
env_opts.esize = strtoul(optarg, NULL, 0);
|
||||
break;
|
||||
case 'h':
|
||||
usage(is_printenv);
|
||||
exit(EXIT_SUCCESS);
|
||||
case 'v':
|
||||
fprintf(stderr, "fw_env v2020.01-standalone\n");
|
||||
exit(EXIT_SUCCESS);
|
||||
case 'a':
|
||||
break;
|
||||
case '?':
|
||||
fprintf(stderr, "Unknown option: -%c\n", optopt);
|
||||
usage(is_printenv);
|
||||
return -1;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int retval = EXIT_SUCCESS;
|
||||
char *cmdname = *argv;
|
||||
|
||||
if (strrchr(cmdname, '/')) {
|
||||
cmdname = strrchr(cmdname, '/') + 1;
|
||||
}
|
||||
|
||||
if (strcmp(cmdname, CMD_PRINTENV) == 0) {
|
||||
do_printenv = 1;
|
||||
} else if (strcmp(cmdname, CMD_SETENV) == 0) {
|
||||
do_printenv = 0;
|
||||
} else {
|
||||
fprintf(stderr, "Error: Must be called as '%s' or '%s' (not '%s')\n", CMD_PRINTENV, CMD_SETENV, cmdname);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (parse_env_args(argc, argv, do_printenv) != 0) {
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
argc -= optind;
|
||||
argv += optind;
|
||||
|
||||
if (do_printenv) {
|
||||
if (fw_printenv(argc, argv, noheader, &env_opts) != 0)
|
||||
retval = EXIT_FAILURE;
|
||||
} else {
|
||||
if (script_file) {
|
||||
fprintf(stderr, "Script mode not implemented\n");
|
||||
retval = EXIT_FAILURE;
|
||||
} else {
|
||||
if (argc < 1) {
|
||||
fprintf(stderr, "Error: No variable name specified\n");
|
||||
usage(0);
|
||||
retval = EXIT_FAILURE;
|
||||
} else if (fw_env_set(argc, argv, &env_opts) != 0) {
|
||||
retval = EXIT_FAILURE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
Reference in New Issue
Block a user