imx8x: Fixup serial driver
authorLukas Humbel <lukas.humbel@inf.ethz.ch>
Thu, 7 Nov 2019 15:56:42 +0000 (16:56 +0100)
committerLukas Humbel <lukas.humbel@inf.ethz.ch>
Fri, 8 Nov 2019 10:46:35 +0000 (11:46 +0100)
Signed-off-by: Lukas Humbel <lukas.humbel@inf.ethz.ch>

devices/lpuart.dev
hake/menu.lst.armv8_imx8x
platforms/Hakefile
usr/drivers/serial/Hakefile
usr/drivers/serial/serial_kernel.c
usr/drivers/serial/serial_lpuart.c

index 07cddf3..a6e086d 100644 (file)
@@ -190,8 +190,6 @@ device lpuart msbfirst (addr base) "LPUART" {
                buf    10 "Data buffer";
        };
 
-       register write_data wo also addr (base, 0x1c) "LPUART Transmit Data Register" type(uint32);
-
        register match addr(base, 0x20) "LPUART Match Address Register" {
                _    6;
                ma2 10 "Match Address 2";
index e4604ad..1ac4a20 100644 (file)
@@ -26,11 +26,11 @@ modulenounzip /skb_ramfs.cpio.gz nospawn
 # Drivers
 #module /armv8/sbin/corectrl auto
 #module /armv8/sbin/pci auto
+module /armv8/sbin/serial_lpuart auto 
 
 
 # General user domains
-#module /armv8/sbin/serial_tmas auto portbase=2
-#module /armv8/sbin/fish nospawn
-#module /armv8/sbin/angler serial0.terminal xterm
+module /armv8/sbin/fish nospawn
+module /armv8/sbin/angler serial0.terminal xterm
 
 # End of file, this needs to have a certain length...
index 4e39076..156f130 100644 (file)
@@ -394,6 +394,7 @@ let bin_rcce_lu = [ "/sbin/" ++ f | f <- [
                        "pci",
                        "memtest",
                        "serial_kernel",
+                       "serial_lpuart",
                        "fish",
                        "angler",
                        "kaluga",
index 8e9c92a..ba4bf34 100644 (file)
         architectures = ["x86_64"]
   },
 
+  build drivermodule { target = "serial_lpuart_module",
+        cFiles = [ "serial_lpuart.c" ],
+        flounderDefs = [ "terminal" , "terminal_config",
+                         "terminal_session" ],
+        architectures = [ "armv8" ],
+        mackerelDevices = ["lpuart"],
+        addLibraries = [ "serial_common", "int_route_client", "thc", "term_server"]
+  },
+
+  build driverdomain {
+      target = "serial_lpuart",
+      addModules = ["serial_lpuart_module", "serial_kernel_module"],
+      architectures = ["armv8"]
+   },
+
   -- build application {
   --       target = "serial_pc16550d",
   --       cFiles = [ "main_ddomain.c"],
index 0ec43d6..9988654 100644 (file)
@@ -49,10 +49,12 @@ serial_kernel_init(struct serial_kernel *sk, struct capref irq_src)
     sk->m.output_arg = sk;
 
     // Register interrupt handler
-    err = int_route_client_route_and_connect(irq_src, 0,
-            get_default_waitset(), serial_interrupt, sk);
-    if (err_is_fail(err)) {
-        USER_PANIC_ERR(err, "interrupt setup failed.");
+    if (!capref_is_null(irq_src)) {
+        err = int_route_client_route_and_connect(irq_src, 0, get_default_waitset(),
+                                                 serial_interrupt, sk);
+        if (err_is_fail(err)) {
+            USER_PANIC_ERR(err, "interrupt setup failed.");
+        }
     }
 
     // offer service now we're up
@@ -72,7 +74,12 @@ init_kernel(struct bfdriver_instance* bfi, uint64_t flags, iref_t *dev)
     struct capref irq_src;
     irq_src.cnode = bfi->argcn;
     irq_src.slot = PCIARG_SLOT_INT;
-
+    if (flags == 1) {
+        irq_src = NULL_CAP;
+    } else {
+        irq_src.cnode = bfi->argcn;
+        irq_src.slot = PCIARG_SLOT_INT;
+    }
 
     // Initialize serial driver
     err = serial_kernel_init(sk, irq_src);
index a943a4d..ff30965 100644 (file)
 #include <barrelfish/deferred.h>
 #include <barrelfish/systime.h>
 
-#define DEFAULT_PORTBASE            0x3f8   //< COM1 port
-#define DEFAULT_IRQ                 4       //< COM1 IRQ
-
 
 //#define LPUART_DEBUG_ON
 
 #if defined(LPUART_DEBUG_ON) || defined(GLOBAL_DEBUG)
-#define LPUART_DEBUG(x...) debug_printf(x)
+#    define LPUART_DEBUG(x...) debug_printf(x)
 #else
-#define LPUART_DEBUG(x...) ((void)0)
+#    define LPUART_DEBUG(x...) ((void)0)
 #endif
 
 struct serial_lpuart {
     struct serial_common m;
     struct lpuart_t uart;
-
 };
-__attribute__((__unused__))
+
 static void print_regvalues(struct serial_lpuart *spc)
-{   char buffer[10000];
-    lpuart_pr(buffer,10000,&spc->uart);
-    LPUART_DEBUG("printing lpuart  %s\n",buffer);
+{
+    char buffer[10000];
+    lpuart_pr(buffer, 10000, &spc->uart);
+    LPUART_DEBUG("printing lpuart  %s\n", buffer);
 }
 
-__attribute__((__unused__))
-// CALL THIS FUNCTION IN INIT
 static void serial_poll(struct serial_lpuart *spc)
-{  
-    while(lpuart_stat_rdrf_rdf(&spc->uart)){
+{
+    while (lpuart_stat_rdrf_rdf(&spc->uart)) {
         LPUART_DEBUG("befohooore\n");
-        char c = lpuart_read_data_buf_rdf((&spc->uart));
-        if(c) LPUART_DEBUG("Read char=%c\n", c); 
-        else LPUART_DEBUG("Read NULL char\n");
+        char c = lpuart_rxdata_buf_rdf((&spc->uart));
+        if (c)
+            LPUART_DEBUG("Read char=%c\n", c);
+        else
+            LPUART_DEBUG("Read NULL char\n");
         serial_input(&spc->m, &c, 1);
-        uint8_t or= lpuart_stat_or_rdf(&spc->uart);
-        if(or==1) { 
+        uint8_t or = lpuart_stat_or_rdf(&spc->uart);
+        if (or == 1) {
             LPUART_DEBUG("OR FLAG IS SET\n");
-            lpuart_stat_or_wrf(&spc->uart,1);
+            lpuart_stat_or_wrf(&spc->uart, 1);
         }
-    }   
+    }
 }
-static void serial_poll2(void* arg){
+
+static void serial_poll2(void *arg)
+{
     LPUART_DEBUG("my call back worked, arg=%p\n", arg);
     serial_poll((struct serial_lpuart *)arg);
-    struct deferred_event* de= malloc(sizeof(struct deferred_event));
+    struct deferred_event *de = malloc(sizeof(struct deferred_event));
     deferred_event_init(de);
     struct event_closure ec;
     ec.handler = serial_poll2;
     ec.arg = arg;
-    errval_t err = deferred_event_register(de, get_default_waitset(),
-                                           1000, ec);
+    errval_t err = deferred_event_register(de, get_default_waitset(), 1000, ec);
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "deferred event register failed.");
     }
 }
-__attribute__((__unused__))
-static void install_event(delayus_t delay, struct serial_lpuart *spc) {
-    struct deferred_event* de= malloc(sizeof(struct deferred_event));
+
+static void install_event(delayus_t delay, struct serial_lpuart *spc)
+{
+    struct deferred_event *de = malloc(sizeof(struct deferred_event));
     deferred_event_init(de);
-    errval_t err = deferred_event_register(de, get_default_waitset(),
-                                           delay, MKCLOSURE(serial_poll2, spc));
+    errval_t err = deferred_event_register(de, get_default_waitset(), delay,
+                                           MKCLOSURE(serial_poll2, spc));
     if (err_is_fail(err)) {
         USER_PANIC_ERR(err, "deferred event register failed.");
     }
 }
 
-// __attribute__((__unused__))
-// static void serial_interrupt(void *m)
-// {
-//     // Figure out which interrupt happened
-//     // -> we have data to read -> call serial_poll
-//     // 
-// }
-
 
 static void hw_init(struct serial_lpuart *spc)
-{   // Disable transceiver
+{  // Disable transceiver
     lpuart_ctrl_t ctrl = lpuart_ctrl_rawrd(&spc->uart);
     ctrl = lpuart_ctrl_te_insert(ctrl, 0);
     ctrl = lpuart_ctrl_re_insert(ctrl, 0);
@@ -115,13 +105,13 @@ static void hw_init(struct serial_lpuart *spc)
     baud = lpuart_baud_bothedge_insert(baud, 1);
     baud = lpuart_baud_sbr_insert(baud, 139);
     lpuart_baud_rawwr(&spc->uart, baud);
-    //enable FIFOs
-     lpuart_fifo_t fcr = lpuart_fifo_default;
+    // enable FIFOs
+    lpuart_fifo_t fcr = lpuart_fifo_default;
     ctrl = lpuart_ctrl_default;
     ctrl = lpuart_ctrl_te_insert(ctrl, 0);
     ctrl = lpuart_ctrl_re_insert(ctrl, 0);
     lpuart_ctrl_wr(&spc->uart, ctrl);
-    //enable fifo
+    // enable fifo
     fcr = lpuart_fifo_rxfe_insert(fcr, 1);
     lpuart_fifo_wr(&spc->uart, fcr);
     fcr = lpuart_fifo_txfe_insert(fcr, 1);
@@ -149,77 +139,32 @@ static void hw_init(struct serial_lpuart *spc)
      lpuart_ctrl_feie_wrf(&spc->uart,1);
      //Parity Error Interrupt Enable
      lpuart_ctrl_peie_wrf(&spc->uart,1);
-      */
+     */
 }
 
-__attribute__((__unused__))
-static void serial_putc(struct serial_lpuart *spc,char c)
+static void serial_putc(struct serial_lpuart *spc, char c)
 {
-    // // Wait until FIFO can hold more characters
-    // while(!pc16550d_lsr_thre_rdf(&spc->uart));
-    // // Write character
-    // pc16550d_thr_wr(&spc->uart, c);
     lpuart_t *u = &spc->uart;
     assert(u->base != 0);
 
-    while(lpuart_stat_tdre_rdf(u) == 0);
-   lpuart_write_data_wr(u,c);
+    while (lpuart_stat_tdre_rdf(u) == 0)
+        ;
+    lpuart_txdata_wr(u, c);
 }
 
-static void serial_write(void * m, const char *c, size_t len)
+static void serial_write(void *m, const char *c, size_t len)
 {
-    struct serial_lpuart * spc = m;
+    struct serial_lpuart *spc = m;
     for (int i = 0; i < len; i++) {
         serial_putc(spc, c[i]);
     }
 }
 
-// #define MAX_NUM_UARTS 1
-// lpaddr_t platform_uart_base[MAX_NUM_UARTS] =
-// {
-//         0x5A090000
-// };
-
-// errval_t serial_early_init(unsigned n)
-// {unsigned serial_num_physical_ports = 1;
-//     assert(!paging_mmu_enabled());
-//     assert(n < serial_num_physical_ports);
-
-//     lpuart_initialize(&uarts[n],
-//         (mackerel_addr_t)local_phys_to_mem(platform_uart_base[n]));
-
-//     // Make sure that the UART is enabled and transmitting - not all platforms
-//     // do this for us.serial_putc
-//    hw_init(&uarts[n]);serial_putc
-
-//     return SYS_ERR_OK;serial_putc
-// }
-
-/**
- * \brief Configure the serial interface, from a caller that knows
- * that this i__attribute__((__unused__))s a bunch of PL011s, and furthermore where they are in
- * the physical address space.
- */
-// errval_t serial_early_init_mmu_enabled(unsigned n)
-// {
-//     assert(paging_mmu_enabled());serial_putc
-//     assert(n < serial_num_physicaserial_putcorts);
-
-//     lpuart_initialize(&uarts[n],
-//         (mackerel_addr_t)local_phys_to_mem(platform_uart_base[n]));
-
-//     // Make sure that the UART is enabled and transmitting - not all platforms
-//     // do this for us.
-//     lpuart_hw_init(&uarts[n]);
-
-//     return SYS_ERR_OK;
-// }
+static errval_t serial_lpuart_init(struct serial_lpuart *spc, struct capref irq_src)
+{
+    debug_printf("Hello world from serial lpuart driver\n");
 
-static errval_t
-serial_lpuart_init(struct serial_lpuart *spc, struct capref irq_src)
-{   debug_printf("Hello world from serial lpuart driver\n");
-    
-    //errval_t err;
+    // errval_t err;
 
     // if(capref_is_null(irq_src))
     //     USER_PANIC("serial_kernel requires an irq cap");
@@ -227,10 +172,10 @@ serial_lpuart_init(struct serial_lpuart *spc, struct capref irq_src)
     spc->m.output = serial_write;
     spc->m.output_arg = spc;
 
-    //Register interrupt handler
-    //err = int_route_client_route_and_connect(irq_src, 0,
+    // Register interrupt handler
+    // err = int_route_client_route_and_connect(irq_src, 0,
     //        get_default_waitset(), serial_interrupt, spc);
-    //if (err_is_fail(err)) {
+    // if (err_is_fail(err)) {
     //    USER_PANIC_ERR(err, "interrupt setup failed.");
     // }
 
@@ -240,38 +185,19 @@ serial_lpuart_init(struct serial_lpuart *spc, struct capref irq_src)
     start_service(&spc->m);
     return SYS_ERR_OK;
 }
-// static errval_t serial_lpuart_init(unsigned port, lvaddr_t base, bool hwinit)
-// {   errval_t err;
-//     assert(paging_mmu_enabled());
-//     assert(port < serial_num_physical_ports);
-
-//     lpuart_t *u = &uarts[port];
-
-//     // [Re]initialize the Mackerel state for the UART
-//     lpuart_initialize(u, (mackerel_addr_t) base);
 
-//     if (hwinit) {
-//         lpuart_hw_init(u);
-//     }
-//     return SYS_ERR_OK;
-// }
-
-
-static errval_t
-init(struct bfdriver_instance* bfi, uint64_t flags, iref_t *dev)
+static errval_t init(struct bfdriver_instance *bfi, uint64_t flags, iref_t *dev)
 {
     errval_t err;
     struct serial_lpuart *spc = malloc(sizeof(struct serial_lpuart));
     init_serial_common(&spc->m);
-    //copy
+    // copy
     lvaddr_t vbase;
-    struct capref devframe_cap = {
-        .slot = DRIVERKIT_ARGCN_SLOT_BAR0,
-        .cnode = bfi->argcn
-    };
+    struct capref devframe_cap = { .slot = DRIVERKIT_ARGCN_SLOT_BAR0,
+                                   .cnode = bfi->argcn };
     err = map_device_cap(devframe_cap, &vbase);
     debug_printf("vbase = %p\n", vbase);
-    lpuart_initialize (&spc->uart,(mackerel_addr_t) vbase);
+    lpuart_initialize(&spc->uart, (mackerel_addr_t)vbase);
 
     /*  struct capref irq_src;
     irq_src.cnode = bfi->argcn;
@@ -286,20 +212,24 @@ init(struct bfdriver_instance* bfi, uint64_t flags, iref_t *dev)
     return SYS_ERR_OK;
 }
 
-static errval_t attach(struct bfdriver_instance* bfi) {
+static errval_t attach(struct bfdriver_instance *bfi)
+{
     return SYS_ERR_OK;
 }
 
-static errval_t detach(struct bfdriver_instance* bfi) {
+static errval_t detach(struct bfdriver_instance *bfi)
+{
     return SYS_ERR_OK;
 }
 
-static errval_t set_sleep_level(struct bfdriver_instance* bfi, uint32_t level) {
+static errval_t set_sleep_level(struct bfdriver_instance *bfi, uint32_t level)
+{
     return SYS_ERR_OK;
 }
 
-static errval_t destroy(struct bfdriver_instance* bfi) {
-    struct lpuart_t * spc = bfi->dstate;
+static errval_t destroy(struct bfdriver_instance *bfi)
+{
+    struct lpuart_t *spc = bfi->dstate;
     free(spc);
     bfi->dstate = NULL;
     // XXX: Tear-down the service
@@ -307,8 +237,8 @@ static errval_t destroy(struct bfdriver_instance* bfi) {
     return SYS_ERR_OK;
 }
 
-static errval_t get_ep(struct bfdriver_instance* bfi, bool lmp, struct capref* ret_cap)
-{   
+static errval_t get_ep(struct bfdriver_instance *bfi, bool lmp, struct capref *ret_cap)
+{
     USER_PANIC("NIY \n");
     return SYS_ERR_OK;
 }