Changeset 5 for trunk/kernel/kern/printk.c

Timestamp:

Apr 26, 2017, 2:11:56 PM (8 years ago)

Author:

alain

Message:

Introduce the chdev_t structure in place of the device_t structure.

File:

• trunk/kernel/kern/printk.c (modified) (8 diffs)

trunk/kernel/kern/printk.c

@@ -24 +24 @@
 #include <hal_types.h>
 #include <hal_irqmask.h>
-#include <printk.h>
-#include <stdarg.h>
+#include <hal_special.h>
 #include <dev_txt.h>
 #include <remote_spinlock.h>
 #include <cluster.h>
+#include <printk.h>
 
 ///////////////////////////////////////////////////////////////////////////////////
-// This static function is called by printk(), nolock_printk() and user_printk()
+// This static function is called by kernel_printf() to display a string on the
+// TXT channel defined by the <channel> argument. 
+// The access mode is defined by the <busy> argument:
+// - if <busy> is true, it uses the dev_txt_sync_write() function, that takes the
+//   TXT lock, and call directly the relevant TXT driver, without descheduling.
+// - if <busy is false, it uses the dev_txt_write() function, that register the
+//   write buffer in the relevant TXT chdev queue, and uses a descheduling policy.
 ///////////////////////////////////////////////////////////////////////////////////
+// @ channel  : TXT channel.
+// @ busy     : TXT device acces mode.
+// @ buf      : buffer containing the characters.
+// @ nc       : number of characters.
+// return 0 if success / return -1 if TTY0 busy after 10000 retries.
+///////////////////////////////////////////////////////////////////////////////////
+static error_t txt_write( uint32_t  channel,
+                          uint32_t  busy,
+                          char    * buffer,
+                          uint32_t  count )
+{
+    if( busy ) return dev_txt_sync_write( channel , buffer , count );
+    else       return dev_txt_write( channel , buffer , count );
+}  
+
+//////////////////////////////////////////////////////////////////////////////////////
+// This static function is called by printk() and user_printk() to build
+// a formated string.
+//////////////////////////////////////////////////////////////////////////////////////
+// @ channel   : channel index.
+// @ busy      : TXT device access mode.
+// @ format    : printf like format.
+// @ args      : format arguments.
+//////////////////////////////////////////////////////////////////////////////////////
 static void kernel_printf( uint32_t   channel,
+                           uint32_t   busy,
                            char     * format, 
                            va_list  * args ) 
@@ -46 +77 @@
         if (i) 
         {
-            dev_txt_sync_write( channel, format, i );
+            txt_write( channel, busy, format, i );
             format += i;
         }
@@ -83 +114 @@
                 {
                     val = -val;
-                    dev_txt_sync_write( channel, "-" , 1 );
+                    txt_write( channel, busy, "-" , 1 );
                 }
                 for(i = 0; i < 10; i++) 
@@ -109 +140 @@
             {
                 uint32_t val = va_arg( *args , uint32_t );
-                dev_txt_sync_write( channel, "0x" , 2 );
+                txt_write( channel, busy, "0x" , 2 );
                 for(i = 0; i < 8; i++) 
                 {
-                    buf[7 - i] = HexaTab[val % 16];
+                    buf[7 - i] = HexaTab[val & 0xF];
                     if (!(val = (val>>4)))  break;
                 }
@@ -119 +150 @@
                 break;
             }
-            case ('X'):             /* 32 bits hexadecimal unsigned  on 10 char*/
+            case ('X'):             /* 32 bits hexadecimal unsigned  on 10 char */
             {
                 uint32_t val = va_arg( *args , uint32_t );
-                dev_txt_sync_write( channel, "0x" , 2 );
+                txt_write( channel, busy, "0x" , 2 );
                 for(i = 0; i < 8; i++) 
                 {
-                    buf[7 - i] = HexaTab[val % 16];
+                    buf[7 - i] = HexaTab[val & 0xF];
                     val = (val>>4);
                 }
@@ -135 +166 @@
             {
                 uint64_t val = va_arg( *args , uint64_t );
-                dev_txt_sync_write( channel, "0x" , 2 );
+                txt_write( channel, busy, "0x" , 2 );
                 for(i = 0; i < 16; i++) 
                 {
-                    buf[15 - i] = HexaTab[val % 16];
-                    if (!(val /= 16))  break;
+                    buf[15 - i] = HexaTab[val & 0xF];
+                    if (!(val = (val>>4)))  break;
                 }
                 len =  i + 1;
                 pbuf = &buf[15 - i];
+                break;
+            }
+            case ('L'):           /* 64 bits hexadecimal unsigned on 18 char */ 
+            {
+                uint64_t val = va_arg( *args , uint64_t );
+                txt_write( channel, busy, "0x" , 2 );
+                for(i = 0; i < 16; i++) 
+                {
+                    buf[15 - i] = HexaTab[val & 0xF];
+                    val = (val>>4);
+                }
+                len =  16;
+                pbuf = buf;
                 break;
             }
@@ -157 +201 @@
             default:
             {
-                dev_txt_sync_write( channel ,
-                                    "\n[PANIC] in kernel_printf() : illegal format\n", 45 );
+                txt_write( channel , busy,
+                           "\n[PANIC] in kernel_printf() : illegal format\n", 45 );
             }
         }
 
-        if( pbuf != NULL ) dev_txt_sync_write( channel, pbuf, len );
+        if( pbuf != NULL ) txt_write( channel, busy, pbuf, len );
         
         goto printf_text;
@@ -169 +213 @@
 }  // end kernel_printf()
 
-///////////////////////////////////////
-void nolock_printk( char* format, ...)
-{
-    va_list   args;
+////////////////////////////////
+void printk( char * format, ...)
+{
+    va_list       args;
 
     // call kernel_printf
     va_start( args , format );
-    kernel_printf( 0, format , &args );
+    kernel_printf( 0 , 1 , format , &args );
     va_end( args );
 }
 
-////////////////////////////////
-void printk( char* format, ...)
-{
-    va_list       args;
-    uint32_t  save_sr;
-
-    // disable IRQs
-    hal_disable_irq( &save_sr );
-
-    // get TXT0 lock
-    cluster_t * cluster = LOCAL_CLUSTER;
-    remote_spinlock_lock( XPTR( cluster->io_cxy , &cluster->txt0_lock ) );
+/////////////////////////////////////
+void user_printk( char* format, ...)
+{
+    va_list   args;
+
+    // get calling thread TXT channel TODO
+    uint32_t channel = 0;
 
     // call kernel_printf
     va_start( args , format );
-    kernel_printf( 0, format , &args );
-    va_end( args );
-
-    // release TXT0 lock
-    remote_spinlock_unlock( XPTR( cluster->io_cxy , &cluster->txt0_lock ) );
-
-    // restore IRQs
-    hal_restore_irq( save_sr );
-}
-
-/////////////////////////////////////
-void user_printk( char* format, ...)
-{
-    va_list   args;
-
-    // get calling thread TXT channel TODO
-    uint32_t channel = 0;
-
-    // call kernel_printf
-    va_start( args , format );
-    kernel_printf( channel, format , &args );
+    kernel_printf( channel, 0 , format , &args );
     va_end( args );
 }
 
-
+///////////////////////////////////////////
+inline void assert( bool_t       condition,
+                    const char * function_name,
+                    char       * string )
+{
+    if( condition == false )
+    {
+        printk("\n[PANIC] in %s : %s\n" , function_name , string );
+        hal_core_sleep();
+    }
+}
 
 // Local Variables: