SimpleOS

LXR

Navigation



Site hébergé par : enix

The LXR Cross Referencer for SOS

source navigation ]
diff markup ]
identifier search ]
general search ]
 
 
Article:1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 6.5 ] [ 7 ] [ 7.5 ] [ 8 ] [ 9 ] [ 9.5 ]

Diff markup

Differences between /drivers/x86_videomem.c (Article 7.5) and /drivers/x86_videomem.c (Article 9)


001 /* Copyright (C) 2004  David Decotigny            001 /* Copyright (C) 2004  David Decotigny
002                                                   002 
003    This program is free software; you can redi    003    This program is free software; you can redistribute it and/or
004    modify it under the terms of the GNU Genera    004    modify it under the terms of the GNU General Public License
005    as published by the Free Software Foundatio    005    as published by the Free Software Foundation; either version 2
006    of the License, or (at your option) any lat    006    of the License, or (at your option) any later version.
007                                                !! 007 
008    This program is distributed in the hope tha    008    This program is distributed in the hope that it will be useful,
009    but WITHOUT ANY WARRANTY; without even the     009    but WITHOUT ANY WARRANTY; without even the implied warranty of
010    MERCHANTABILITY or FITNESS FOR A PARTICULAR    010    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
011    GNU General Public License for more details    011    GNU General Public License for more details.
012                                                !! 012 
013    You should have received a copy of the GNU     013    You should have received a copy of the GNU General Public License
014    along with this program; if not, write to t    014    along with this program; if not, write to the Free Software
015    Foundation, Inc., 59 Temple Place - Suite 3    015    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
016    USA.                                        !! 016    USA.
017 */                                                017 */
018 #include <sos/klibc.h>                            018 #include <sos/klibc.h>
019 #include <hwcore/ioports.h>                       019 #include <hwcore/ioports.h>
020                                                   020 
021 #include "x86_videomem.h"                         021 #include "x86_videomem.h"
022                                                   022 
023 /* The text video memory starts at address 0xB    023 /* The text video memory starts at address 0xB8000. Odd bytes are the
024    ASCII value of the character, even bytes ar    024    ASCII value of the character, even bytes are attribute for the
025    preceding character. */                        025    preceding character. */
026 #define VIDEO   0xb8000                           026 #define VIDEO   0xb8000
027                                                   027 
028                                                   028 
029 /* Console screen size */                         029 /* Console screen size */
030 #define LINES   25                                030 #define LINES   25
031 #define COLUMNS 80                                031 #define COLUMNS 80
032                                                   032 
                                                   >> 033 /*
                                                   >> 034  * VGA ports and commands.
                                                   >> 035  * 
                                                   >> 036  * @see Ralf Brown's interrupt (and port) list   
                                                   >> 037  * http://www-2.cs.cmu.edu/~ralf/files.html      
                                                   >> 038  */
                                                   >> 039 
                                                   >> 040 /* VGA ports */
                                                   >> 041 #define VGA_COMMAND_PORT 0x3D4
                                                   >> 042 #define VGA_DATA_PORT    0x3D5
                                                   >> 043 
                                                   >> 044 /* VGA commands */
                                                   >> 045 #define VGA_SET_CURSOR_START 0xA
                                                   >> 046 #define VGA_SET_CURSOR_END   0xB
                                                   >> 047 #define VGA_SET_CURSOR_HIGH  0xE
                                                   >> 048 #define VGA_SET_CURSOR_LOW   0xF
033                                                   049 
034 /** The structure of a character element in th    050 /** The structure of a character element in the video memory. @see
035     http://webster.cs.ucr.edu/AoA DOS edition     051     http://webster.cs.ucr.edu/AoA DOS edition chapter 23 */
036 typedef struct {                                  052 typedef struct {
037   unsigned char character;                        053   unsigned char character;
038   unsigned char attribute;                        054   unsigned char attribute;
039 } __attribute__ ((packed)) x86_video_mem[LINES    055 } __attribute__ ((packed)) x86_video_mem[LINES*COLUMNS];
040                                                   056 
041                                                   057 
042                                                   058 
043 /** The base pointer for the video memory */      059 /** The base pointer for the video memory */
044 static volatile x86_video_mem *video = (volati    060 static volatile x86_video_mem *video = (volatile x86_video_mem*)VIDEO;
045                                                   061 
046 sos_ret_t sos_x86_videomem_setup(void)            062 sos_ret_t sos_x86_videomem_setup(void)
047 {                                                 063 {
048   /*                                           << 
049    * Hide cursor. @see Ralf Brown's interrupt  << 
050    * http://www-2.cs.cmu.edu/~ralf/files.html  << 
051    */                                          << 
052 #define CRT_REG_INDEX 0x3d4                    << 
053 #define CRT_REG_DATA  0x3d5                    << 
054                                                << 
055   /* CRT index port => ask for access to regis    064   /* CRT index port => ask for access to register 0xa ("cursor
056      start") */                                   065      start") */
057   outb(0x0a, CRT_REG_INDEX);                   !! 066   outb(0x0a, VGA_COMMAND_PORT);
058                                                   067 
059   /* (RBIL Tables 708 & 654) CRT Register 0xa     068   /* (RBIL Tables 708 & 654) CRT Register 0xa => bit 5 = cursor OFF */
060   outb(1 << 5, CRT_REG_DATA);                  !! 069   outb(1 << 5, VGA_DATA_PORT);
061                                                   070 
062   return SOS_OK;                                  071   return SOS_OK;
063 }                                                 072 }
064                                                   073 
065                                                   074 
066 sos_ret_t sos_x86_videomem_cls(unsigned char a    075 sos_ret_t sos_x86_videomem_cls(unsigned char attribute)
067 {                                                 076 {
068   /* Clears the screen */                         077   /* Clears the screen */
069   int i;                                          078   int i;
070   for(i = 0 ; i < LINES*COLUMNS ; i++)            079   for(i = 0 ; i < LINES*COLUMNS ; i++)
071     {                                             080     {
072       (*video)[i].character = 0;                  081       (*video)[i].character = 0;
073       (*video)[i].attribute = attribute;          082       (*video)[i].attribute = attribute;
074     }                                             083     }
075                                                   084 
076   return SOS_OK;                               !! 085   return SOS_OK;
077 }                                                 086 }
078                                                   087 
079                                                   088 
080 sos_ret_t sos_x86_videomem_putstring(unsigned     089 sos_ret_t sos_x86_videomem_putstring(unsigned char row, unsigned char col,
081                                      unsigned     090                                      unsigned char attribute,
082                                      const cha    091                                      const char *str)
083 {                                                 092 {
084   unsigned video_offs = row*COLUMNS + col;        093   unsigned video_offs = row*COLUMNS + col;
085                                                   094 
086   if (video_offs >= LINES*COLUMNS)                095   if (video_offs >= LINES*COLUMNS)
087     return -SOS_EINVAL;                           096     return -SOS_EINVAL;
088                                                !! 097 
089   for ( ; str && *str && (video_offs < LINES*C    098   for ( ; str && *str && (video_offs < LINES*COLUMNS) ; str++, video_offs++)
090     {                                             099     {
091       (*video)[video_offs].character = (unsign    100       (*video)[video_offs].character = (unsigned char)*str;
092       (*video)[video_offs].attribute = attribu    101       (*video)[video_offs].attribute = attribute;
093     }                                             102     }
094                                                   103 
095   return SOS_OK;                                  104   return SOS_OK;
096 }                                                 105 }
097                                                   106 
098                                                   107 
099 sos_ret_t sos_x86_videomem_putchar(unsigned ch    108 sos_ret_t sos_x86_videomem_putchar(unsigned char row, unsigned char col,
100                                    unsigned ch    109                                    unsigned char attribute,
101                                    unsigned ch    110                                    unsigned char c)
102 {                                                 111 {
103   unsigned video_offs = row*COLUMNS + col;        112   unsigned video_offs = row*COLUMNS + col;
104                                                   113 
105   if (video_offs >= LINES*COLUMNS)                114   if (video_offs >= LINES*COLUMNS)
106     return -SOS_EINVAL;                           115     return -SOS_EINVAL;
107                                                !! 116 
108   (*video)[video_offs].character = c;             117   (*video)[video_offs].character = c;
109   (*video)[video_offs].attribute = attribute;     118   (*video)[video_offs].attribute = attribute;
110                                                   119 
111   return SOS_OK;                                  120   return SOS_OK;
112 }                                                 121 }
113                                                   122 
114                                                   123 
115 sos_ret_t sos_x86_videomem_printf(unsigned cha    124 sos_ret_t sos_x86_videomem_printf(unsigned char row, unsigned char col,
116                                   unsigned cha    125                                   unsigned char attribute,
117                                   const char *    126                                   const char *format, /* args */...)
118 {                                                 127 {
119   char buff[256];                                 128   char buff[256];
120   va_list ap;                                     129   va_list ap;
121                                                !! 130 
122   va_start(ap, format);                           131   va_start(ap, format);
123   vsnprintf(buff, sizeof(buff), format, ap);      132   vsnprintf(buff, sizeof(buff), format, ap);
124   va_end(ap);                                     133   va_end(ap);
125                                                !! 134 
126   return sos_x86_videomem_putstring(row, col,     135   return sos_x86_videomem_putstring(row, col, attribute, buff);
                                                   >> 136 }
                                                   >> 137 
                                                   >> 138 
                                                   >> 139 /*
                                                   >> 140  * Console that supports scrolling, based on the low-level code
                                                   >> 141  * above. This console only takes part of the screen, starting at row
                                                   >> 142  * CONSOLE_ROW_START. The rows before that one are free for use by the
                                                   >> 143  * kernel debugging messages.
                                                   >> 144  */
                                                   >> 145 
                                                   >> 146 /* Current row in the high-level console. Must be signed, because of
                                                   >> 147    computations inside sos_screen_putchar() */
                                                   >> 148 static int row;
                                                   >> 149 
                                                   >> 150 /* Current column in the high-level console. Must be signed, because
                                                   >> 151    of computations inside sos_screen_putchar() */
                                                   >> 152 static int col;
                                                   >> 153 
                                                   >> 154 /* The limit between the low-level console, accessible to the kernel,
                                                   >> 155    and the high-level console, accessible to the user applications
                                                   >> 156    through the sos_screen_putchar() function. */
                                                   >> 157 #define CONSOLE_ROW_START 12
                                                   >> 158 
                                                   >> 159 static void sos_screen_set_cursor (unsigned int row, unsigned int col)
                                                   >> 160 {
                                                   >> 161   unsigned int pos;
                                                   >> 162 
                                                   >> 163   pos = (row * COLUMNS + col);
                                                   >> 164 
                                                   >> 165   outb(VGA_SET_CURSOR_HIGH, VGA_COMMAND_PORT);
                                                   >> 166   outb( (pos >> 8), VGA_DATA_PORT);
                                                   >> 167   outb(VGA_SET_CURSOR_LOW, VGA_COMMAND_PORT);
                                                   >> 168   outb( (pos & 0xFF), VGA_DATA_PORT);
                                                   >> 169 }
                                                   >> 170 
                                                   >> 171 sos_ret_t sos_screen_putchar (char c)
                                                   >> 172 {
                                                   >> 173   if (c == '\r')
                                                   >> 174     {
                                                   >> 175       /* Go to first row */
                                                   >> 176       col = 0;
                                                   >> 177     }
                                                   >> 178 
                                                   >> 179   /* New line */
                                                   >> 180   else if (c == '\n')
                                                   >> 181     {
                                                   >> 182       /* Go to next line */
                                                   >> 183       col = 0;
                                                   >> 184       row ++;
                                                   >> 185     }
                                                   >> 186 
                                                   >> 187   /* Remove the last character */
                                                   >> 188   else if (c == '\b')
                                                   >> 189     {
                                                   >> 190       /* Next character should be displayed instead of the current
                                                   >> 191          one */
                                                   >> 192       col --;
                                                   >> 193 
                                                   >> 194       /* Handle the case where we're at the beginning of a line */
                                                   >> 195       if (col < 0)
                                                   >> 196         {
                                                   >> 197           row --;
                                                   >> 198           col = COLUMNS-1;
                                                   >> 199 
                                                   >> 200           if (row < CONSOLE_ROW_START)
                                                   >> 201             {
                                                   >> 202               row = CONSOLE_ROW_START;
                                                   >> 203               col = 0;
                                                   >> 204             }
                                                   >> 205         }
                                                   >> 206 
                                                   >> 207       /* Replace the current character with a space */
                                                   >> 208       sos_x86_videomem_putchar
                                                   >> 209         (row, col, SOS_X86_VIDEO_FG_BLUE | SOS_X86_VIDEO_BG_LTGRAY, ' ');
                                                   >> 210     }
                                                   >> 211   else if (c != 0)
                                                   >> 212     {
                                                   >> 213       sos_x86_videomem_putchar
                                                   >> 214         (row, col, SOS_X86_VIDEO_FG_BLUE | SOS_X86_VIDEO_BG_LTGRAY, c);
                                                   >> 215       col++;
                                                   >> 216       if (col == COLUMNS)
                                                   >> 217         {
                                                   >> 218           col = 0;
                                                   >> 219           row++;
                                                   >> 220         }
                                                   >> 221     }
                                                   >> 222 
                                                   >> 223   /* Need to scroll ? */
                                                   >> 224   if (row == LINES)
                                                   >> 225     {
                                                   >> 226       int i;
                                                   >> 227 
                                                   >> 228       /* Copy each line in the previous line */
                                                   >> 229       for (i = CONSOLE_ROW_START; i < LINES; i++)
                                                   >> 230         memcpy ((char*) video + i * COLUMNS * 2,
                                                   >> 231                 (char*) video + ((i + 1) * COLUMNS * 2),
                                                   >> 232                 COLUMNS * 2);
                                                   >> 233 
                                                   >> 234       /* Reset the last line of the console */
                                                   >> 235       for (i = 0; i < COLUMNS; i++)
                                                   >> 236         sos_x86_videomem_putchar
                                                   >> 237           (LINES-1, i, SOS_X86_VIDEO_FG_BLUE | SOS_X86_VIDEO_BG_LTGRAY, ' ');
                                                   >> 238 
                                                   >> 239       row--;
                                                   >> 240     }
                                                   >> 241 
                                                   >> 242   sos_screen_set_cursor (row, col);
                                                   >> 243 
                                                   >> 244   return SOS_OK;
                                                   >> 245 }
                                                   >> 246 
                                                   >> 247 sos_ret_t sos_screen_init (void)
                                                   >> 248 {
                                                   >> 249   int i, j;
                                                   >> 250 
                                                   >> 251   row = CONSOLE_ROW_START;
                                                   >> 252   col = 0;
                                                   >> 253 
                                                   >> 254   /* Set the first scan line for the cursor, and the blinking
                                                   >> 255      mode. First scan line is 11, so that we have a visible
                                                   >> 256      cursor. */
                                                   >> 257   outb(VGA_SET_CURSOR_START, VGA_COMMAND_PORT);
                                                   >> 258   outb(((0x2 << 5) | 14), VGA_DATA_PORT);
                                                   >> 259 
                                                   >> 260   for (i = CONSOLE_ROW_START; i < LINES; i++)
                                                   >> 261     {
                                                   >> 262       for (j = 0; j < COLUMNS; j++)
                                                   >> 263         sos_x86_videomem_putchar
                                                   >> 264           (i, j, SOS_X86_VIDEO_FG_BLUE | SOS_X86_VIDEO_BG_LTGRAY, ' ');
                                                   >> 265     }
                                                   >> 266 
                                                   >> 267   sos_screen_set_cursor (row, col);
                                                   >> 268 
                                                   >> 269   return SOS_OK;
127 }                                                 270 }
                                                      

source navigation ] diff markup ] identifier search ] general search ]