Changeset 424 for trunk/hal/tsar_mips32

Timestamp:

Jan 29, 2018, 5:57:05 PM (7 years ago)

Author:

alain

Message:

cosmetic.

Location:

trunk/hal/tsar_mips32/drivers

Files:

• soclib_pic.c (modified) (1 diff)
• soclib_tty.c (modified) (3 diffs)
• soclib_tty.h (modified) (1 diff)

trunk/hal/tsar_mips32/drivers/soclib_pic.c

@@ -549 +549 @@
 
     // we must make a fake use for ack value to avoid a warning
-    if( (ack + 1) == 0 ) panic("this should never happen");
+    if( (ack + 1) == 0 ) asm volatile( "nop" );
 }
     

trunk/hal/tsar_mips32/drivers/soclib_tty.c

@@ -180 +180 @@
     uint32_t   i;
 
-#if CONFIG_READ_DEBUG
+#if (CONFIG_READ_DEBUG & 0x1) || (CONFIG_WRITE_DEBUG & 0x1)
 enter_tty_isr = hal_time_stamp();
 #endif
@@ -279 +279 @@
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
 
-#if CONFIG_READ_DEBUG
+#if (CONFIG_READ_DEBUG & 0x1) || (CONFIG_WRITE_DEBUG & 0x1)
 exit_tty_isr = hal_time_stamp();
 #endif
@@ -285 +285 @@
 }  // end soclib_tty_isr()
 
+/*
+/////////////////////////////////////////////////////////////////
+void __attribute__ ((noinline)) soclib_tty_isr( chdev_t * chdev )
+{
+    xptr_t     root_xp;      // extended pointer on command list root
+    xptr_t     client_xp;    // extended pointer on client thread
+    cxy_t      client_cxy;   // client thread cluster
+    thread_t * client_ptr;   // client_thread local pointer
+    uint32_t   type;         // command type
+    uint32_t   count;        // number of bytes in buffer
+    xptr_t     buf_xp;       // extended pointer on buffer
+    xptr_t     status_xp;    // extended pointer on TTY_STATUS register
+    xptr_t     write_xp;     // extended pointer on TTY_WRITE register
+    xptr_t     read_xp;      // extended pointer on TTY_READ register
+    uint32_t   status;       // TTY terminal status
+    char       byte;         // read byte
+    uint32_t   i;
+
+#if (CONFIG_READ_DEBUG & 0x1) || (CONFIG_WRITE_DEBUG & 0x1)
+enter_tty_isr = hal_time_stamp();
+#endif
+
+txt_dmsg("\n[DBG] %s : core[%x,%d] enter / cycle %d\n", 
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid , hal_time_stamp() );
+
+    // get SOCLIB_TTY peripheral cluster and local pointer
+    cxy_t      tty_cxy = GET_CXY( chdev->base );
+    uint32_t * tty_ptr = (uint32_t *)GET_PTR( chdev->base );
+
+    // get channel base address
+    uint32_t * base = tty_ptr + TTY_SPAN * chdev->channel;
+
+    // get extended pointer on TTY registers
+    status_xp = XPTR( tty_cxy , base + TTY_STATUS );
+    write_xp  = XPTR( tty_cxy , base + TTY_WRITE );
+    read_xp   = XPTR( tty_cxy , base + TTY_READ );
+
+    // get TTY_STATUS
+    status = hal_remote_lw( status_xp );
+
+    // get extended pointer on the command list root
+    root_xp = XPTR( local_cxy , &chdev->wait_root );
+
+    // get extended pointer on client thread
+    if(xlist_is_empty(root_xp)) client_xp = XLIST_FIRST_ELEMENT(root, thread_t, wait_list);
+    else                        client_xp = XPTR_NULL;
+
+    if( client_xp )
+    {
+        // get client thread cluster and local pointer
+        client_cxy = GET_CXY( client_xp );
+        client_ptr = (thread_t *)GET_PTR( client_xp );
+
+        // get command arguments
+        type    = hal_remote_lw ( XPTR( client_cxy , &client_ptr->txt_cmd.type   ) );
+        count   = hal_remote_lw ( XPTR( client_cxy , &client_ptr->txt_cmd.count  ) );
+        buf_xp  = hal_remote_lwd( XPTR( client_cxy , &client_ptr->txt_cmd.buf_xp ) );
+    }
+
+    ///////////// handle RX if TTY_RX full
+    if( status & TTY_STATUS_RX_FULL )   
+    {
+        // get a byte from TTY_READ, and acknowledge RX_IRQ
+        byte = (char)hal_remote_lb( read_xp );
+
+        // FIXME The RX_IRQ must be always enabled !!!  
+        // xptr_t reg_xp = XPTR( tty_cxy , base + TTY_RX_IRQ_ENABLE );
+        // hal_remote_sw( reg_xp , 0 );
+
+        // analyse received character 
+        switch( byte )
+        {
+            case CONTROL_C:          // SIGINT to process
+            case CONTROL_D:
+            {
+                // TODO SIGINT
+                return
+            }
+            break;
+            default:                 
+            { 
+                if( (type == TXT_READ) && (client_xp != XPTR_NULL) )  
+                {
+                    // write byte to command buffer
+                    hal_remote_sb( buf_xp , byte );
+
+                    // set status in command
+                    hal_remote_sw( XPTR( client_cxy , &client_ptr->txt_cmd.error ) , 0 );
+
+                    hal_fence();
+
+                    // unblock server thread
+                    thread_unblock( XPTR(local_cxy,chdev->server), THREAD_BLOCKED_DEV_ISR );
+                }
+                else                    // discard byte
+                {
+                    // TODO WARNING
+                    return
+                }
+            }
+        }
+    } // end RX handling
+
+    //////////////// handle TX if WRITE command pending
+    if( (type == TXT_WRITE) && (client_xp != XPTR_NULL) ) 
+    {
+        // loop on characters
+        for( i = 0 ; i < count ; i++ )
+        {
+            // get TTY_STATUS
+            status = hal_remote_lw( status_xp );
+
+            if( (status & TTY_STATUS_TX_FULL) == 0 ) // TTY_TX empty => move one byte
+            {
+                // get one byte from command buffer
+                byte = (char)hal_remote_lb( buf_xp + i );
+
+                // write byte to TTY_WRITE, and acknowledge TX_IRQ
+                hal_remote_sb( write_xp , byte );
+            }
+            else         // TTY_TX full => update command arguments and exit ISR for retry
+            {
+                hal_remote_sw ( XPTR( client_cxy , &client_ptr->txt_cmd.count ), count-i );
+                hal_remote_swd( XPTR( client_cxy , &client_ptr->txt_cmd.buf_xp ), buf_xp+i );
+                return;
+            }
+        }
+
+        // disable TX_IRQ 
+        xptr_t reg_xp = XPTR( tty_cxy , base + TTY_TX_IRQ_ENABLE );
+        hal_remote_sw( reg_xp , 0 );
+
+        // set I/O operation status in command
+        hal_remote_sw( XPTR( client_cxy , &client_ptr->txt_cmd.error ) , 0 );
+
+        hal_fence();
+
+        // unblock server thread
+        thread_unblock( XPTR( local_cxy , chdev->server ) , THREAD_BLOCKED_DEV_ISR );
+
+    }  // end TX handling
+
+txt_dmsg("\n[DBG] %s : core[%x,%d] exit / cycle %d\n", 
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
+
+#if (CONFIG_READ_DEBUG & 0x1) || (CONFIG_WRITE_DEBUG & 0x1)
+exit_tty_isr = hal_time_stamp();
+#endif
+
+}  // end soclib_tty_isr()
+
+*/

trunk/hal/tsar_mips32/drivers/soclib_tty.h

@@ -83 +83 @@
 
 /****************************************************************************************
- * This ISR should be executed only for the TXT_READ and TXT_WRITE commands.
+ * This ISR is executed to handle both the TTY_TX_IRQ and the TTY_RX_IRQ.
+ * - the TTY_RX_IRQ is activated as soon as the TTY_STATUS_RX_FULL bit is set in the
+ *   TTY status register, indicating a character registered in the TTY_READ register.
+ *
+ *   . if it exist a TXT_READ command registered in the command queue, and thit copies the
+ *     character to the command buffer, acknowledges the TTY_RX_IRQ, and unblock the 
+ *     associated server thread.
+     
+ *   . the control characters are directly handled by the txt ^C / ^D /  and the this IRQ ca
+ * 
+ the TXT_READ and TXT_WRITE commands.
  * It gets the command arguments from the first client thread in the TXT chdev queue:
  * - if TXT_READ, it transfers one byte from the TTY_READ_REG to the command buffer.