]> code.bitgloo.com Git - clyne/stmos.git/commitdiff
Fixed syscalls, initrd program works
authortcsullivan <tullivan99@gmail.com>
Thu, 18 Jul 2019 22:43:22 +0000 (18:43 -0400)
committertcsullivan <tullivan99@gmail.com>
Thu, 18 Jul 2019 22:43:22 +0000 (18:43 -0400)
12 files changed:
run.sh
src/initrd/Makefile
src/initrd/init.c
src/kernel/clock.c
src/kernel/gpio.c
src/kernel/svc.c
src/kernel/task.c
src/kernel/vfs.c
src/libgpio/gpio.c
src/libgpio/libgpio.a
src/pdclib/platform/stmos/functions/os/syscalls.c
src/pdclib/stmos_install_headers.sh [new file with mode: 0755]

diff --git a/run.sh b/run.sh
index a1c344c9a3f423509562c631df49640f67917a90..8253d059c338c72bb62afc97ec1ae3808c758c81 100755 (executable)
--- a/run.sh
+++ b/run.sh
@@ -3,7 +3,7 @@
 # Starts openocd and connects gdb to the target, for programming/debugging
 #
 
-openocd -f /usr/share/openocd/scripts/board/st_nucleo_l476rg.cfg &
+openocd -f /usr/local/share/openocd/scripts/board/st_nucleo_l4.cfg &
 sleep 1 # Need to wait some time for openocd to connect
 gdb-multiarch -ex "target remote localhost:3333" main.elf
 pkill openocd # Ensure openocd exits when we're done
index 82785f40f758202c300e18f3f803e75c01791b8c..3385008ed26d6199f87069fa34ba59122a988369 100644 (file)
@@ -16,6 +16,7 @@ all: $(OFILES)
 files/%: %.c
        @echo "  CC     " $<
        @$(CROSS)$(CC) $(CFLAGS) $< ../libgpio/libgpio.a -o $@
+       @cp -v $@ init.debug
        @$(CROSS)strip $@
 
 clean:
index dc88ff8e97272eb6a4370e77a5ef8373aea2c500..ad3be4124065529befca7c2f2a104c109b3448f5 100644 (file)
@@ -10,8 +10,7 @@
 int main(void)
 {
        gpioMode(5, OUTPUT);
-
-       printf("Hello, world!\n");
+       printf("Hello, world!\n\r");
 
        while (1) {
                gpioWrite(5, 1);
index a49b4c1d6a80ed84d849ffba2b3841b195e12bda..41a31992cbaf6709f7a9676ba40796cdcdab12e4 100644 (file)
@@ -27,14 +27,14 @@ volatile uint32_t clock_ticks = 0;
 
 volatile uint8_t tim2_finished = 1;
 
-void clock_svc(uint32_t *args)
+void clock_svc(uint32_t n, uint32_t *ret, uint32_t *args)
 {
-       if (args[0] == 0)
-               task_sleep(args[1]);
-       else if (args[0] == 1)
-               clock_udelay(args[1]);
-       else if (args[0] == 2)
-               *((unsigned int *)args[1]) = clock_millis();
+       if (n == 0)
+               task_sleep(args[0]);
+       else if (n == 1)
+               clock_udelay(args[0]);
+       else if (n == 2)
+               *((unsigned int *)ret) = clock_millis();
 }
 
 void clock_init(void)
index 33423b94b53288ea51c1bb4d8c607e0a6a024d42..3bd67cb0ae22199dd80a3ea66ba414853af89dc1 100644 (file)
@@ -25,29 +25,29 @@ static GPIO_TypeDef *gpio_ports[8] = {
        GPIOE, GPIOF, GPIOG, GPIOH
 };
 
-void gpio_svc(uint32_t *args)
+void gpio_svc(uint32_t n, uint32_t *ret, uint32_t *args)
 {
-       GPIO_TypeDef *port = gpio_ports[args[1] >> 4];
-       uint32_t pin = args[1] & 0xF;
+       GPIO_TypeDef *port = gpio_ports[args[0] >> 4];
+       uint32_t pin = args[0] & 0xF;
 
-       switch (args[0]) {
+       switch (n) {
        case 0:
-               gpio_mode(port, pin, args[2]);
+               gpio_mode(port, pin, args[1]);
                break;
        case 1:
-               gpio_type(port, pin, args[2]);
+               gpio_type(port, pin, args[1]);
                break;
        case 2:
-               gpio_pupd(port, pin, args[2]);
+               gpio_pupd(port, pin, args[1]);
                break;
        case 3:
-               gpio_speed(port, pin, args[2]);
+               gpio_speed(port, pin, args[1]);
                break;
        case 4:
-               gpio_dout(port, pin, args[2]);
+               gpio_dout(port, pin, args[1]);
                break;
        case 5:
-               *((int *)args[2]) = gpio_din(port, pin);
+               *((int *)ret) = gpio_din(port, pin);
                break;
        }
 }
index 9044141b11a9c165ef7430c135de0ca725b906ad..7c81e5f8395c1364a0b4a2b9abc3db04db53007a 100644 (file)
 #include "clock.h"
 #include "task.h"
 
-extern void gpio_svc(uint32_t *);
-extern void clock_svc(uint32_t *);
-extern void task_svc(uint32_t *);
-extern void vfs_svc(uint32_t *args);
+extern void gpio_svc(uint32_t, uint32_t *, uint32_t *);
+extern void clock_svc(uint32_t, uint32_t *, uint32_t *);
+extern void task_svc(uint32_t, uint32_t *, uint32_t *);
+extern void vfs_svc(uint32_t, uint32_t *, uint32_t *args);
 
 void SVC_Handler(void) {
-       uint32_t *args;
+       uint32_t *stack;
 
        asm("\
                tst lr, #4; \
                ite eq; \
                mrseq %0, msp; \
                mrsne %0, psp; \
-       " : "=r" (args));
+       " : "=r" (stack));
 
-       int svc_number = ((char *)args[6])[-2];
+       int svc_number = ((char *)stack[6])[-2];
+       uint32_t min_number = stack[0];
+       uint32_t *ret = (uint32_t *)stack[1];
+       uint32_t *args = (uint32_t *)stack[2];
 
        switch (svc_number) {
        case -1:
@@ -50,7 +53,7 @@ void SVC_Handler(void) {
                 * 4 - sbrk (TODO bad)
                 * 5 - execve
                 */
-               task_svc(args);
+               task_svc(min_number, ret, args);
                break;
 
        case 1: /* GPIO-related calls
@@ -61,7 +64,7 @@ void SVC_Handler(void) {
                 * 4 - gpio_dout
                 * 5 - gpio_din
                 */
-               gpio_svc(args);
+               gpio_svc(min_number, ret, args);
                break;
 
        case 2: /* Clock-related calls
@@ -69,7 +72,7 @@ void SVC_Handler(void) {
                 * 1 - udelay
                 * 2 - ticks
                 */
-               clock_svc(args);
+               clock_svc(min_number, ret, args);
                break;
 
        case 3: /* Filesystem-related calls
@@ -79,7 +82,7 @@ void SVC_Handler(void) {
                 * 3 - read
                 * 4 - write
                 */
-               vfs_svc(args);
+               vfs_svc(min_number, ret, args);
                break;
        default:
                break;
index c5d09d42cc220779a8c2972b35ffdf3dcdb8e329..304e6087030bc3a33cb8adeefdc3b46a4287c84b 100644 (file)
@@ -31,28 +31,28 @@ static task_t *task_queue;
 static uint8_t task_disable = 0;
 static pid_t task_next_pid = 0;
 
-void task_svc(uint32_t *args)
+void task_svc(uint32_t n, uint32_t *ret, uint32_t *args)
 {
-       switch (args[0]) {
+       switch (n) {
        case 0:
-               task_exit(args[1]);
+               task_exit(args[0]);
                break;
        case 1:
-               *((int *)args[1]) = task_fork();
+               *((int *)ret) = task_fork();
                break;
        case 2:
-               *((int *)args[1]) = task_getpid();
+               *((int *)ret) = task_getpid();
                break;
        case 3:
-               *((int *)args[4]) = task_waitpid(args[1], (int *)args[2],
-                       args[3]);
+               *((int *)ret) = task_waitpid(args[0], (int *)args[1],
+                       args[2]);
                break;
        case 4:
-               *((void **)args[2]) = task_sbrk(args[1]);
+               *((void **)ret) = task_sbrk(args[0]);
                break;
        case 5:
-               *((uint32_t *)args[4]) = elf_execve((const char *)args[1],
-                       (char * const *)args[2], (char * const *)args[3]);
+               *((uint32_t *)ret) = elf_execve((const char *)args[0],
+                       (char * const *)args[1], (char * const *)args[2]);
                break;
        default:
                break;
@@ -325,7 +325,7 @@ void PendSV_Handler(void)
                        task_current = task_queue;
 
                if (task_current->status.state == TASK_SLEEPING &&
-                       task_current->status.value <= ticks)
+                       task_current->status.value < ticks)
                        task_current->status.state = TASK_RUNNING;
        } while (task_current->status.state != TASK_RUNNING);
 
index b9be9bc9eea05def5dc5d03ac770535769f4c468..8d4b9753175839c26694d5721b393878b64e0737 100644 (file)
@@ -35,24 +35,24 @@ static vfs_file vfs_files[VFS_MAX_FILES];
        if (pid != fpid && fpid != 0) \
                return 0; }
 
-void vfs_svc(uint32_t *args)
+void vfs_svc(uint32_t n, uint32_t *ret, uint32_t *args)
 {
-       switch (args[0]) {
+       switch (n) {
        case 0:
-               *((int *)args[3]) = vfs_mount((vfs_volume_funcs *)args[1],
-                       args[2]);
+               *((int *)ret) = vfs_mount((vfs_volume_funcs *)args[0],
+                       args[1]);
                break;
        case 1:
-               *((int *)args[3]) = vfs_open((const char *)args[1], args[2]);
+               *((int *)ret) = vfs_open((const char *)args[0], args[1]);
                break;
        case 2:
-               *((int *)args[2]) = vfs_close(args[1]);
+               *((int *)ret) = vfs_close(args[0]);
                break;
        case 3:
-               *((int *)args[4]) = vfs_read(args[1], args[2], (uint8_t *)args[3]);
+               *((int *)ret) = vfs_read(args[0], args[1], (uint8_t *)args[2]);
                break;
        case 4:
-               *((int *)args[4]) = vfs_write(args[1], args[2], (const uint8_t *)args[3]);
+               *((int *)ret) = vfs_write(args[0], args[1], (const uint8_t *)args[2]);
                break;
        default:
                break;
index fdc877cdc1b32d4a025ff9808e9f68d7195083aa..522817f62cb21201f96e3dd25e8ff9c3b5f7778a 100644 (file)
@@ -2,77 +2,79 @@
 
 #include <stdint.h>
 
+#define NOOPTIMIZE __attribute__((optimize(0)))
+
+NOOPTIMIZE
 void gpioMode(gpio_pin_t pin, int mode)
 {
-       register uint32_t r1 __asm("r1") = pin;
-       register uint32_t r2 __asm("r2") = mode;
-       __asm("\
+       uint32_t args[2] = { (uint32_t)pin, mode };
+       __asm volatile("\
                mov r0, 0; \
-               mov r1, %0; \
-               mov r2, %1; \
+               mov r1, 0; \
+               mov r2, %0; \
                svc 1; \
-       " :: "r" (r1), "r" (r2));
+       " :: "r" (args));
 }
 
+NOOPTIMIZE
 void gpioType(gpio_pin_t pin, int type)
 {
-       register uint32_t r1 __asm("r1") = pin;
-       register uint32_t r2 __asm("r2") = type;
-       __asm("\
+       uint32_t args[2] = { (uint32_t)pin, type };
+       __asm volatile("\
                mov r0, 1; \
-               mov r1, %0; \
-               mov r2, %1; \
+               mov r1, 0; \
+               mov r2, %0; \
                svc 1; \
-       " :: "r" (r1), "r" (r2));
+       " :: "r" (args));
 }
 
+NOOPTIMIZE
 void gpioPuPd(gpio_pin_t pin, int pupd)
 {
-       register uint32_t r1 __asm("r1") = pin;
-       register uint32_t r2 __asm("r2") = pupd;
-       __asm("\
+       uint32_t args[2] = { (uint32_t)pin, pupd };
+       __asm volatile("\
                mov r0, 2; \
-               mov r1, %0; \
-               mov r2, %1; \
+               mov r1, 0; \
+               mov r2, %0; \
                svc 1; \
-       " :: "r" (r1), "r" (r2));
+       " :: "r" (args));
 }
 
+NOOPTIMIZE
 void gpioSpeed(gpio_pin_t pin, int speed)
 {
-       register uint32_t r1 __asm("r1") = pin;
-       register uint32_t r2 __asm("r2") = speed;
-       __asm("\
+       uint32_t args[2] = { (uint32_t)pin, speed };
+       __asm volatile("\
                mov r0, 3; \
-               mov r1, %0; \
-               mov r2, %1; \
+               mov r1, 0; \
+               mov r2, %0; \
                svc 1; \
-       " :: "r" (r1), "r" (r2));
+       " :: "r" (args));
 }
 
+NOOPTIMIZE
 void gpioWrite(gpio_pin_t pin, int value)
 {
-       register uint32_t r1 __asm("r1") = pin;
-       register uint32_t r2 __asm("r2") = value;
-       __asm("\
+       uint32_t args[2] = { (uint32_t)pin, value };
+       __asm volatile("\
                mov r0, 4; \
-               mov r1, %0; \
-               mov r2, %1; \
+               mov r1, 0; \
+               mov r2, %0; \
                svc 1; \
-       " :: "r" (r1), "r" (r2));
+       " :: "r" (args));
 }
 
+NOOPTIMIZE
 int gpioRead(gpio_pin_t pin)
 {
-       int ret = 0;
-       register uint32_t r1 __asm("r1") = pin;
-       register uint32_t r2 __asm("r2") = (uint32_t)&ret;
-       __asm("\
+       volatile int ret = 0;
+       uint32_t args[1] = { (uint32_t)pin };
+       __asm volatile("\
                mov r0, 5; \
                mov r1, %0; \
                mov r2, %1; \
                svc 1; \
-       " :: "r" (r1), "r" (r2));
+       " :: "r" (&ret), "r" (args));
        return ret;
 }
 
index b8c781de136b452a0ea69d15200c57c8cf03e195..36cb0e8672a51d0453e4013bcd19c797899547b0 100644 (file)
Binary files a/src/libgpio/libgpio.a and b/src/libgpio/libgpio.a differ
index 912b9889cddd7f5e6156fb8391c1a7b02265038f..823da237d235841187d96c2f4f8831958465e1c8 100644 (file)
@@ -1,72 +1,73 @@
 #include "syscalls.h"
 
+#define NOOPTIMIZE __attribute__((optimize(0)))
+
 //
 // Task-related calls
 
+NOOPTIMIZE
 void _exit(int code)
 {
-       register uint32_t r1 __asm("r1") = code;
-       __asm("\
+       uint32_t args[1] = { code };
+       __asm volatile("\
                mov r0, 0; \
-               mov r1, %0; \
+               mov r1, 0; \
+               mov r2, %0; \
                svc 0; \
-       " :: "r" (r1));
+       " :: "r" (args));
 }
 
+NOOPTIMIZE
 int fork(void)
 {
-       int ret = 0;
-       register uint32_t r1 __asm("r1") = (uint32_t)&ret;
-       __asm("\
+       volatile uint32_t ret = 0;
+       __asm volatile("\
                mov r0, 1; \
                mov r1, %0; \
+               mov r2, 0; \
                svc 0; \
-       " :: "r" (r1));
+       " :: "r" (&ret));
        return ret;
 }
 
+NOOPTIMIZE
 int getpid(void)
 {
-       int ret = 0;
-       register uint32_t r1 __asm("r1") = (uint32_t)&ret;
-       __asm("\
+       volatile uint32_t ret = 0;
+       __asm volatile("\
                mov r0, 2; \
                mov r1, %0; \
+               mov r2, 0; \
                svc 0; \
-       " :: "r" (r1));
+       " :: "r" (&ret));
        return ret;
 }
 
+NOOPTIMIZE
 void *sbrk(unsigned int bytes)
 {
-       uint32_t ret = 0;
-       register uint32_t r1 __asm("r1") = bytes;
-       register uint32_t r2 __asm("r2") = (uint32_t)&ret;
+       volatile uint32_t ret = 0;
+       uint32_t args[1] = { bytes };
        __asm("\
                mov r0, 4; \
                mov r1, %0; \
                mov r2, %1; \
                svc 0; \
-       " :: "r" (r1), "r" (r2));
-       __asm("mov %0, r2" : "=r" (ret));
-       return *((void **)ret);
+       " :: "r" (&ret), "r" (args));
+       return (void *)ret;
 }
 
+NOOPTIMIZE
 int execve(const char *file, char * const argv[], char * const envp[])
 {
        volatile uint32_t ret = 0;
-       register uint32_t r1 __asm("r1") = (uint32_t)file;
-       register uint32_t r2 __asm("r2") = (uint32_t)argv;
-       register uint32_t r3 __asm("r3") = (uint32_t)envp;
-       register uint32_t r12 __asm("r12") = (uint32_t)&ret;
+       uint32_t args[3] = { (uint32_t)file, (uint32_t)argv, (uint32_t)envp };
        __asm("\
                mov r0, 5; \
                mov r1, %0; \
                mov r2, %1; \
-               mov r3, %2; \
-               mov r12, %3; \
                svc 0; \
-       " :: "r" (r1), "r" (r2), "r" (r3), "r" (r12));
+       " :: "r" (&ret), "r" (args));
 
        if (ret == (uint32_t)-1)
                return ret;
@@ -77,110 +78,101 @@ int execve(const char *file, char * const argv[], char * const envp[])
 //
 // Clock-related calls
 
+NOOPTIMIZE
 void delay(unsigned int ms)
 {
-       register uint32_t r1 __asm("r1") = ms;
+       uint32_t args[1] = { ms };
        __asm("\
                mov r0, 0; \
-               mov r1, %0; \
+               mov r1, 0; \
+               mov r2, %0; \
                svc 2; \
-       " :: "r" (r1));
+       " :: "r" (args));
 }
 
+NOOPTIMIZE
 unsigned int ticks(void)
 {
-       unsigned int ret = 0;
-       register uint32_t r1 __asm("r1") = (uint32_t)&ret;
+       volatile unsigned int ret = 0;
        __asm("\
                mov r0, 2; \
                mov r1, %0; \
+               mov r2, 0; \
                svc 2; \
-       " :: "r" (r1));
+       " :: "r" (&ret));
        return ret;
 }
 
 //
 // File-related calls
 
+NOOPTIMIZE
 int mount(vfs_volume_funcs *funcs, uint32_t flags)
 {
-       int ret = 0;
-       register uint32_t r1 __asm("r1") = (uint32_t)funcs;
-       register uint32_t r2 __asm("r2") = flags;
-       register uint32_t r3 __asm("r3") = (uint32_t)&ret;
+       volatile int ret = 0;
+       uint32_t args[2] = { (uint32_t)funcs, flags };
        __asm("\
                mov r0, 0; \
                mov r1, %0; \
                mov r2, %1; \
-               mov r3, %2; \
                svc 3; \
-       " :: "r" (r1), "r" (r2), "r" (r3));
+       " :: "r" (&ret), "r" (args));
        return ret;
 }
 
+NOOPTIMIZE
 int open(const char *path, uint32_t flags)
 {
-       int ret = 0;
-       register uint32_t r1 __asm("r1") = (uint32_t)path;
-       register uint32_t r2 __asm("r2") = flags;
-       register uint32_t r3 __asm("r3") = (uint32_t)&ret;
+       volatile int ret = 0;
+       uint32_t args[2] = { (uint32_t)path, flags };
        __asm("\
                mov r0, 1; \
                mov r1, %0; \
                mov r2, %1; \
-               mov r3, %2; \
                svc 3; \
-       " :: "r" (r1), "r" (r2), "r" (r3));
+       " :: "r" (&ret), "r" (args));
        return ret;
 }
 
+NOOPTIMIZE
 int close(int fd)
 {
-       int ret = 0;
-       register uint32_t r1 __asm("r1") = fd;
-       register uint32_t r2 __asm("r2") = (uint32_t)&ret;
+       volatile int ret = 0;
+       uint32_t args[1] = { fd };
        __asm("\
                mov r0, 2; \
                mov r1, %0; \
                mov r2, %1; \
                svc 3; \
-       " :: "r" (r1), "r" (r2));
+       " :: "r" (&ret), "r" (args));
        return ret;
 }
 
+NOOPTIMIZE
 int read(int fd, uint32_t count, uint8_t *buffer)
 {
-       int ret = 0;
-       register uint32_t r1 __asm("r1") = fd;
-       register uint32_t r2 __asm("r2") = count;
-       register uint32_t r3 __asm("r3") = (uint32_t)buffer;
-       register uint32_t r12 __asm("r12") = (uint32_t)&ret;
+       volatile int ret = 0;
+       uint32_t args[3] = { fd, count, (uint32_t)buffer };
        __asm("\
                mov r0, 3; \
                mov r1, %0; \
                mov r2, %1; \
-               mov r3, %2; \
-               mov r12, %3; \
                svc 3; \
-       " :: "r" (r1), "r" (r2), "r" (r3), "r" (r12));
+       " :: "r" (&ret), "r" (args));
        return ret;
 }
 
+NOOPTIMIZE
 int write(int fd, uint32_t count, const uint8_t *buffer)
 {
-       int ret = 0;
-       register uint32_t r1 __asm("r1") = fd;
-       register uint32_t r2 __asm("r2") = count;
-       register uint32_t r3 __asm("r3") = (uint32_t)buffer;
-       register uint32_t r12 __asm("r12") = (uint32_t)&ret;
+       volatile int ret = 0;
+       uint32_t args[3] = { fd, count, (uint32_t)buffer };
        __asm("\
                mov r0, 4; \
                mov r1, %0; \
                mov r2, %1; \
-               mov r3, %2; \
-               mov r12, %3; \
                svc 3; \
-       " :: "r" (r1), "r" (r2), "r" (r3), "r" (r12));
+       " :: "r" (&ret), "r" (args));
        return ret;
 }
 
diff --git a/src/pdclib/stmos_install_headers.sh b/src/pdclib/stmos_install_headers.sh
new file mode 100755 (executable)
index 0000000..02f46ab
--- /dev/null
@@ -0,0 +1,6 @@
+#!/bin/bash
+# Installs header files to arm-stmos directory (~/arm-stmos)
+
+cp -Rv include/* $HOME/arm-stmos/usr/include
+cp -Rv platform/stmos/include/* $HOME/arm-stmos/usr/include
+