src/tty/teletype.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       teletype.cpp, version 1.1                          *
************************************************************
*                                                          *
*teletype.cpp, support for the virtual consoles, outputting*
*text to it. Also the keystroke handler for the consoles   *
*                                                          *
*18'04'04- fork from the 0.05 branch(1.1)                  *
*                                                          *
*http://www.osdever.net/FreeVGA/home.htm - FreeVGA         *
*                                                          *
***********************************************************/

/*todo: movecurs(int) to work with negative values
        put ('\b') doesn't work*/

#include "src/common/shared.hpp"
#include "src/common/error.hpp"
#include "src/common/io.hpp"
#include "src/memory/align.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/alloc4k.hpp"
#include "src/memory/pager.hpp"
#include "src/memory/heap.hpp"
#include "src/common/string.hpp"
#include "src/thread/scheduler.hpp"
#include "src/tty/teletype.hpp"

bool volatile TTYDisableLock=false;     //the locks on the consoles aren't respected if true.
/*global variables*/
teletype videoHW ((ChCol*) VIDEO_MEMORY + CONSOLE_XSIZE, CONSOLE_XSIZE, CONSOLE_YSIZE, CONSOLE_YSIZE, NULL, NULL, CONSOLE_COLOR);       /*video mem for 0xb8000*/
teletype *active_console = &tty1;       /*active console*/
/*upper pannel*/
teletype tty_panel ((ChCol*) VIDEO_MEMORY, CONSOLE_XSIZE, 1, 1, NULL, NULL, TTY_PANEL_COLOR);
/*virtual consoles*/
teletype tty1 (tty1_buf, CONSOLE_XSIZE, CONSOLE_YSIZE, VIRTCONS_LINES, &videoHW, &tui_kbd_handler, CONSOLE_COLOR);
teletype tty2 (tty2_buf, CONSOLE_XSIZE, CONSOLE_YSIZE, VIRTCONS_LINES, &videoHW, &tui_kbd_handler, CONSOLE_COLOR);
teletype tty3 (tty3_buf, CONSOLE_XSIZE, CONSOLE_YSIZE, VIRTCONS_LINES, &videoHW, &tui_kbd_handler, CONSOLE_COLOR);
teletype tty4 (tty4_buf, CONSOLE_XSIZE, CONSOLE_YSIZE, VIRTCONS_LINES, &videoHW, &tui_kbd_handler, CONSOLE_COLOR);
teletype tty5 (tty5_buf, CONSOLE_XSIZE, CONSOLE_YSIZE, VIRTCONS_LINES, &videoHW, &tui_kbd_handler, CONSOLE_COLOR);
teletype tty6 (tty6_buf, CONSOLE_XSIZE, CONSOLE_YSIZE, VIRTCONS_LINES, &videoHW, &tui_kbd_handler, CONSOLE_COLOR);
teletype tty7 (tty7_buf, CONSOLE_XSIZE, CONSOLE_YSIZE, VIRTCONS_LINES, &videoHW, &tui_kbd_handler, CONSOLE_COLOR);
teletype tty8 (tty8_buf, CONSOLE_XSIZE, CONSOLE_YSIZE, VIRTCONS_LINES, &videoHW, &tui_kbd_handler, CONSOLE_COLOR);
teletype tty9 (tty9_buf, CONSOLE_XSIZE, CONSOLE_YSIZE, VIRTCONS_LINES, &videoHW, &tui_kbd_handler, CONSOLE_COLOR);
teletype tty0 (tty0_buf, CONSOLE_XSIZE, CONSOLE_YSIZE, VIRTCONS_LINES, &videoHW, &tui_kbd_handler, CONSOLE_COLOR);
/*tty buffers. bss yea?*/
ChCol tty1_buf [VIRTCONS_LINES * CONSOLE_XSIZE] __attribute__ ((section (".bss.dontcare")));
ChCol tty2_buf [VIRTCONS_LINES * CONSOLE_XSIZE] __attribute__ ((section (".bss.dontcare")));
ChCol tty3_buf [VIRTCONS_LINES * CONSOLE_XSIZE] __attribute__ ((section (".bss.dontcare")));
ChCol tty4_buf [VIRTCONS_LINES * CONSOLE_XSIZE] __attribute__ ((section (".bss.dontcare")));
ChCol tty5_buf [VIRTCONS_LINES * CONSOLE_XSIZE] __attribute__ ((section (".bss.dontcare")));
ChCol tty6_buf [VIRTCONS_LINES * CONSOLE_XSIZE] __attribute__ ((section (".bss.dontcare")));
ChCol tty7_buf [VIRTCONS_LINES * CONSOLE_XSIZE] __attribute__ ((section (".bss.dontcare")));
ChCol tty8_buf [VIRTCONS_LINES * CONSOLE_XSIZE] __attribute__ ((section (".bss.dontcare")));
ChCol tty9_buf [VIRTCONS_LINES * CONSOLE_XSIZE] __attribute__ ((section (".bss.dontcare")));
ChCol tty0_buf [VIRTCONS_LINES * CONSOLE_XSIZE] __attribute__ ((section (".bss.dontcare")));
/*==================================CONSOLE FUNCTIONS==================================*/

namespace Teletype {

ChCol *vidmem;
//this simple function maps the color video memory (4000 bytes at 0xb8000) to kernel space. so we don't care about the
//first 4Mib to be mapped
void init()
 {

uint32 **pgd, *pgt;
        vidmem= (ChCol*) Memory::Physical::ballocate(4096, PAGE_ALIGN);
//QuickHack(tm) for mapping video memory into the memory space and unmapping the first 4 Mib
//depenends on the first 4 Mib to be identity mapped
        asm volatile("mov %%cr3, %%eax" : "=a" (pgd));
        //map 0xb8000 to vidmem
        pgt= (uint32*)((uint32)pgd[(uint32)vidmem/PGT_WIDE]&0xfffff000);
        pgt[((uint32)vidmem&0x003fffff)/PAGE_SIZE]= video_memory|PTE_PRESENT|PTE_WRITEABLE;
        //unmap first 4Mib
//update: if we unmap them, mboot info about loaded modules will become inaccessible
//      pgd[0]=0;
        //flush tlb buffers
        asm volatile("movl %cr3, %eax\nmovl %eax, %cr3");
//change the framebuffers for the panel and the videoHW
        videoHW.video=vidmem+CONSOLE_XSIZE;
        tty_panel.video=vidmem;
 }

 };     /*namespace Teletype*/

/*create a teletype object*/
teletype::teletype(ChCol *buffer, int _xsize, int _ysize, int _lines, teletype *vHW, int (*kbd_h)(), uint8 col)
 {
//      lock_tty.init("tty");
        sem_init(&sem_tty,1,"tty");
/*the buffer for the console*/
        video=(ChCol*) buffer;
/*screen size*/
        xsize=_xsize; ysize=_ysize; lines= _lines; yfocus=yoffset=0;
        color = col;
        start=0;lgth=0;
/*the hardware teletype*/
        HW = vHW;
        kbd_handler=kbd_h;
//      tui_focus=NULL;
/*now clrscr*/
        clrscr();
 }

/*clear the screen*/
void teletype::clrscr()
 {
/*clear all data*/
        memset((void*) video, color * 0x01000100, sizeof (ChCol) * xsize * lines);
/*be at the top*/
        yfocus=yoffset = 0;
        start=0;lgth=0;
        x=y=0;
        gotoxy(0, 0);
/*clrscr the parent*/
        if (HW)
        if (this == active_console)
                HW->clrscr();
 }

/*returns in buf*/
int teletype::line (int n)
 {
int val = n + start;
/*sanity*/
        if (val < 0)
                return -1;
        if (n >= lines)
                return -1;
/*if overlaps the cyclic buffer*/
        if (val >= lines)
                return val - lines;
/*if does not overlap*/
        return val;
 }

/*returns ptr*/
ChCol *teletype::lineptr (int n)
 {
int l = line(n);
ChCol *r;
/*sanity*/
        if (l == -1)
                r= NULL; else
/*pointer in the buffer*/
        r= video + l * xsize;

        if ((uint32)r<0x1000)
         { asm volatile("cli"); TTYDisableLock=true; say(const_cast<char*>("%x"),r);asm volatile ("cli\nhlt");}
        return r;
 }

/*move cursor*/
void teletype::movecurs(int n)
 {
int k;
int nl;
        x+=n;
        if (x >= xsize)
         {
                k = x / xsize;
                x = x % xsize;
                y+=k;
        /*set the lgth var*/
                nl=y+yfocus+k;
                if (nl > lgth)
                        lgth=nl;
         }
        if (y >= ysize)
         {
                yfocus += ysize - y + 1;
                yoffset=yfocus;
                y= ysize-1;
        /*check, if we have to cycle the buffer*/
                if (lgth>lines)
                        del_top(lgth-lines);
        /*repaint the screen*/
                if (HW)
                if (this == active_console)
                        HW->repaint(this);
         }
 }


//put a lock on the console
void teletype::llock() {
        _PF;
        if (TTYDisableLock)     //we don't want exception handlers to cout on a locked console
                Preturn();

// try to acquire the semaphore. if not possible for a long time, continue anyways
int cnt=0xffff;
        while (cnt--)
                if (sem_trywait(&sem_tty)==ESUCCESS)
                        Preturn();
        Preturn();
 }

// release the lock on the console
void teletype::lulock() {
//      lock_tty.ulock();
        sem_post(&sem_tty);
 }

/*repaint*/
void teletype::repaint(teletype *tty)
 { _Pf("tty'::repaint");
int i;
/*turn the cursor off if we are looking at old text and on if looking at recent text*/
        videoHW_toggle_cursor(tty->yfocus == tty->yoffset);
/*this is the other way around, but it's slower*/
        for (i=0;i<ysize;i++)
                memmove (lineptr(yoffset + i),
                        tty->lineptr(tty->yoffset+i),
                        160);

        preturn();
 }

/*delete the n top lines*/
void teletype::del_top(int n)
 {
/*memory: wipe out that lines*/
        memset((void*) lineptr(0), color * 0x01000100, n * sizeof(ChCol) * xsize);
/*accounting: forget about these lines*/
        yoffset-=n; yfocus-=n;
        start+=n;if (start>=lines) start-=lines;
        lgth-=n;
 }

/*change cursor pos*/
void teletype::gotoxy(int px, int py)
 {
 /* ***** */
//      llock();
/*TBD: scrolling down/up*/
        x=px; y=py;
        if (this == active_console) 
                videoHW_gotoxy(y * xsize + x + GOTOXY_ADDEND);
 return; /* *** */

/*sync yoffset and yfocus*/
        if (yoffset != yfocus) {
                yoffset=yfocus;
                if (HW)
                if (this == active_console) HW->repaint(this); }
// asm volatile ("cli\nhlt");
//      lulock();
        return ;
/*check*/
        if ((px < 0) || (px >= xsize))  /*x in the range*/
                return ;
        if (py + yfocus < 0)    /*if wanna scroll up*/
                return ;
        if (py + yfocus > lines)        /*if wanna scroll down when the buffer's full*/
                sysfail("oy! teletype::gotoxy, error #1");
 }

/*makes the line to be visible on top*/
void teletype::showtop(int py)
 {
/*sanity*/
        if (py < 0)
                py = 0;
        if (py + ysize > lines)
                py = lines - ysize;
/*change line and repaint*/
        yoffset = py;
        if (HW)
        if (this == active_console)
                HW->repaint(this);
 }

/*put a char & no move*/
void teletype::put(char ch)
 {
        put(ch,color);
 }

/*put a char & no move*/
void teletype::put(char ch, uint8 col)
 { _Pf("Tty'::put");
//      llock();
/*sync yoffset and yfocus*/
        if (yoffset != yfocus) {
                yoffset=yfocus;
                if (HW) if (this == active_console) HW->repaint(this); }

        switch (ch)
         {
        case '\n':
                movecurs(xsize-x);
                break;
        case '\t':
                tab(8);
/*      int new_x;
                new_x = align_up(x+1, 8);
                while (x < new_x)
                 {
                        poke (' ', x,y, col);
                        x++;
                 }*/
                break;
        case 13:
                x=0;
                break;
        case '\a':
                break;
        case '\b':
                poke (' ', x-1,y, color);
                movecurs(-1);
                break;
        default:
                poke (ch, x,y, col);
                movecurs(1);
                break;
         }
//      lulock();

        preturn();
 }

/*putch & move*/
void teletype::putch(char ch)
 {
        putch(ch,color);
 }

/*putch & move*/
void teletype::putch(char ch, uint8 col)
 {
        put(ch,col);
        gotoxy(x,y);
 }

/*poke a str*/
void teletype::poke_str(char *ch, int px, int py, uint8 col, uint32 limit)
 {
uint32 oldx=x,oldy=y;
uint32 cnt=0;
        gotoxy(px,py);
        while ( (*ch) && (cnt < limit) ) put(*(ch++),col);
        gotoxy(oldx,oldy);
 }

/*poke a char*/
void teletype::poke (char ch, int px, int py, uint8 col)
 {
ChCol *l = lineptr(py + yfocus);
/*sanity*/
        if (l == NULL)
                return ;
        if (px < 0)
                return ;
        if (px >= xsize)
                return ;

/*change in local buffer*/
        l[px].ch=ch;
        l[px].col=col;
/*change in parent*/
        if (HW)
        if (this == active_console)
                HW->poke(ch,px,py,col);
 }

int teletype::getx() {
        return x;
 }

int teletype::gety() {
        return y;
 }

int teletype::getxsize() {
        return xsize;
 }

int teletype::getysize() {
        return ysize;
 }

/*change the color*/
void teletype::setcol(uint8 col) {
        color = col;
 }

/*scroll by i*ysize/2 down*/
void teletype::scroll(int i)
 {
/*the new top line of the terminal*/
int newyoffset = yoffset + i * ysize / 2;
/*do not scroll below the last edited line*/
        if (newyoffset + ysize > lgth)
                newyoffset = lgth - ysize;
/*now change the value*/
        showtop(newyoffset);
 }

//align x by i
void teletype::tab(int i)
 {
int new_x= align_up(x+1, i);
        while (x < new_x)
         {
                poke(' ', x,y, color);
                x++;
         }
 }

// /*sets the tui focus on a thread*/
// void teletype::set_tui_focus(thread_t *thread) {
//      tui_focus=thread;
//  }
// 
// /*clear focus*/
// void teletype::clear_tui_focus() {
//      tui_focus=NULL;
//  }

/*===================GENERAL USE FUNCTIONS TO PRINT TO ACTIVE CONSOLE==================*/
/*cout num*/
void coutnum(uint32 n, uint32 radix, uint32 n_pos, char first_letter)
 {
        coutnum(active_console,n,radix,n_pos,first_letter);
 }

/*cout num*/
void coutnum(teletype *tty, uint32 n, uint32 radix, uint32 n_pos, char first_letter) {
        coutnum(tty,n,radix,n_pos,first_letter,'0');
 }

/*cout num*/
void coutnum(teletype *tty, uint32 n, uint32 radix, uint32 n_pos, char first_letter, char EmptyLetter)
 {
uint32 cipher;
bool FirstCipherPut=false;
        tty->llock();
        while (n_pos)
         {
                cipher = n / n_pos;
                if (cipher <= 9) { if ((cipher==0)&&(n_pos/radix)&&(FirstCipherPut==false)) tty->put(EmptyLetter); else
                        { tty->put(cipher + (char) '0'); FirstCipherPut=true; } }
                        else tty->put(cipher + first_letter - 0xA);

                n -= cipher * n_pos;
                n_pos = n_pos / radix;
         }
        tty->gotoxy(tty->getx(),tty->gety());
        tty->lulock();
 }

/*cout num*/
void coutnum(teletype *tty, uint32 n, uint32 radix, uint32 n_pos, char first_letter, uint8 col)
 {
        tty->llock();
uint32 cipher;
        while (n_pos)
         {
                cipher = n / n_pos;
                if (cipher <= 9) tty->put(cipher + (char) '0',col);
                        else tty->put(cipher + first_letter - 0xA,col);

                n -= cipher * n_pos;
                n_pos = n_pos / radix;
         }
        tty->gotoxy(tty->getx(),tty->gety());
        tty->lulock();
 }

/* decimal */
void coutDec(uint32 i) {
   if (i == 0) {
      putch('0');
      return ;
   }
   for (uint32 rank=1000000000; rank; rank /= 10) {
      if (rank > i)
         continue;
      putch( '0'+(i / rank)%10 );
   }
}

/*write a string*/
void cout (const char *ch)
 {
//      while ( (*ch) ) active_console->put(*(ch++));
//      active_console->gotoxy(active_console->getx(),active_console->gety());
        cout(active_console,const_cast<char*>(ch));
 }

/*write a string to the selected console*/
void cout(teletype *tty, char *ch)
 {
        tty->llock();
        while ( (*ch) ) tty->put(*(ch++));
        tty->gotoxy(tty->getx(),tty->gety());
        tty->lulock();
 }

/*colored string*/
void cout (char *ch, uint8 color)
 {
        active_console->llock();
        while ( (*ch) ) active_console->put(*(ch++),color);
        active_console->gotoxy(active_console->getx(),active_console->gety());
        active_console->lulock();
 }

/*write a num*/
void cout (uint32 i)
 {
        coutnum(i, 16, 0x10000000, 'A');
 }

/*write a num*/
void cout (uint32 i,uint8 col)
 {
        coutnum(active_console, i, 16, 0x10000000, 'A', col);
 }

/*write a num*/
void cout (teletype *tty, uint32 i)
 {
        coutnum(tty,i,16,0x10000000,'A');
 }

/*write a byte*/
void coutb(uint8 ch)
 {
        coutnum(ch, 0x10, 0x10, 'A');
 }

/*output a char*/
void putch(char ch)
 {
        active_console->llock();
        active_console->putch(ch);
        active_console->lulock();
 }

/*write here at most limit bytes of ch in color, without moving the cursor pos*/
void writehere(char *ch, uint8 color, uint32 limit)
 {
        active_console->llock();
        active_console->poke_str(ch,color,active_console->getx(), active_console->gety(), limit);
        active_console->lulock();
 }

/*poke a char onto the screen*/
void poke_char(char ch, uint8 color, int x, int y)
 {
        active_console->llock();
        active_console->poke(ch, x,y, color);
        active_console->lulock();
 }

/*poke a str*/
void poke_str(char *ch, uint8 color, int x, int y, uint32 limit)
 {
        active_console->llock();
        active_console->poke_str(ch, color, x,y, limit);
        active_console->lulock();
 }

/*write formated text*/
void kprintf(const char *text, ...) 
 {
/*here we keep the formatted string*/
string formatted_text;
/*format text*/
        formatted_text.inval();
        formatted_text.formatText(const_cast<char*>(text), (char*)((uint32)&text + 1));
/*print text*/
        cout(formatted_text.v());

/*dispose string*/
        formatted_text.done();
 }

//standard-alike routines
void ksnprintf(char *str, size_t size, char *format, ...)
  {
string foo;
uint32 len;
          foo.inval(); foo.formatText(format, (char*)((uint32)&format + 1));
          len= foo.length();
          len= (len<size?len:size-1);
          memmove(str, foo.v( ), len );
          str[len]='\0';
  }

/*write formated text*/
void kprintf_alert(char *text, ...)
 {
/*here we keep the formatted string*/
string formatted_text;
/*format text*/
        formatted_text.inval();
        formatted_text.formatText(text, (char*)((uint32)&text + 1));
/*print text*/
        alert(formatted_text.v());

/*dispose string*/
        formatted_text.done();
 }

/*formatted print*/
void kprintf(teletype *tty, char *text, ...)
 {
/*here we keep the formatted string*/
string formatted_text;
/*format text*/
        formatted_text.inval();
        formatted_text.formatText(text, (char*)((uint32)&text + 1));
/*print text*/
        cout(tty, formatted_text.v());

/*dispose string*/
        formatted_text.done();
 }

/*===================================MORE FUNCTIONS====================================*/
/*io to move cursor*/
void videoHW_gotoxy(int n)
 {
union
 {
        uint32 u;
        uint8 c[2]; //** czy nie 4?
 } un;
        un.u = n;

uint32 fl;
        asm volatile("pushf\npopl %0\ncli":"=g"(fl));
   IOPorts::outb (0x3d4, 0xf);
   IOPorts::outb (0x3d5, un.c[0]);
        IOPorts::outb (0x3d4, 0xe);
   IOPorts::outb (0x3d5, un.c[1]);
        asm volatile("pushl %0\npopf"::"g"(fl));
 }

/*io to toggle cursor visibility*/
void videoHW_toggle_cursor(bool on)
 {
uint8 val;
uint32 fl;
        asm volatile("pushf\npopl %0\ncli":"=g"(fl));
/*get current state*/
        IOPorts::outb(0x3d4, 0xa);
        val = IOPorts::inb(0x3d5);
/*toggle the bit*/
        val &= 0xff - 0x20;
        val |= (!on) << 5;
/*set new state*/
        IOPorts::outb (0x3d4, 0xa);
        IOPorts::outb (0x3d5, val);
        asm volatile("pushl %0\npopf"::"g"(fl));
 }

/*the handler for keyevents for the tui*/
int tui_kbd_handler()
 {
        return 1;
//      kprintf("mod: %x scan: %x code: %x type: %x %x\n",
//      last_key_event.modifiers,
//      last_key_event.scan,
//      last_key_event.code,
//      last_key_event.event);

// /*check for shift*/
//      if (last_key_event.modifiers & ANY_SHIFT)
//       {
//              switch (last_key_event.code)
//               {
//              case K_PAGEUP:
//                      active_console->scroll(-1);
//                      return ESUCCESS;
//              case K_PAGEDOWN:
//                      active_console->scroll(1);
//                      return ESUCCESS;
//               }
//       }
//      if (last_key_event.modifiers & ANY_CTRL)
//       {
//              switch (last_key_event.code)
//               {
//              case K_F1: tty_switch(&tty1,"tty1"); return ESUCCESS;
//              case K_F2: tty_switch(&tty2,"tty2"); return ESUCCESS;
//              case K_F3: tty_switch(&tty3,"tty3"); return ESUCCESS;
//              case K_F4: tty_switch(&tty4,"tty4"); return ESUCCESS;
//              case K_F5: tty_switch(&tty5,"tty5"); return ESUCCESS;
//              case K_F6: tty_switch(&tty6,"tty6"); return ESUCCESS;
//              case K_F7: tty_switch(&tty7,"tty7"); return ESUCCESS;
//              case K_F8: tty_switch(&tty8,"tty8"); return ESUCCESS;
//              case K_F9: tty_switch(&tty9,"tty9"); return ESUCCESS;
//              case K_F10:tty_switch(&tty0,"tty0"); return ESUCCESS;
//               }
//       }
// 
// /*returning fail sends the keypress to the next handler*/
//      return EFAIL;
 }

/*switch to other console*/
void tty_switch(teletype *tty, char *name)
 {
/*change the pointer*/
        active_console = tty;
/*repaint*/
        tty->HW->repaint(tty);
/*change cursor position*/
        tty->gotoxy(tty->getx(), tty->gety());
/*change panel caption*/
        tty_panel.poke_str(name, TTY_NO_X,0, TTY_PANEL_COLOR, 5);
 }

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---