/* $NetBSD: video_subr.c,v 1.13 2012/02/12 16:34:11 matt Exp $ */ /*- * Copyright (c) 2000 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by UCHIYAMA Yasushi. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include __KERNEL_RCSID(0, "$NetBSD: video_subr.c,v 1.13 2012/02/12 16:34:11 matt Exp $"); #include #include #include #include #include #define BPP2 ({ \ u_int8_t bitmap; \ bitmap = *(volatile u_int8_t*)addr; \ *(volatile u_int8_t*)addr = \ (bitmap & ~(0x3 << ((3 - (x % 4)) * 2))); \ }) #define BPP4 ({ \ u_int8_t bitmap; \ bitmap = *(volatile u_int8_t*)addr; \ *(volatile u_int8_t*)addr = \ (bitmap & ~(0xf << ((1 - (x % 2)) * 4))); \ }) #define BPP8 ({ \ *(volatile u_int8_t*)addr = 0xff; \ }) #define BRESENHAM(a, b, c, d, func) ({ \ u_int32_t fbaddr = vc->vc_fbvaddr; \ u_int32_t fbwidth = vc->vc_fbwidth; \ u_int32_t fbdepth = vc->vc_fbdepth; \ len = a, step = b -1; \ if (step == 0) \ return; \ kstep = len == 0 ? 0 : 1; \ for (i = k = 0, j = step / 2; i <= step; i++) { \ x = xbase c; \ y = ybase d; \ addr = fbaddr + (((y * fbwidth + x) * fbdepth) >> 3); \ func; \ j -= len; \ while (j < 0) { \ j += step; \ k += kstep; \ } \ } \ }) #define DRAWLINE(func) ({ \ if (x < 0) { \ if (y < 0) { \ if (_y < _x) { \ BRESENHAM(_y, _x, -i, -k, func); \ } else { \ BRESENHAM(_x, _y, -k, -i, func); \ } \ } else { \ if (_y < _x) { \ BRESENHAM(_y, _x, -i, +k, func); \ } else { \ BRESENHAM(_x, _y, -k, +i, func); \ } \ } \ } else { \ if (y < 0) { \ if (_y < _x) { \ BRESENHAM(_y, _x, +i, -k, func); \ } else { \ BRESENHAM(_x, _y, +k, -i, func); \ } \ } else { \ if (_y < _x) { \ BRESENHAM(_y, _x, +i, +k, func); \ } else { \ BRESENHAM(_x, _y, +k, +i, func); \ } \ } \ } \ }) #define LINEFUNC(b) \ static void \ linebpp##b(struct video_chip *vc, int x0, int y0, int x1, int y1) \ { \ u_int32_t addr; \ int i, j, k, len, step, kstep; \ int x, _x, y, _y; \ int xbase, ybase; \ x = x1 - x0; \ y = y1 - y0; \ _x = abs(x); \ _y = abs(y); \ xbase = x0; \ ybase = y0; \ DRAWLINE(BPP##b); \ } #define DOTFUNC(b) \ static void \ dotbpp##b(struct video_chip *vc, int x, int y) \ { \ u_int32_t addr; \ addr = vc->vc_fbvaddr + (((y * vc->vc_fbwidth + x) * \ vc->vc_fbdepth) >> 3); \ BPP##b; \ } LINEFUNC(2) LINEFUNC(4) LINEFUNC(8) DOTFUNC(2) DOTFUNC(4) DOTFUNC(8) static void linebpp_unimpl(struct video_chip *, int, int, int, int); static void dotbpp_unimpl(struct video_chip *, int, int); int cmap_work_alloc(u_int8_t **r, u_int8_t **g, u_int8_t **b, u_int32_t **rgb, int cnt) { KASSERT(LEGAL_CLUT_INDEX(cnt - 1)); #define ALLOC_BUF(x, bit) \ if (x) { \ *x = malloc(cnt * sizeof(u_int ## bit ## _t), \ M_DEVBUF, M_WAITOK); \ if (*x == 0) \ goto errout; \ } ALLOC_BUF(r, 8); ALLOC_BUF(g, 8); ALLOC_BUF(b, 8); ALLOC_BUF(rgb, 32); #undef ALLOCBUF return (0); errout: cmap_work_free(*r, *g, *b, *rgb); return (ENOMEM); } void cmap_work_free(u_int8_t *r, u_int8_t *g, u_int8_t *b, u_int32_t *rgb) { if (r) free(r, M_DEVBUF); if (g) free(g, M_DEVBUF); if (b) free(b, M_DEVBUF); if (rgb) free(rgb, M_DEVBUF); } void rgb24_compose(u_int32_t *rgb24, u_int8_t *r, u_int8_t *g, u_int8_t *b, int cnt) { int i; KASSERT(rgb24 && r && g && b && LEGAL_CLUT_INDEX(cnt - 1)); for (i = 0; i < cnt; i++) { *rgb24++ = RGB24(r[i], g[i], b[i]); } } void rgb24_decompose(u_int32_t *rgb24, u_int8_t *r, u_int8_t *g, u_int8_t *b, int cnt) { int i; KASSERT(rgb24 && r && g && b && LEGAL_CLUT_INDEX(cnt - 1)); for (i = 0; i < cnt; i++) { u_int32_t rgb = *rgb24++; *r++ = (rgb >> 16) & 0xff; *g++ = (rgb >> 8) & 0xff; *b++ = rgb & 0xff; } } /* * Debug routines. */ void video_calibration_pattern(struct video_chip *vc) { int x, y; x = vc->vc_fbwidth - 40; y = vc->vc_fbheight - 40; video_line(vc, 40, 40, x , 40); video_line(vc, x , 40, x , y ); video_line(vc, x , y , 40, y ); video_line(vc, 40, y , 40, 40); video_line(vc, 40, 40, x , y ); video_line(vc, x, 40, 40, y ); } static void linebpp_unimpl(struct video_chip *vc, int x0, int y0, int x1, int y1) { return; } static void dotbpp_unimpl(struct video_chip *vc, int x, int y) { return; } void video_attach_drawfunc(struct video_chip *vc) { switch (vc->vc_fbdepth) { default: vc->vc_drawline = linebpp_unimpl; vc->vc_drawdot = dotbpp_unimpl; break; case 8: vc->vc_drawline = linebpp8; vc->vc_drawdot = dotbpp8; break; case 4: vc->vc_drawline = linebpp4; vc->vc_drawdot = dotbpp4; break; case 2: vc->vc_drawline = linebpp2; vc->vc_drawdot = dotbpp2; break; } } void video_line(struct video_chip *vc, int x0, int y0, int x1, int y1) { if (vc->vc_drawline) vc->vc_drawline(vc, x0, y0, x1, y1); } void video_dot(struct video_chip *vc, int x, int y) { if (vc->vc_drawdot) vc->vc_drawdot(vc, x, y); } int video_reverse_color(void) { struct { int reverse, normal; } ctype[] = { { BIFB_D2_M2L_3, BIFB_D2_M2L_0 }, { BIFB_D2_M2L_3x2, BIFB_D2_M2L_0x2 }, { BIFB_D8_FF, BIFB_D8_00 }, { BIFB_D16_FFFF, BIFB_D16_0000, }, { -1, -1 } /* terminator */ }, *ctypep; u_int16_t fbtype; /* check reverse color */ fbtype = bootinfo->fb_type; for (ctypep = ctype; ctypep->normal != -1 ; ctypep++) { if (fbtype == ctypep->normal) { return (0); } else if (fbtype == ctypep->reverse) { return (1); } } printf(": WARNING unknown frame buffer type 0x%04x.\n", fbtype); return (0); }