1 /* $NetBSD: bicons.c,v 1.14 2011/07/17 20:54:51 joerg Exp $ */
2
3 /*-
4 * Copyright (c) 1999-2001
5 * Shin Takemura and PocketBSD Project. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by the PocketBSD project
18 * and its contributors.
19 * 4. Neither the name of the project nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 *
35 */
36
37 #include <sys/cdefs.h>
38 __KERNEL_RCSID(0, "$NetBSD: bicons.c,v 1.14 2011/07/17 20:54:51 joerg Exp $");
39
40 #define HALF_FONT
41
42 #include <sys/param.h>
43 #include <sys/device.h>
44 #include <sys/systm.h>
45 #include <sys/conf.h>
46 #include <dev/cons.h>
47
48 #include <machine/bootinfo.h>
49 #include <sys/bus.h>
50 #include <machine/platid.h>
51
52 #include <dev/hpc/biconsvar.h>
53 #include <dev/hpc/bicons.h>
54 extern u_int8_t font_clR8x8_data[];
55 #define FONT_HEIGHT 8
56 #define FONT_WIDTH 1
57
58 static void put_oxel_D2_M2L_3(u_int8_t *, u_int8_t, u_int8_t);
59 static void put_oxel_D2_M2L_3x2(u_int8_t *, u_int8_t, u_int8_t);
60 static void put_oxel_D2_M2L_0(u_int8_t *, u_int8_t, u_int8_t);
61 static void put_oxel_D2_M2L_0x2(u_int8_t *, u_int8_t, u_int8_t);
62 static void put_oxel_D4_M2L_F(u_int8_t *, u_int8_t, u_int8_t);
63 static void put_oxel_D4_M2L_Fx2(u_int8_t *, u_int8_t, u_int8_t);
64 static void put_oxel_D4_M2L_0(u_int8_t *, u_int8_t, u_int8_t);
65 static void put_oxel_D4_M2L_0x2(u_int8_t *, u_int8_t, u_int8_t);
66 static void put_oxel_D8_00(u_int8_t *, u_int8_t, u_int8_t);
67 static void put_oxel_D8_FF(u_int8_t *, u_int8_t, u_int8_t);
68 static void put_oxel_D16_0000(u_int8_t *, u_int8_t, u_int8_t);
69 static void put_oxel_D16_FFFF(u_int8_t *, u_int8_t, u_int8_t);
70
71 static const struct {
72 int type;
73 const char *name;
74 void (*func)(u_int8_t *, u_int8_t, u_int8_t);
75 u_int8_t clear_byte;
76 int16_t oxel_bytes;
77 } fb_table[] = {
78 { BIFB_D2_M2L_3, BIFBN_D2_M2L_3,
79 put_oxel_D2_M2L_3, 0, 2 },
80 { BIFB_D2_M2L_3x2, BIFBN_D2_M2L_3x2,
81 put_oxel_D2_M2L_3x2, 0, 1 },
82 { BIFB_D2_M2L_0, BIFBN_D2_M2L_0,
83 put_oxel_D2_M2L_0, 0xff, 2 },
84 { BIFB_D2_M2L_0x2, BIFBN_D2_M2L_0x2,
85 put_oxel_D2_M2L_0x2, 0xff, 1 },
86 { BIFB_D4_M2L_F, BIFBN_D4_M2L_F,
87 put_oxel_D4_M2L_F, 0x00, 4 },
88 { BIFB_D4_M2L_Fx2, BIFBN_D4_M2L_Fx2,
89 put_oxel_D4_M2L_Fx2, 0x00, 2 },
90 { BIFB_D4_M2L_0, BIFBN_D4_M2L_0,
91 put_oxel_D4_M2L_0, 0xff, 4 },
92 { BIFB_D4_M2L_0x2, BIFBN_D4_M2L_0x2,
93 put_oxel_D4_M2L_0x2, 0xff, 2 },
94 { BIFB_D8_00, BIFBN_D8_00,
95 put_oxel_D8_00, 0xff, 8 },
96 { BIFB_D8_FF, BIFBN_D8_FF,
97 put_oxel_D8_FF, 0x00, 8 },
98 { BIFB_D16_0000, BIFBN_D16_0000,
99 put_oxel_D16_0000, 0xff, 16 },
100 { BIFB_D16_FFFF, BIFBN_D16_FFFF,
101 put_oxel_D16_FFFF, 0x00, 16 },
102 };
103 #define FB_TABLE_SIZE (sizeof(fb_table) / sizeof(*fb_table))
104
105 static u_int8_t *fb_vram;
106 static int16_t fb_line_bytes;
107 static u_int8_t fb_clear_byte;
108 int16_t bicons_ypixel;
109 int16_t bicons_xpixel;
110 #ifdef HALF_FONT
111 static int16_t fb_oxel_bytes = 1;
112 int16_t bicons_width = 80;
113 void (*fb_put_oxel)(u_int8_t *, u_int8_t, u_int8_t) = put_oxel_D2_M2L_3x2;
114 #else /* HALF_FONT */
115 static int16_t fb_oxel_bytes = 2;
116 int16_t bicons_width = 40;
117 void (*fb_put_oxel)(u_int8_t *, u_int8_t, u_int8_t) = put_oxel_D2_M2L_3;
118 #endif /* HALF_FONT */
119 int16_t bicons_height;
120 static int16_t curs_x;
121 static int16_t curs_y;
122
123 static int bicons_priority;
124 int biconscninit(struct consdev *);
125 void biconscnprobe(struct consdev *);
126 void biconscnputc(dev_t, int);
127 int biconscngetc(dev_t); /* harmless place holder */
128
129 static void draw_char(int, int, int);
130 static void clear(int, int);
131 static void scroll(int, int, int);
132 static void bicons_puts(const char *);
133 static void bicons_printf(const char *, ...) __unused;
134
135 int
bicons_init(struct consdev * cndev)136 bicons_init(struct consdev *cndev)
137 {
138
139 if (biconscninit(cndev) != 0)
140 return (1);
141
142 biconscnprobe(cndev);
143
144 return (0); /* success */
145 }
146
147 int
biconscninit(struct consdev * cndev)148 biconscninit(struct consdev *cndev)
149 {
150 int fb_index = -1;
151
152 if (bootinfo->fb_addr == 0) {
153 /* Bootinfo don't have frame buffer address */
154 return (1);
155 }
156
157 for (fb_index = 0; fb_index < FB_TABLE_SIZE; fb_index++)
158 if (fb_table[fb_index].type == bootinfo->fb_type)
159 break;
160
161 if (FB_TABLE_SIZE <= fb_index || fb_index == -1) {
162 /* Unknown frame buffer type, don't enable bicons. */
163 return (1);
164 }
165
166 fb_vram = (u_int8_t *)bootinfo->fb_addr;
167 fb_line_bytes = bootinfo->fb_line_bytes;
168 bicons_xpixel = bootinfo->fb_width;
169 bicons_ypixel = bootinfo->fb_height;
170
171 fb_put_oxel = fb_table[fb_index].func;
172 fb_clear_byte = fb_table[fb_index].clear_byte;
173 fb_oxel_bytes = fb_table[fb_index].oxel_bytes;
174
175 bicons_width = bicons_xpixel / (8 * FONT_WIDTH);
176 bicons_height = bicons_ypixel / FONT_HEIGHT;
177 clear(0, bicons_ypixel);
178
179 curs_x = 0;
180 curs_y = 0;
181
182 bicons_puts("builtin console type = ");
183 bicons_puts(fb_table[fb_index].name);
184 bicons_puts("\n");
185
186 return (0);
187 }
188
189 void
biconscnprobe(struct consdev * cndev)190 biconscnprobe(struct consdev *cndev)
191 {
192 extern const struct cdevsw biconsdev_cdevsw;
193 int maj;
194
195 /* locate the major number */
196 maj = cdevsw_lookup_major(&biconsdev_cdevsw);
197
198 cndev->cn_dev = makedev(maj, 0);
199 cndev->cn_pri = bicons_priority;
200 }
201
202 void
bicons_set_priority(int priority)203 bicons_set_priority(int priority)
204 {
205 bicons_priority = priority;
206 }
207
208 int
biconscngetc(dev_t dev)209 biconscngetc(dev_t dev)
210 {
211 printf("no input method. reboot me.\n");
212 while (1)
213 ;
214 /* NOTREACHED */
215 return 0;
216 }
217
218 void
biconscnputc(dev_t dev,int c)219 biconscnputc(dev_t dev, int c)
220 {
221 int line_feed = 0;
222
223 switch (c) {
224 case 0x08: /* back space */
225 if (--curs_x < 0) {
226 curs_x = 0;
227 }
228 /* erase character ar cursor position */
229 draw_char(curs_x, curs_y, ' ');
230 break;
231 case '\r':
232 curs_x = 0;
233 break;
234 case '\n':
235 curs_x = 0;
236 line_feed = 1;
237 break;
238 default:
239 draw_char(curs_x, curs_y, c);
240 if (bicons_width <= ++curs_x) {
241 curs_x = 0;
242 line_feed = 1;
243 }
244 }
245
246 if (line_feed) {
247 if (bicons_height <= ++curs_y) {
248 /* scroll up */
249 scroll(FONT_HEIGHT, (bicons_height - 1) * FONT_HEIGHT,
250 - FONT_HEIGHT);
251 clear((bicons_height - 1) * FONT_HEIGHT, FONT_HEIGHT);
252 curs_y--;
253 }
254 }
255 }
256
257 void
bicons_puts(const char * s)258 bicons_puts(const char *s)
259 {
260 while (*s)
261 biconscnputc(0, *s++);
262 }
263
264
265 void
bicons_putn(const char * s,int n)266 bicons_putn(const char *s, int n)
267 {
268 while (0 < n--)
269 biconscnputc(0, *s++);
270 }
271
272 void
273 #ifdef __STDC__
bicons_printf(const char * fmt,...)274 bicons_printf(const char *fmt, ...)
275 #else
276 bicons_printf(fmt, va_alist)
277 char *fmt;
278 va_dcl
279 #endif
280 {
281 va_list ap;
282 char buf[0x100];
283
284 va_start(ap, fmt);
285 vsnprintf(buf, sizeof(buf), fmt, ap);
286 va_end(ap);
287 bicons_puts(buf);
288 }
289
290 static void
draw_char(int x,int y,int c)291 draw_char(int x, int y, int c)
292 {
293 int i;
294 u_int8_t *p;
295
296 if (!fb_vram)
297 return;
298
299 p = &fb_vram[(y * FONT_HEIGHT * fb_line_bytes) +
300 x * FONT_WIDTH * fb_oxel_bytes];
301 for (i = 0; i < FONT_HEIGHT; i++) {
302 (*fb_put_oxel)(p, font_clR8x8_data
303 [FONT_WIDTH * (FONT_HEIGHT * c + i)], 0xff);
304 p += (fb_line_bytes);
305 }
306 }
307
308 static void
clear(int y,int height)309 clear(int y, int height)
310 {
311 u_int8_t *p;
312
313 if (!fb_vram)
314 return;
315
316 p = &fb_vram[y * fb_line_bytes];
317
318 while (0 < height--) {
319 memset(p, fb_clear_byte,
320 bicons_width * fb_oxel_bytes * FONT_WIDTH);
321 p += fb_line_bytes;
322 }
323 }
324
325 static void
scroll(int y,int height,int d)326 scroll(int y, int height, int d)
327 {
328 u_int8_t *from, *to;
329
330 if (!fb_vram)
331 return;
332
333 if (d < 0) {
334 from = &fb_vram[y * fb_line_bytes];
335 to = from + d * fb_line_bytes;
336 while (0 < height--) {
337 memcpy(to, from, bicons_width * fb_oxel_bytes);
338 from += fb_line_bytes;
339 to += fb_line_bytes;
340 }
341 } else {
342 from = &fb_vram[(y + height - 1) * fb_line_bytes];
343 to = from + d * fb_line_bytes;
344 while (0 < height--) {
345 memcpy(to, from, bicons_xpixel * fb_oxel_bytes / 8);
346 from -= fb_line_bytes;
347 to -= fb_line_bytes;
348 }
349 }
350 }
351
352 /*=============================================================================
353 *
354 * D2_M2L_3
355 *
356 */
357 static void
put_oxel_D2_M2L_3(u_int8_t * xaddr,u_int8_t data,u_int8_t mask)358 put_oxel_D2_M2L_3(u_int8_t *xaddr, u_int8_t data, u_int8_t mask)
359 {
360 #if 1
361 u_int16_t *addr = (u_int16_t *)xaddr;
362 static u_int16_t map0[] = {
363 0x0000, 0x0300, 0x0c00, 0x0f00, 0x3000, 0x3300, 0x3c00, 0x3f00,
364 0xc000, 0xc300, 0xcc00, 0xcf00, 0xf000, 0xf300, 0xfc00, 0xff00,
365 };
366 static u_int16_t map1[] = {
367 0x0000, 0x0003, 0x000c, 0x000f, 0x0030, 0x0033, 0x003c, 0x003f,
368 0x00c0, 0x00c3, 0x00cc, 0x00cf, 0x00f0, 0x00f3, 0x00fc, 0x00ff,
369 };
370 *addr = (map1[data >> 4] | map0[data & 0x0f]);
371 #else
372 static u_int8_t map[] = {
373 0x00, 0x03, 0x0c, 0x0f, 0x30, 0x33, 0x3c, 0x3f,
374 0xc0, 0xc3, 0xcc, 0xcf, 0xf0, 0xf3, 0xfc, 0xff,
375 };
376 u_int8_t *addr = xaddr;
377
378 *addr++ = (map[(data >> 4) & 0x0f] & map[(mask >> 4) & 0x0f]) |
379 (*addr & ~map[(mask >> 4) & 0x0f]);
380 *addr = (map[(data >> 0) & 0x0f] & map[(mask >> 0) & 0x0f]) |
381 (*addr & ~map[(mask >> 0) & 0x0f]);
382 #endif
383 }
384
385 /*=============================================================================
386 *
387 * D2_M2L_3x2
388 *
389 */
390 static void
put_oxel_D2_M2L_3x2(u_int8_t * xaddr,u_int8_t data,u_int8_t mask)391 put_oxel_D2_M2L_3x2(u_int8_t *xaddr, u_int8_t data, u_int8_t mask)
392 {
393 register u_int8_t odd = (data & 0xaa);
394 register u_int8_t even = (data & 0x55);
395
396 *xaddr = (odd | (even << 1)) | ((odd >> 1) & even);
397 }
398
399 /*=============================================================================
400 *
401 * D2_M2L_0
402 *
403 */
404 static void
put_oxel_D2_M2L_0(u_int8_t * xaddr,u_int8_t data,u_int8_t mask)405 put_oxel_D2_M2L_0(u_int8_t *xaddr, u_int8_t data, u_int8_t mask)
406 {
407 #if 1
408 u_int16_t *addr = (u_int16_t *)xaddr;
409 static u_int16_t map0[] = {
410 0xff00, 0xfc00, 0xf300, 0xf000, 0xcf00, 0xcc00, 0xc300, 0xc000,
411 0x3f00, 0x3c00, 0x3300, 0x3000, 0x0f00, 0x0c00, 0x0300, 0x0000,
412 };
413 static u_int16_t map1[] = {
414 0x00ff, 0x00fc, 0x00f3, 0x00f0, 0x00cf, 0x00cc, 0x00c3, 0x00c0,
415 0x003f, 0x003c, 0x0033, 0x0030, 0x000f, 0x000c, 0x0003, 0x0000,
416 };
417 *addr = (map1[data >> 4] | map0[data & 0x0f]);
418 #else
419 static u_int8_t map[] = {
420 0x00, 0x03, 0x0c, 0x0f, 0x30, 0x33, 0x3c, 0x3f,
421 0xc0, 0xc3, 0xcc, 0xcf, 0xf0, 0xf3, 0xfc, 0xff,
422 };
423 u_int8_t *addr = xaddr;
424
425 *addr++ = (~(map[(data >> 4) & 0x0f] & map[(mask >> 4) & 0x0f])) |
426 (*addr & ~map[(mask >> 4) & 0x0f]);
427 *addr = (~(map[(data >> 0) & 0x0f] & map[(mask >> 0) & 0x0f])) |
428 (*addr & ~map[(mask >> 0) & 0x0f]);
429 #endif
430 }
431
432 /*=============================================================================
433 *
434 * D2_M2L_0x2
435 *
436 */
437 static void
put_oxel_D2_M2L_0x2(u_int8_t * xaddr,u_int8_t data,u_int8_t mask)438 put_oxel_D2_M2L_0x2(u_int8_t *xaddr, u_int8_t data, u_int8_t mask)
439 {
440 register u_int8_t odd = (data & 0xaa);
441 register u_int8_t even = (data & 0x55);
442
443 *xaddr = ~((odd | (even << 1)) | ((odd >> 1) & even));
444 }
445
446 /*=============================================================================
447 *
448 * D4_M2L_F
449 *
450 */
451 static void
put_oxel_D4_M2L_F(u_int8_t * xaddr,u_int8_t data,u_int8_t mask)452 put_oxel_D4_M2L_F(u_int8_t *xaddr, u_int8_t data, u_int8_t mask)
453 {
454 u_int32_t *addr = (u_int32_t *)xaddr;
455 static u_int32_t map[] = {
456 0x0000, 0x0f00, 0xf000, 0xff00, 0x000f, 0x0f0f, 0xf00f, 0xff0f,
457 0x00f0, 0x0ff0, 0xf0f0, 0xfff0, 0x00ff, 0x0fff, 0xf0ff, 0xffff,
458 };
459 *addr = (map[data >> 4] | (map[data & 0x0f] << 16));
460 }
461
462 /*=============================================================================
463 *
464 * D4_M2L_Fx2
465 *
466 */
467 static void
put_oxel_D4_M2L_Fx2(u_int8_t * xaddr,u_int8_t data,u_int8_t mask)468 put_oxel_D4_M2L_Fx2(u_int8_t *xaddr, u_int8_t data, u_int8_t mask)
469 {
470 u_int16_t *addr = (u_int16_t *)xaddr;
471 static u_int16_t map[] = {
472 0x00, 0x08, 0x08, 0x0f, 0x80, 0x88, 0x88, 0x8f,
473 0x80, 0x88, 0x88, 0x8f, 0xf0, 0xf8, 0xf8, 0xff,
474 };
475
476 *addr = (map[data >> 4] | (map[data & 0x0f] << 8));
477 }
478
479 /*=============================================================================
480 *
481 * D4_M2L_0
482 *
483 */
484 static void
put_oxel_D4_M2L_0(u_int8_t * xaddr,u_int8_t data,u_int8_t mask)485 put_oxel_D4_M2L_0(u_int8_t *xaddr, u_int8_t data, u_int8_t mask)
486 {
487 u_int32_t *addr = (u_int32_t *)xaddr;
488 static u_int32_t map[] = {
489 0xffff, 0xf0ff, 0x0fff, 0x00ff, 0xfff0, 0xf0f0, 0x0ff0, 0x00f0,
490 0xff0f, 0xf00f, 0x0f0f, 0x000f, 0xff00, 0xf000, 0x0f00, 0x0000,
491 };
492 *addr = (map[data >> 4] | (map[data & 0x0f] << 16));
493 }
494
495 /*=============================================================================
496 *
497 * D4_M2L_0x2
498 *
499 */
500 static void
put_oxel_D4_M2L_0x2(u_int8_t * xaddr,u_int8_t data,u_int8_t mask)501 put_oxel_D4_M2L_0x2(u_int8_t *xaddr, u_int8_t data, u_int8_t mask)
502 {
503 u_int16_t *addr = (u_int16_t *)xaddr;
504 static u_int16_t map[] = {
505 0xff, 0xf8, 0xf8, 0xf0, 0x8f, 0x88, 0x88, 0x80,
506 0x8f, 0x88, 0x88, 0x80, 0x0f, 0x08, 0x08, 0x00,
507 };
508
509 *addr = (map[data >> 4] | (map[data & 0x0f] << 8));
510 }
511
512 /*=============================================================================
513 *
514 * D8_00
515 *
516 */
517 static void
put_oxel_D8_00(u_int8_t * xaddr,u_int8_t data,u_int8_t mask)518 put_oxel_D8_00(u_int8_t *xaddr, u_int8_t data, u_int8_t mask)
519 {
520 int i;
521 u_int8_t *addr = xaddr;
522
523 for (i = 0; i < 8; i++) {
524 if (mask & 0x80) {
525 *addr = (data & 0x80) ? 0x00 : 0xFF;
526 }
527 addr++;
528 data <<= 1;
529 mask <<= 1;
530 }
531 }
532
533 /*=============================================================================
534 *
535 * D8_FF
536 *
537 */
538 static void
put_oxel_D8_FF(u_int8_t * xaddr,u_int8_t data,u_int8_t mask)539 put_oxel_D8_FF(u_int8_t *xaddr, u_int8_t data, u_int8_t mask)
540 {
541 int i;
542 u_int8_t *addr = xaddr;
543
544 for (i = 0; i < 8; i++) {
545 if (mask & 0x80) {
546 *addr = (data & 0x80) ? 0xFF : 0x00;
547 }
548 addr++;
549 data <<= 1;
550 mask <<= 1;
551 }
552 }
553
554 /*=============================================================================
555 *
556 * D16_0000
557 *
558 */
559 static void
put_oxel_D16_0000(u_int8_t * xaddr,u_int8_t data,u_int8_t mask)560 put_oxel_D16_0000(u_int8_t *xaddr, u_int8_t data, u_int8_t mask)
561 {
562 int i;
563 u_int16_t *addr = (u_int16_t *)xaddr;
564
565 for (i = 0; i < 8; i++) {
566 if (mask & 0x80) {
567 *addr = (data & 0x80) ? 0x0000 : 0xFFFF;
568 }
569 addr++;
570 data <<= 1;
571 mask <<= 1;
572 }
573 }
574
575 /*=============================================================================
576 *
577 * D16_FFFF
578 *
579 */
580 static void
put_oxel_D16_FFFF(u_int8_t * xaddr,u_int8_t data,u_int8_t mask)581 put_oxel_D16_FFFF(u_int8_t *xaddr, u_int8_t data, u_int8_t mask)
582 {
583 int i;
584 u_int16_t *addr = (u_int16_t *)xaddr;
585
586 for (i = 0; i < 8; i++) {
587 if (mask & 0x80) {
588 *addr = (data & 0x80) ? 0xFFFF : 0x0000;
589 }
590 addr++;
591 data <<= 1;
592 mask <<= 1;
593 }
594 }
595