Changeset 539

Timestamp:

Sep 21, 2018, 10:21:42 PM (6 years ago)

Author:

nicolas.van.phan@…

Message:

TTY MUX 4 : Multiplex TTY character sending

Now, when a thread wants to write to a tty,
when the dev_txt_write() or dev_txt_sync_write() are called,
they all call soclib_mtty_aux() with a channel number.
The soclib_mtty_aux() function will write the string char by char,
with each char preceded by the channel number, so that the receiving end
knows to which tty a character is addressed to.

N.B. dev_txt_write() makes *synchronous* writes for the moment
because unlike the vci_tty_tsar, the vci_multi_tty doesn't raise
interrupt except when a new char is received, so we can't use the
interrupt mechanism for writes.

N.B. Now, the TTY DEV threads all write to the same register (WRITE),
but when a thread sends a 2-byte (tty dest. nb. + char), the two must be
send consecutively, without another thread sending a byte in between.
Consequently, a lock has been added to guarantee this atomicity.

Location:

trunk

Files:

• hal/tsar_mips32/drivers/soclib_mtty.c (modified) (4 diffs)
• kernel/devices/dev_txt.c (modified) (2 diffs)
• kernel/devices/dev_txt.h (modified) (1 diff)
• kernel/kern/kernel_init.c (modified) (2 diffs)

trunk/hal/tsar_mips32/drivers/soclib_mtty.c

@@ -48 +48 @@
 #endif
 
+extern   chdev_directory_t    chdev_dir;  // allocated in the kernel_init.c file.
+extern   spinlock_t           txt0_lock;  // Initialized in kernel_init.c
 ////////////////////////////////////////////////////////////////////////////////////
 // These global variables implement the MTTY_RX  FIFOs (one per channel)
@@ -538 +540 @@
     char     * buffer = ((txt_sync_args_t *)args)->buffer;
     uint32_t   count  = ((txt_sync_args_t *)args)->count;
+    uint32_t   channel = ((txt_sync_args_t *)args)->channel;
     
     // get TXT0 chdev cluster and local pointer
@@ -554 +557 @@
     xptr_t status_xp = XPTR( tty_cxy , tty_ptr + MTTY_STATUS );
 
+    reg_t  save_sr;
+
     // loop on characters (busy waiting policy)
     for( i = 0 ; i < count ; i++ )
     {
+        // This is the MTTY multiplexing
+        // Before each character, we send the destination TTY number for this char.
+        // The two bytes (dest number + char) must be sent consecutively,
+        // so to guarantee this atomicity, we use a lock to prevent other
+        // concurrent server DEV threads to write a byte in between our two bytes
+
+        // Get the lock
+        spinlock_lock_busy( &txt0_lock, &save_sr );
+
+        // Send the destination TTY number
         do
         {
@@ -564 +579 @@
 
             // transfer one byte if TX buffer empty
+            if ( empty )  hal_remote_sb( write_xp , channel + '0' );
+            
+        }
+        while ( empty == false );
+
+        // Send the character
+        do
+        {
+            // get MTTY_STATUS
+            status = hal_remote_lw( status_xp );
+            empty  = ( (status & MTTY_STATUS_TX_FULL) == 0 );
+
+            // transfer one byte if TX buffer empty
             if ( empty )  hal_remote_sb( write_xp , buffer[i] );
         }
         while ( empty == false );
+
+        // Release the lock
+        spinlock_unlock_busy( &txt0_lock, save_sr );
     }
 }  // end soclib_mtty_aux()

trunk/kernel/devices/dev_txt.c

@@ -173 +173 @@
 #endif
 
+    // get extended pointer on TXT[0] chdev
+    xptr_t dev_xp = chdev_dir.txt_tx[0];
+
+    assert( (dev_xp != XPTR_NULL) , __FUNCTION__ ,
+    "undefined TXT0 chdev descriptor" );
+
+    // get TXTO chdev cluster and local pointer
+    cxy_t    dev_cxy  = GET_CXY( dev_xp );
+    chdev_t * dev_ptr = (chdev_t *)GET_PTR( dev_xp );
+
+    // If we use MTTYs (vci_multi_tty), we perform only sync writes
+    if( dev_ptr->impl == IMPL_TXT_MTY )
+    {
+        // get driver command function
+        dev_aux_t * aux = (dev_aux_t *)hal_remote_lpt( XPTR( dev_cxy , &dev_ptr->aux ) );
+
+        // build arguments structure
+        txt_sync_args_t  args;
+        args.dev_xp = dev_xp;
+        args.buffer = buffer;
+        args.count  = count;
+        args.channel = channel;
+
+        // call driver function
+        aux( &args );
+
+        return 0;
+    }
+
+    // Otherwise, we use vci_tty_tsar so we can use async writes
+    else
+    {
     return dev_txt_access( TXT_WRITE , channel , buffer , count );
+    }
 
 #if DEBUG_DEV_TXT_TX
@@ -238 +271 @@
     args.buffer = buffer;
     args.count  = count;
+    args.channel = 0;
 
     // call driver function

trunk/kernel/devices/dev_txt.h

@@ -106 +106 @@
     char      * buffer;    /*! local pointer on characters array                         */
     uint32_t    count;     /*! number of characters in buffer                            */
+    uint32_t    channel;   /*! channel, aka which tty to write to                        */
 }
 txt_sync_args_t;

trunk/kernel/kern/kernel_init.c

@@ -88 +88 @@
 chdev_t              txt0_chdev                              CONFIG_CACHE_LINE_ALIGNED;
 
+// This variable defines the TXT0 lock for writing characters to MTY0
+__attribute__((section(".kdata")))
+spinlock_t           txt0_lock                               CONFIG_CACHE_LINE_ALIGNED;
+
 // This variables define the kernel process0 descriptor
 __attribute__((section(".kdata")))
@@ -282 +286 @@
     dev_tbl = info->int_dev;
 
+    // Initialize spinlock for writing to MTY0
+    spinlock_init(&txt0_lock);
+    
     // Loop on internal peripherals of cluster (0,0) to find MTY0
     for ( i = 0; i < dev_nr; i++ )