implements pio.h functions and makefile update to optimize size

- remove syscall.h, unused and not implemented
- bug fix for memcmp() in string.c

other changes are still partially unfinished and might not work

7 files changed, 70 insertions, 54 deletions

diff --git a/sw/z80/kernel/drivers/pio.c b/sw/z80/kernel/drivers/pio.c
index 289ebe0..4321fb8 100644
--- a/sw/z80/kernel/drivers/pio.c
+++ b/sw/z80/kernel/drivers/pio.c
@@ -3,17 +3,38 @@
 static uint8_t *pio_port = (uint8_t *) ADDR_DEV_PIO;
 static uint8_t *pio_ctrl = (uint8_t *) (ADDR_DEV_PIO + 2);
 
-void _pio_data(int port, uint8_t data)
+inline void _pio_data(int port, uint8_t data)
 {
     *(pio_port + port) = data;
 }
 
-void _pio_command(int port, uint8_t cmd)
+inline void _pio_control(int port, uint8_t cmd)
 {
     *(pio_ctrl + port) = cmd;
 }
 
-/* void pio_set_mode(int port, int mode)
+void pio_set_mode(int port, int mode, uint8_t io)
 {
+    // 0x0F is a control sequence to set mode
+    _pio_control(port, ((mode << 6) | 0x0F));
 
-} */
+    // this mode requires an additional argument that sets
+    // a mode for each pin
+    if (mode == PIO_MODE_BIT_IO) {
+        _pio_control(port, io);
+    }
+}
+
+void pio_set_interrupts(int port, int control)
+{
+    // 0x07 is a control sequence to set interrupts
+    _pio_control(port, (control | 0x07));
+}
+
+void pio_set_interrupts_mask(int port, int control, uint8_t mask)
+{
+    // 0x17 is a control sequence to set interrupts
+    // and to interpret the next byte as a mask
+    _pio_control(port, (control | 0x17));
+    _pio_control(port, mask);
+}
diff --git a/sw/z80/kernel/include/drivers/pio.h b/sw/z80/kernel/include/drivers/pio.h
index 5d289ca..0df2ed0 100644
--- a/sw/z80/kernel/include/drivers/pio.h
+++ b/sw/z80/kernel/include/drivers/pio.h
@@ -7,25 +7,27 @@
 #define PIO_A       0
 #define PIO_B       1
 
-#define PIO_MODE_0  0
-#define PIO_MODE_1  1
-#define PIO_MODE_2  2
-#define PIO_MODE_3  3
+#define PIO_MODE_BYTE_IN   0
+#define PIO_MODE_BYTE_OUT  1
+#define PIO_MODE_BYTE_BI   2
+#define PIO_MODE_BIT_IO    3
 
 #define PIO_INT_ACTIVE_HIGH     (1<<5)
 #define PIO_INT_AND_MODE        (1<<6)
 #define PIO_INT_ENABLE          (1<<7)
 
 
-void _pio_data(int port, uint8_t data);
-void _pio_command(int port, uint8_t cmd);
+inline void _pio_data(int port, uint8_t data);
+inline void _pio_control(int port, uint8_t cmd);
+
+void pio_set_mode(int port, int mode, uint8_t io);
 
-void pio_set_mode(int port, int mode);
 void pio_set_interrupts(int port, int control);
-void pio_set_interrupts_mask(int port, uint8_t mask);
-void pio_set_io(int port, uint8_t io);
+void pio_set_interrupts_mask(int port, int control, uint8_t mask);
 
 // uint8_t pio_read_data(int port);
+uint8_t pio_read(int port);
+void pio_write(int port, uint8_t data);
 
 inline int pio_read_pin(int port, uint8_t pin);
 inline void pio_write_pin(int port, uint8_t pin);
diff --git a/sw/z80/kernel/include/memory.h b/sw/z80/kernel/include/memory.h
index e4352b5..60fc98a 100644
--- a/sw/z80/kernel/include/memory.h
+++ b/sw/z80/kernel/include/memory.h
@@ -33,8 +33,7 @@
 
 struct page
 {
-	uint used :1;
-	pid_t pid;     // process owner of the page
+	pid_t pid;       // process owner of the page (0 if free)
     uint16_t addr;   // physical address
 };
 
diff --git a/sw/z80/kernel/include/process.h b/sw/z80/kernel/include/process.h
index d7aa7fd..3b0c843 100644
--- a/sw/z80/kernel/include/process.h
+++ b/sw/z80/kernel/include/process.h
@@ -9,6 +9,12 @@
   */
 #define PROC_COUNT 2 
 
+/* the pid is defined with a single byte (pid_t is uint8_t), because of that 
+ * there cannot be more than 255 processes open at the same time. this is a
+ * limitation but for our purposes is more than enough
+ */
+#define PID_COUNT_MAX 255
+
 struct executable
 {
     void *text;
@@ -19,19 +25,12 @@ struct executable
 
 struct process
 {
-    uint blocked :1;    // process is waiting for hardware or locked
-    uint running :1;    // pid is used
-    struct page pages[4];      // pages used by the process
-    // TODO: implement quick callback?
+    uint blocked :1;      // process is waiting for hardware or locked
+    uint running :1;      // pid is used
+    uint pages;           // number of pages used by the process
+    struct page page[4];  // pages used by the process
 };
 
-/* the pid is defined with a single byte (pid_t is uint8_t), because of that 
- * there cannot be more than 255 processes open at the same time. this is a
- * limitation but for our purposes is more than enough
- */
-extern struct process proc_table[255];
-extern struct process *current_proc;
-
 pid_t newpid(void);
 
 int fork(void);
diff --git a/sw/z80/kernel/include/syscall.h b/sw/z80/kernel/include/syscall.h
deleted file mode 100644
index 29941c9..0000000
--- a/sw/z80/kernel/include/syscall.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef __SYS_CALL_H__
-#define __SYS_CALL_H__
-
-/*
-*   Enable / disable virtual address traslation
-*/
-
-extern void v_addr(uint8_t flag);
-
-/*
-*   Programs execution
-*/
-
-extern void prog_exec_0(void);
-extern void prog_exec_1(void);
-
-extern void prog_stop_0(void);
-extern void prog_stop_1(void);
-
-#endif
\ No newline at end of file
diff --git a/sw/z80/kernel/memory.c b/sw/z80/kernel/memory.c
index f174906..ca9f447 100644
--- a/sw/z80/kernel/memory.c
+++ b/sw/z80/kernel/memory.c
@@ -7,7 +7,7 @@ int mmu_write_table(void)
     int i;
 
     for (i = 0; i < PAGES_MAX_COUNT; i++) {
-        if (pages_table[i].used) {
+        if (pages_table[i].pid != 0) {
             // write to mmu table
         }
     }
@@ -20,13 +20,12 @@ int page_map(int page, int pid, uint16_t addr)
     if (page >= PAGES_MAX_COUNT)
         return -1;
 
-    if (pages_table[page].used)
+    if (pages_table[page].pid != 0)
         return -2;
 
     pages_table[page].addr = addr;
     pages_table[page].pid = pid;
 
-    pages_table[page].used = 1;
     return 0;
 }
 
@@ -35,9 +34,9 @@ int page_unmap(int page)
     if (page >= PAGES_MAX_COUNT)
         return -1;
 
-    if (pages_table[page].used == 0)
+    if (pages_table[page].pid == 0)
         return -2;
 
-    pages_table[page].used = 0;
+    pages_table[page].pid = 0;
     return 0;
 }
diff --git a/sw/z80/kernel/process.c b/sw/z80/kernel/process.c
index 49b86b8..b43fa11 100644
--- a/sw/z80/kernel/process.c
+++ b/sw/z80/kernel/process.c
@@ -1,16 +1,32 @@
 #include "process.h"
 
-struct process proc_table[255];
+static struct process proc_table[PID_COUNT_MAX];
+static struct process *current_proc;
 
 pid_t newpid(void)
 {
+    int i;
     static pid_t last_pid = 0;
-    return ++last_pid;
+
+    for (i = 0; i < PID_COUNT_MAX; i++, last_pid++) {
+        if (last_pid == PID_COUNT_MAX) {
+            last_pid = 0;
+            continue;            
+        }
+
+        if (!proc_table[last_pid].running)
+            break;
+    }
+
+    if (i >= PID_COUNT_MAX)
+        return 0;
+
+    return last_pid;
 }
 
 int fork(void)
 {
-    
+
 }
 
 int exec(char *path, char *args)