Main Page   Modules   Alphabetical List   Data Structures   File List   Data Fields   Globals   Related Pages  

console.c File Reference

Virtual consoles. More...

#include <const.h>
#include <stdarg.h>
#include <stdio.h>
#include <arch/mem.h>
#include <kernel/keyboard.h>
#include <kernel/kmalloc.h>
#include <kernel/task.h>
#include <kernel/video.h>
#include <kernel/console.h>

Go to the source code of this file.

Defines

#define VIDEO_BUFFER   VIDEO_MEM_ADDRESS
 The address of the video buffer in memory.

#define VIDEO_BUF_DIM   (80*25)
 The size of the video buffer (in standard text-mode).


Functions

console_t * get_console_addr (int c)
 Get the address of a console structure.
Parameters:
c  The console id.
Returns:
The address of the console structure.
Exceptions:
NULL  Console c does not exists.

int get_curr_console ()
 Get the current console id.
Returns:
The current console id.

bool set_curr_console (int c)
 Set the current console.
Parameters:
c  The console id to set as current console.
Returns:
  • TRUE if c is a valid console id.
  • FALSE if c is not a valid console id.

bool switch_to_console (int c)
 Change the current console and refresh the screen.
Parameters:
c  The console to switch to.
Returns:
  • TRUE if c is a valid console id.
  • FALSE if c is not a valid console id.

void clrscr ()
 Clear the screen.

byte get_color ()
 Get the current text color of the console.
Returns:
The value of the color.

void set_color (byte attrib)
 Set the text color for the current console.
Parameters:
attrib  The color value.

void scroll_up ()
 Scroll the console up.

void gotoxy (int x, int y)
 Place the cursor at the (x, y) coordinates.
Note:
If x or y get a value of -1 they does not change their value.

void kputchar (int c)
 Put a character on the current console.
Parameters:
c  The ASCII value of the character.

int kprintf (const char *fmt,...)
 Print a string to the current console.
Parameters:
message  The format of the message.
...  The variables to print.

void init_main_console ()
 Initialize the special console #0 as the video memory buffer.

void create_virtual_console ()
 Allocate and initialize memory space for virtual consoles.
Note:
Before you can run this procedure you have to initialize the virtual memory manager.


Variables

console_t vir_cons [K_TOT_VIR_CONS+1]
 Virual consoles buffer (console #0 is the special console).

int curr_cons = 1
 Index of the current console.

Detailed Description

Virtual consoles.

Author:
Andrea Righi <drizzt@inwind.it>
Date:
Last update: 2003-11-01
Note:
Copyright (©) 2003 Andrea Righi

Definition in file console.c.

Define Documentation

#define VIDEO_BUF_DIM   (80*25)
 

The size of the video buffer (in standard text-mode).

Definition at line 24 of file console.c.

#define VIDEO_BUFFER   VIDEO_MEM_ADDRESS
 

The address of the video buffer in memory.

Definition at line 22 of file console.c.

Function Documentation

void clrscr (    ) 
 

Clear the screen.

Definition at line 101 of file console.c. 

00102 {
00103         task_t *p;
00104 
00105         if ( !(p=get_curr_task()) )
00106         {
00107                 // If there is no task clear the main console           //
00108                 k_clrscr( (console_t *)(&vir_cons[0]) );
00109                 return;
00110         }
00111 
00112         if ( p->console==curr_cons )
00113                 // The task is running in the current console.          //
00114                 // So clear the main console                            //
00115                 k_clrscr( (console_t *)(&vir_cons[0]) );
00116         else
00117                 // The task is not running in the current console.      //
00118                 // Clear the task console                               //
00119                 k_clrscr( (console_t *)(&vir_cons[p->console]) );
00120 }

void create_virtual_console (    ) 
 

Allocate and initialize memory space for virtual consoles.

Note:
Before you can run this procedure you have to initialize the virtual memory manager.

Definition at line 282 of file console.c. 

00283 {
00284         int i;
00285 
00286         for (i=1; i < (K_TOT_VIR_CONS+1); i++)
00287         {
00288                 vir_cons[i].vid_buffer = kmalloc( VIDEO_BUF_DIM*sizeof(word) );
00289                 memsetw(vir_cons[i].vid_buffer, 0, VIDEO_BUF_DIM);
00290                 vir_cons[i].cur_pos = 0;
00291                 vir_cons[i].cur_color = DEFAULT_COLOR;
00292         }
00293 
00294         // Copy the current video parameters into the first     //
00295         // virtual console.                                     //
00296         memcpyw(vir_cons[1].vid_buffer, vir_cons[0].vid_buffer, VIDEO_BUF_DIM);
00297         vir_cons[1].cur_pos = vir_cons[0].cur_pos;
00298         vir_cons[1].cur_color = vir_cons[0].cur_color;
00299 
00300         // Automatic switch to the first virtual console        //
00301         curr_cons = 1;
00302 }

byte get_color (    ) 
 

Get the current text color of the console.

Returns:
The value of the color.

Definition at line 124 of file console.c. 

00125 {
00126         task_t *p;
00127 
00128         if ( !(p=get_curr_task()) )
00129         {
00130                 // If there is no task return the main console color    //
00131                 return( k_get_color((console_t *)(&vir_cons[0])) );
00132         }
00133 
00134         if ( p->console==curr_cons )
00135                 // The task is running in the current console.          //
00136                 // So return the main console color                     //
00137                 return( k_get_color((console_t *)(&vir_cons[0])) );
00138         else
00139                 // The task is not running in the current console.      //
00140                 // Return the task console color                        //
00141                 return( k_get_color((console_t *)(&vir_cons[p->console])) );
00142 }

console_t* get_console_addr (  int    c ) 
 

Get the address of a console structure.

Parameters:
c  The console id.
Returns:
The address of the console structure.
Exceptions:
NULL  Console c does not exists.

Definition at line 37 of file console.c. 

00038 {
00039         if ( (c>=0) && (c<=K_TOT_VIR_CONS) )
00040                 return( (console_t *)(&vir_cons[c]) );
00041 
00042         return((console_t *)NULL);
00043 }

int get_curr_console (    ) 
 

Get the current console id.

Returns:
The current console id.

Definition at line 47 of file console.c. 

00048 {
00049         return(curr_cons);
00050 }

void gotoxy (  int    x,
int    y
) 
 

Place the cursor at the (x, y) coordinates.

Note:
If x or y get a value of -1 they does not change their value.

Definition at line 193 of file console.c. 

00194 {
00195         task_t *p;
00196 
00197         if ( !(p=get_curr_task()) )
00198         {
00199                 // If there is no task print to the video buffer        //
00200                 k_gotoxy((console_t *)(&vir_cons[0]), x, y);
00201                 return;
00202         }
00203 
00204         if ( p->console==curr_cons )
00205                 // The task is running in the current console.          //
00206                 // So execute directly to the video memory              //
00207                 k_gotoxy((console_t *)(&vir_cons[0]), x, y);
00208         else
00209                 // The task is not running in the current console.      //
00210                 // Execute into its video buffer                        //
00211                 k_gotoxy((console_t *)(&vir_cons[p->console]), x, y);
00212 }

void init_main_console (    ) 
 

Initialize the special console #0 as the video memory buffer.

Definition at line 268 of file console.c. 

00269 {
00270         vir_cons[0].vid_buffer = (word *)VIDEO_BUFFER;
00271         vir_cons[0].cur_pos = 0;
00272         vir_cons[0].cur_color = DEFAULT_COLOR;
00273 
00274         // Clear the screen                                             //
00275         k_clrscr( (console_t *)(&vir_cons[0]) );
00276 }

int kprintf (  const char *    fmt,
...   
) 
 

Print a string to the current console.

Parameters:
message  The format of the message.
...  The variables to print.

Definition at line 245 of file console.c. 

00246 {
00247         char buf[1024];
00248         va_list args;
00249         int i;
00250 
00251         va_start( args, fmt );
00252 
00253         vsnprintf( buf, sizeof(buf), fmt, args );
00254         va_end( args );
00255 
00256         for( i=0; i<1024; i++ )
00257         {
00258                 if( !buf[i] ) break;
00259                 kputchar( buf[i] );
00260         }
00261 
00262         return( i );
00263 }

void kputchar (  int    c ) 
 

Put a character on the current console.

Parameters:
c  The ASCII value of the character.

Definition at line 216 of file console.c. 

00217 {
00218         task_t *p = get_curr_task();
00219         uint32_t IF = GET_IF();
00220 
00221         if ( !p )
00222         {
00223                 // If there is no task print to the video buffer.
00224                 _kputchar((console_t *)(&vir_cons[0]), c);
00225                 return;
00226         }
00227 
00228         disable();
00229 
00230         if ( p->console==curr_cons )
00231                 // The task is running in the current console.
00232                 // So print directly to the video memory.
00233                 _kputchar((console_t *)(&vir_cons[0]), c);
00234         else
00235                 // The task is not running in the current console.
00236                 // Print into its video buffer.
00237                 _kputchar((console_t *)(&vir_cons[p->console]), c);
00238 
00239         SET_IF( IF );
00240 }

void scroll_up (    ) 
 

Scroll the console up.

Definition at line 168 of file console.c. 

00169 {
00170         task_t *p;
00171 
00172         if ( !(p=get_curr_task()) )
00173         {
00174                 // If there is no task execute in the video buffer      //
00175                 k_scroll_up( (console_t *)(&vir_cons[0]) );
00176                 return;
00177         }
00178 
00179         if ( p->console==curr_cons )
00180                 // The task is running in the current console.          //
00181                 // So execute directly to the video memory              //
00182                 k_scroll_up( (console_t *)(&vir_cons[0]) );
00183         else
00184                 // The task is not running in the current console.      //
00185                 // Execute into its video buffer                        //
00186                 k_scroll_up( (console_t *)(&vir_cons[p->console]) );
00187 }

void set_color (  byte    attrib ) 
 

Set the text color for the current console.

Parameters:
attrib  The color value.

Definition at line 146 of file console.c. 

00147 {
00148         task_t *p;
00149 
00150         if ( !(p=get_curr_task()) )
00151         {
00152                 // If there is no task set the main console color       //
00153                 k_set_color( (console_t *)(&vir_cons[0]), attrib );
00154                 return;
00155         }
00156 
00157         if ( p->console==curr_cons )
00158                 // The task is running in the current console.          //
00159                 // So set the main console color                        //
00160                 k_set_color( (console_t *)(&vir_cons[0]), attrib );
00161         else
00162                 // The task is not running in the current console.      //
00163                 // Set the task console color                           //
00164                 k_set_color( (console_t *)(&vir_cons[p->console]), attrib );
00165 }

bool set_curr_console (  int    c ) 
 

Set the current console.

Parameters:
c  The console id to set as current console.
Returns:
  • TRUE if c is a valid console id.
  • FALSE if c is not a valid console id.

Definition at line 57 of file console.c. 

00058 {
00059         if ( (c > 0) && (c <= K_TOT_VIR_CONS) )
00060                 curr_cons = c;
00061         else
00062                 return(FALSE);
00063 
00064         return(TRUE);
00065 }

bool switch_to_console (  int    c ) 
 

Change the current console and refresh the screen.

Parameters:
c  The console to switch to.
Returns:
  • TRUE if c is a valid console id.
  • FALSE if c is not a valid console id.

Definition at line 72 of file console.c. 

00073 {
00074         if ( c == curr_cons)
00075                 // Attempt to switch to the current console             //
00076                 return(TRUE);
00077 
00078         // Copy old console parameters from video memory                //
00079         memcpyw(vir_cons[curr_cons].vid_buffer, vir_cons[0].vid_buffer, VIDEO_BUF_DIM);
00080         vir_cons[curr_cons].cur_pos = vir_cons[0].cur_pos;
00081         vir_cons[curr_cons].cur_color = vir_cons[0].cur_color;
00082 
00083         if ( set_curr_console(c) )
00084         {
00085                 // Set new console parameters to the video memory       //
00086                 memcpyw(vir_cons[0].vid_buffer, vir_cons[c].vid_buffer, VIDEO_BUF_DIM);
00087                 k_set_cur_pos( (console_t *)(&vir_cons[0]), vir_cons[c].cur_pos );
00088                 k_set_color( (console_t *)(&vir_cons[0]), vir_cons[c].cur_color );
00089 
00090                 // Set keyboard parameters of the new selected console  //
00091                 update_leds();
00092 
00093                 return(TRUE);
00094         }
00095         return(FALSE);
00096 }

Variable Documentation

int curr_cons = 1 [static]
 

Index of the current console.

Definition at line 29 of file console.c.

console_t vir_cons[K_TOT_VIR_CONS+1] [static]
 

Virual consoles buffer (console #0 is the special console).

Definition at line 27 of file console.c.

Generated on Fri Feb 20 15:32:17 2004 for Minirighi by doxygen1.2.18