Rev 1135 | Rev 1298 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
836 | palkovsky | 1 | /* |
2 | * Copyright (C) 2006 Ondrej Palkovsky |
||
3 | * All rights reserved. |
||
4 | * |
||
5 | * Redistribution and use in source and binary forms, with or without |
||
6 | * modification, are permitted provided that the following conditions |
||
7 | * are met: |
||
8 | * |
||
9 | * - Redistributions of source code must retain the above copyright |
||
10 | * notice, this list of conditions and the following disclaimer. |
||
11 | * - Redistributions in binary form must reproduce the above copyright |
||
12 | * notice, this list of conditions and the following disclaimer in the |
||
13 | * documentation and/or other materials provided with the distribution. |
||
14 | * - The name of the author may not be used to endorse or promote products |
||
15 | * derived from this software without specific prior written permission. |
||
16 | * |
||
17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
||
18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
||
19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
||
20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
||
21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
||
22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||
23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||
24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||
25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
||
26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||
27 | */ |
||
28 | |||
837 | palkovsky | 29 | #include <genarch/fb/font-8x16.h> |
30 | #include <genarch/fb/fb.h> |
||
836 | palkovsky | 31 | #include <console/chardev.h> |
32 | #include <console/console.h> |
||
839 | palkovsky | 33 | #include <panic.h> |
896 | jermar | 34 | #include <memstr.h> |
836 | palkovsky | 35 | |
862 | palkovsky | 36 | #include "helenos.xbm" |
37 | |||
836 | palkovsky | 38 | SPINLOCK_INITIALIZE(fb_lock); |
39 | |||
1135 | decky | 40 | static __u8 *fbaddress = NULL; |
836 | palkovsky | 41 | |
1135 | decky | 42 | static unsigned int xres = 0; |
43 | static unsigned int yres = 0; |
||
44 | static unsigned int scanline = 0; |
||
45 | static unsigned int pixelbytes = 0; |
||
836 | palkovsky | 46 | |
1135 | decky | 47 | static unsigned int position = 0; |
48 | static unsigned int columns = 0; |
||
49 | static unsigned int rows = 0; |
||
836 | palkovsky | 50 | |
51 | |||
1135 | decky | 52 | #define COL_WIDTH 8 |
53 | #define ROW_BYTES (scanline * FONT_SCANLINES) |
||
836 | palkovsky | 54 | |
1135 | decky | 55 | #define BGCOLOR 0x000080 |
56 | #define FGCOLOR 0xffff00 |
||
57 | #define LOGOCOLOR 0x2020b0 |
||
58 | |||
59 | #define RED(x, bits) ((x >> (16 + 8 - bits)) & ((1 << bits) - 1)) |
||
60 | #define GREEN(x, bits) ((x >> (8 + 8 - bits)) & ((1 << bits) - 1)) |
||
61 | #define BLUE(x, bits) ((x >> (8 - bits)) & ((1 << bits) - 1)) |
||
62 | |||
63 | #define POINTPOS(x, y) (y * scanline + x * pixelbytes) |
||
64 | |||
838 | palkovsky | 65 | /***************************************************************/ |
66 | /* Pixel specific fuctions */ |
||
67 | |||
1135 | decky | 68 | static void (*putpixel)(unsigned int x, unsigned int y, int color); |
69 | static int (*getpixel)(unsigned int x, unsigned int y); |
||
839 | palkovsky | 70 | |
71 | /** Put pixel - 24-bit depth, 1 free byte */ |
||
1135 | decky | 72 | static void putpixel_4byte(unsigned int x, unsigned int y, int color) |
836 | palkovsky | 73 | { |
1135 | decky | 74 | *((__u32 *)(fbaddress + POINTPOS(x, y))) = color; |
836 | palkovsky | 75 | } |
76 | |||
1135 | decky | 77 | /** Return pixel color - 24-bit depth, 1 free byte */ |
78 | static int getpixel_4byte(unsigned int x, unsigned int y) |
||
838 | palkovsky | 79 | { |
1135 | decky | 80 | return *((__u32 *)(fbaddress + POINTPOS(x, y))) & 0xffffff; |
839 | palkovsky | 81 | } |
82 | |||
1135 | decky | 83 | /** Put pixel - 24-bit depth */ |
84 | static void putpixel_3byte(unsigned int x, unsigned int y, int color) |
||
839 | palkovsky | 85 | { |
1135 | decky | 86 | unsigned int startbyte = POINTPOS(x, y); |
839 | palkovsky | 87 | |
1135 | decky | 88 | fbaddress[startbyte] = RED(color, 8); |
89 | fbaddress[startbyte + 1] = GREEN(color, 8); |
||
90 | fbaddress[startbyte + 2] = BLUE(color, 8); |
||
839 | palkovsky | 91 | } |
92 | |||
1135 | decky | 93 | /** Return pixel color - 24-bit depth */ |
94 | static int getpixel_3byte(unsigned int x, unsigned int y) |
||
839 | palkovsky | 95 | { |
1135 | decky | 96 | unsigned int startbyte = POINTPOS(x, y); |
838 | palkovsky | 97 | |
1135 | decky | 98 | return fbaddress[startbyte] << 16 | fbaddress[startbyte + 1] << 8 | fbaddress[startbyte + 2]; |
838 | palkovsky | 99 | } |
100 | |||
839 | palkovsky | 101 | /** Put pixel - 16-bit depth (5:6:6) */ |
1135 | decky | 102 | static void putpixel_2byte(unsigned int x, unsigned int y, int color) |
839 | palkovsky | 103 | { |
104 | /* 5-bit, 5-bits, 5-bits */ |
||
1135 | decky | 105 | *((__u16 *)(fbaddress + POINTPOS(x, y))) = RED(color, 5) << 11 | GREEN(color, 6) << 5 | BLUE(color, 5); |
839 | palkovsky | 106 | } |
107 | |||
1135 | decky | 108 | /** Return pixel color - 16-bit depth (5:6:6) */ |
109 | static int getpixel_2byte(unsigned int x, unsigned int y) |
||
839 | palkovsky | 110 | { |
1135 | decky | 111 | int color = *((__u16 *)(fbaddress + POINTPOS(x, y))); |
112 | return (((color >> 11) & 0x1f) << (16 + 3)) | (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3); |
||
839 | palkovsky | 113 | } |
114 | |||
886 | jermar | 115 | /** Put pixel - 8-bit depth (3:2:3) */ |
1135 | decky | 116 | static void putpixel_1byte(unsigned int x, unsigned int y, int color) |
839 | palkovsky | 117 | { |
1135 | decky | 118 | fbaddress[POINTPOS(x, y)] = RED(color, 3) << 5 | GREEN(color, 2) << 3 | BLUE(color, 3); |
119 | } |
||
839 | palkovsky | 120 | |
1135 | decky | 121 | /** Return pixel color - 8-bit depth (3:2:3) */ |
122 | static int getpixel_1byte(unsigned int x, unsigned int y) |
||
123 | { |
||
124 | int color = fbaddress[POINTPOS(x, y)]; |
||
125 | return (((color >> 5) & 0x7) << (16 + 5)) | (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5); |
||
839 | palkovsky | 126 | } |
127 | |||
1135 | decky | 128 | /** Fill line with color BGCOLOR */ |
129 | static void clear_line(unsigned int y) |
||
130 | { |
||
131 | unsigned int x; |
||
132 | |||
133 | for (x = 0; x < xres; x++) |
||
134 | (*putpixel)(x, y, BGCOLOR); |
||
135 | } |
||
839 | palkovsky | 136 | |
1135 | decky | 137 | |
138 | /** Fill screen with background color */ |
||
139 | static void clear_screen(void) |
||
839 | palkovsky | 140 | { |
1135 | decky | 141 | unsigned int y; |
839 | palkovsky | 142 | |
1135 | decky | 143 | for (y = 0; y < yres; y++) |
144 | clear_line(y); |
||
839 | palkovsky | 145 | } |
146 | |||
1135 | decky | 147 | |
838 | palkovsky | 148 | /** Scroll screen one row up */ |
149 | static void scroll_screen(void) |
||
150 | { |
||
1135 | decky | 151 | unsigned int i; |
838 | palkovsky | 152 | |
1135 | decky | 153 | memcpy((void *) fbaddress, (void *) &fbaddress[ROW_BYTES], scanline * yres - ROW_BYTES); |
838 | palkovsky | 154 | |
155 | /* Clear last row */ |
||
1135 | decky | 156 | for (i = 0; i < FONT_SCANLINES; i++) |
157 | clear_line((rows - 1) * FONT_SCANLINES + i); |
||
838 | palkovsky | 158 | } |
159 | |||
160 | |||
1135 | decky | 161 | static void invert_pixel(unsigned int x, unsigned int y) |
836 | palkovsky | 162 | { |
1135 | decky | 163 | (*putpixel)(x, y, ~(*getpixel)(x, y)); |
836 | palkovsky | 164 | } |
165 | |||
166 | |||
167 | /** Draw one line of glyph at a given position */ |
||
1135 | decky | 168 | static void draw_glyph_line(unsigned int glline, unsigned int x, unsigned int y) |
836 | palkovsky | 169 | { |
1135 | decky | 170 | unsigned int i; |
836 | palkovsky | 171 | |
1135 | decky | 172 | for (i = 0; i < 8; i++) |
173 | if (glline & (1 << (7 - i))) { |
||
174 | (*putpixel)(x + i, y, FGCOLOR); |
||
836 | palkovsky | 175 | } else |
1135 | decky | 176 | (*putpixel)(x + i, y, BGCOLOR); |
836 | palkovsky | 177 | } |
178 | |||
838 | palkovsky | 179 | /***************************************************************/ |
180 | /* Character-console functions */ |
||
181 | |||
836 | palkovsky | 182 | /** Draw character at given position */ |
1135 | decky | 183 | static void draw_glyph(__u8 glyph, unsigned int col, unsigned int row) |
836 | palkovsky | 184 | { |
1135 | decky | 185 | unsigned int y; |
836 | palkovsky | 186 | |
1135 | decky | 187 | for (y = 0; y < FONT_SCANLINES; y++) |
188 | draw_glyph_line(fb_font[glyph * FONT_SCANLINES + y], col * COL_WIDTH, row * FONT_SCANLINES + y); |
||
836 | palkovsky | 189 | } |
190 | |||
191 | /** Invert character at given position */ |
||
1135 | decky | 192 | static void invert_char(unsigned int col, unsigned int row) |
836 | palkovsky | 193 | { |
1135 | decky | 194 | unsigned int x; |
195 | unsigned int y; |
||
836 | palkovsky | 196 | |
1135 | decky | 197 | for (x = 0; x < COL_WIDTH; x++) |
198 | for (y = 0; y < FONT_SCANLINES; y++) |
||
199 | invert_pixel(col * COL_WIDTH + x, row * FONT_SCANLINES + y); |
||
836 | palkovsky | 200 | } |
201 | |||
202 | /** Draw character at default position */ |
||
203 | static void draw_char(char chr) |
||
204 | { |
||
1135 | decky | 205 | draw_glyph(chr, position % columns, position / columns); |
836 | palkovsky | 206 | } |
207 | |||
1135 | decky | 208 | static void draw_logo(unsigned int startx, unsigned int starty) |
862 | palkovsky | 209 | { |
1135 | decky | 210 | unsigned int x; |
211 | unsigned int y; |
||
212 | unsigned int byte; |
||
213 | unsigned int rowbytes; |
||
862 | palkovsky | 214 | |
1135 | decky | 215 | rowbytes = (helenos_width - 1) / 8 + 1; |
862 | palkovsky | 216 | |
1135 | decky | 217 | for (y = 0; y < helenos_height; y++) |
218 | for (x = 0; x < helenos_width; x++) { |
||
219 | byte = helenos_bits[rowbytes * y + x / 8]; |
||
862 | palkovsky | 220 | byte >>= x % 8; |
221 | if (byte & 1) |
||
1135 | decky | 222 | (*putpixel)(startx + x, starty + y, LOGOCOLOR); |
862 | palkovsky | 223 | } |
224 | } |
||
225 | |||
838 | palkovsky | 226 | /***************************************************************/ |
227 | /* Stdout specific functions */ |
||
228 | |||
836 | palkovsky | 229 | static void invert_cursor(void) |
230 | { |
||
1135 | decky | 231 | invert_char(position % columns, position / columns); |
836 | palkovsky | 232 | } |
233 | |||
234 | /** Print character to screen |
||
235 | * |
||
236 | * Emulate basic terminal commands |
||
237 | */ |
||
238 | static void fb_putchar(chardev_t *dev, char ch) |
||
239 | { |
||
1287 | vana | 240 | spinlock_lock(&fb_lock); |
1135 | decky | 241 | |
242 | switch (ch) { |
||
243 | case '\n': |
||
244 | invert_cursor(); |
||
245 | position += columns; |
||
246 | position -= position % columns; |
||
247 | break; |
||
248 | case '\r': |
||
249 | invert_cursor(); |
||
250 | position -= position % columns; |
||
251 | break; |
||
252 | case '\b': |
||
253 | invert_cursor(); |
||
254 | if (position % columns) |
||
255 | position--; |
||
256 | break; |
||
257 | case '\t': |
||
258 | invert_cursor(); |
||
259 | do { |
||
260 | draw_char(' '); |
||
261 | position++; |
||
262 | } while (position % 8); |
||
263 | break; |
||
264 | default: |
||
265 | draw_char(ch); |
||
838 | palkovsky | 266 | position++; |
836 | palkovsky | 267 | } |
1135 | decky | 268 | |
269 | if (position >= columns * rows) { |
||
836 | palkovsky | 270 | position -= columns; |
271 | scroll_screen(); |
||
272 | } |
||
1135 | decky | 273 | |
836 | palkovsky | 274 | invert_cursor(); |
1135 | decky | 275 | |
1287 | vana | 276 | spinlock_unlock(&fb_lock); |
836 | palkovsky | 277 | } |
278 | |||
279 | static chardev_t framebuffer; |
||
280 | static chardev_operations_t fb_ops = { |
||
281 | .write = fb_putchar, |
||
282 | }; |
||
283 | |||
284 | |||
285 | /** Initialize framebuffer as a chardev output device |
||
286 | * |
||
1135 | decky | 287 | * @param addr Address of theframebuffer |
288 | * @param x Screen width in pixels |
||
289 | * @param y Screen height in pixels |
||
290 | * @param bpp Bits per pixel (8, 16, 24, 32) |
||
291 | * @param scan Bytes per one scanline |
||
292 | * |
||
836 | palkovsky | 293 | */ |
1135 | decky | 294 | void fb_init(__address addr, unsigned int x, unsigned int y, unsigned int bpp, unsigned int scan) |
836 | palkovsky | 295 | { |
1135 | decky | 296 | switch (bpp) { |
297 | case 8: |
||
298 | putpixel = putpixel_1byte; |
||
299 | getpixel = getpixel_1byte; |
||
300 | pixelbytes = 1; |
||
301 | break; |
||
302 | case 16: |
||
303 | putpixel = putpixel_2byte; |
||
304 | getpixel = getpixel_2byte; |
||
305 | pixelbytes = 2; |
||
306 | break; |
||
307 | case 24: |
||
308 | putpixel = putpixel_3byte; |
||
309 | getpixel = getpixel_3byte; |
||
310 | pixelbytes = 3; |
||
311 | break; |
||
312 | case 32: |
||
313 | putpixel = putpixel_4byte; |
||
314 | getpixel = getpixel_4byte; |
||
315 | pixelbytes = 4; |
||
316 | break; |
||
317 | default: |
||
318 | panic("Unsupported bpp"); |
||
839 | palkovsky | 319 | } |
1135 | decky | 320 | |
321 | fbaddress = (unsigned char *) addr; |
||
836 | palkovsky | 322 | xres = x; |
323 | yres = y; |
||
1135 | decky | 324 | scanline = scan; |
836 | palkovsky | 325 | |
1135 | decky | 326 | rows = y / FONT_SCANLINES; |
327 | columns = x / COL_WIDTH; |
||
836 | palkovsky | 328 | |
329 | clear_screen(); |
||
1135 | decky | 330 | draw_logo(xres - helenos_width, 0); |
836 | palkovsky | 331 | invert_cursor(); |
332 | |||
333 | chardev_initialize("fb", &framebuffer, &fb_ops); |
||
334 | stdout = &framebuffer; |
||
335 | } |