Simple serial port receive implementation.

ppisa · ppisa · commit 1889bd9353b3 · 2019-02-25T14:57:00.000+01:00
Simple polled mode serial port input implemented for
serial port peripheral and for read and readv system
calls. When end of input character reserve is reached
for read/readv, newline is automatically appended.

Signed-off-by: Pavel Pisa &lt;pisa@cmp.felk.cvut.cz&gt;
diff --git a/qtmips_gui/mainwindow.cpp b/qtmips_gui/mainwindow.cpp
@@ -154,6 +154,8 @@ void MainWindow::create_core(const machine::MachineConfig &config) {
     osemu::OsSyscallExceptionHandler *osemu_handler = new osemu::OsSyscallExceptionHandler;
     machine->register_exception_handler(machine::EXCAUSE_SYSCALL, osemu_handler);
     connect(osemu_handler, SIGNAL(char_written(int,uint)), terminal, SLOT(tx_byte(int,uint)));
+    connect(osemu_handler, SIGNAL(rx_byte_pool(int,uint&,bool&)),
+            terminal, SLOT(rx_byte_pool(int,uint&,bool&)));
 #endif
 
     // Connect machine signals and slots
diff --git a/qtmips_gui/terminaldock.cpp b/qtmips_gui/terminaldock.cpp
@@ -49,6 +49,11 @@ TerminalDock::TerminalDock(QWidget *parent, QSettings *settings) : QDockWidget(p
     terminal_text->setMinimumSize(30, 30);
     layout_box->addWidget(terminal_text);
     append_cursor = new QTextCursor(terminal_text->document());
+    layout_bottom_box = new QHBoxLayout();
+    layout_bottom_box->addWidget(new QLabel("Input:"));
+    input_edit = new QLineEdit();
+    layout_bottom_box->addWidget(input_edit);
+    layout_box->addLayout(layout_bottom_box);
 
     setObjectName("Terminal");
     setWindowTitle("Terminal");
@@ -62,6 +67,8 @@ void TerminalDock::setup(const machine::SerialPort *ser_port) {
     if (ser_port == nullptr)
         return;
     connect(ser_port, SIGNAL(tx_byte(uint)), this, SLOT(tx_byte(uint)));
+    connect(ser_port, SIGNAL(rx_byte_pool(int,uint&,bool&)),
+            this, SLOT(rx_byte_pool(int,uint&,bool&)));
 }
 
 void TerminalDock::tx_byte(unsigned int data) {
@@ -76,3 +83,13 @@ void TerminalDock::tx_byte(int fd, unsigned int data)
     (void)fd;
     tx_byte(data);
 }
+
+void TerminalDock::rx_byte_pool(int fd, unsigned int &data, bool &available) {
+    QString str = input_edit->text();
+    available = false;
+    if (str.count() > 0) {
+        data = str[0].toLatin1();
+        input_edit->setText(str.remove(0, 1));
+        available = true;
+    }
+}
diff --git a/qtmips_gui/terminaldock.h b/qtmips_gui/terminaldock.h
@@ -39,6 +39,7 @@
 #include <QDockWidget>
 #include <QLabel>
 #include <QFormLayout>
+#include <QLineEdit>
 #include <QTextEdit>
 #include <QTextCursor>
 #include "qtmipsmachine.h"
@@ -54,13 +55,16 @@ class TerminalDock : public QDockWidget {
 public slots:
     void tx_byte(unsigned int data);
     void tx_byte(int fd, unsigned int data);
+    void rx_byte_pool(int fd, unsigned int &data, bool &available);
 
 private:
     QVBoxLayout *layout_box;
+    QHBoxLayout *layout_bottom_box;
     QWidget *top_widget, *top_form;
     QFormLayout *layout_top_form;
     QTextEdit *terminal_text;
     QTextCursor *append_cursor;
+    QLineEdit *input_edit;
 };
 
 #endif // TERMINALDOCK_H
diff --git a/qtmips_machine/serialport.cpp b/qtmips_machine/serialport.cpp
@@ -51,13 +51,26 @@ using namespace machine;
 
 SerialPort::SerialPort() {
     rx_st_reg = 0;
+    rx_data_reg = 0;
     tx_st_reg = 0;
 }
 
 SerialPort::~SerialPort() {
 
 }
 
+void SerialPort::pool_rx_byte() const {
+    unsigned int byte = 0;
+    bool available = false;
+    if (!(rx_st_reg & SERP_RX_ST_REG_READY_m)) {
+        emit rx_byte_pool(0, byte, available);
+        if (available) {
+            rx_data_reg = byte;
+            rx_st_reg |= SERP_RX_ST_REG_READY_m;
+        }
+    }
+}
+
 bool SerialPort::wword(std::uint32_t address, std::uint32_t value) {
 #if 0
     printf("SerialPort::wword address 0x%08lx data 0x%08lx\n",
@@ -90,10 +103,17 @@ std::uint32_t SerialPort::rword(std::uint32_t address, bool debug_access) const
 #endif
     switch (address) {
     case SERP_RX_ST_REG_o:
+        pool_rx_byte();
         value = rx_st_reg;
         break;
     case SERP_RX_DATA_REG_o:
-        value = 0;
+        pool_rx_byte();
+        if (rx_st_reg & SERP_RX_ST_REG_READY_m) {
+            value = rx_data_reg;
+            rx_st_reg &= ~SERP_RX_ST_REG_READY_m;
+        } else {
+            value = 0;
+        }
         break;
     case SERP_TX_ST_REG_o:
         value = tx_st_reg | SERP_TX_ST_REG_READY_m;
diff --git a/qtmips_machine/serialport.h b/qtmips_machine/serialport.h
@@ -52,14 +52,17 @@ class SerialPort : public MemoryAccess {
 
 signals:
     void tx_byte(unsigned int data);
+    void rx_byte_pool(int fd, unsigned int &data, bool &available) const;
     void write_notification(std::uint32_t address, std::uint32_t value);
     void read_notification(std::uint32_t address, std::uint32_t *value) const;
 
 public:
     bool wword(std::uint32_t address, std::uint32_t value);
     std::uint32_t rword(std::uint32_t address, bool debug_access = false) const;
 private:
-    std::uint32_t rx_st_reg;
+    void pool_rx_byte() const;
+    mutable std::uint32_t rx_st_reg;
+    mutable std::uint32_t rx_data_reg;
     std::uint32_t tx_st_reg;
 };
 
diff --git a/qtmips_osemu/ossyscall.cpp b/qtmips_osemu/ossyscall.cpp
@@ -62,7 +62,7 @@ static const mips_syscall_desc_t mips_syscall_args[] = {
         MIPS_SYS(sys_syscall    , 8, syscall_default_handler)    /* 4000 */
         MIPS_SYS(sys_exit       , 1, syscall_default_handler)
         MIPS_SYS(sys_fork       , 0, syscall_default_handler)
-        MIPS_SYS(sys_read       , 3, syscall_default_handler)
+        MIPS_SYS(sys_read       , 3, do_sys_read)
         MIPS_SYS(sys_write      , 3, do_sys_write)
         MIPS_SYS(sys_open       , 3, syscall_default_handler)    /* 4005 */
         MIPS_SYS(sys_close      , 1, syscall_default_handler)
@@ -204,7 +204,7 @@ static const mips_syscall_desc_t mips_syscall_args[] = {
         MIPS_SYS(sys_select     , 5, syscall_default_handler)
         MIPS_SYS(sys_flock      , 2, syscall_default_handler)
         MIPS_SYS(sys_msync      , 3, syscall_default_handler)
-        MIPS_SYS(sys_readv      , 3, syscall_default_handler)    /* 4145 */
+        MIPS_SYS(sys_readv      , 3, do_sys_readv)    /* 4145 */
         MIPS_SYS(sys_writev     , 3, do_sys_writev)
         MIPS_SYS(sys_cacheflush , 3, syscall_default_handler)
         MIPS_SYS(sys_cachectl   , 3, syscall_default_handler)
@@ -598,6 +598,83 @@ int OsSyscallExceptionHandler::do_sys_write(std::uint32_t &result, Core *core,
     return 0;
 }
 
+// ssize_t readv(int fd, const struct iovec *iov, int iovcnt);
+int OsSyscallExceptionHandler::do_sys_readv(std::uint32_t &result, Core *core,
+               std::uint32_t syscall_num,
+               std::uint32_t a1, std::uint32_t a2, std::uint32_t a3,
+               std::uint32_t a4, std::uint32_t a5, std::uint32_t a6,
+               std::uint32_t a7, std::uint32_t a8) {
+    (void)core; (void)syscall_num;
+    (void)a1; (void)a2; (void)a3; (void)a4; (void)a5; (void)a6; (void)a7; (void)a8;
+
+    result = 0;
+    int fd = a1;
+    std::uint32_t iov = a2;
+    int iovcnt = a3;
+    MemoryAccess *mem = core->get_mem_data();
+    bool available;
+    unsigned int byte;
+
+    printf("sys_readv to fd %d\n", fd);
+
+    while (iovcnt-- > 0) {
+        std::uint32_t iov_base = mem->read_word(iov);
+        std::uint32_t iov_len = mem->read_word(iov + 4);
+        iov += 8;
+        available = true;
+        for (std::uint32_t i = 0; i < iov_len; i++) {
+            emit rx_byte_pool(fd, byte, available);
+            if (!available) {
+                // add final newline if there are no more data
+                mem->write_byte(iov_base++, '\n');
+                result += 1;
+                break;
+            }
+            mem->write_byte(iov_base++, byte);
+            result += 1;
+        }
+        if (!available)
+            break;
+    }
+
+    return 0;
+}
+
+// ssize_t read(int fd, void *buf, size_t count);
+int OsSyscallExceptionHandler::do_sys_read(std::uint32_t &result, Core *core,
+               std::uint32_t syscall_num,
+               std::uint32_t a1, std::uint32_t a2, std::uint32_t a3,
+               std::uint32_t a4, std::uint32_t a5, std::uint32_t a6,
+               std::uint32_t a7, std::uint32_t a8) {
+    (void)core; (void)syscall_num;
+    (void)a1; (void)a2; (void)a3; (void)a4; (void)a5; (void)a6; (void)a7; (void)a8;
+
+    result = 0;
+    int fd = a1;
+    std::uint32_t buf = a2;
+    int size = a3;
+    MemoryAccess *mem = core->get_mem_data();
+    bool available;
+    unsigned int byte;
+
+    printf("sys_read to fd %d\n", fd);
+
+    result = 0;
+    while (size-- > 0) {
+        emit rx_byte_pool(fd, byte, available);
+        if (!available) {
+            // add final newline if there are no more data
+            mem->write_byte(buf++, '\n');
+            result += 1;
+            break;
+        }
+        mem->write_byte(buf++, byte);
+        result += 1;
+    }
+
+    return 0;
+}
+
 // int or void * brk(void *addr);
 int OsSyscallExceptionHandler::do_sys_brk(std::uint32_t &result, Core *core,
                std::uint32_t syscall_num,
diff --git a/qtmips_osemu/ossyscall.h b/qtmips_osemu/ossyscall.h
@@ -66,10 +66,13 @@ class OsSyscallExceptionHandler : public machine::ExceptionHandler {
     OSSYCALL_HANDLER_DECLARE(do_sys_set_thread_area);
     OSSYCALL_HANDLER_DECLARE(do_sys_writev);
     OSSYCALL_HANDLER_DECLARE(do_sys_write);
+    OSSYCALL_HANDLER_DECLARE(do_sys_readv);
+    OSSYCALL_HANDLER_DECLARE(do_sys_read);
     OSSYCALL_HANDLER_DECLARE(do_sys_brk);
     OSSYCALL_HANDLER_DECLARE(do_sys_mmap2);
 signals:
     void char_written(int fd, unsigned int val);
+    void rx_byte_pool(int fd, unsigned int &data, bool &available);
 private:
     std::uint32_t brk_limit;
     std::uint32_t anonymous_base;
