NetBSD-5.0.2/sys/dev/hpc/video_subr.c
/* $NetBSD: video_subr.c,v 1.11 2008/04/28 20:23:48 martin 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 <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: video_subr.c,v 1.11 2008/04/28 20:23:48 martin Exp $");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <machine/bootinfo.h>
#include <dev/hpc/video_subr.h>
#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 *, int, int, int, int); \
static void \
linebpp##b(vc, x0, y0, x1, y1) \
struct video_chip *vc; \
int x0, y0, x1, 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 *, int, int); \
static void \
dotbpp##b(vc, x, y) \
struct video_chip *vc; \
int x, 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()
{
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);
}