Add submodule dependency filesHEADmaster

Change-Id: Iaf8d18082d3991dec7c0ebbea540f092188eb4ec

1 files changed, 432 insertions, 0 deletions

diff --git a/roms/u-boot/common/log.c b/roms/u-boot/common/log.c
new file mode 100644
index 000000000..ea407c6db
--- /dev/null
+++ b/roms/u-boot/common/log.c
@@ -0,0 +1,432 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Logging support
+ *
+ * Copyright (c) 2017 Google, Inc
+ * Written by Simon Glass <sjg@chromium.org>
+ */
+
+#include <common.h>
+#include <log.h>
+#include <malloc.h>
+#include <asm/global_data.h>
+#include <dm/uclass.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+static const char *const log_cat_name[] = {
+	"none",
+	"arch",
+	"board",
+	"core",
+	"driver-model",
+	"device-tree",
+	"efi",
+	"alloc",
+	"sandbox",
+	"bloblist",
+	"devres",
+	"acpi",
+	"boot",
+};
+
+_Static_assert(ARRAY_SIZE(log_cat_name) == LOGC_COUNT - LOGC_NONE,
+	       "log_cat_name size");
+
+static const char *const log_level_name[] = {
+	"EMERG",
+	"ALERT",
+	"CRIT",
+	"ERR",
+	"WARNING",
+	"NOTICE",
+	"INFO",
+	"DEBUG",
+	"CONTENT",
+	"IO",
+};
+
+_Static_assert(ARRAY_SIZE(log_level_name) == LOGL_COUNT, "log_level_name size");
+
+/* All error responses MUST begin with '<' */
+const char *log_get_cat_name(enum log_category_t cat)
+{
+	const char *name;
+
+	if (cat < 0 || cat >= LOGC_COUNT)
+		return "<invalid>";
+	if (cat >= LOGC_NONE)
+		return log_cat_name[cat - LOGC_NONE];
+
+#if CONFIG_IS_ENABLED(DM)
+	name = uclass_get_name((enum uclass_id)cat);
+#else
+	name = NULL;
+#endif
+
+	return name ? name : "<missing>";
+}
+
+enum log_category_t log_get_cat_by_name(const char *name)
+{
+	enum uclass_id id;
+	int i;
+
+	for (i = LOGC_NONE; i < LOGC_COUNT; i++)
+		if (!strcmp(name, log_cat_name[i - LOGC_NONE]))
+			return i;
+	id = uclass_get_by_name(name);
+	if (id != UCLASS_INVALID)
+		return (enum log_category_t)id;
+
+	return LOGC_NONE;
+}
+
+const char *log_get_level_name(enum log_level_t level)
+{
+	if (level >= LOGL_COUNT)
+		return "INVALID";
+	return log_level_name[level];
+}
+
+enum log_level_t log_get_level_by_name(const char *name)
+{
+	int i;
+
+	for (i = 0; i < LOGL_COUNT; i++) {
+		if (!strcasecmp(log_level_name[i], name))
+			return i;
+	}
+
+	return LOGL_NONE;
+}
+
+struct log_device *log_device_find_by_name(const char *drv_name)
+{
+	struct log_device *ldev;
+
+	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
+		if (!strcmp(drv_name, ldev->drv->name))
+			return ldev;
+	}
+
+	return NULL;
+}
+
+bool log_has_cat(enum log_category_t cat_list[], enum log_category_t cat)
+{
+	int i;
+
+	for (i = 0; i < LOGF_MAX_CATEGORIES && cat_list[i] != LOGC_END; i++) {
+		if (cat_list[i] == cat)
+			return true;
+	}
+
+	return false;
+}
+
+bool log_has_file(const char *file_list, const char *file)
+{
+	int file_len = strlen(file);
+	const char *s, *p;
+	int substr_len;
+
+	for (s = file_list; *s; s = p + (*p != '\0')) {
+		p = strchrnul(s, ',');
+		substr_len = p - s;
+		if (file_len >= substr_len &&
+		    !strncmp(file + file_len - substr_len, s, substr_len))
+			return true;
+	}
+
+	return false;
+}
+
+/**
+ * log_passes_filters() - check if a log record passes the filters for a device
+ *
+ * @ldev: Log device to check
+ * @rec: Log record to check
+ * @return true if @rec is not blocked by the filters in @ldev, false if it is
+ */
+static bool log_passes_filters(struct log_device *ldev, struct log_rec *rec)
+{
+	struct log_filter *filt;
+
+	if (rec->flags & LOGRECF_FORCE_DEBUG)
+		return true;
+
+	/* If there are no filters, filter on the default log level */
+	if (list_empty(&ldev->filter_head)) {
+		if (rec->level > gd->default_log_level)
+			return false;
+		return true;
+	}
+
+	list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
+		if (filt->flags & LOGFF_LEVEL_MIN) {
+			if (rec->level < filt->level)
+				continue;
+		} else if (rec->level > filt->level) {
+			continue;
+		}
+
+		if ((filt->flags & LOGFF_HAS_CAT) &&
+		    !log_has_cat(filt->cat_list, rec->cat))
+			continue;
+
+		if (filt->file_list &&
+		    !log_has_file(filt->file_list, rec->file))
+			continue;
+
+		if (filt->flags & LOGFF_DENY)
+			return false;
+		else
+			return true;
+	}
+
+	return false;
+}
+
+/**
+ * log_dispatch() - Send a log record to all log devices for processing
+ *
+ * The log record is sent to each log device in turn, skipping those which have
+ * filters which block the record.
+ *
+ * All log messages created while processing log record @rec are ignored.
+ *
+ * @rec:	log record to dispatch
+ * Return:	0 msg sent, 1 msg not sent while already dispatching another msg
+ */
+static int log_dispatch(struct log_rec *rec, const char *fmt, va_list args)
+{
+	struct log_device *ldev;
+	char buf[CONFIG_SYS_CBSIZE];
+
+	/*
+	 * When a log driver writes messages (e.g. via the network stack) this
+	 * may result in further generated messages. We cannot process them here
+	 * as this might result in infinite recursion.
+	 */
+	if (gd->processing_msg)
+		return 1;
+
+	/* Emit message */
+	gd->processing_msg = true;
+	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
+		if ((ldev->flags & LOGDF_ENABLE) &&
+		    log_passes_filters(ldev, rec)) {
+			if (!rec->msg) {
+				int len;
+
+				len = vsnprintf(buf, sizeof(buf), fmt, args);
+				rec->msg = buf;
+				gd->log_cont = len && buf[len - 1] != '\n';
+			}
+			ldev->drv->emit(ldev, rec);
+		}
+	}
+	gd->processing_msg = false;
+	return 0;
+}
+
+int _log(enum log_category_t cat, enum log_level_t level, const char *file,
+	 int line, const char *func, const char *fmt, ...)
+{
+	struct log_rec rec;
+	va_list args;
+
+	if (!gd)
+		return -ENOSYS;
+
+	/* Check for message continuation */
+	if (cat == LOGC_CONT)
+		cat = gd->logc_prev;
+	if (level == LOGL_CONT)
+		level = gd->logl_prev;
+
+	rec.cat = cat;
+	rec.level = level & LOGL_LEVEL_MASK;
+	rec.flags = 0;
+	if (level & LOGL_FORCE_DEBUG)
+		rec.flags |= LOGRECF_FORCE_DEBUG;
+	if (gd->log_cont)
+		rec.flags |= LOGRECF_CONT;
+	rec.file = file;
+	rec.line = line;
+	rec.func = func;
+	rec.msg = NULL;
+
+	if (!(gd->flags & GD_FLG_LOG_READY)) {
+		gd->log_drop_count++;
+
+		/* display dropped traces with console puts and DEBUG_UART */
+		if (rec.level <= CONFIG_LOG_DEFAULT_LEVEL ||
+		    rec.flags & LOGRECF_FORCE_DEBUG) {
+			char buf[CONFIG_SYS_CBSIZE];
+
+			va_start(args, fmt);
+			vsnprintf(buf, sizeof(buf), fmt, args);
+			puts(buf);
+			va_end(args);
+		}
+
+		return -ENOSYS;
+	}
+	va_start(args, fmt);
+	if (!log_dispatch(&rec, fmt, args)) {
+		gd->logc_prev = cat;
+		gd->logl_prev = level;
+	}
+	va_end(args);
+
+	return 0;
+}
+
+int log_add_filter_flags(const char *drv_name, enum log_category_t cat_list[],
+			 enum log_level_t level, const char *file_list,
+			 int flags)
+{
+	struct log_filter *filt;
+	struct log_device *ldev;
+	int ret;
+	int i;
+
+	ldev = log_device_find_by_name(drv_name);
+	if (!ldev)
+		return -ENOENT;
+	filt = calloc(1, sizeof(*filt));
+	if (!filt)
+		return -ENOMEM;
+
+	filt->flags = flags;
+	if (cat_list) {
+		filt->flags |= LOGFF_HAS_CAT;
+		for (i = 0; ; i++) {
+			if (i == ARRAY_SIZE(filt->cat_list)) {
+				ret = -ENOSPC;
+				goto err;
+			}
+			filt->cat_list[i] = cat_list[i];
+			if (cat_list[i] == LOGC_END)
+				break;
+		}
+	}
+	filt->level = level;
+	if (file_list) {
+		filt->file_list = strdup(file_list);
+		if (!filt->file_list) {
+			ret = -ENOMEM;
+			goto err;
+		}
+	}
+	filt->filter_num = ldev->next_filter_num++;
+	/* Add deny filters to the beginning of the list */
+	if (flags & LOGFF_DENY)
+		list_add(&filt->sibling_node, &ldev->filter_head);
+	else
+		list_add_tail(&filt->sibling_node, &ldev->filter_head);
+
+	return filt->filter_num;
+
+err:
+	free(filt);
+	return ret;
+}
+
+int log_remove_filter(const char *drv_name, int filter_num)
+{
+	struct log_filter *filt;
+	struct log_device *ldev;
+
+	ldev = log_device_find_by_name(drv_name);
+	if (!ldev)
+		return -ENOENT;
+
+	list_for_each_entry(filt, &ldev->filter_head, sibling_node) {
+		if (filt->filter_num == filter_num) {
+			list_del(&filt->sibling_node);
+			free(filt);
+
+			return 0;
+		}
+	}
+
+	return -ENOENT;
+}
+
+/**
+ * log_find_device_by_drv() - Find a device by its driver
+ *
+ * @drv: Log driver
+ * @return Device associated with that driver, or NULL if not found
+ */
+static struct log_device *log_find_device_by_drv(struct log_driver *drv)
+{
+	struct log_device *ldev;
+
+	list_for_each_entry(ldev, &gd->log_head, sibling_node) {
+		if (ldev->drv == drv)
+			return ldev;
+	}
+	/*
+	 * It is quite hard to pass an invalid driver since passing an unknown
+	 * LOG_GET_DRIVER(xxx) would normally produce a compilation error. But
+	 * it is possible to pass NULL, for example, so this
+	 */
+
+	return NULL;
+}
+
+int log_device_set_enable(struct log_driver *drv, bool enable)
+{
+	struct log_device *ldev;
+
+	ldev = log_find_device_by_drv(drv);
+	if (!ldev)
+		return -ENOENT;
+	if (enable)
+		ldev->flags |= LOGDF_ENABLE;
+	else
+		ldev->flags &= ~LOGDF_ENABLE;
+
+	return 0;
+}
+
+int log_init(void)
+{
+	struct log_driver *drv = ll_entry_start(struct log_driver, log_driver);
+	const int count = ll_entry_count(struct log_driver, log_driver);
+	struct log_driver *end = drv + count;
+
+	/*
+	 * We cannot add runtime data to the driver since it is likely stored
+	 * in rodata. Instead, set up a 'device' corresponding to each driver.
+	 * We only support having a single device.
+	 */
+	INIT_LIST_HEAD((struct list_head *)&gd->log_head);
+	while (drv < end) {
+		struct log_device *ldev;
+
+		ldev = calloc(1, sizeof(*ldev));
+		if (!ldev) {
+			debug("%s: Cannot allocate memory\n", __func__);
+			return -ENOMEM;
+		}
+		INIT_LIST_HEAD(&ldev->filter_head);
+		ldev->drv = drv;
+		ldev->flags = drv->flags;
+		list_add_tail(&ldev->sibling_node,
+			      (struct list_head *)&gd->log_head);
+		drv++;
+	}
+	gd->flags |= GD_FLG_LOG_READY;
+	if (!gd->default_log_level)
+		gd->default_log_level = CONFIG_LOG_DEFAULT_LEVEL;
+	gd->log_fmt = log_get_default_format();
+	gd->logc_prev = LOGC_NONE;
+	gd->logl_prev = LOGL_INFO;
+
+	return 0;
+}