Merge branch 'zephyr'

Author: mkellner

build/devices/zephyr/app/CMakeLists.txt

@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.20.0)
+
+set(CMAKE_OBJECT_PATH_MAX 1024)
+
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+project(moddable)
+
+# export all the flags used by zephyr
+zephyr_get_include_directories_for_lang_as_string(       C includes)
+zephyr_get_system_include_directories_for_lang_as_string(C system_includes)
+zephyr_get_compile_definitions_for_lang_as_string(       C definitions)
+zephyr_get_compile_options_for_lang_as_string(           C options)
+
+if(DEFINED CMAKE_C_COMPILER_TARGET)
+  set(target_flag "--target=${CMAKE_C_COMPILER_TARGET}")
+endif()
+
+set(external_project_cflags
+  "${target_flag} ${includes} ${definitions} ${options} ${system_includes}"
+  )
+
+add_subdirectory("${MODDABLE_BUILD_DIR}" "${MODDABLE_BUILD_DIR}/app")
+find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
+
+# message(STATUS "*-*-*-*-*-*-*-*-*")
+# get_cmake_property(_variableNames VARIABLES)
+# list (SORT _variableNames)
+# foreach (_variableName ${_variableNames})
+#      message(STATUS "${_variableName}=${${_variableName}}")
+# endforeach()
+
+
+target_sources(app PRIVATE
+	src/main.c
+	src/debugger.c
+	src/serial_fifo.c
+	)
+

build/devices/zephyr/app/prj.conf

@@ -0,0 +1,25 @@
+CONFIG_STDOUT_CONSOLE=y
+CONFIG_GPIO=y
+CONFIG_I2C=y
+CONFIG_EVENTS=y
+CONFIG_NEWLIB_LIBC=y
+CONFIG_REBOOT=y
+
+CONFIG_ASSERT=y
+CONFIG_MAIN_STACK_SIZE=8192
+CONFIG_HEAP_MEM_POOL_SIZE=65536
+CONFIG_MULTITHREADING=y
+
+CONFIG_HWINFO=y
+CONFIG_UART_INTERRUPT_DRIVEN=y
+
+# future
+# CONFIG_NETWORKING
+
+CONFIG_SYS_HEAP_RUNTIME_STATS=y
+# CONFIG_SYS_HEAP_ARRAY_SIZE=4                                                    
+# CONFIG_HAVE_CUSTOM_LINKER_SCRIPT=y                                              
+# CONFIG_CUSTOM_LINKER_SCRIPT="linker_arm_nocopy.ld"                              
+# CONFIG_XIP=y
+
+

build/devices/zephyr/app/src/debugger.c

@@ -0,0 +1,141 @@
+
+#include "xs.h"
+#include "xsHost.h"
+
+#include <zephyr/kernel.h>
+#include <zephyr/device.h>
+#include <zephyr/drivers/uart.h>
+#include <zephyr/sys/ring_buffer.h>
+
+#include "mc.defines.h"
+
+#ifndef DEBUGGER_SPEED
+	#define DEBUGGER_SPEED 115200		// in .dts?
+#endif
+
+#define DEBUGGER_STACK 2048
+#define DEBUGGER_PRIORITY	3
+
+k_tid_t gDebugTID;
+struct k_thread gDebugThread;
+K_THREAD_STACK_DEFINE(gDebugStack, DEBUGGER_STACK);
+
+#define DEBUG_QUEUE_LEN			2
+
+#define RING_BUF_SIZE	1024
+static struct ring_buf m_rx_ringbuf;
+static uint8_t rx_ringbuf_buffer[RING_BUF_SIZE];
+
+#define UART_DEVICE_NODE DT_CHOSEN(zephyr_shell_uart)
+static const struct device *const uart_dev = DEVICE_DT_GET(UART_DEVICE_NODE);
+
+static uint8_t gNotifyOutstanding = 0;
+struct k_msgq dbgServiceQueue;
+
+static void die(char *x) {
+	while (1)
+		;
+}
+
+void serial_cb(const struct device *dev, void *user_data)
+{
+	if (!uart_irq_update(uart_dev))
+		return;
+
+	while (uart_irq_rx_ready(uart_dev)) {
+		uint8_t buf[32];
+		
+		uint32_t space = ring_buf_space_get(&m_rx_ringbuf);
+		if (space == 0)
+			die("rx ring buffer full");
+
+		uint32_t use = (space < sizeof(buf)) ? space : sizeof(buf);
+		uint32_t read = uart_fifo_read(uart_dev, buf, use);
+		if (read > 0) {
+			uint32_t written = ring_buf_put(&m_rx_ringbuf, buf, read);
+			if (written != read)
+				die("rx ring buffer full");
+			if (!gNotifyOutstanding) {
+				gNotifyOutstanding = 1;
+				k_msgq_put(&dbgServiceQueue, &gNotifyOutstanding, K_NO_WAIT);
+			}
+		}
+	}
+}
+
+static void debugLoop(void *a, void *b, void *c)
+{
+	uint32_t msg;
+	uint32_t *running = a;
+	
+	int ret = uart_irq_callback_user_data_set(uart_dev, serial_cb, NULL);
+	if (ret < 0) {
+		if ((ret == -ENOTSUP) || (ret == -ENOSYS))
+			printk("Interrupt-driven UART not enabled.\n");
+		else
+			printk("error setting UART callback: %d\n", ret);
+		*running = -1;
+		return;
+	}
+
+	uart_irq_rx_enable(uart_dev);
+	*running = 1;
+
+	while (true) {
+		int err = k_msgq_get(&dbgServiceQueue, &msg, K_MSEC(10000));
+		if (err) continue;
+
+		gNotifyOutstanding = 0;
+#ifdef mxDebug
+		if (ring_buf_size_get(&m_rx_ringbuf) > 0)
+			fxReceiveLoop();
+#endif
+	}
+}
+
+
+void setupDebugger(uint32_t *running)
+{
+	if (!device_is_ready(uart_dev)) {
+		printk("UART device not found!\n");
+		*running = -1;
+		return;
+	}
+
+	k_msgq_alloc_init(&dbgServiceQueue, sizeof(uint8_t), DEBUG_QUEUE_LEN);
+
+	// initial ringbuf
+	ring_buf_init(&m_rx_ringbuf, sizeof(rx_ringbuf_buffer), rx_ringbuf_buffer);
+
+	// make debugger thread
+	gDebugTID = k_thread_create(&gDebugThread, gDebugStack, K_THREAD_STACK_SIZEOF(gDebugStack), debugLoop, running, NULL, NULL, DEBUGGER_PRIORITY, 0, K_NO_WAIT);
+}
+
+void ESP_put(uint8_t *c, int count)
+{
+	while (count) {
+		ESP_putc(*c++);
+		count--;
+	}
+}
+
+void ESP_putc(int c)
+{
+	uint8_t ch = c;
+
+	uart_poll_out(uart_dev, ch);
+}
+
+int ESP_getc(void)
+{
+	uint8_t c;
+	uint32_t len;
+
+	len = ring_buf_get(&m_rx_ringbuf, &c, 1);
+	if (1 == len)
+		return c;
+
+	return -1;
+}
+
+

build/devices/zephyr/app/src/main.c

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2016 Intel Corporation
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr/kernel.h>
+#include <zephyr/drivers/gpio.h>
+
+#include "xsmc.h"
+#include "xsHost.h"
+#include "xsHosts.h"
+#include "mc.defines.h"
+
+#include "modInstrumentation.h"
+
+xsMachine *gThe = NULL;
+
+#if MODDEF_XS_TEST
+	uint8_t gSoftReset;
+#endif
+
+static void runLoop(void *p1, void *p2, void *p3)
+{
+	uint32_t running = 0;
+	setupDebugger(&running);
+
+	while (running == 0) {
+		modDelayMilliseconds(10);
+	}
+
+	while(1) {
+		gThe = modCloneMachine(NULL, NULL);
+		modRunMachineSetup(gThe);
+
+#if MODDEF_XS_TEST
+		xsMachine *the = gThe;
+		gSoftReset = 0;
+		while (!gSoftReset) {
+			modTimersExecute();
+			modMessageService(gThe, modTimersNext());
+			modInstrumentationAdjust(Turns, +1);
+		}
+		xsDeleteMachine(the);
+#else
+		while (true) {
+			modTimersExecute();
+			modMessageService(gThe, modTimersNext());
+			modInstrumentationAdjust(Turns, +1);
+		}
+#endif
+	}
+}
+
+#define PRIORITY 3
+K_THREAD_DEFINE(main_thread, 4096, runLoop, NULL, NULL, NULL, PRIORITY, 0, 0);
+
+int main(void)
+{
+	// nuthin.
+
+	return 0;
+}

build/devices/zephyr/app/src/serial_fifo.c

@@ -0,0 +1,65 @@
+#include "xsPlatform.h"
+#include <stdint.h>
+#include "serial_fifo.h"
+
+#define __INLINE inline
+
+static __INLINE uint32_t F_length(fifo_t *fifo) {
+	uint32_t tmp = fifo->read;
+	return fifo->write - tmp;
+}
+
+static __INLINE void F_put(fifo_t *fifo, uint8_t c) {
+	fifo->buf[fifo->write & fifo->size_mask] = c;
+	fifo->write++;
+}
+
+static __INLINE void F_get(fifo_t *fifo, uint8_t *c) {
+	*c = fifo->buf[fifo->read & fifo->size_mask];
+	fifo->read++;
+}
+
+void fifo_flush(fifo_t *fifo) {
+	fifo->read = fifo->write;
+}
+
+uint32_t fifo_length(fifo_t *fifo) {
+	return F_length(fifo);
+}
+
+uint32_t fifo_full(fifo_t *fifo) {
+	if (0 == (fifo->size_mask - F_length(fifo) + 1))
+		return 1;
+	return 0;
+}
+
+int fifo_get(fifo_t *fifo, uint8_t *c) {
+	if (F_length(fifo) == 0)
+		return -1;
+	F_get(fifo, c);
+	return 0;
+}
+
+int fifo_put(fifo_t *fifo, uint8_t c) {
+	if (0 == (fifo->size_mask - F_length(fifo) + 1))
+		return -1;
+	F_put(fifo, c);
+	return 0;
+}
+
+
+int fifo_init(fifo_t *fifo, uint8_t *buf, uint32_t size) {
+	if (0 == buf)
+		return -1;
+
+	if (! ((0 != size) && (0 == ((size - 1) & size))))
+		return -2;		// bad size - needs to be base 2
+
+	fifo->buf = buf;
+	fifo->size_mask = size - 1;
+	fifo->read = 0;
+	fifo->write = 0;
+
+	return 0;
+}
+

build/devices/zephyr/app/src/serial_fifo.h

@@ -0,0 +1,19 @@
+
+#ifndef __SERIAL_FIFO__
+#define __SERIAL_FIFO__
+
+typedef struct {
+	uint8_t		*buf;
+	uint32_t	size_mask;
+	volatile uint32_t read;
+	volatile uint32_t write;
+} fifo_t;
+
+uint32_t fifo_length(fifo_t *fifo);
+uint32_t fifo_full(fifo_t *fifo);
+int fifo_put(fifo_t *fifo, uint8_t c);
+int fifo_get(fifo_t *fifo, uint8_t *c);
+void fifo_flush(fifo_t *fifo);
+int fifo_init(fifo_t *fifo, uint8_t *buf, uint32_t size);
+
+#endif // __SERIAL_FIFO__