Subversion Repositories HelenOS

Rev

Rev 2089 | Rev 2141 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2089 Rev 2102
1
/*
1
/*
2
 * Copyright (c) 2006 Ondrej Palkovsky
2
 * Copyright (c) 2006 Ondrej Palkovsky
3
 * All rights reserved.
3
 * All rights reserved.
4
 *
4
 *
5
 * Redistribution and use in source and binary forms, with or without
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
6
 * modification, are permitted provided that the following conditions
7
 * are met:
7
 * are met:
8
 *
8
 *
9
 * - Redistributions of source code must retain the above copyright
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
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
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.
15
 *   derived from this software without specific prior written permission.
16
 *
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
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
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
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
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
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
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.
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
27
 */
28
 
28
 
29
/** @addtogroup genarch
29
/** @addtogroup genarch
30
 * @{
30
 * @{
31
 */
31
 */
32
/** @file
32
/** @file
33
 */
33
 */
34
 
34
 
35
#include <genarch/fb/font-8x16.h>
35
#include <genarch/fb/font-8x16.h>
36
#include <genarch/fb/visuals.h>
36
#include <genarch/fb/visuals.h>
37
#include <genarch/fb/fb.h>
37
#include <genarch/fb/fb.h>
38
#include <console/chardev.h>
38
#include <console/chardev.h>
39
#include <console/console.h>
39
#include <console/console.h>
40
#include <sysinfo/sysinfo.h>
40
#include <sysinfo/sysinfo.h>
41
#include <mm/slab.h>
41
#include <mm/slab.h>
42
#include <panic.h>
42
#include <panic.h>
43
#include <memstr.h>
43
#include <memstr.h>
44
#include <config.h>
44
#include <config.h>
45
#include <bitops.h>
45
#include <bitops.h>
46
#include <print.h>
46
#include <print.h>
47
#include <ddi/ddi.h>
47
#include <ddi/ddi.h>
48
#include <arch/types.h>
48
#include <arch/types.h>
49
 
49
 
50
#include "helenos.xbm"
50
#include "helenos.xbm"
51
 
51
 
52
static parea_t fb_parea;        /**< Physical memory area for fb. */
52
static parea_t fb_parea;        /**< Physical memory area for fb. */
53
 
53
 
54
SPINLOCK_INITIALIZE(fb_lock);
54
SPINLOCK_INITIALIZE(fb_lock);
55
 
55
 
56
static uint8_t *fbaddress = NULL;
56
static uint8_t *fbaddress = NULL;
57
 
57
 
58
static uint8_t *blankline = NULL;
58
static uint8_t *blankline = NULL;
59
static uint8_t *dbbuffer = NULL;    /* Buffer for fast scrolling console */
59
static uint8_t *dbbuffer = NULL;    /* Buffer for fast scrolling console */
60
static index_t dboffset;
60
static index_t dboffset;
61
 
61
 
62
static unsigned int xres = 0;
62
static unsigned int xres = 0;
63
static unsigned int yres = 0;
63
static unsigned int yres = 0;
64
static unsigned int scanline = 0;
64
static unsigned int scanline = 0;
65
static unsigned int pixelbytes = 0;
65
static unsigned int pixelbytes = 0;
66
#ifdef FB_INVERT_COLORS
66
#ifdef FB_INVERT_COLORS
67
static bool invert_colors = true;
67
static bool invert_colors = true;
68
#else
68
#else
69
static bool invert_colors = false;
69
static bool invert_colors = false;
70
#endif
70
#endif
71
 
71
 
72
static unsigned int position = 0;
72
static unsigned int position = 0;
73
static unsigned int columns = 0;
73
static unsigned int columns = 0;
74
static unsigned int rows = 0;
74
static unsigned int rows = 0;
75
 
75
 
76
#define COL_WIDTH   8
76
#define COL_WIDTH   8
77
#define ROW_BYTES   (scanline * FONT_SCANLINES)
77
#define ROW_BYTES   (scanline * FONT_SCANLINES)
78
 
78
 
79
#define BGCOLOR     0x000080
79
#define BGCOLOR     0x000080
80
#define FGCOLOR     0xffff00
80
#define FGCOLOR     0xffff00
81
#define LOGOCOLOR   0x2020b0
81
#define LOGOCOLOR   0x2020b0
82
 
82
 
83
#define RED(x, bits)    ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
83
#define RED(x, bits)    ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
84
#define GREEN(x, bits)  ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
84
#define GREEN(x, bits)  ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
85
#define BLUE(x, bits)   ((x >> (8 - bits)) & ((1 << bits) - 1))
85
#define BLUE(x, bits)   ((x >> (8 - bits)) & ((1 << bits) - 1))
86
 
86
 
87
#define POINTPOS(x, y)  ((y) * scanline + (x) * pixelbytes)
87
#define POINTPOS(x, y)  ((y) * scanline + (x) * pixelbytes)
88
 
88
 
89
/***************************************************************/
89
/***************************************************************/
90
/* Pixel specific fuctions */
90
/* Pixel specific fuctions */
91
 
91
 
92
static void (*rgb2scr)(void *, int);
92
static void (*rgb2scr)(void *, int);
93
static int (*scr2rgb)(void *);
93
static int (*scr2rgb)(void *);
94
 
94
 
95
static inline int COLOR(int color)
95
static inline int COLOR(int color)
96
{
96
{
97
    return invert_colors ? ~color : color;
97
    return invert_colors ? ~color : color;
98
}
98
}
99
 
99
 
100
/* Conversion routines between different color representations */
100
/* Conversion routines between different color representations */
101
static void rgb_byte0888(void *dst, int rgb)
101
static void rgb_byte0888(void *dst, int rgb)
102
{
102
{
103
    *((int *) dst) = rgb;
103
    *((int *) dst) = rgb;
104
}
104
}
105
 
105
 
106
static int byte0888_rgb(void *src)
106
static int byte0888_rgb(void *src)
107
{
107
{
108
    return (*((int *) src)) & 0xffffff;
108
    return (*((int *) src)) & 0xffffff;
109
}
109
}
110
 
110
 
111
static void bgr_byte0888(void *dst, int rgb)
111
static void bgr_byte0888(void *dst, int rgb)
112
{
112
{
113
    *((uint32_t *) dst) = BLUE(rgb, 8) << 16 | GREEN(rgb, 8) << 8 |
113
    *((uint32_t *) dst) = BLUE(rgb, 8) << 16 | GREEN(rgb, 8) << 8 |
114
        RED(rgb, 8);
114
        RED(rgb, 8);
115
}
115
}
116
 
116
 
117
static int byte0888_bgr(void *src)
117
static int byte0888_bgr(void *src)
118
{
118
{
119
    int color = *(uint32_t *)(src);
119
    int color = *(uint32_t *)(src);
120
    return ((color & 0xff) << 16) | (((color >> 8) & 0xff) << 8) |
120
    return ((color & 0xff) << 16) | (((color >> 8) & 0xff) << 8) |
121
        ((color >> 16) & 0xff);
121
        ((color >> 16) & 0xff);
122
}
122
}
123
 
123
 
124
static void rgb_byte888(void *dst, int rgb)
124
static void rgb_byte888(void *dst, int rgb)
125
{
125
{
126
    uint8_t *scr = dst;
126
    uint8_t *scr = (uint8_t *) dst;
127
#if defined(FB_INVERT_ENDIAN)
127
#if defined(FB_INVERT_ENDIAN)
128
    scr[0] = RED(rgb, 8);
128
    scr[0] = RED(rgb, 8);
129
    scr[1] = GREEN(rgb, 8);
129
    scr[1] = GREEN(rgb, 8);
130
    scr[2] = BLUE(rgb, 8);
130
    scr[2] = BLUE(rgb, 8);
131
#else
131
#else
132
    scr[2] = RED(rgb, 8);
132
    scr[2] = RED(rgb, 8);
133
    scr[1] = GREEN(rgb, 8);
133
    scr[1] = GREEN(rgb, 8);
134
    scr[0] = BLUE(rgb, 8);
134
    scr[0] = BLUE(rgb, 8);
135
#endif
135
#endif
136
}
136
}
137
 
137
 
138
static int byte888_rgb(void *src)
138
static int byte888_rgb(void *src)
139
{
139
{
140
    uint8_t *scr = src;
140
    uint8_t *scr = (uint8_t *) src;
141
#if defined(FB_INVERT_ENDIAN)
141
#if defined(FB_INVERT_ENDIAN)
142
    return scr[0] << 16 | scr[1] << 8 | scr[2];
142
    return scr[0] << 16 | scr[1] << 8 | scr[2];
143
#else
143
#else
144
    return scr[2] << 16 | scr[1] << 8 | scr[0];
144
    return scr[2] << 16 | scr[1] << 8 | scr[0];
145
#endif  
145
#endif  
146
}
146
}
147
 
147
 
148
/**  16-bit depth (5:5:5) */
148
/**  16-bit depth (5:5:5) */
149
static void rgb_byte555(void *dst, int rgb)
149
static void rgb_byte555(void *dst, int rgb)
150
{
150
{
151
    /* 5-bit, 5-bits, 5-bits */
151
    /* 5-bit, 5-bits, 5-bits */
152
    *((uint16_t *) dst) = RED(rgb, 5) << 10 | GREEN(rgb, 5) << 5 |
152
    *((uint16_t *) dst) = RED(rgb, 5) << 10 | GREEN(rgb, 5) << 5 |
153
        BLUE(rgb, 5);
153
        BLUE(rgb, 5);
154
}
154
}
155
 
155
 
156
/** 16-bit depth (5:5:5) */
156
/** 16-bit depth (5:5:5) */
157
static int byte555_rgb(void *src)
157
static int byte555_rgb(void *src)
158
{
158
{
159
    int color = *(uint16_t *)(src);
159
    int color = *(uint16_t *)(src);
160
    return (((color >> 10) & 0x1f) << (16 + 3)) |
160
    return (((color >> 10) & 0x1f) << (16 + 3)) |
161
        (((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3);
161
        (((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3);
162
}
162
}
163
 
163
 
164
/**  16-bit depth (5:6:5) */
164
/**  16-bit depth (5:6:5) */
165
static void rgb_byte565(void *dst, int rgb)
165
static void rgb_byte565(void *dst, int rgb)
166
{
166
{
167
    /* 5-bit, 6-bits, 5-bits */
167
    /* 5-bit, 6-bits, 5-bits */
168
    *((uint16_t *) dst) = RED(rgb, 5) << 11 | GREEN(rgb, 6) << 5 |
168
    *((uint16_t *) dst) = RED(rgb, 5) << 11 | GREEN(rgb, 6) << 5 |
169
        BLUE(rgb, 5);
169
        BLUE(rgb, 5);
170
}
170
}
171
 
171
 
172
/** 16-bit depth (5:6:5) */
172
/** 16-bit depth (5:6:5) */
173
static int byte565_rgb(void *src)
173
static int byte565_rgb(void *src)
174
{
174
{
175
    int color = *(uint16_t *)(src);
175
    int color = *(uint16_t *)(src);
176
    return (((color >> 11) & 0x1f) << (16 + 3)) |
176
    return (((color >> 11) & 0x1f) << (16 + 3)) |
177
        (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
177
        (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
178
}
178
}
179
 
179
 
180
/** Put pixel - 8-bit depth (color palette/3:2:3)
180
/** Put pixel - 8-bit depth (color palette/3:2:3)
181
 *
181
 *
182
 * Even though we try 3:2:3 color scheme here, an 8-bit framebuffer
182
 * Even though we try 3:2:3 color scheme here, an 8-bit framebuffer
183
 * will most likely use a color palette. The color appearance
183
 * will most likely use a color palette. The color appearance
184
 * will be pretty random and depend on the default installed
184
 * will be pretty random and depend on the default installed
185
 * palette. This could be fixed by supporting custom palette
185
 * palette. This could be fixed by supporting custom palette
186
 * and setting it to simulate the 8-bit truecolor.
186
 * and setting it to simulate the 8-bit truecolor.
187
 */
187
 */
188
static void rgb_byte8(void *dst, int rgb)
188
static void rgb_byte8(void *dst, int rgb)
189
{
189
{
190
    *((uint8_t *) dst) = RED(rgb, 3) << 5 | GREEN(rgb, 2) << 3 |
190
    *((uint8_t *) dst) = RED(rgb, 3) << 5 | GREEN(rgb, 2) << 3 |
191
        BLUE(rgb, 3);
191
        BLUE(rgb, 3);
192
}
192
}
193
 
193
 
194
/** Return pixel color - 8-bit depth (color palette/3:2:3)
194
/** Return pixel color - 8-bit depth (color palette/3:2:3)
195
 *
195
 *
196
 * See the comment for rgb_byte().
196
 * See the comment for rgb_byte().
197
 */
197
 */
198
static int byte8_rgb(void *src)
198
static int byte8_rgb(void *src)
199
{
199
{
200
    int color = *(uint8_t *)src;
200
    int color = *(uint8_t *)src;
201
    return (((color >> 5) & 0x7) << (16 + 5)) |
201
    return (((color >> 5) & 0x7) << (16 + 5)) |
202
        (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
202
        (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
203
}
203
}
204
 
204
 
205
static void putpixel(unsigned int x, unsigned int y, int color)
205
static void putpixel(unsigned int x, unsigned int y, int color)
206
{
206
{
207
    (*rgb2scr)(&fbaddress[POINTPOS(x, y)], COLOR(color));
207
    (*rgb2scr)(&fbaddress[POINTPOS(x, y)], COLOR(color));
208
 
208
 
209
    if (dbbuffer) {
209
    if (dbbuffer) {
210
        int dline = (y + dboffset) % yres;
210
        int dline = (y + dboffset) % yres;
211
        (*rgb2scr)(&dbbuffer[POINTPOS(x, dline)], COLOR(color));
211
        (*rgb2scr)(&dbbuffer[POINTPOS(x, dline)], COLOR(color));
212
    }
212
    }
213
}
213
}
214
 
214
 
215
/** Get pixel from viewport */
215
/** Get pixel from viewport */
216
static int getpixel(unsigned int x, unsigned int y)
216
static int getpixel(unsigned int x, unsigned int y)
217
{
217
{
218
    if (dbbuffer) {
218
    if (dbbuffer) {
219
        int dline = (y + dboffset) % yres;
219
        int dline = (y + dboffset) % yres;
220
        return COLOR((*scr2rgb)(&dbbuffer[POINTPOS(x, dline)]));
220
        return COLOR((*scr2rgb)(&dbbuffer[POINTPOS(x, dline)]));
221
    }
221
    }
222
    return COLOR((*scr2rgb)(&fbaddress[POINTPOS(x, y)]));
222
    return COLOR((*scr2rgb)(&fbaddress[POINTPOS(x, y)]));
223
}
223
}
224
 
224
 
225
 
225
 
226
/** Fill screen with background color */
226
/** Fill screen with background color */
227
static void clear_screen(void)
227
static void clear_screen(void)
228
{
228
{
229
    unsigned int y;
229
    unsigned int y;
230
 
230
 
231
    for (y = 0; y < yres; y++) {
231
    for (y = 0; y < yres; y++) {
232
        memcpy(&fbaddress[scanline * y], blankline, xres * pixelbytes);
232
        memcpy(&fbaddress[scanline * y], blankline, xres * pixelbytes);
233
        if (dbbuffer)
233
        if (dbbuffer)
234
            memcpy(&dbbuffer[scanline * y], blankline,
234
            memcpy(&dbbuffer[scanline * y], blankline,
235
                xres * pixelbytes);
235
                xres * pixelbytes);
236
    }
236
    }
237
}
237
}
238
 
238
 
239
 
239
 
240
/** Scroll screen one row up */
240
/** Scroll screen one row up */
241
static void scroll_screen(void)
241
static void scroll_screen(void)
242
{
242
{
243
    if (dbbuffer) {
243
    if (dbbuffer) {
244
        count_t first;
244
        count_t first;
245
       
245
       
246
        /* Clear the last row */
246
        /* Clear the last row */
247
        memcpy(&dbbuffer[dboffset * scanline], blankline, ROW_BYTES);
247
        memcpy(&dbbuffer[dboffset * scanline], blankline, ROW_BYTES);
248
       
248
       
249
        dboffset = (dboffset + FONT_SCANLINES) % yres;
249
        dboffset = (dboffset + FONT_SCANLINES) % yres;
250
        first = yres - dboffset;
250
        first = yres - dboffset;
251
       
251
       
252
        /* Move all rows one row up */
252
        /* Move all rows one row up */
253
        if (xres * pixelbytes == scanline) {
253
        if (xres * pixelbytes == scanline) {
254
            memcpy(fbaddress, &dbbuffer[dboffset * scanline],
254
            memcpy(fbaddress, &dbbuffer[dboffset * scanline],
255
                first * scanline);
255
                first * scanline);
256
            memcpy(&fbaddress[first * scanline], dbbuffer,
256
            memcpy(&fbaddress[first * scanline], dbbuffer,
257
                dboffset * scanline);
257
                dboffset * scanline);
258
        } else {
258
        } else {
259
            /*
259
            /*
260
             * When the scanline is bigger than number of bytes
260
             * When the scanline is bigger than number of bytes
261
             * in the X-resolution, chances are that the
261
             * in the X-resolution, chances are that the
262
             * frame buffer memory past the X-resolution is special
262
             * frame buffer memory past the X-resolution is special
263
             * in some way. For example, the SUNW,ffb framebuffer
263
             * in some way. For example, the SUNW,ffb framebuffer
264
             * wraps this area around the beginning of the same
264
             * wraps this area around the beginning of the same
265
             * line. To avoid troubles, copy only memory as
265
             * line. To avoid troubles, copy only memory as
266
             * specified by the resolution.
266
             * specified by the resolution.
267
             */
267
             */
268
            int i;
268
            unsigned int i;
269
 
269
 
270
            for (i = 0; i < first; i++)
270
            for (i = 0; i < first; i++)
271
                memcpy(&fbaddress[i * scanline],
271
                memcpy(&fbaddress[i * scanline],
272
                    &dbbuffer[(dboffset + i) * scanline],
272
                    &dbbuffer[(dboffset + i) * scanline],
273
                    xres * pixelbytes);
273
                    xres * pixelbytes);
274
            for (i = 0; i < dboffset; i++)
274
            for (i = 0; i < dboffset; i++)
275
                memcpy(&fbaddress[(first + i) * scanline],
275
                memcpy(&fbaddress[(first + i) * scanline],
276
                    &dbbuffer[i * scanline], xres * pixelbytes);
276
                    &dbbuffer[i * scanline], xres * pixelbytes);
277
        }
277
        }
278
    } else {
278
    } else {
279
        uint8_t *lastline = &fbaddress[(rows - 1) * ROW_BYTES];
279
        uint8_t *lastline = &fbaddress[(rows - 1) * ROW_BYTES];
280
       
280
       
281
        if (xres * pixelbytes == scanline) {
281
        if (xres * pixelbytes == scanline) {
282
            /* Move all rows one row up */
282
            /* Move all rows one row up */
283
            memcpy((void *) fbaddress,
283
            memcpy((void *) fbaddress,
284
                (void *) &fbaddress[ROW_BYTES],
284
                (void *) &fbaddress[ROW_BYTES],
285
                scanline * yres - ROW_BYTES);
285
                scanline * yres - ROW_BYTES);
286
            /* Clear the last row */
286
            /* Clear the last row */
287
            memcpy((void *) lastline, (void *) blankline,
287
            memcpy((void *) lastline, (void *) blankline,
288
                ROW_BYTES);
288
                ROW_BYTES);
289
        } else {
289
        } else {
290
            /*
290
            /*
291
             * See the comment in the dbbuffer case.
291
             * See the comment in the dbbuffer case.
292
             */
292
             */
293
            int i;
293
            unsigned int i;
294
 
294
 
295
            /* Move all rows one row up */
295
            /* Move all rows one row up */
296
            for (i = 0; i < yres - FONT_SCANLINES; i++)
296
            for (i = 0; i < yres - FONT_SCANLINES; i++)
297
                memcpy(&fbaddress[i * scanline],
297
                memcpy(&fbaddress[i * scanline],
298
                    &fbaddress[(i + FONT_SCANLINES) * scanline],
298
                    &fbaddress[(i + FONT_SCANLINES) * scanline],
299
                    xres * pixelbytes);
299
                    xres * pixelbytes);
300
            /* Clear the last row */
300
            /* Clear the last row */
301
            for (i = 0; i < FONT_SCANLINES; i++)
301
            for (i = 0; i < FONT_SCANLINES; i++)
302
                memcpy(&lastline[i * scanline],
302
                memcpy(&lastline[i * scanline],
303
                    &blankline[i * scanline],
303
                    &blankline[i * scanline],
304
                    xres * pixelbytes);
304
                    xres * pixelbytes);
305
        }
305
        }
306
    }
306
    }
307
}
307
}
308
 
308
 
309
 
309
 
310
static void invert_pixel(unsigned int x, unsigned int y)
310
static void invert_pixel(unsigned int x, unsigned int y)
311
{
311
{
312
    putpixel(x, y, ~getpixel(x, y));
312
    putpixel(x, y, ~getpixel(x, y));
313
}
313
}
314
 
314
 
315
 
315
 
316
/** Draw one line of glyph at a given position */
316
/** Draw one line of glyph at a given position */
317
static void draw_glyph_line(unsigned int glline, unsigned int x, unsigned int y)
317
static void draw_glyph_line(unsigned int glline, unsigned int x, unsigned int y)
318
{
318
{
319
    unsigned int i;
319
    unsigned int i;
320
 
320
 
321
    for (i = 0; i < 8; i++)
321
    for (i = 0; i < 8; i++)
322
        if (glline & (1 << (7 - i))) {
322
        if (glline & (1 << (7 - i))) {
323
            putpixel(x + i, y, FGCOLOR);
323
            putpixel(x + i, y, FGCOLOR);
324
        } else
324
        } else
325
            putpixel(x + i, y, BGCOLOR);
325
            putpixel(x + i, y, BGCOLOR);
326
}
326
}
327
 
327
 
328
/***************************************************************/
328
/***************************************************************/
329
/* Character-console functions */
329
/* Character-console functions */
330
 
330
 
331
/** Draw character at given position */
331
/** Draw character at given position */
332
static void draw_glyph(uint8_t glyph, unsigned int col, unsigned int row)
332
static void draw_glyph(uint8_t glyph, unsigned int col, unsigned int row)
333
{
333
{
334
    unsigned int y;
334
    unsigned int y;
335
 
335
 
336
    for (y = 0; y < FONT_SCANLINES; y++)
336
    for (y = 0; y < FONT_SCANLINES; y++)
337
        draw_glyph_line(fb_font[glyph * FONT_SCANLINES + y],
337
        draw_glyph_line(fb_font[glyph * FONT_SCANLINES + y],
338
            col * COL_WIDTH, row * FONT_SCANLINES + y);
338
            col * COL_WIDTH, row * FONT_SCANLINES + y);
339
}
339
}
340
 
340
 
341
/** Invert character at given position */
341
/** Invert character at given position */
342
static void invert_char(unsigned int col, unsigned int row)
342
static void invert_char(unsigned int col, unsigned int row)
343
{
343
{
344
    unsigned int x;
344
    unsigned int x;
345
    unsigned int y;
345
    unsigned int y;
346
 
346
 
347
    for (x = 0; x < COL_WIDTH; x++)
347
    for (x = 0; x < COL_WIDTH; x++)
348
        for (y = 0; y < FONT_SCANLINES; y++)
348
        for (y = 0; y < FONT_SCANLINES; y++)
349
            invert_pixel(col * COL_WIDTH + x,
349
            invert_pixel(col * COL_WIDTH + x,
350
                row * FONT_SCANLINES + y);
350
                row * FONT_SCANLINES + y);
351
}
351
}
352
 
352
 
353
/** Draw character at default position */
353
/** Draw character at default position */
354
static void draw_char(char chr)
354
static void draw_char(char chr)
355
{
355
{
356
    draw_glyph(chr, position % columns, position / columns);
356
    draw_glyph(chr, position % columns, position / columns);
357
}
357
}
358
 
358
 
359
static void draw_logo(unsigned int startx, unsigned int starty)
359
static void draw_logo(unsigned int startx, unsigned int starty)
360
{
360
{
361
    unsigned int x;
361
    unsigned int x;
362
    unsigned int y;
362
    unsigned int y;
363
    unsigned int byte;
363
    unsigned int byte;
364
    unsigned int rowbytes;
364
    unsigned int rowbytes;
365
 
365
 
366
    rowbytes = (helenos_width - 1) / 8 + 1;
366
    rowbytes = (helenos_width - 1) / 8 + 1;
367
 
367
 
368
    for (y = 0; y < helenos_height; y++)
368
    for (y = 0; y < helenos_height; y++)
369
        for (x = 0; x < helenos_width; x++) {
369
        for (x = 0; x < helenos_width; x++) {
370
            byte = helenos_bits[rowbytes * y + x / 8];
370
            byte = helenos_bits[rowbytes * y + x / 8];
371
            byte >>= x % 8;
371
            byte >>= x % 8;
372
            if (byte & 1)
372
            if (byte & 1)
373
                putpixel(startx + x, starty + y,
373
                putpixel(startx + x, starty + y,
374
                    COLOR(LOGOCOLOR));
374
                    COLOR(LOGOCOLOR));
375
        }
375
        }
376
}
376
}
377
 
377
 
378
/***************************************************************/
378
/***************************************************************/
379
/* Stdout specific functions */
379
/* Stdout specific functions */
380
 
380
 
381
static void invert_cursor(void)
381
static void invert_cursor(void)
382
{
382
{
383
    invert_char(position % columns, position / columns);
383
    invert_char(position % columns, position / columns);
384
}
384
}
385
 
385
 
386
/** Print character to screen
386
/** Print character to screen
387
 *
387
 *
388
 *  Emulate basic terminal commands
388
 *  Emulate basic terminal commands
389
 */
389
 */
390
static void fb_putchar(chardev_t *dev, char ch)
390
static void fb_putchar(chardev_t *dev, char ch)
391
{
391
{
392
    spinlock_lock(&fb_lock);
392
    spinlock_lock(&fb_lock);
393
   
393
   
394
    switch (ch) {
394
    switch (ch) {
395
    case '\n':
395
    case '\n':
396
        invert_cursor();
396
        invert_cursor();
397
        position += columns;
397
        position += columns;
398
        position -= position % columns;
398
        position -= position % columns;
399
        break;
399
        break;
400
    case '\r':
400
    case '\r':
401
        invert_cursor();
401
        invert_cursor();
402
        position -= position % columns;
402
        position -= position % columns;
403
        break;
403
        break;
404
    case '\b':
404
    case '\b':
405
        invert_cursor();
405
        invert_cursor();
406
        if (position % columns)
406
        if (position % columns)
407
            position--;
407
            position--;
408
        break;
408
        break;
409
    case '\t':
409
    case '\t':
410
        invert_cursor();
410
        invert_cursor();
411
        do {
411
        do {
412
            draw_char(' ');
412
            draw_char(' ');
413
            position++;
413
            position++;
414
        } while ((position % 8) && position < columns * rows);
414
        } while ((position % 8) && position < columns * rows);
415
        break;
415
        break;
416
    default:
416
    default:
417
        draw_char(ch);
417
        draw_char(ch);
418
        position++;
418
        position++;
419
    }
419
    }
420
   
420
   
421
    if (position >= columns * rows) {
421
    if (position >= columns * rows) {
422
        position -= columns;
422
        position -= columns;
423
        scroll_screen();
423
        scroll_screen();
424
    }
424
    }
425
   
425
   
426
    invert_cursor();
426
    invert_cursor();
427
   
427
   
428
    spinlock_unlock(&fb_lock);
428
    spinlock_unlock(&fb_lock);
429
}
429
}
430
 
430
 
431
static chardev_t framebuffer;
431
static chardev_t framebuffer;
432
static chardev_operations_t fb_ops = {
432
static chardev_operations_t fb_ops = {
433
    .write = fb_putchar,
433
    .write = fb_putchar,
434
};
434
};
435
 
435
 
436
 
436
 
437
/** Initialize framebuffer as a chardev output device
437
/** Initialize framebuffer as a chardev output device
438
 *
438
 *
439
 * @param addr   Physical address of the framebuffer
439
 * @param addr   Physical address of the framebuffer
440
 * @param x      Screen width in pixels
440
 * @param x      Screen width in pixels
441
 * @param y      Screen height in pixels
441
 * @param y      Screen height in pixels
442
 * @param scan   Bytes per one scanline
442
 * @param scan   Bytes per one scanline
443
 * @param visual Color model
443
 * @param visual Color model
444
 *
444
 *
445
 */
445
 */
446
void fb_init(uintptr_t addr, unsigned int x, unsigned int y, unsigned int scan,
446
void fb_init(uintptr_t addr, unsigned int x, unsigned int y, unsigned int scan,
447
    unsigned int visual)
447
    unsigned int visual)
448
{
448
{
449
    switch (visual) {
449
    switch (visual) {
450
    case VISUAL_INDIRECT_8:
450
    case VISUAL_INDIRECT_8:
451
        rgb2scr = rgb_byte8;
451
        rgb2scr = rgb_byte8;
452
        scr2rgb = byte8_rgb;
452
        scr2rgb = byte8_rgb;
453
        pixelbytes = 1;
453
        pixelbytes = 1;
454
        break;
454
        break;
455
    case VISUAL_RGB_5_5_5:
455
    case VISUAL_RGB_5_5_5:
456
        rgb2scr = rgb_byte555;
456
        rgb2scr = rgb_byte555;
457
        scr2rgb = byte555_rgb;
457
        scr2rgb = byte555_rgb;
458
        pixelbytes = 2;
458
        pixelbytes = 2;
459
        break;
459
        break;
460
    case VISUAL_RGB_5_6_5:
460
    case VISUAL_RGB_5_6_5:
461
        rgb2scr = rgb_byte565;
461
        rgb2scr = rgb_byte565;
462
        scr2rgb = byte565_rgb;
462
        scr2rgb = byte565_rgb;
463
        pixelbytes = 2;
463
        pixelbytes = 2;
464
        break;
464
        break;
465
    case VISUAL_RGB_8_8_8:
465
    case VISUAL_RGB_8_8_8:
466
        rgb2scr = rgb_byte888;
466
        rgb2scr = rgb_byte888;
467
        scr2rgb = byte888_rgb;
467
        scr2rgb = byte888_rgb;
468
        pixelbytes = 3;
468
        pixelbytes = 3;
469
        break;
469
        break;
470
    case VISUAL_RGB_8_8_8_0:
470
    case VISUAL_RGB_8_8_8_0:
471
        rgb2scr = rgb_byte888;
471
        rgb2scr = rgb_byte888;
472
        scr2rgb = byte888_rgb;
472
        scr2rgb = byte888_rgb;
473
        pixelbytes = 4;
473
        pixelbytes = 4;
474
        break;
474
        break;
475
    case VISUAL_RGB_0_8_8_8:
475
    case VISUAL_RGB_0_8_8_8:
476
        rgb2scr = rgb_byte0888;
476
        rgb2scr = rgb_byte0888;
477
        scr2rgb = byte0888_rgb;
477
        scr2rgb = byte0888_rgb;
478
        pixelbytes = 4;
478
        pixelbytes = 4;
479
        break;
479
        break;
480
    case VISUAL_BGR_0_8_8_8:
480
    case VISUAL_BGR_0_8_8_8:
481
        rgb2scr = bgr_byte0888;
481
        rgb2scr = bgr_byte0888;
482
        scr2rgb = byte0888_bgr;
482
        scr2rgb = byte0888_bgr;
483
        pixelbytes = 4;
483
        pixelbytes = 4;
484
        break;
484
        break;
485
    default:
485
    default:
486
        panic("Unsupported visual.\n");
486
        panic("Unsupported visual.\n");
487
    }
487
    }
488
   
488
   
489
    unsigned int fbsize = scan * y;
489
    unsigned int fbsize = scan * y;
490
   
490
   
491
    /* Map the framebuffer */
491
    /* Map the framebuffer */
492
    fbaddress = (uint8_t *) hw_map((uintptr_t) addr, fbsize);
492
    fbaddress = (uint8_t *) hw_map((uintptr_t) addr, fbsize);
493
   
493
   
494
    xres = x;
494
    xres = x;
495
    yres = y;
495
    yres = y;
496
    scanline = scan;
496
    scanline = scan;
497
   
497
   
498
    rows = y / FONT_SCANLINES;
498
    rows = y / FONT_SCANLINES;
499
    columns = x / COL_WIDTH;
499
    columns = x / COL_WIDTH;
500
 
500
 
501
    fb_parea.pbase = (uintptr_t) addr;
501
    fb_parea.pbase = (uintptr_t) addr;
502
    fb_parea.vbase = (uintptr_t) fbaddress;
502
    fb_parea.vbase = (uintptr_t) fbaddress;
503
    fb_parea.frames = SIZE2FRAMES(fbsize);
503
    fb_parea.frames = SIZE2FRAMES(fbsize);
504
    fb_parea.cacheable = false;
504
    fb_parea.cacheable = false;
505
    ddi_parea_register(&fb_parea);
505
    ddi_parea_register(&fb_parea);
506
 
506
 
507
    sysinfo_set_item_val("fb", NULL, true);
507
    sysinfo_set_item_val("fb", NULL, true);
508
    sysinfo_set_item_val("fb.kind", NULL, 1);
508
    sysinfo_set_item_val("fb.kind", NULL, 1);
509
    sysinfo_set_item_val("fb.width", NULL, xres);
509
    sysinfo_set_item_val("fb.width", NULL, xres);
510
    sysinfo_set_item_val("fb.height", NULL, yres);
510
    sysinfo_set_item_val("fb.height", NULL, yres);
511
    sysinfo_set_item_val("fb.scanline", NULL, scan);
511
    sysinfo_set_item_val("fb.scanline", NULL, scan);
512
    sysinfo_set_item_val("fb.visual", NULL, visual);
512
    sysinfo_set_item_val("fb.visual", NULL, visual);
513
    sysinfo_set_item_val("fb.address.physical", NULL, addr);
513
    sysinfo_set_item_val("fb.address.physical", NULL, addr);
514
    sysinfo_set_item_val("fb.address.color", NULL,
514
    sysinfo_set_item_val("fb.address.color", NULL,
515
        PAGE_COLOR((uintptr_t) fbaddress));
515
        PAGE_COLOR((uintptr_t) fbaddress));
516
    sysinfo_set_item_val("fb.invert-colors", NULL, invert_colors);
516
    sysinfo_set_item_val("fb.invert-colors", NULL, invert_colors);
517
 
517
 
518
    /* Allocate double buffer */
518
    /* Allocate double buffer */
519
    unsigned int order = fnzb(SIZE2FRAMES(fbsize) - 1) + 1;
519
    unsigned int order = fnzb(SIZE2FRAMES(fbsize) - 1) + 1;
520
    dbbuffer = (uint8_t *) frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
520
    dbbuffer = (uint8_t *) frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
521
    if (!dbbuffer)
521
    if (!dbbuffer)
522
        printf("Failed to allocate scroll buffer.\n");
522
        printf("Failed to allocate scroll buffer.\n");
523
    dboffset = 0;
523
    dboffset = 0;
524
 
524
 
525
    /* Initialized blank line */
525
    /* Initialized blank line */
526
    blankline = (uint8_t *) malloc(ROW_BYTES, FRAME_ATOMIC);
526
    blankline = (uint8_t *) malloc(ROW_BYTES, FRAME_ATOMIC);
527
    if (!blankline)
527
    if (!blankline)
528
        panic("Failed to allocate blank line for framebuffer.");
528
        panic("Failed to allocate blank line for framebuffer.");
529
    for (y = 0; y < FONT_SCANLINES; y++)
529
    for (y = 0; y < FONT_SCANLINES; y++)
530
        for (x = 0; x < xres; x++)
530
        for (x = 0; x < xres; x++)
531
            (*rgb2scr)(&blankline[POINTPOS(x, y)], COLOR(BGCOLOR));
531
            (*rgb2scr)(&blankline[POINTPOS(x, y)], COLOR(BGCOLOR));
532
   
532
   
533
    clear_screen();
533
    clear_screen();
534
 
534
 
535
    /* Update size of screen to match text area */
535
    /* Update size of screen to match text area */
536
    yres = rows * FONT_SCANLINES;
536
    yres = rows * FONT_SCANLINES;
537
 
537
 
538
    draw_logo(xres - helenos_width, 0);
538
    draw_logo(xres - helenos_width, 0);
539
    invert_cursor();
539
    invert_cursor();
540
 
540
 
541
    chardev_initialize("fb", &framebuffer, &fb_ops);
541
    chardev_initialize("fb", &framebuffer, &fb_ops);
542
    stdout = &framebuffer;
542
    stdout = &framebuffer;
543
}
543
}
544
 
544
 
545
/** @}
545
/** @}
546
 */
546
 */
547
 
547