Code-base clean-up and refactoring (#47)

[lunaix-os.git] / lunaix-os / hal / char / serial.c

diff --git a/lunaix-os/hal/char/serial.c b/lunaix-os/hal/char/serial.c
index 2c4a272a39f216dd9942c021aac1cc0730ecb176..d3d14c70eb66dbe13b1e0136aed677a0f4c0537d 100644 (file)
--- a/lunaix-os/hal/char/serial.c
+++ b/lunaix-os/hal/char/serial.c
@@ -1,38 +1,62 @@
 #include <lunaix/device.h>
 #include <lunaix/mm/valloc.h>
 #include <lunaix/spike.h>
 #include <lunaix/device.h>
 #include <lunaix/mm/valloc.h>
 #include <lunaix/spike.h>

+#include <lunaix/owloysius.h>

 #include <lunaix/status.h>
 #include <lunaix/status.h>

+#include <lunaix/syslog.h>

 
 

-#include <sys/mm/mempart.h>
+#include <asm/pagetable.h>

 
 #include <hal/serial.h>
 
 #include <hal/serial.h>

+#include <hal/term.h>
+
+LOG_MODULE("serial")
+
+#define lock_sdev(sdev) device_lock((sdev)->dev)
+#define unlock_sdev(sdev) device_unlock((sdev)->dev)
+#define unlock_and_wait(sdev, wq)                                              \
+    ({                                                                         \
+        unlock_sdev(sdev);                                                     \
+        pwait(&(sdev)->wq);                                                    \
+        lock_sdev(sdev);                                                       \
+    })

 
 static DEFINE_LLIST(serial_devs);
 static int serial_idx = 0;
 
 
 static DEFINE_LLIST(serial_devs);
 static int serial_idx = 0;
 

+static struct device_cat* serial_cat;
+

 #define serial_device(dev) ((struct serial_dev*)(dev)->underlay)
 
 int
 serial_accept_one(struct serial_dev* sdev, u8_t val)
 {
 #define serial_device(dev) ((struct serial_dev*)(dev)->underlay)
 
 int
 serial_accept_one(struct serial_dev* sdev, u8_t val)
 {

-    return !!fifo_putone(&sdev->rxbuf, val);
+    return !!rbuffer_put(&sdev->rxbuf, val);

 }
 
 int
 serial_accept_buffer(struct serial_dev* sdev, void* val, size_t len)
 {
 }
 
 int
 serial_accept_buffer(struct serial_dev* sdev, void* val, size_t len)
 {

-    return !!fifo_write(&sdev->rxbuf, val, len);
+    return !!rbuffer_puts(&sdev->rxbuf, val, len);

 }
 
 void
 serial_end_recv(struct serial_dev* sdev)
 {
 }
 
 void
 serial_end_recv(struct serial_dev* sdev)
 {

+    mark_device_done_read(sdev->dev);
+

     pwake_one(&sdev->wq_rxdone);
     pwake_one(&sdev->wq_rxdone);

+
+    struct termport_capability* tpcap;
+    tpcap = get_capability(sdev->tp_cap, typeof(*tpcap));
+    term_notify_data_avaliable(tpcap);

 }
 
 void
 serial_end_xmit(struct serial_dev* sdev, size_t len)
 {
 }
 
 void
 serial_end_xmit(struct serial_dev* sdev, size_t len)
 {

+    mark_device_done_write(sdev->dev);
+

     sdev->wr_len = len;
     pwake_one(&sdev->wq_txdone);
 }
     sdev->wr_len = len;
     pwake_one(&sdev->wq_txdone);
 }


@@ -40,11 +64,11 @@ serial_end_xmit(struct serial_dev* sdev, size_t len)
 int
 serial_readone_nowait(struct serial_dev* sdev, u8_t* val)
 {
 int
 serial_readone_nowait(struct serial_dev* sdev, u8_t* val)
 {

-    mutex_lock(&sdev->lock);
+    lock_sdev(sdev);

 
 

-    int rd_len = fifo_readone(&sdev->rxbuf, val);
+    int rd_len = rbuffer_get(&sdev->rxbuf, (char*)val);

 
 

-    mutex_unlock(&sdev->lock);
+    unlock_sdev(sdev);

 
     return rd_len;
 }
 
     return rd_len;
 }


@@ -52,26 +76,30 @@ serial_readone_nowait(struct serial_dev* sdev, u8_t* val)
 void
 serial_readone(struct serial_dev* sdev, u8_t* val)
 {
 void
 serial_readone(struct serial_dev* sdev, u8_t* val)
 {

-    mutex_lock(&sdev->lock);
+    lock_sdev(sdev);

 
 

-    while (!fifo_readone(&sdev->rxbuf, val)) {
-        pwait(&sdev->wq_rxdone);
+    mark_device_doing_read(sdev->dev);
+
+    while (!rbuffer_get(&sdev->rxbuf, (char*)val)) {
+        unlock_and_wait(sdev, wq_rxdone);

     }
 
     }
 

-    mutex_unlock(&sdev->lock);
+    unlock_sdev(sdev);

 }
 
 size_t
 serial_readbuf(struct serial_dev* sdev, u8_t* buf, size_t len)
 {
 }
 
 size_t
 serial_readbuf(struct serial_dev* sdev, u8_t* buf, size_t len)
 {

-    mutex_lock(&sdev->lock);
+    lock_sdev(sdev);
+
+    mark_device_doing_read(sdev->dev);

 
     size_t rdlen;
 
     size_t rdlen;

-    while (!(rdlen = fifo_read(&sdev->rxbuf, buf, len))) {
-        pwait(&sdev->wq_rxdone);
+    while (!(rdlen = rbuffer_gets(&sdev->rxbuf, (char*)buf, len))) {
+        unlock_and_wait(sdev, wq_rxdone);

     }
 
     }
 

-    mutex_unlock(&sdev->lock);
+    unlock_sdev(sdev);

 
     return rdlen;
 }
 
     return rdlen;
 }


@@ -79,11 +107,13 @@ serial_readbuf(struct serial_dev* sdev, u8_t* buf, size_t len)
 int
 serial_readbuf_nowait(struct serial_dev* sdev, u8_t* buf, size_t len)
 {
 int
 serial_readbuf_nowait(struct serial_dev* sdev, u8_t* buf, size_t len)
 {

-    mutex_lock(&sdev->lock);
+    lock_sdev(sdev);

 
 

-    int rdlen = fifo_read(&sdev->rxbuf, buf, len);
+    mark_device_doing_read(sdev->dev);

 
 

-    mutex_unlock(&sdev->lock);
+    int rdlen = rbuffer_gets(&sdev->rxbuf, (char*)buf, len);
+
+    unlock_sdev(sdev);

 
     return rdlen;
 }
 
     return rdlen;
 }


@@ -91,17 +121,19 @@ serial_readbuf_nowait(struct serial_dev* sdev, u8_t* buf, size_t len)
 int
 serial_writebuf(struct serial_dev* sdev, u8_t* buf, size_t len)
 {
 int
 serial_writebuf(struct serial_dev* sdev, u8_t* buf, size_t len)
 {

-    mutex_lock(&sdev->lock);
+    lock_sdev(sdev);
+
+    mark_device_doing_write(sdev->dev);

 
     if (sdev->write(sdev, buf, len) == RXTX_DONE) {
         goto done;
     }
 
 
     if (sdev->write(sdev, buf, len) == RXTX_DONE) {
         goto done;
     }
 

-    pwait(&sdev->wq_txdone);
+    unlock_and_wait(sdev, wq_txdone);

 
 done:
     int rdlen = sdev->wr_len;
 
 done:
     int rdlen = sdev->wr_len;

-    mutex_unlock(&sdev->lock);
+    unlock_sdev(sdev);

 
     return rdlen;
 }
 
     return rdlen;
 }


@@ -109,38 +141,54 @@ done:
 int
 serial_writebuf_nowait(struct serial_dev* sdev, u8_t* buf, size_t len)
 {
 int
 serial_writebuf_nowait(struct serial_dev* sdev, u8_t* buf, size_t len)
 {

-    mutex_lock(&sdev->lock);
+    lock_sdev(sdev);
+
+    mark_device_doing_write(sdev->dev);

 
     sdev->write(sdev, buf, len);
     int rdlen = sdev->wr_len;
 
 
     sdev->write(sdev, buf, len);
     int rdlen = sdev->wr_len;
 

-    mutex_unlock(&sdev->lock);
+    unlock_sdev(sdev);

 
     return rdlen;
 }
 
 static int
 
     return rdlen;
 }
 
 static int

-__serial_read(struct device* dev, void* buf, size_t offset, size_t len)
+__serial_read(struct device* dev, void* buf, off_t fpos, size_t len)
+{
+    return serial_readbuf(serial_device(dev), (u8_t*)buf, len);
+}
+
+static int
+__serial_read_async(struct device* dev, void* buf, off_t fpos, size_t len)

 {
 {

-    return serial_readbuf(serial_device(dev), &((u8_t*)buf)[offset], len);
+    return serial_readbuf_nowait(
+        serial_device(dev), (u8_t*)buf, len);

 }
 
 static int
 }
 
 static int

-__serial_read_page(struct device* dev, void* buf, size_t offset)
+__serial_read_page(struct device* dev, void* buf, off_t fpos)

 {
 {

-    return serial_readbuf(serial_device(dev), &((u8_t*)buf)[offset], MEM_PAGE);
+    return serial_readbuf(serial_device(dev), (u8_t*)buf, PAGE_SIZE);

 }
 
 static int
 }
 
 static int

-__serial_write(struct device* dev, void* buf, size_t offset, size_t len)
+__serial_write(struct device* dev, void* buf, off_t fpos, size_t len)

 {
 {

-    return serial_writebuf(serial_device(dev), &((u8_t*)buf)[offset], len);
+    return serial_writebuf(serial_device(dev), (u8_t*)buf, len);

 }
 
 static int
 }
 
 static int

-__serial_write_page(struct device* dev, void* buf, size_t offset)
+__serial_write_async(struct device* dev, void* buf, off_t fpos, size_t len)

 {
 {

-    return serial_writebuf(serial_device(dev), &((u8_t*)buf)[offset], MEM_PAGE);
+    return serial_writebuf_nowait(
+        serial_device(dev), (u8_t*)buf, len);
+}
+
+static int
+__serial_write_page(struct device* dev, void* buf, off_t fpos)
+{
+    return serial_writebuf(serial_device(dev), (u8_t*)buf, PAGE_SIZE);

 }
 
 static int
 }
 
 static int


@@ -155,26 +203,103 @@ __serial_exec_command(struct device* dev, u32_t req, va_list args)
     return sdev->exec_cmd(sdev, req, args);
 }
 
     return sdev->exec_cmd(sdev, req, args);
 }
 

+static int
+__serial_poll_event(struct device* dev)
+{
+    struct serial_dev* sdev = serial_device(dev);
+
+    return sdev->dev->poll_evflags;
+}
+
+static void sdev_execmd(struct serial_dev* sdev, u32_t req, ...)
+{
+    va_list args;
+    va_start(args, req);
+
+    sdev->exec_cmd(sdev, req, args);
+
+    va_end(args);
+}
+
+static void
+__serial_set_speed(struct device* dev, speed_t speed)
+{
+    struct serial_dev* sdev = serial_device(dev);
+    lock_sdev(sdev);
+
+    sdev_execmd(sdev, SERIO_SETBRDRATE, speed);
+
+    unlock_sdev(sdev);
+}
+
+static void
+__serial_set_baseclk(struct device* dev, unsigned int base)
+{
+    struct serial_dev* sdev = serial_device(dev);
+    lock_sdev(sdev);
+
+    sdev_execmd(sdev, SERIO_SETBRDBASE, base);
+
+    unlock_sdev(sdev);
+}
+
+static void
+__serial_set_cntrl_mode(struct device* dev, tcflag_t cflag)
+{
+    struct serial_dev* sdev = serial_device(dev);
+    lock_sdev(sdev);
+
+    sdev_execmd(sdev, SERIO_SETCNTRLMODE, cflag);
+
+    unlock_sdev(sdev);
+}
+

 #define RXBUF_SIZE 512
 
 #define RXBUF_SIZE 512
 

+static struct termport_cap_ops tpcap_ops = {
+    .set_cntrl_mode = __serial_set_cntrl_mode,
+    .set_clkbase = __serial_set_baseclk,
+    .set_speed = __serial_set_speed
+};
+

 struct serial_dev*
 struct serial_dev*

-serial_create()
+serial_create(struct devclass* class, char* if_ident)

 {
 {

-    struct serial_dev* sdev = valloc(sizeof(struct serial_dev));
-    struct device* dev = device_addseq(NULL, sdev, "ttyS%d", serial_idx++);
+    struct serial_dev* sdev = vzalloc(sizeof(struct serial_dev));
+    struct device* dev = device_allocseq(dev_meta(serial_cat), sdev);

     dev->ops.read = __serial_read;
     dev->ops.read_page = __serial_read_page;
     dev->ops.read = __serial_read;
     dev->ops.read_page = __serial_read_page;

+    dev->ops.read_async = __serial_read_async;
+    dev->ops.write_async = __serial_write_async;

     dev->ops.write = __serial_write;
     dev->ops.write_page = __serial_write_page;
     dev->ops.exec_cmd = __serial_exec_command;
     dev->ops.write = __serial_write;
     dev->ops.write_page = __serial_write_page;
     dev->ops.exec_cmd = __serial_exec_command;

-
+    dev->ops.poll = __serial_poll_event;
+    

     sdev->dev = dev;
     dev->underlay = sdev;
 
     sdev->dev = dev;
     dev->underlay = sdev;
 

-    fifo_init(&sdev->rxbuf, valloc(RXBUF_SIZE), RXBUF_SIZE, 0);
+    struct termport_capability* tp_cap = 
+        new_capability(TERMPORT_CAP, struct termport_capability);
+    
+    term_cap_set_operations(tp_cap, &tpcap_ops);
+    sdev->tp_cap = cap_meta(tp_cap);
+
+    waitq_init(&sdev->wq_rxdone);
+    waitq_init(&sdev->wq_txdone);
+    rbuffer_init(&sdev->rxbuf, valloc(RXBUF_SIZE), RXBUF_SIZE);

     llist_append(&serial_devs, &sdev->sdev_list);
     llist_append(&serial_devs, &sdev->sdev_list);

-    // llist_init_head(&sdev->cmds);
+    
+    device_grant_capability(dev, cap_meta(tp_cap));
+
+    register_device(dev, class, "%s%d", if_ident, class->variant);

 
 

+    term_create(dev, if_ident);
+
+    INFO("interface: %s, %xh:%xh.%d", dev->name_val, 
+            class->fn_grp, class->device, class->variant);
+
+    class->variant++;

     return sdev;
 }
 
     return sdev;
 }
 


@@ -184,10 +309,19 @@ serial_get_avilable()
     struct serial_dev *pos, *n;
     llist_for_each(pos, n, &serial_devs, sdev_list)
     {
     struct serial_dev *pos, *n;
     llist_for_each(pos, n, &serial_devs, sdev_list)
     {

-        if (!mutex_on_hold(&pos->lock)) {
+        if (!device_locked(pos->dev)) {

             return pos;
         }
     }
 
     return NULL;
             return pos;
         }
     }
 
     return NULL;

-}
\ No newline at end of file
+}
+
+static void
+init_serial_dev()
+{
+    serial_cat = device_addcat(NULL, "serial");
+
+    assert(serial_cat);
+}
+owloysius_fetch_init(init_serial_dev, on_earlyboot)
\ No newline at end of file