/* $NetBSD: omrasops.c,v 1.27 2024/09/20 03:24:05 isaki Exp $ */
/*-
* Copyright (c) 2000 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Tohru Nishimura.
*
* 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> /* RCS ID & Copyright macro defns */
__KERNEL_RCSID(0, "$NetBSD: omrasops.c,v 1.27 2024/09/20 03:24:05 isaki Exp $");
/*
* Designed specifically for 'm68k bitorder';
* - most significant byte is stored at lower address,
* - most significant bit is displayed at left most on screen.
* Implementation relies on;
* - first column is at 32bit aligned address,
* - font glyphs are stored in 32bit padded.
*/
/*
* BMSEL affects both of
* 1) which plane a write to the common bitmap plane is reflected on and
* 2) which plane's ROP a write to the common ROP is reflected on.
*
* The common ROP is not a ROP applied to write to the common bitmap plane.
* It's equivalent to set ROPs of the plane selected in the plane mask one
* by one.
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wsdisplayvar.h>
#include <dev/rasops/rasops.h>
#include <arch/luna68k/dev/omrasopsvar.h>
#ifdef luna68k
#define USE_M68K_ASM 1
#endif
/* To provide optimization conditions to compilers */
#if defined(__GNUC__)
#define ASSUME(cond) if (!(cond)) __unreachable()
#elif defined(__clang__) && __has_builtin(__builtin_assume)
#define ASSUME(cond) __builtin_assume(cond)
#else
#define ASSUME(cond) (void)(cond)
#endif
/* XXX it should be redesigned, including making the attributes support 8bpp */
typedef struct {
union {
int32_t all;
struct {
int8_t ismulti; /* is multi color used */
uint8_t fg;
uint8_t bg;
uint8_t reserved;
};
};
} rowattr_t;
/* wscons emulator operations */
static void om_cursor(void *, int, int, int);
static int om_mapchar(void *, int, u_int *);
static void om_putchar(void *, int, int, u_int, long);
static void om1_copycols(void *, int, int, int, int);
static void om4_copycols(void *, int, int, int, int);
static void om1_copyrows(void *, int, int, int num);
static void om4_copyrows(void *, int, int, int num);
static void om_erasecols(void *, int, int, int, long);
static void om_eraserows(void *, int, int, long);
static int om_allocattr(void *, int, int, int, long *);
static void om_fill(int, int, uint8_t *, int, int, uint32_t, int, int);
static void om_fill_color(int, int, uint8_t *, int, int, int, int);
static void om_rascopy_single(int, uint8_t *, uint8_t *, int16_t, int16_t,
uint8_t[]);
static void om4_rascopy_multi(uint8_t *, uint8_t *, int16_t, int16_t);
static void om_unpack_attr(long, uint8_t *, uint8_t *, int *);
static int omrasops_init(struct rasops_info *, int, int);
/*
* XXX should be fixed...
* This number of elements is derived from howmany(1024, fontheight = 24).
* But it is currently initialized with row = 34, so it is used only up to 34.
*/
#define OMRASOPS_MAX_ROWS 43
static rowattr_t rowattr[OMRASOPS_MAX_ROWS];
#define ALL1BITS (~0U)
#define ALL0BITS (0U)
#define BLITWIDTH (32)
#define ALIGNMASK (0x1f)
#define BYTESDONE (4)
#if 0 /* XXX not used yet */
/*
* internal attributes. see om_allocattr().
*/
#define OMFB_ATTR_MULTICOLOR (1U << 31)
#define OMFB_ATTR_UNDERLINE (1U << 17)
#define OMFB_ATTR_BOLD (1U << 16)
#endif
/*
* XXX deprecated.
* This way cannot be extended to 8bpp, so don't use it in new code.
*/
#define P0(addr) ((uint32_t *)((uint8_t *)(addr) + OMFB_PLANEOFFS * 1))
#define P1(addr) ((uint32_t *)((uint8_t *)(addr) + OMFB_PLANEOFFS * 2))
#define P2(addr) ((uint32_t *)((uint8_t *)(addr) + OMFB_PLANEOFFS * 3))
#define P3(addr) ((uint32_t *)((uint8_t *)(addr) + OMFB_PLANEOFFS * 4))
/*
* macros to handle unaligned bit copy ops.
* See src/sys/dev/rasops/rasops_masks.h for MI version.
* Also refer src/sys/arch/hp300/dev/maskbits.h.
* (which was implemented for ancient src/sys/arch/hp300/dev/grf_hy.c)
*/
/* luna68k version GETBITS() that gets w bits from bit x at psrc memory */
#define FASTGETBITS(psrc, x, w, dst) \
asm("bfextu %3{%1:%2},%0" \
: "=d" (dst) \
: "di" (x), "di" (w), "o" (*(uint32_t *)(psrc)))
/* luna68k version PUTBITS() that puts w bits from bit x at pdst memory */
/* XXX this macro assumes (x + w) <= 32 to handle unaligned residual bits */
#define FASTPUTBITS(src, x, w, pdst) \
asm("bfins %3,%0{%1:%2}" \
: "+o" (*(uint32_t *)(pdst)) \
: "di" (x), "di" (w), "d" (src) \
: "memory" )
#define GETBITS(psrc, x, w, dst) FASTGETBITS(psrc, x, w, dst)
#define PUTBITS(src, x, w, pdst) FASTPUTBITS(src, x, w, pdst)
/*
* Clear lower w bits from x.
* x must be filled with 1 at least lower w bits.
*/
#if USE_M68K_ASM
#define CLEAR_LOWER_BITS(x, w) \
asm volatile( \
" bclr %[width],%[data] ;\n" \
" addq.l #1,%[data] ;\n" \
: [data] "+&d" (x) \
: [width] "d" (w) \
: \
)
#else
#define CLEAR_LOWER_BITS(x, w) x = ((x) & ~(1U << (w))) + 1
#endif
/* Set planemask for the common plane and the common ROP */
static inline void
om_set_planemask(int planemask)
{
*(volatile uint32_t *)OMFB_PLANEMASK = planemask;
}
/* Get a ROP address */
static inline volatile uint32_t *
om_rop_addr(int plane, int rop)
{
return (volatile uint32_t *)
(OMFB_ROP_P0 + OMFB_PLANEOFFS * plane + rop * 4);
}
/* Set ROP and ROP's mask for individual plane */
static inline void
om_set_rop(int plane, int rop, uint32_t mask)
{
*om_rop_addr(plane, rop) = mask;
}
/* Set ROP and ROP's mask for current setplanemask-ed plane(s) */
static inline void
om_set_rop_curplane(int rop, uint32_t mask)
{
((volatile uint32_t *)(OMFB_ROP_COMMON))[rop] = mask;
}
/* Reset planemask and ROP */
static inline void
om_reset_planemask_and_rop(void)
{
om_set_planemask(hwplanemask);
om_set_rop_curplane(ROP_THROUGH, ~0U);
}
static inline void
om_set_rowattr(int row, uint8_t fg, uint8_t bg)
{
if (rowattr[row].fg == fg && rowattr[row].bg == bg)
return;
if (rowattr[row].ismulti)
return;
if (rowattr[row].fg == rowattr[row].bg) {
/* From the initial (erased) state, */
if (rowattr[row].fg != fg && rowattr[row].bg != bg) {
/* if both are changed at once, it's multi color */
rowattr[row].ismulti = true;
} else {
/* otherwise, it's single color */
rowattr[row].fg = fg;
rowattr[row].bg = bg;
}
} else {
rowattr[row].ismulti = true;
}
}
static inline void
om_reset_rowattr(int row, uint8_t bg)
{
/* Setting fg equal to bg means 'reset' or 'erased'. */
rowattr[row].ismulti = false;
rowattr[row].bg = bg;
rowattr[row].fg = bg;
}
/*
* Fill rectangle.
* val is assumed only ALL0BITS or ALL1BITS, because all bits are used as is
* regardless of bit offset of the destination.
*/
static void
om_fill(int planemask, int rop, uint8_t *dstptr, int dstbitoffs, int dstspan,
uint32_t val, int width, int height)
{
uint32_t mask;
uint32_t prev_mask;
int32_t height_m1;
int dw; /* 1 pass width bits */
ASSUME(width > 0);
ASSUME(height > 0);
ASSUME(0 <= dstbitoffs && dstbitoffs < 32);
om_set_planemask(planemask);
height_m1 = height - 1;
mask = ALL1BITS >> dstbitoffs;
prev_mask = ~mask;
dw = 32 - dstbitoffs;
/* do-while loop seems slightly faster than a for loop */
do {
uint8_t *d;
int32_t h;
width -= dw;
if (width < 0) {
CLEAR_LOWER_BITS(mask, -width);
/* To exit this loop. */
width = 0;
}
if (prev_mask != mask) {
om_set_rop_curplane(rop, mask);
prev_mask = mask;
}
d = dstptr;
dstptr += 4;
h = height_m1;
#if USE_M68K_ASM
asm volatile("\n"
"om_fill_loop_h:\n"
" move.l %[val],(%[d]) ;\n"
" add.l %[dstspan],%[d] ;\n"
" dbra %[h],om_fill_loop_h ;\n"
: /* output */
[d] "+&a" (d),
[h] "+&d" (h)
: /* input */
[val] "d" (val),
[dstspan] "r" (dstspan)
: /* clobbers */
"memory"
);
#else
do {
*(uint32_t *)d = val;
d += dstspan;
} while (--h >= 0);
#endif
mask = ALL1BITS;
dw = 32;
} while (width > 0);
}
static void
om_fill_color(int planecount, int color, uint8_t *dstptr, int dstbitoffs,
int dstspan, int width, int height)
{
uint32_t mask;
uint32_t prev_mask;
int32_t height_m1;
int dw; /* 1 pass width bits */
ASSUME(width > 0);
ASSUME(height > 0);
ASSUME(planecount > 0);
/* select all planes */
om_set_planemask(hwplanemask);
mask = ALL1BITS >> dstbitoffs;
prev_mask = ~mask;
dw = 32 - dstbitoffs;
height_m1 = height - 1;
do {
uint8_t *d;
int32_t plane;
int32_t h;
int16_t rop;
width -= dw;
if (width < 0) {
CLEAR_LOWER_BITS(mask, -width);
/* To exit this loop. */
width = 0;
}
if (prev_mask != mask) {
for (plane = 0; plane < planecount; plane++) {
if ((color & (1U << plane)) != 0)
rop = ROP_ONE;
else
rop = ROP_ZERO;
om_set_rop(plane, rop, mask);
}
prev_mask = mask;
}
d = dstptr;
dstptr += 4;
h = height_m1;
#if USE_M68K_ASM
asm volatile("\n"
"om_fill_color_loop_h:\n"
" clr.l (%[d]) ;\n"
" add.l %[dstspan],%[d] ;\n"
" dbra %[h],om_fill_color_loop_h ;\n"
: /* output */
[d] "+&a" (d),
[h] "+&d" (h)
: /* input */
[dstspan] "r" (dstspan)
: /* clobbers */
"memory"
);
#else
do {
/*
* ROP is either ONE or ZERO,
* so don't care what you write to *d.
*/
*(uint32_t *)d = 0;
d += dstspan;
} while (--h >= 0);
#endif
mask = ALL1BITS;
dw = 32;
} while (width > 0);
}
/*
* Calculate ROP depending on fg/bg color combination as follows.
* This is called per individual plane while shifting fg and bg.
* So the LSB of fg and bg points to this plane.
*
* All ROP values we want to use here happens to be a multiple of 5.
*
* bg fg rop result
* -- -- ---------------- ------
* 0 0 ROP_ZERO = 0 0
* 0 1 ROP_THROUGH = 5 D
* 1 0 ROP_INV1 = 10 ~D
* 1 1 ROP_ONE = 15 1
*
* This allows characters to be drawn in the specified fg/bg colors with
* a single write to the common plane.
*/
static inline int
om_fgbg2rop(uint8_t fg, uint8_t bg)
{
int t;
t = (bg & 1) * 2 + (fg & 1);
return t * 5;
}
/*
* Blit a character at the specified co-ordinates.
* This function modifies(breaks) the planemask and ROPs.
*/
static void
om_putchar(void *cookie, int row, int startcol, u_int uc, long attr)
{
struct rasops_info *ri = cookie;
uint8_t *fontptr;
uint8_t *dstcmn;
uint32_t mask;
int width;
int height;
int planecount;
int x, y;
int fontstride;
int fontx;
int plane;
int dw; /* 1 pass width bits */
int xh, xl;
uint8_t fg, bg;
/* ROP address cache */
static volatile uint32_t *ropaddr[OMFB_MAX_PLANECOUNT];
static uint8_t last_fg, last_bg;
if (uc >= 0x80)
return;
width = ri->ri_font->fontwidth;
height = ri->ri_font->fontheight;
planecount = ri->ri_depth;
fontstride = ri->ri_font->stride;
y = height * row;
x = width * startcol;
fontptr = (uint8_t *)ri->ri_font->data +
(uc - ri->ri_font->firstchar) * ri->ri_fontscale;
om_unpack_attr(attr, &fg, &bg, NULL);
om_set_rowattr(row, fg, bg);
if (last_fg != fg || last_bg != bg) {
last_fg = fg;
last_bg = bg;
/* calculate ROP */
for (plane = 0; plane < planecount; plane++) {
int t = om_fgbg2rop(fg, bg);
ropaddr[plane] = om_rop_addr(plane, t);
fg >>= 1;
bg >>= 1;
}
}
/* divide x into the lower 5 bits and the rest. */
xh = x >> 5;
xl = x & 0x1f;
/* write to common plane */
dstcmn = (uint8_t *)ri->ri_bits + xh * 4 + y * OMFB_STRIDE;
/* select all plane */
om_set_planemask(hwplanemask);
fontx = 0;
mask = ALL1BITS >> xl;
dw = 32 - xl;
ASSUME(planecount == 1 ||
planecount == 4 ||
planecount == 8);
do {
uint8_t *d;
uint8_t *f;
int32_t h;
width -= dw;
if (width < 0) {
CLEAR_LOWER_BITS(mask, -width);
/* To exit this loop. */
width = 0;
}
switch (planecount) {
case 8:
*(ropaddr[7]) = mask;
*(ropaddr[6]) = mask;
*(ropaddr[5]) = mask;
*(ropaddr[4]) = mask;
/* FALLTHROUGH */
case 4:
*(ropaddr[3]) = mask;
*(ropaddr[2]) = mask;
*(ropaddr[1]) = mask;
/* FALLTHROUGH */
case 1:
*(ropaddr[0]) = mask;
break;
}
d = dstcmn;
f = fontptr;
h = height - 1;
do {
uint32_t v;
GETBITS(f, fontx, dw, v);
/* no need to shift v because it's masked by ROP */
*(uint32_t *)d = v;
d += OMFB_STRIDE;
f += fontstride;
} while (--h >= 0);
dstcmn += 4;
fontx += dw;
mask = ALL1BITS;
dw = 32;
} while (width > 0);
om_reset_planemask_and_rop();
}
static void
om_erasecols(void *cookie, int row, int startcol, int ncols, long attr)
{
struct rasops_info *ri = cookie;
int startx;
int width;
int height;
int planecount;
int sh, sl;
int y;
int scanspan;
uint8_t *p;
uint8_t fg, bg;
scanspan = ri->ri_stride;
y = ri->ri_font->fontheight * row;
startx = ri->ri_font->fontwidth * startcol;
width = ri->ri_font->fontwidth * ncols;
height = ri->ri_font->fontheight;
planecount = ri->ri_depth;
om_unpack_attr(attr, &fg, &bg, NULL);
sh = startx >> 5;
sl = startx & 0x1f;
p = (uint8_t *)ri->ri_bits + y * scanspan + sh * 4;
/* I'm not sure */
om_set_rowattr(row, fg, bg);
if (bg == 0) {
/* om_fill seems slightly efficient */
om_fill(hwplanemask, ROP_ZERO,
p, sl, scanspan, 0, width, height);
} else {
om_fill_color(planecount, bg, p, sl, scanspan, width, height);
}
/* reset mask value */
om_reset_planemask_and_rop();
}
static void
om_eraserows(void *cookie, int startrow, int nrows, long attr)
{
struct rasops_info *ri = cookie;
int startx;
int width;
int height;
int planecount;
int sh, sl;
int y;
int scanspan;
int row;
uint8_t *p;
uint8_t fg, bg;
scanspan = ri->ri_stride;
y = ri->ri_font->fontheight * startrow;
startx = 0;
width = ri->ri_emuwidth;
height = ri->ri_font->fontheight * nrows;
planecount = ri->ri_depth;
om_unpack_attr(attr, &fg, &bg, NULL);
sh = startx >> 5;
sl = startx & 0x1f;
p = (uint8_t *)ri->ri_bits + y * scanspan + sh * 4;
for (row = startrow; row < startrow + nrows; row++) {
om_reset_rowattr(row, bg);
}
if (bg == 0) {
/* om_fill seems slightly efficient */
om_fill(hwplanemask, ROP_ZERO,
p, sl, scanspan, 0, width, height);
} else {
om_fill_color(planecount, bg, p, sl, scanspan, width, height);
}
/* reset mask value */
om_reset_planemask_and_rop();
}
/*
* Single plane raster copy.
* dst: destination plane pointer.
* src: source plane pointer.
* if y-forward, src > dst, point to left-top.
* if y-backward, src < dst, point to left-bottom.
* width: pixel width (must > 0)
* height: pixel height (> 0 if forward, < 0 if backward)
* rop: ROP array with planecount elements.
*
* This function modifies(breaks) the planemask and ROPs.
*/
static void
om_rascopy_single(int planecount, uint8_t *dst, uint8_t *src,
int16_t width, int16_t height, uint8_t rop[])
{
uint32_t mask;
int wh;
int wl;
int step;
int plane;
int16_t height_m1;
int16_t w, h;
step = OMFB_STRIDE;
/*
* X direction is always forward (or ascend order) to use (An)+
* addressing mode in asm.
*/
/* Reverse order Y if backward copy */
if (height < 0) {
/* The sign is managed by step, height is always positive */
step = -step;
height = -height;
}
height_m1 = height - 1;
/*
* On single, it's not necessary to process two longwords at a time,
* but we do so for symmetry and speedup.
*/
/* First, transfer a rectangle consist of two longwords */
wh = (width >> 6);
if (wh > 0) {
int step8 = step - wh * 8;
#if USE_M68K_ASM
wh--; /* for dbra */
h = height_m1;
asm volatile("\n"
"om_rascopy_single_LL:\n"
" move.w %[wh],%[w] ;\n"
"1:\n"
" move.l (%[src])+,(%[dst])+ ;\n"
" move.l (%[src])+,(%[dst])+ ;\n"
" dbra %[w],1b ;\n"
" adda.l %[step8],%[src] ;\n"
" adda.l %[step8],%[dst] ;\n"
" dbra %[h],om_rascopy_single_LL ;\n"
: /* output */
[src] "+&a" (src),
[dst] "+&a" (dst),
[h] "+&d" (h),
[w] "=&d" (w)
: /* input */
[wh] "r" (wh),
[step8] "r" (step8)
: /* clobbers */
"memory"
);
#else
wh--; /* to match to asm side */
for (h = height_m1; h >= 0; h--) {
uint32_t *s32 = (uint32_t *)src;
uint32_t *d32 = (uint32_t *)dst;
for (w = wh; w >= 0; w--) {
*d32++ = *s32++;
*d32++ = *s32++;
}
src = (uint8_t *)s32 + step8;
dst = (uint8_t *)d32 + step8;
}
#endif
if ((width & 0x3f) == 0) {
/* transfer completed */
return;
}
/* rewind y for the next transfer */
src -= height * step;
dst -= height * step;
}
if ((width & 32) != 0) {
/* Transfer one longword since an odd longword */
#if USE_M68K_ASM
h = height_m1;
asm volatile("\n"
"om_rascopy_single_L:\n"
" move.l (%[src]),(%[dst]) ;\n"
" adda.l %[step],%[src] ;\n"
" adda.l %[step],%[dst] ;\n"
" dbra %[h],om_rascopy_single_L ;\n"
: /* output */
[src] "+&a" (src),
[dst] "+&a" (dst),
[h] "+&d" (h)
: /* input */
[step] "r" (step)
: /* clobbers */
"memory"
);
#else
for (h = height_m1; h >= 0; h--) {
*(uint32_t *)dst = *(uint32_t *)src;
dst += step;
src += step;
}
#endif
if ((width & 0x1f) == 0) {
/* transfer completed */
return;
}
/* rewind y for the next transfer */
src += 4 - height * step;
dst += 4 - height * step;
}
wl = width & 0x1f;
/* wl > 0 at this point */
/* Then, transfer residual bits */
mask = ALL1BITS << (32 - wl);
/*
* The common ROP cannot be used here. Because the hardware doesn't
* allow you to set the mask while keeping the ROP states.
*/
for (plane = 0; plane < planecount; plane++) {
om_set_rop(plane, rop[plane], mask);
}
#if USE_M68K_ASM
h = height_m1;
asm volatile("\n"
"om_rascopy_single_bit:\n"
" move.l (%[src]),(%[dst]) ;\n"
" adda.l %[step],%[src] ;\n"
" adda.l %[step],%[dst] ;\n"
" dbra %[h],om_rascopy_single_bit ;\n"
: /* output */
[src] "+&a" (src),
[dst] "+&a" (dst),
[h] "+&d" (h)
: /* input */
[step] "r" (step)
: /* clobbers */
"memory"
);
#else
for (h = height_m1; h >= 0; h--) {
*(uint32_t *)dst = *(uint32_t *)src;
dst += step;
src += step;
}
#endif
for (plane = 0; plane < planecount; plane++) {
om_set_rop(plane, rop[plane], ALL1BITS);
}
}
/*
* Multiple plane raster copy.
* dst0: destination pointer in Plane0.
* src0: source pointer in Plane0.
* if y-forward, src0 > dst0, point to left-top.
* if y-backward, src0 < dst0, point to left-bottom.
* width: pixel width (must > 0)
* height: pixel height (> 0 if forward, < 0 if backward)
*
* This function modifies(breaks) the planemask and ROPs.
*/
static void
om4_rascopy_multi(uint8_t *dst0, uint8_t *src0, int16_t width, int16_t height)
{
uint8_t *dst1, *dst2, *dst3;
int wh;
int wl;
int rewind;
int step;
uint32_t mask;
int16_t height_m1;
int16_t w, h;
step = OMFB_STRIDE;
/*
* X direction is always forward (or ascend order) to use (An)+
* addressing mode in asm.
*/
/* Reverse order Y if backward copy */
if (height < 0) {
/* The sign is managed by step, height is always positive */
step = -step;
height = -height;
}
height_m1 = height - 1;
dst1 = dst0 + OMFB_PLANEOFFS;
dst2 = dst1 + OMFB_PLANEOFFS;
dst3 = dst2 + OMFB_PLANEOFFS;
/* First, transfer a rectangle consist of two longwords */
wh = width >> 6;
if (wh > 0) {
int step8 = step - wh * 8;
#if USE_M68K_ASM
wh--; /* for dbra */
h = height_m1;
asm volatile("\n"
"om4_rascopy_multi_LL:\n"
" move.w %[wh],%[w] ;\n"
"1:\n"
/*
* Optimized for 68030.
*
* On LUNA, the following is faster than any of
* "MOVE.L (An)+,(An)+", "MOVE.L (An,Dn),(An,Dn)", or
* "MOVEM.L", due to the relationship of instruction
* overlaps and access waits.
*
* The head time of (An)+ as source operand is 0 and
* the head time of ADDA instruction is 2. If the
* previous instruction has some write wait cycles,
* i.e., tail cycles, (An)+ as source operand cannot
* overlap it but ADDA instruction can.
*/
" move.l (%[src0]),(%[dst0])+ ;\n" /* P0 */
" adda.l %[PLANEOFFS],%[src0] ;\n"
" move.l (%[src0]),(%[dst1])+ ;\n" /* P1 */
" adda.l %[PLANEOFFS],%[src0] ;\n"
" move.l (%[src0]),(%[dst2])+ ;\n" /* P2 */
" adda.l %[PLANEOFFS],%[src0] ;\n"
" move.l (%[src0]),(%[dst3])+ ;\n" /* P3 */
/* Expect an overlap, so don't use (An)+ */
" addq.l #4,%[src0] ;\n"
" move.l (%[src0]),(%[dst3])+ ;\n" /* P3 */
" suba.l %[PLANEOFFS],%[src0] ;\n"
" move.l (%[src0]),(%[dst2])+ ;\n" /* P2 */
" suba.l %[PLANEOFFS],%[src0] ;\n"
" move.l (%[src0]),(%[dst1])+ ;\n" /* P1 */
" suba.l %[PLANEOFFS],%[src0] ;\n"
" move.l (%[src0])+,(%[dst0])+ ;\n" /* P0 */
" dbra %[w],1b ;\n"
" adda.l %[step8],%[src0] ;\n"
" adda.l %[step8],%[dst0] ;\n"
" adda.l %[step8],%[dst1] ;\n"
" adda.l %[step8],%[dst2] ;\n"
" adda.l %[step8],%[dst3] ;\n"
" dbra %[h],om4_rascopy_multi_LL ;\n"
: /* output */
[src0] "+&a" (src0),
[dst0] "+&a" (dst0),
[dst1] "+&a" (dst1),
[dst2] "+&a" (dst2),
[dst3] "+&a" (dst3),
[h] "+&d" (h),
[w] "=&d" (w)
: /* input */
[wh] "r" (wh),
[PLANEOFFS] "r" (OMFB_PLANEOFFS),
[step8] "r" (step8)
: /* clobbers */
"memory"
);
#else
wh--; /* to match to asm side */
for (h = height_m1; h >= 0; h--) {
for (w = wh; w >= 0; w--) {
*(uint32_t *)dst0 = *(uint32_t *)src0;
dst0 += 4;
src0 += OMFB_PLANEOFFS;
*(uint32_t *)dst1 = *(uint32_t *)src0;
dst1 += 4;
src0 += OMFB_PLANEOFFS;
*(uint32_t *)dst2 = *(uint32_t *)src0;
dst2 += 4;
src0 += OMFB_PLANEOFFS;
*(uint32_t *)dst3 = *(uint32_t *)src0;
dst3 += 4;
src0 += 4;
*(uint32_t *)dst3 = *(uint32_t *)src0;
dst3 += 4;
src0 -= OMFB_PLANEOFFS;
*(uint32_t *)dst2 = *(uint32_t *)src0;
dst2 += 4;
src0 -= OMFB_PLANEOFFS;
*(uint32_t *)dst1 = *(uint32_t *)src0;
dst1 += 4;
src0 -= OMFB_PLANEOFFS;
*(uint32_t *)dst0 = *(uint32_t *)src0;
dst0 += 4;
src0 += 4;
}
src0 += step8;
dst0 += step8;
dst1 += step8;
dst2 += step8;
dst3 += step8;
}
#endif
if ((width & 0x3f) == 0) {
/* transfer completed */
return;
}
/* rewind y for the next transfer */
src0 -= height * step;
dst0 -= height * step;
dst1 -= height * step;
dst2 -= height * step;
dst3 -= height * step;
}
/* This rewind rewinds the plane, so Y order is irrelevant */
rewind = OMFB_STRIDE - OMFB_PLANEOFFS * 3;
if ((width & 32) != 0) {
/* Transfer one longword since an odd longword */
#if USE_M68K_ASM
h = height_m1;
asm volatile("\n"
"om4_rascopy_multi_L:\n"
" move.l (%[src0]),(%[dst0]) ;\n"
" adda.l %[PLANEOFFS],%[src0] ;\n"
" move.l (%[src0]),(%[dst1]) ;\n"
" adda.l %[PLANEOFFS],%[src0] ;\n"
" move.l (%[src0]),(%[dst2]) ;\n"
" adda.l %[PLANEOFFS],%[src0] ;\n"
" move.l (%[src0]),(%[dst3]) ;\n"
" adda.l %[rewind],%[src0] ;\n"
" adda.l %[step],%[dst0] ;\n"
" adda.l %[step],%[dst1] ;\n"
" adda.l %[step],%[dst2] ;\n"
" adda.l %[step],%[dst3] ;\n"
" dbra %[h],om4_rascopy_multi_L ;\n"
: /* output */
[src0] "+&a" (src0),
[dst0] "+&a" (dst0),
[dst1] "+&a" (dst1),
[dst2] "+&a" (dst2),
[dst3] "+&a" (dst3),
[h] "+&d" (h)
: /* input */
[PLANEOFFS] "r" (OMFB_PLANEOFFS),
[rewind] "r" (rewind),
[step] "r" (step)
: /* clobbers */
"memory"
);
#else
for (h = height_m1; h >= 0; h--) {
*(uint32_t *)dst0 = *(uint32_t *)src0;
src0 += OMFB_PLANEOFFS;
*(uint32_t *)dst1 = *(uint32_t *)src0;
src0 += OMFB_PLANEOFFS;
*(uint32_t *)dst2 = *(uint32_t *)src0;
src0 += OMFB_PLANEOFFS;
*(uint32_t *)dst3 = *(uint32_t *)src0;
src0 += rewind;
dst0 += step;
dst1 += step;
dst2 += step;
dst3 += step;
}
#endif
if ((width & 0x1f) == 0) {
/* transfer completed */
return;
}
/* rewind y for the next transfer */
src0 += 4 - height * step;
dst0 += 4 - height * step;
dst1 += 4 - height * step;
dst2 += 4 - height * step;
dst3 += 4 - height * step;
}
wl = width & 0x1f;
/* wl > 0 at this point */
/* Then, transfer residual bits */
mask = ALL1BITS << (32 - wl);
om_set_planemask(hwplanemask);
om_set_rop_curplane(ROP_THROUGH, mask);
#if USE_M68K_ASM
h = height_m1;
asm volatile("\n"
"om4_rascopy_multi_bit:\n"
" move.l (%[src0]),(%[dst0]) ;\n"
" adda.l %[PLANEOFFS],%[src0] ;\n"
" move.l (%[src0]),(%[dst1]) ;\n"
" adda.l %[PLANEOFFS],%[src0] ;\n"
" move.l (%[src0]),(%[dst2]) ;\n"
" adda.l %[PLANEOFFS],%[src0] ;\n"
" move.l (%[src0]),(%[dst3]) ;\n"
" adda.l %[rewind],%[src0] ;\n"
" adda.l %[step],%[dst0] ;\n"
" adda.l %[step],%[dst1] ;\n"
" adda.l %[step],%[dst2] ;\n"
" adda.l %[step],%[dst3] ;\n"
" dbra %[h],om4_rascopy_multi_bit ;\n"
: /* output */
[src0] "+&a" (src0),
[dst0] "+&a" (dst0),
[dst1] "+&a" (dst1),
[dst2] "+&a" (dst2),
[dst3] "+&a" (dst3),
[h] "+&d" (h)
: /* input */
[PLANEOFFS] "r" (OMFB_PLANEOFFS),
[rewind] "r" (rewind),
[step] "r" (step)
: /* clobbers */
"memory"
);
#else
for (h = height_m1; h >= 0; h--) {
*(uint32_t *)dst0 = *(uint32_t *)src0;
src0 += OMFB_PLANEOFFS;
*(uint32_t *)dst1 = *(uint32_t *)src0;
src0 += OMFB_PLANEOFFS;
*(uint32_t *)dst2 = *(uint32_t *)src0;
src0 += OMFB_PLANEOFFS;
*(uint32_t *)dst3 = *(uint32_t *)src0;
src0 += rewind;
dst0 += step;
dst1 += step;
dst2 += step;
dst3 += step;
}
#endif
om_reset_planemask_and_rop();
}
static void
om1_copyrows(void *cookie, int srcrow, int dstrow, int nrows)
{
struct rasops_info *ri = cookie;
uint8_t *p, *q;
int scanspan, offset, srcy, height, width, w;
uint32_t rmask;
scanspan = ri->ri_stride;
height = ri->ri_font->fontheight * nrows;
offset = (dstrow - srcrow) * scanspan * ri->ri_font->fontheight;
srcy = ri->ri_font->fontheight * srcrow;
if (srcrow < dstrow && srcrow + nrows > dstrow) {
scanspan = -scanspan;
srcy = srcy + height - 1;
}
p = (uint8_t *)ri->ri_bits + srcy * ri->ri_stride;
w = ri->ri_emuwidth;
width = w;
rmask = ALL1BITS << (-width & ALIGNMASK);
q = p;
while (height > 0) {
*P0(p + offset) = *P0(p); /* always aligned */
width -= 2 * BLITWIDTH;
while (width > 0) {
p += BYTESDONE;
*P0(p + offset) = *P0(p);
width -= BLITWIDTH;
}
p += BYTESDONE;
*P0(p + offset) = (*P0(p) & rmask) | (*P0(p + offset) & ~rmask);
p = (q += scanspan);
width = w;
height--;
}
}
static void
om4_copyrows(void *cookie, int srcrow, int dstrow, int nrows)
{
struct rasops_info *ri = cookie;
uint8_t *src, *dst;
int width, rowheight;
int planecount;
int ptrstep, rowstep;
int srcplane;
int i;
int r;
uint8_t rop[OMFB_MAX_PLANECOUNT];
width = ri->ri_emuwidth;
rowheight = ri->ri_font->fontheight;
planecount = ri->ri_depth;
src = (uint8_t *)ri->ri_bits + srcrow * rowheight * ri->ri_stride;
dst = (uint8_t *)ri->ri_bits + dstrow * rowheight * ri->ri_stride;
if (nrows <= 0 || srcrow == dstrow) {
return;
} else if (srcrow < dstrow) {
/* y-backward */
/* select the bottom raster of the bottom row */
srcrow += nrows - 1;
dstrow += nrows - 1;
src += nrows * rowheight * ri->ri_stride - ri->ri_stride;
dst += nrows * rowheight * ri->ri_stride - ri->ri_stride;
rowstep = -1;
rowheight = -rowheight;
} else {
/* y-forward */
rowstep = 1;
}
ptrstep = ri->ri_stride * rowheight;
om_set_planemask(hwplanemask);
srcplane = 0;
while (nrows > 0) {
r = 1;
if (rowattr[srcrow].ismulti == false &&
rowattr[srcrow].fg == rowattr[srcrow].bg &&
rowattr[srcrow].all == rowattr[dstrow].all) {
goto skip;
}
/* count the number of rows with the same attributes */
for (; r < nrows; r++) {
if (rowattr[srcrow + r * rowstep].all !=
rowattr[srcrow].all) {
break;
}
}
/* r is the number of rows including srcrow itself */
if (rowattr[srcrow].ismulti) {
/*
* src,dst point to the common plane. src0,dst0 will
* point to the same offset in plane0 because plane0
* is placed just after the common plane.
*/
uint8_t *src0 = src + OMFB_PLANEOFFS;
uint8_t *dst0 = dst + OMFB_PLANEOFFS;
om_set_rop_curplane(ROP_THROUGH, ALL1BITS);
om4_rascopy_multi(dst0, src0, width, rowheight * r);
} else {
uint8_t *srcp;
uint8_t fg;
uint8_t bg;
uint8_t set;
fg = rowattr[srcrow].fg;
bg = rowattr[srcrow].bg;
set = fg ^ bg;
if (set == 0) {
/* use fg since both can be acceptable */
set = fg;
} else if ((set & fg) != 0) {
/*
* set is the set of bits that set in fg and
* cleared in bg.
*/
set &= fg;
} else {
/*
* otherwise, set is the set of bits that
* (probably) set in bg and cleared in fg.
*/
uint8_t tmp;
set &= bg;
/* and swap fg and bg */
tmp = fg;
fg = bg;
bg = tmp;
}
for (i = 0; i < planecount; i++) {
int t = om_fgbg2rop(fg, bg);
rop[i] = t;
om_set_rop(i, rop[i], ALL1BITS);
fg >>= 1;
bg >>= 1;
}
/*
* If any bit in 'set' is set, any of them can be used.
* If all bits in 'set' are cleared, use plane 0.
* srcplane is the plane that fg is set and bg is
* cleared.
*/
srcplane = (set != 0) ? (31 - __builtin_clz(set)) : 0;
srcp = src + OMFB_PLANEOFFS + srcplane * OMFB_PLANEOFFS;
om_rascopy_single(planecount, dst, srcp,
width, rowheight * r, rop);
}
skip:
for (i = 0; i < r; i++) {
rowattr[dstrow] = rowattr[srcrow];
srcrow += rowstep;
dstrow += rowstep;
src += ptrstep;
dst += ptrstep;
nrows--;
}
}
}
/*
* XXX om{1,4}_copycols can be merged, but these are not frequently executed
* and have low execution costs. So I'm putting it off for now.
*/
static void
om1_copycols(void *cookie, int startrow, int srccol, int dstcol, int ncols)
{
struct rasops_info *ri = cookie;
uint8_t *sp, *dp, *sq, *dq, *basep;
int scanspan, height, w, y, srcx, dstx;
int sb, eb, db, sboff, full, cnt, lnum, rnum;
uint32_t lmask, rmask, tmp;
bool sbover;
scanspan = ri->ri_stride;
y = ri->ri_font->fontheight * startrow;
srcx = ri->ri_font->fontwidth * srccol;
dstx = ri->ri_font->fontwidth * dstcol;
height = ri->ri_font->fontheight;
w = ri->ri_font->fontwidth * ncols;
basep = (uint8_t *)ri->ri_bits + y * scanspan;
sb = srcx & ALIGNMASK;
db = dstx & ALIGNMASK;
om_reset_planemask_and_rop();
if (db + w <= BLITWIDTH) {
/* Destination is contained within a single word */
sp = basep + (srcx / 32) * 4;
dp = basep + (dstx / 32) * 4;
while (height > 0) {
GETBITS(P0(sp), sb, w, tmp);
PUTBITS(tmp, db, w, P0(dp));
dp += scanspan;
sp += scanspan;
height--;
}
return;
}
lmask = (db == 0) ? 0 : ALL1BITS >> db;
eb = (db + w) & ALIGNMASK;
rmask = (eb == 0) ? 0 : ALL1BITS << (32 - eb);
lnum = (32 - db) & ALIGNMASK;
rnum = (dstx + w) & ALIGNMASK;
if (lmask != 0)
full = (w - (32 - db)) / 32;
else
full = w / 32;
sbover = (sb + lnum) >= 32;
if (dstcol < srccol || srccol + ncols < dstcol) {
/* copy forward (left-to-right) */
sp = basep + (srcx / 32) * 4;
dp = basep + (dstx / 32) * 4;
if (lmask != 0) {
sboff = sb + lnum;
if (sboff >= 32)
sboff -= 32;
} else {
sboff = sb;
}
sq = sp;
dq = dp;
while (height > 0) {
if (lmask != 0) {
GETBITS(P0(sp), sb, lnum, tmp);
PUTBITS(tmp, db, lnum, P0(dp));
dp += BYTESDONE;
if (sbover)
sp += BYTESDONE;
}
for (cnt = full; cnt; cnt--) {
GETBITS(P0(sp), sboff, 32, tmp);
*P0(dp) = tmp;
sp += BYTESDONE;
dp += BYTESDONE;
}
if (rmask != 0) {
GETBITS(P0(sp), sboff, rnum, tmp);
PUTBITS(tmp, 0, rnum, P0(dp));
}
sp = (sq += scanspan);
dp = (dq += scanspan);
height--;
}
} else {
/* copy backward (right-to-left) */
sp = basep + ((srcx + w) / 32) * 4;
dp = basep + ((dstx + w) / 32) * 4;
sboff = (srcx + w) & ALIGNMASK;
sboff -= rnum;
if (sboff < 0) {
sp -= BYTESDONE;
sboff += 32;
}
sq = sp;
dq = dp;
while (height > 0) {
if (rnum != 0) {
GETBITS(P0(sp), sboff, rnum, tmp);
PUTBITS(tmp, 0, rnum, P0(dp));
}
for (cnt = full; cnt; cnt--) {
sp -= BYTESDONE;
dp -= BYTESDONE;
GETBITS(P0(sp), sboff, 32, tmp);
*P0(dp) = tmp;
}
if (lmask != 0) {
if (sbover)
sp -= BYTESDONE;
dp -= BYTESDONE;
GETBITS(P0(sp), sb, lnum, tmp);
PUTBITS(tmp, db, lnum, P0(dp));
}
sp = (sq += scanspan);
dp = (dq += scanspan);
height--;
}
}
}
static void
om4_copycols(void *cookie, int startrow, int srccol, int dstcol, int ncols)
{
struct rasops_info *ri = cookie;
uint8_t *sp, *dp, *sq, *dq, *basep;
int scanspan, height, w, y, srcx, dstx;
int sb, eb, db, sboff, full, cnt, lnum, rnum;
uint32_t lmask, rmask, tmp;
bool sbover;
scanspan = ri->ri_stride;
y = ri->ri_font->fontheight * startrow;
srcx = ri->ri_font->fontwidth * srccol;
dstx = ri->ri_font->fontwidth * dstcol;
height = ri->ri_font->fontheight;
w = ri->ri_font->fontwidth * ncols;
basep = (uint8_t *)ri->ri_bits + y * scanspan;
sb = srcx & ALIGNMASK;
db = dstx & ALIGNMASK;
om_reset_planemask_and_rop();
if (db + w <= BLITWIDTH) {
/* Destination is contained within a single word */
sp = basep + (srcx / 32) * 4;
dp = basep + (dstx / 32) * 4;
while (height > 0) {
GETBITS(P0(sp), sb, w, tmp);
PUTBITS(tmp, db, w, P0(dp));
GETBITS(P1(sp), sb, w, tmp);
PUTBITS(tmp, db, w, P1(dp));
GETBITS(P2(sp), sb, w, tmp);
PUTBITS(tmp, db, w, P2(dp));
GETBITS(P3(sp), sb, w, tmp);
PUTBITS(tmp, db, w, P3(dp));
dp += scanspan;
sp += scanspan;
height--;
}
return;
}
lmask = (db == 0) ? 0 : ALL1BITS >> db;
eb = (db + w) & ALIGNMASK;
rmask = (eb == 0) ? 0 : ALL1BITS << (32 - eb);
lnum = (32 - db) & ALIGNMASK;
rnum = (dstx + w) & ALIGNMASK;
if (lmask != 0)
full = (w - (32 - db)) / 32;
else
full = w / 32;
sbover = (sb + lnum) >= 32;
if (dstcol < srccol || srccol + ncols < dstcol) {
/* copy forward (left-to-right) */
sp = basep + (srcx / 32) * 4;
dp = basep + (dstx / 32) * 4;
if (lmask != 0) {
sboff = sb + lnum;
if (sboff >= 32)
sboff -= 32;
} else {
sboff = sb;
}
sq = sp;
dq = dp;
while (height > 0) {
if (lmask != 0) {
GETBITS(P0(sp), sb, lnum, tmp);
PUTBITS(tmp, db, lnum, P0(dp));
GETBITS(P1(sp), sb, lnum, tmp);
PUTBITS(tmp, db, lnum, P1(dp));
GETBITS(P2(sp), sb, lnum, tmp);
PUTBITS(tmp, db, lnum, P2(dp));
GETBITS(P3(sp), sb, lnum, tmp);
PUTBITS(tmp, db, lnum, P3(dp));
dp += BYTESDONE;
if (sbover)
sp += BYTESDONE;
}
for (cnt = full; cnt; cnt--) {
GETBITS(P0(sp), sboff, 32, tmp);
*P0(dp) = tmp;
GETBITS(P1(sp), sboff, 32, tmp);
*P1(dp) = tmp;
GETBITS(P2(sp), sboff, 32, tmp);
*P2(dp) = tmp;
GETBITS(P3(sp), sboff, 32, tmp);
*P3(dp) = tmp;
sp += BYTESDONE;
dp += BYTESDONE;
}
if (rmask != 0) {
GETBITS(P0(sp), sboff, rnum, tmp);
PUTBITS(tmp, 0, rnum, P0(dp));
GETBITS(P1(sp), sboff, rnum, tmp);
PUTBITS(tmp, 0, rnum, P1(dp));
GETBITS(P2(sp), sboff, rnum, tmp);
PUTBITS(tmp, 0, rnum, P2(dp));
GETBITS(P3(sp), sboff, rnum, tmp);
PUTBITS(tmp, 0, rnum, P3(dp));
}
sp = (sq += scanspan);
dp = (dq += scanspan);
height--;
}
} else {
/* copy backward (right-to-left) */
sp = basep + ((srcx + w) / 32) * 4;
dp = basep + ((dstx + w) / 32) * 4;
sboff = (srcx + w) & ALIGNMASK;
sboff -= rnum;
if (sboff < 0) {
sp -= BYTESDONE;
sboff += 32;
}
sq = sp;
dq = dp;
while (height > 0) {
if (rnum != 0) {
GETBITS(P0(sp), sboff, rnum, tmp);
PUTBITS(tmp, 0, rnum, P0(dp));
GETBITS(P1(sp), sboff, rnum, tmp);
PUTBITS(tmp, 0, rnum, P1(dp));
GETBITS(P2(sp), sboff, rnum, tmp);
PUTBITS(tmp, 0, rnum, P2(dp));
GETBITS(P3(sp), sboff, rnum, tmp);
PUTBITS(tmp, 0, rnum, P3(dp));
}
for (cnt = full; cnt; cnt--) {
sp -= BYTESDONE;
dp -= BYTESDONE;
GETBITS(P0(sp), sboff, 32, tmp);
*P0(dp) = tmp;
GETBITS(P1(sp), sboff, 32, tmp);
*P1(dp) = tmp;
GETBITS(P2(sp), sboff, 32, tmp);
*P2(dp) = tmp;
GETBITS(P3(sp), sboff, 32, tmp);
*P3(dp) = tmp;
}
if (lmask != 0) {
if (sbover)
sp -= BYTESDONE;
dp -= BYTESDONE;
GETBITS(P0(sp), sb, lnum, tmp);
PUTBITS(tmp, db, lnum, P0(dp));
GETBITS(P1(sp), sb, lnum, tmp);
PUTBITS(tmp, db, lnum, P1(dp));
GETBITS(P2(sp), sb, lnum, tmp);
PUTBITS(tmp, db, lnum, P2(dp));
GETBITS(P3(sp), sb, lnum, tmp);
PUTBITS(tmp, db, lnum, P3(dp));
}
sp = (sq += scanspan);
dp = (dq += scanspan);
height--;
}
}
}
/*
* Map a character.
*/
static int
om_mapchar(void *cookie, int c, u_int *cp)
{
struct rasops_info *ri = cookie;
struct wsdisplay_font *wf = ri->ri_font;
if (wf->encoding != WSDISPLAY_FONTENC_ISO) {
c = wsfont_map_unichar(wf, c);
if (c < 0)
goto fail;
}
if (c < wf->firstchar || c >= (wf->firstchar + wf->numchars))
goto fail;
*cp = c;
return 5;
fail:
*cp = ' ';
return 0;
}
/*
* Position|{enable|disable} the cursor at the specified location.
*/
static void
om_cursor(void *cookie, int on, int row, int col)
{
struct rasops_info *ri = cookie;
int startx;
int width;
int height;
int sh, sl;
int y;
int scanspan;
uint8_t *p;
if (!on) {
/* make sure it's on */
if ((ri->ri_flg & RI_CURSOR) == 0)
return;
row = ri->ri_crow;
col = ri->ri_ccol;
} else {
/* unpaint the old copy. */
ri->ri_crow = row;
ri->ri_ccol = col;
}
scanspan = ri->ri_stride;
y = ri->ri_font->fontheight * row;
startx = ri->ri_font->fontwidth * col;
width = ri->ri_font->fontwidth;
height = ri->ri_font->fontheight;
sh = startx >> 5;
sl = startx & 0x1f;
p = (uint8_t *)ri->ri_bits + y * scanspan + sh * 4;
/* ROP_INV2 ignores data from MPU and inverts the current VRAM data */
om_fill(hwplanemask, ROP_INV2, p, sl, scanspan, 0, width, height);
ri->ri_flg ^= RI_CURSOR;
/* reset mask value */
om_reset_planemask_and_rop();
}
/*
* Allocate attribute. We just pack these into an integer.
*
* Attribute bitmap:
* b31: Multi color (used by copyrows)
* b30-18: 0 (reserved)
* b17: Underline (not supported yet)
* b16: Bold (or HILIT if 1bpp; not supported yet)
* b15-8: fg color code
* b7-0: bg color code
*/
#if 0
/*
* Future plan:
* Place fg and bg side by side in advance to reduce the computation cost
* at the time of ROP setting.
*
* bit: 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
* f7 b7 f6 b6 f5 b5 f4 b4 f3 b3 f2 b2 f1 b1 f0 b0
*
* In this form, use bit1..0 if 1bpp, use bit7..0 if 4bpp.
*/
#endif
static int
om_allocattr(void *cookie, int fg, int bg, int flags, long *attrp)
{
struct rasops_info *ri = cookie;
int planecount = ri->ri_depth;
uint32_t a;
uint16_t c;
a = 0;
c = 0;
if ((flags & WSATTR_BLINK) != 0)
return EINVAL;
if ((flags & WSATTR_WSCOLORS) == 0) {
fg = WSCOL_WHITE; /* maybe 7 or 1 */
bg = WSCOL_BLACK; /* maybe 0 */
}
if ((flags & WSATTR_REVERSE) != 0) {
int tmp;
tmp = fg;
fg = bg;
bg = tmp;
}
if ((flags & WSATTR_HILIT) != 0) {
if (planecount == 1) {
#if 0
a |= OMFB_ATTR_BOLD;
#else
return EINVAL;
#endif
} else if (fg < 8) {
fg += 8;
}
}
if ((flags & WSATTR_UNDERLINE) != 0) {
#if 0
a |= OMFB_ATTR_UNDERLINE;
#else
return EINVAL;
#endif
}
fg &= hwplanemask;
bg &= hwplanemask;
#if 0
int i;
for (i = 0; i < planecount; i++) {
c += c;
c += ((fg & 1) << 1) | (bg & 1);
fg >>= 1;
bg >>= 1;
}
#else
c = (fg << 8) | bg;
#endif
a |= c;
*attrp = a;
return 0;
}
static void
om_unpack_attr(long attr, uint8_t *fg, uint8_t *bg, int *underline)
{
uint8_t f, b;
f = (attr >> 8) & hwplanemask;
b = attr & hwplanemask;
if (fg)
*fg = f;
if (bg)
*bg = b;
}
/*
* Init subset of rasops(9) for omrasops.
*/
int
omrasops1_init(struct rasops_info *ri, int wantrows, int wantcols)
{
omrasops_init(ri, wantrows, wantcols);
/* fill our own emulops */
ri->ri_ops.cursor = om_cursor;
ri->ri_ops.mapchar = om_mapchar;
ri->ri_ops.putchar = om_putchar;
ri->ri_ops.copycols = om1_copycols;
ri->ri_ops.erasecols = om_erasecols;
ri->ri_ops.copyrows = om1_copyrows;
ri->ri_ops.eraserows = om_eraserows;
ri->ri_ops.allocattr = om_allocattr;
ri->ri_caps = WSSCREEN_REVERSE;
ri->ri_flg |= RI_CFGDONE;
return 0;
}
int
omrasops4_init(struct rasops_info *ri, int wantrows, int wantcols)
{
omrasops_init(ri, wantrows, wantcols);
/* fill our own emulops */
ri->ri_ops.cursor = om_cursor;
ri->ri_ops.mapchar = om_mapchar;
ri->ri_ops.putchar = om_putchar;
ri->ri_ops.copycols = om4_copycols;
ri->ri_ops.erasecols = om_erasecols;
ri->ri_ops.copyrows = om4_copyrows;
ri->ri_ops.eraserows = om_eraserows;
ri->ri_ops.allocattr = om_allocattr;
ri->ri_caps = WSSCREEN_HILIT | WSSCREEN_WSCOLORS | WSSCREEN_REVERSE;
ri->ri_flg |= RI_CFGDONE;
return 0;
}
static int
omrasops_init(struct rasops_info *ri, int wantrows, int wantcols)
{
int wsfcookie, bpp;
if (wantrows > OMRASOPS_MAX_ROWS)
wantrows = OMRASOPS_MAX_ROWS;
if (wantrows == 0)
wantrows = 34;
if (wantrows < 10)
wantrows = 10;
if (wantcols == 0)
wantcols = 80;
if (wantcols < 20)
wantcols = 20;
/* Use default font */
wsfont_init();
wsfcookie = wsfont_find(NULL, 0, 0, 0, WSDISPLAY_FONTORDER_L2R,
WSDISPLAY_FONTORDER_L2R, WSFONT_FIND_BITMAP);
if (wsfcookie < 0)
panic("%s: no font available", __func__);
if (wsfont_lock(wsfcookie, &ri->ri_font))
panic("%s: unable to lock font", __func__);
ri->ri_wsfcookie = wsfcookie;
KASSERT(ri->ri_font->fontwidth > 4 && ri->ri_font->fontwidth <= 32);
/* all planes are independently addressed */
bpp = 1;
/* Now constrain what they get */
ri->ri_emuwidth = ri->ri_font->fontwidth * wantcols;
ri->ri_emuheight = ri->ri_font->fontheight * wantrows;
if (ri->ri_emuwidth > ri->ri_width)
ri->ri_emuwidth = ri->ri_width;
if (ri->ri_emuheight > ri->ri_height)
ri->ri_emuheight = ri->ri_height;
/* Reduce width until aligned on a 32-bit boundary */
while ((ri->ri_emuwidth * bpp & 31) != 0)
ri->ri_emuwidth--;
ri->ri_cols = ri->ri_emuwidth / ri->ri_font->fontwidth;
ri->ri_rows = ri->ri_emuheight / ri->ri_font->fontheight;
ri->ri_emustride = ri->ri_emuwidth * bpp >> 3;
ri->ri_ccol = 0;
ri->ri_crow = 0;
ri->ri_pelbytes = bpp >> 3;
ri->ri_xscale = (ri->ri_font->fontwidth * bpp) >> 3;
ri->ri_yscale = ri->ri_font->fontheight * ri->ri_stride;
ri->ri_fontscale = ri->ri_font->fontheight * ri->ri_font->stride;
/* Clear the entire display */
if ((ri->ri_flg & RI_CLEAR) != 0)
memset(ri->ri_bits, 0, ri->ri_stride * ri->ri_height);
/* Now centre our window if needs be */
ri->ri_origbits = ri->ri_bits;
if ((ri->ri_flg & RI_CENTER) != 0) {
ri->ri_bits += (((ri->ri_width * bpp >> 3) -
ri->ri_emustride) >> 1) & ~3;
ri->ri_bits += ((ri->ri_height - ri->ri_emuheight) >> 1) *
ri->ri_stride;
ri->ri_yorigin = (int)(ri->ri_bits - ri->ri_origbits)
/ ri->ri_stride;
ri->ri_xorigin = (((int)(ri->ri_bits - ri->ri_origbits)
% ri->ri_stride) * 8 / bpp);
} else
ri->ri_xorigin = ri->ri_yorigin = 0;
return 0;
}