static void leo_clear(struct vc_data *conp, struct display *p, int sy, int sx,
int height, int width)
{
struct fb_info_sbusfb *fb = (struct fb_info_sbusfb *)p->fb_info;
register struct leo_lc_ss0_usr *us = fb->s.leo.lc_ss0_usr;
register struct leo_ld *ss = (struct leo_ld *) fb->s.leo.ld_ss0;
unsigned long flags;
int x, y, w, h;
int i;
spin_lock_irqsave(&fb->lock, flags);
do {
i = sbus_readl(&us->csr);
} while (i & 0x20000000);
sbus_writel((attr_bgcol_ec(p,conp)<<24), &ss->fg);
if (fontheightlog(p)) {
y = sy << fontheightlog(p); h = height << fontheightlog(p);
} else {
y = sy * fontheight(p); h = height * fontheight(p);
}
if (fontwidthlog(p)) {
x = sx << fontwidthlog(p); w = width << fontwidthlog(p);
} else {
x = sx * fontwidth(p); w = width * fontwidth(p);
}
sbus_writel((w - 1) | ((h - 1) << 11), &us->extent);
sbus_writel((x + fb->x_margin) | ((y + fb->y_margin) << 11) | 0x80000000,
&us->fill);
spin_unlock_irqrestore(&fb->lock, flags);
}
static int sun3fbcon_switch(int con, struct fb_info *info)
{
int x_margin, y_margin;
struct fb_info_sbusfb *fb = sbusfbinfo(info);
int lastconsole;
/* Do we have to save the colormap? */
if (fb_display[info->currcon].cmap.len)
fb_get_cmap(&fb_display[info->currcon].cmap, 1, sun3fb_getcolreg, info);
if (info->display_fg) {
lastconsole = info->display_fg->vc_num;
if (lastconsole != con &&
(fontwidth(&fb_display[lastconsole]) != fontwidth(&fb_display[con]) ||
fontheight(&fb_display[lastconsole]) != fontheight(&fb_display[con])))
fb->cursor.mode |= CURSOR_SHAPE;
}
x_margin = (fb_display[con].var.xres_virtual - fb_display[con].var.xres) / 2;
y_margin = (fb_display[con].var.yres_virtual - fb_display[con].var.yres) / 2;
if (fb->margins)
fb->margins(fb, &fb_display[con], x_margin, y_margin);
if (fb->graphmode || fb->x_margin != x_margin || fb->y_margin != y_margin) {
fb->x_margin = x_margin; fb->y_margin = y_margin;
sun3fb_clear_margin(&fb_display[con], 0);
}
info->currcon = con;
/* Install new colormap */
do_install_cmap(con, info);
return 0;
}
static void ffb_clear(struct vc_data *conp, struct display *p, int sy, int sx,
int height, int width)
{
struct fb_info_sbusfb *fb = (struct fb_info_sbusfb *)p->fb_info;
register struct ffb_fbc *fbc = fb->s.ffb.fbc;
unsigned long flags;
u64 yx, hw;
int fg;
spin_lock_irqsave(&fb->lock, flags);
fg = ((u32 *)p->dispsw_data)[attr_bgcol_ec(p,conp)];
if (fg != fb->s.ffb.fg_cache) {
FFBFifo(fb, 5);
upa_writel(fg, &fbc->fg);
fb->s.ffb.fg_cache = fg;
} else
FFBFifo(fb, 4);
if (fontheightlog(p)) {
yx = (u64)sy << (fontheightlog(p) + 32); hw = (u64)height << (fontheightlog(p) + 32);
} else {
yx = (u64)(sy * fontheight(p)) << 32; hw = (u64)(height * fontheight(p)) << 32;
}
if (fontwidthlog(p)) {
yx += sx << fontwidthlog(p); hw += width << fontwidthlog(p);
} else {
yx += sx * fontwidth(p); hw += width * fontwidth(p);
}
upa_writeq(yx + fb->s.ffb.yx_margin, &fbc->by);
upa_writeq(hw, &fbc->bh);
spin_unlock_irqrestore(&fb->lock, flags);
}
static void i810_accel_bmove(struct display *p, int sy, int sx,
int dy, int dx, int height, int width)
{
struct blit_data rect;
int depth;
if (i810_accel->lockup || not_safe())
return;
rect.rop = PAT_COPY_ROP;
dy *= fontheight(p);
sy *= fontheight(p);
rect.dheight = height * fontheight(p);
depth = (p->var.bits_per_pixel + 7) >> 3;
switch (depth) {
case 1:
rect.blit_bpp = BPP8;
break;
case 2:
rect.blit_bpp = BPP16;
break;
case 3:
rect.blit_bpp = BPP24;
break;
}
sx *= fontwidth(p) * depth;
dx *= fontwidth(p) * depth;
rect.dwidth = width * fontwidth(p) * depth;
if (dx <= sx)
rect.xdir = INCREMENT;
else {
rect.xdir = DECREMENT;
sx += rect.dwidth - 1;
dx += rect.dwidth - 1;
}
if (dy <= sy)
rect.dpitch = p->next_line;
else {
rect.dpitch = (-(p->next_line)) & 0xFFFF;
sy += rect.dheight - 1;
dy += rect.dheight - 1;
}
rect.spitch = rect.dpitch;
rect.s_addr[0] = (i810_accel->fb_offset << 12) + (sy * p->next_line) + sx;
rect.d_addr = (i810_accel->fb_offset << 12) + (dy * p->next_line) + dx;
source_copy_blit(&rect);
}
static void fbcon_riva1632_revc(struct display *p, int xx, int yy)
{
struct rivafb_info *rinfo = (struct rivafb_info *) (p->fb_info);
xx *= fontwidth(p);
yy *= fontheight(p);
RIVA_FIFO_FREE(rinfo->riva, Rop, 1);
rinfo->riva.Rop->Rop3 = 0x66; // XOR
riva_rectfill(rinfo, yy, xx, fontheight(p), fontwidth(p), 0xffffffff);
RIVA_FIFO_FREE(rinfo->riva, Rop, 1);
rinfo->riva.Rop->Rop3 = 0xCC; // back to COPY
}
static void ffb_putc(struct vc_data *conp, struct display *p, int c, int yy, int xx)
{
struct fb_info_sbusfb *fb = (struct fb_info_sbusfb *)p->fb_info;
register struct ffb_fbc *fbc = fb->s.ffb.fbc;
unsigned long flags;
int i, xy;
u8 *fd;
u64 fgbg;
spin_lock_irqsave(&fb->lock, flags);
if (fontheightlog(p)) {
xy = (yy << (16 + fontheightlog(p)));
i = ((c & p->charmask) << fontheightlog(p));
} else {
xy = ((yy * fontheight(p)) << 16);
i = (c & p->charmask) * fontheight(p);
}
if (fontwidth(p) <= 8)
fd = p->fontdata + i;
else
fd = p->fontdata + (i << 1);
if (fontwidthlog(p))
xy += (xx << fontwidthlog(p)) + fb->s.ffb.xy_margin;
else
xy += (xx * fontwidth(p)) + fb->s.ffb.xy_margin;
fgbg = (((u64)(((u32 *)p->dispsw_data)[attr_fgcol(p,c)])) << 32) |
((u32 *)p->dispsw_data)[attr_bgcol(p,c)];
if (fgbg != *(u64 *)&fb->s.ffb.fg_cache) {
FFBFifo(fb, 2);
upa_writeq(fgbg, &fbc->fg);
*(u64 *)&fb->s.ffb.fg_cache = fgbg;
}
FFBFifo(fb, 2 + fontheight(p));
upa_writel(xy, &fbc->fontxy);
upa_writel(fontwidth(p), &fbc->fontw);
if (fontwidth(p) <= 8) {
for (i = 0; i < fontheight(p); i++) {
u32 val = *fd++ << 24;
upa_writel(val, &fbc->font);
}
} else {
for (i = 0; i < fontheight(p); i++) {
u32 val = *(u16 *)fd << 16;
upa_writel(val, &fbc->font);
fd += 2;
}
}
spin_unlock_irqrestore(&fb->lock, flags);
}
static void leo_putc(struct vc_data *conp, struct display *p, int c, int yy, int xx)
{
struct fb_info_sbusfb *fb = (struct fb_info_sbusfb *)p->fb_info;
register struct leo_lc_ss0_usr *us = fb->s.leo.lc_ss0_usr;
register struct leo_ld *ss = (struct leo_ld *) fb->s.leo.ld_ss0;
unsigned long flags;
int i, x, y;
u8 *fd;
u32 *u;
spin_lock_irqsave(&fb->lock, flags);
if (fontheightlog(p)) {
y = yy << (fontheightlog(p) + 11);
i = (c & p->charmask) << fontheightlog(p);
} else {
y = (yy * fontheight(p)) << 11;
i = (c & p->charmask) * fontheight(p);
}
if (fontwidth(p) <= 8)
fd = p->fontdata + i;
else
fd = p->fontdata + (i << 1);
if (fontwidthlog(p))
x = xx << fontwidthlog(p);
else
x = xx * fontwidth(p);
do {
i = sbus_readl(&us->csr);
} while (i & 0x20000000);
sbus_writel(attr_fgcol(p,c) << 24, &ss->fg);
sbus_writel(attr_bgcol(p,c) << 24, &ss->bg);
sbus_writel(0xFFFFFFFF<<(32-fontwidth(p)),
&us->fontmsk);
u = ((u32 *)p->screen_base) + y + x;
if (fontwidth(p) <= 8) {
for (i = 0; i < fontheight(p); i++, u += 2048) {
u32 val = *fd++ << 24;
sbus_writel(val, u);
}
} else {
for (i = 0; i < fontheight(p); i++, u += 2048) {
u32 val = *(u16 *)fd << 16;
sbus_writel(val, u);
fd += 2;
}
}
spin_unlock_irqrestore(&fb->lock, flags);
}
static void fbcon_riva32_clear(struct vc_data *conp, struct display *p, int sy,
int sx, int height, int width)
{
u32 bgx;
struct rivafb_info *rinfo = (struct rivafb_info *)(p->fb_info);
bgx = ((u_int32_t*)p->dispsw_data)[attr_bgcol_ec(p, conp)];
sx *= fontwidth(p);
sy *= fontheight(p);
width *= fontwidth(p);
height *= fontheight(p);
riva_rectfill(rinfo, sy, sx, height, width, bgx);
}
static void aafbcon_cursor(struct display *disp, int mode, int x, int y)
{
struct aafb_info *info = (struct aafb_info *)disp->fb_info;
struct aafb_cursor *c = &info->cursor;
x *= fontwidth(disp);
y *= fontheight(disp);
if (c->x == x && c->y == y && (mode == CM_ERASE) == !c->enable)
return;
c->enable = 0;
if (c->on)
aafb_set_cursor(info, 0);
c->x = x - disp->var.xoffset;
c->y = y - disp->var.yoffset;
switch (mode) {
case CM_ERASE:
c->on = 0;
break;
case CM_DRAW:
case CM_MOVE:
if (c->on)
aafb_set_cursor(info, c->on);
else
c->vbl_cnt = CURSOR_DRAW_DELAY;
c->enable = 1;
break;
}
}
static void aafb_set_disp(struct display *disp, int con,
struct aafb_info *info)
{
struct fb_fix_screeninfo fix;
disp->fb_info = &info->info;
aafb_set_var(&disp->var, con, &info->info);
if (disp->conp && disp->conp->vc_sw && disp->conp->vc_sw->con_cursor)
disp->conp->vc_sw->con_cursor(disp->conp, CM_ERASE);
disp->dispsw = &aafb_switch8;
disp->dispsw_data = 0;
aafb_get_fix(&fix, con, &info->info);
disp->screen_base = (u8 *) fix.smem_start;
disp->visual = fix.visual;
disp->type = fix.type;
disp->type_aux = fix.type_aux;
disp->ypanstep = fix.ypanstep;
disp->ywrapstep = fix.ywrapstep;
disp->line_length = fix.line_length;
disp->next_line = 2048;
disp->can_soft_blank = 1;
disp->inverse = 0;
disp->scrollmode = SCROLL_YREDRAW;
aafbcon_set_font(disp, fontwidth(disp), fontheight(disp));
}
static void fbcon_riva_bmove(struct display *p, int sy, int sx, int dy, int dx,
int height, int width)
{
struct rivafb_info *rinfo = (struct rivafb_info *)(p->fb_info);
sx *= fontwidth(p);
sy *= fontheight(p);
dx *= fontwidth(p);
dy *= fontheight(p);
width *= fontwidth(p);
height *= fontheight(p);
RIVA_FIFO_FREE(rinfo->riva, Blt, 3);
rinfo->riva.Blt->TopLeftSrc = (sy << 16) | sx;
rinfo->riva.Blt->TopLeftDst = (dy << 16) | dx;
rinfo->riva.Blt->WidthHeight = (height << 16) | width;
wait_for_idle(rinfo);
}
static void fbcon_riva32_putcs(struct vc_data *conp, struct display *p,
const unsigned short *s, int count, int yy,
int xx)
{
u16 c;
u32 fgx,bgx;
xx *= fontwidth(p);
yy *= fontheight(p);
c = scr_readw(s);
fgx = ((u32 *)p->dispsw_data)[attr_fgcol(p, c)];
bgx = ((u32 *)p->dispsw_data)[attr_bgcol(p, c)];
while (count--) {
c = scr_readw(s++);
fbcon_riva_writechr(conp, p, c, fgx, bgx, yy, xx);
xx += fontwidth(p);
}
}
static void
cyber2000_accel_bmove(struct display *p, int sy, int sx, int dy, int dx,
int height, int width)
{
struct cfb_info *cfb = (struct cfb_info *)p->fb_info;
struct fb_var_screeninfo *var = &p->fb_info->var;
u_long src, dst;
u_int fh, fw;
int cmd = CO_CMD_L_PATTERN_FGCOL;
fw = fontwidth(p);
sx *= fw;
dx *= fw;
width *= fw;
width -= 1;
if (sx < dx) {
sx += width;
dx += width;
cmd |= CO_CMD_L_INC_LEFT;
}
fh = fontheight(p);
sy *= fh;
dy *= fh;
height *= fh;
height -= 1;
if (sy < dy) {
sy += height;
dy += height;
cmd |= CO_CMD_L_INC_UP;
}
src = sx + sy * var->xres_virtual;
dst = dx + dy * var->xres_virtual;
cyber2000_accel_wait(cfb);
cyber2000fb_writeb(0x00, CO_REG_CONTROL, cfb);
cyber2000fb_writeb(0x03, CO_REG_FORE_MIX, cfb);
cyber2000fb_writew(width, CO_REG_WIDTH, cfb);
if (var->bits_per_pixel != 24) {
cyber2000fb_writel(dst, CO_REG_DEST_PTR, cfb);
cyber2000fb_writel(src, CO_REG_SRC_PTR, cfb);
} else {
cyber2000fb_writel(dst * 3, CO_REG_DEST_PTR, cfb);
cyber2000fb_writeb(dst, CO_REG_X_PHASE, cfb);
cyber2000fb_writel(src * 3, CO_REG_SRC_PTR, cfb);
}
cyber2000fb_writew(height, CO_REG_HEIGHT, cfb);
cyber2000fb_writew(cmd, CO_REG_CMD_L, cfb);
cyber2000fb_writew(0x2800, CO_REG_CMD_H, cfb);
}
static void fbcon_riva32_putc(struct vc_data *conp, struct display *p, int c,
int yy, int xx)
{
u32 fgx,bgx;
fgx = ((u32 *)p->dispsw_data)[attr_fgcol(p,c)];
bgx = ((u32 *)p->dispsw_data)[attr_bgcol(p,c)];
xx *= fontwidth(p);
yy *= fontheight(p);
fbcon_riva_writechr(conp, p, c, fgx, bgx, yy, xx);
}
static void fbcon_aty_bmove(struct display *p, int sy, int sx, int dy, int dx,
int height, int width)
{
#ifdef __sparc__
struct fb_info_aty *fb = (struct fb_info_aty *)(p->fb_info);
if (fb->mmaped && (!fb->fb_info.display_fg
|| fb->fb_info.display_fg->vc_num == fb->vtconsole))
return;
#endif
sx *= fontwidth(p);
sy *= fontheight(p);
dx *= fontwidth(p);
dy *= fontheight(p);
width *= fontwidth(p);
height *= fontheight(p);
aty_rectcopy(sx, sy, dx, dy, width, height,
(struct fb_info_aty *)p->fb_info);
}
static void fbcon_riva16_putcs(struct vc_data *conp, struct display *p,
const unsigned short *s, int count, int yy,
int xx)
{
u16 c;
u32 fgx,bgx;
xx *= fontwidth(p);
yy *= fontheight(p);
c = scr_readw(s);
fgx = ((u16 *)p->dispsw_data)[attr_fgcol(p, c)];
bgx = ((u16 *)p->dispsw_data)[attr_bgcol(p, c)];
if (p->var.green.length == 6)
convert_bgcolor_16(&bgx);
while (count--) {
c = scr_readw(s++);
fbcon_riva_writechr(conp, p, c, fgx, bgx, yy, xx);
xx += fontwidth(p);
}
}
void psAxesBBox(
float x, float y, float width, float height,
char *labelFont, float labelSize,
char *titleFont, float titleSize,
int style, int bbox[])
/*
FUNCTION: estimate bounding box for an axes box drawn via psAxesBox
PARAMETERS:
x i x coordinate of lower left corner of box
y i y coordinate of lower left corner of box
width i width of box
height i height of box
labelFont i name of font to use for axes labels
labelSize i size of font to use for axes labels
titleFont i name of font to use for title
titleSize i size of font to use for title
style i NORMAL (axis 1 on bottom, axis 2 on left)
SEISMIC (axis 1 on left, axis 2 on top)
bbox o bounding box (bbox[0:3] = llx, lly, ulx, uly)
NOTES:
psAxesBBox uses font sizes to estimate the bounding box for
an axes box drawn with psAxesBox. To be on the safe side,
psAxesBBox overestimates.
psAxesBBox assumes that the axes labels and titles do not extend
beyond the corresponding edges of the axes box.
AUTHOR: Dave Hale, Colorado School of Mines, 06/27/89
MODIFIED: Ken Larner, Colorado School of Mines, 07/24/90
*/
{
float labelCH,labelCW,titleCH;
/* determine font dimensions */
labelCH = fontheight(labelFont,labelSize);
labelCW = fontwidth(labelFont,labelSize);
titleCH = fontheight(titleFont,titleSize);
/* determine bounding box */
if (style==NORMAL) {
bbox[0] = x-3.5*labelCW-labelCH;
bbox[1] = y-3.0*labelCH;
bbox[2] = x+width+3.0*labelCW;
bbox[3] = y+height+2.0*titleCH+labelCH;
} else {
bbox[0] = x-3.5*labelCW-labelCH;
bbox[1] = y-2.0*titleCH-labelCH;
bbox[2] = x+width+3.0*labelCW;
bbox[3] = y+height+3.0*labelCH;
}
}
static void i810_accel_clear(struct vc_data *conp, struct display *p,
int sy, int sx, int height, int width)
{
struct blit_data rect;
int depth;
if (i810_accel->lockup || not_safe())
return;
rect.dheight = height * fontheight(p);
sy *= fontheight(p);
depth = (p->var.bits_per_pixel + 7) >> 3;
switch(depth) {
case 1:
rect.fg = (u32) attr_bgcol_ec(p, conp);
rect.blit_bpp = BPP8;
break;
case 2:
rect.fg = (int) ((u16 *)p->dispsw_data)[attr_bgcol_ec(p, conp)];
rect.blit_bpp = BPP16;
break;
case 3:
rect.fg = ((int *)p->dispsw_data)[attr_bgcol_ec(p, conp)];
rect.blit_bpp = BPP24;
break;
}
sx *= fontwidth(p) * depth;
rect.dwidth = width * fontwidth(p) * depth;
rect.d_addr = (i810_accel->fb_offset << 12) +
(sy * p->next_line) + sx;
rect.rop = COLOR_COPY_ROP;
rect.dpitch = p->next_line;
color_blit(&rect);
}
static void fbcon_riva16_putc(struct vc_data *conp, struct display *p, int c,
int yy, int xx)
{
u32 fgx,bgx;
fgx = ((u16 *)p->dispsw_data)[attr_fgcol(p,c)];
bgx = ((u16 *)p->dispsw_data)[attr_bgcol(p,c)];
if (p->var.green.length == 6)
convert_bgcolor_16(&bgx);
xx *= fontwidth(p);
yy *= fontheight(p);
fbcon_riva_writechr(conp, p, c, fgx, bgx, yy, xx);
}
static void fbcon_aty_clear(struct vc_data *conp, struct display *p, int sy,
int sx, int height, int width)
{
u32 bgx;
#ifdef __sparc__
struct fb_info_aty *fb = (struct fb_info_aty *)(p->fb_info);
if (fb->mmaped && (!fb->fb_info.display_fg
|| fb->fb_info.display_fg->vc_num == fb->vtconsole))
return;
#endif
bgx = attr_bgcol_ec(p, conp);
bgx |= (bgx << 8);
bgx |= (bgx << 16);
sx *= fontwidth(p);
sy *= fontheight(p);
width *= fontwidth(p);
height *= fontheight(p);
aty_rectfill(sx, sy, width, height, bgx,
(struct fb_info_aty *)p->fb_info);
}
static void i810_accel_clear_margins(struct vc_data *conp, struct display *p,
int bottom_only)
{
struct blit_data rect;
int depth;
unsigned int right_start;
unsigned int bottom_start;
unsigned int right_width, bottom_height;
if (i810_accel->lockup || not_safe())
return;
depth = (p->var.bits_per_pixel + 7) >> 3;
switch(depth) {
case 1:
rect.fg = (u32) attr_bgcol_ec(p, conp);
rect.blit_bpp = BPP8;
break;
case 2:
rect.fg = (int) ((u16 *)p->dispsw_data)[attr_bgcol_ec(p, conp)];
rect.blit_bpp = BPP16;
break;
case 3:
rect.fg = ((int *)p->dispsw_data)[attr_bgcol_ec(p, conp)];
rect.blit_bpp = BPP24;
}
rect.rop = COLOR_COPY_ROP;
rect.dpitch = p->next_line;
right_width = p->var.xres % fontwidth(p);
right_start = p->var.xres - right_width;
if (!bottom_only && right_width) {
rect.dwidth = right_width * depth;
rect.dheight = p->var.yres_virtual;
rect.d_addr = (i810_accel->fb_offset << 12) + ((right_start + p->var.xoffset) * depth);
color_blit(&rect);
}
bottom_height = p->var.yres % fontheight(p);
if (bottom_height) {
bottom_start = p->var.yres - bottom_height;
rect.dwidth = right_start*depth;
rect.dheight = bottom_height;
rect.d_addr = (i810_accel->fb_offset << 12) + (p->var.yoffset + bottom_start) * rect.dpitch;
color_blit(&rect);
}
}
static void riva_clear_margins(struct vc_data *conp, struct display *p,
int bottom_only, u32 bgx)
{
struct rivafb_info *rinfo = (struct rivafb_info *)(p->fb_info);
unsigned int right_start = conp->vc_cols*fontwidth(p);
unsigned int bottom_start = conp->vc_rows*fontheight(p);
unsigned int right_width, bottom_width;
if (!bottom_only && (right_width = p->var.xres - right_start))
riva_rectfill(rinfo, 0, right_start, p->var.yres_virtual,
right_width, bgx);
if ((bottom_width = p->var.yres - bottom_start))
riva_rectfill(rinfo, p->var.yoffset + bottom_start, 0,
bottom_width, right_start, bgx);
}
static void fbcon_riva_writechr(struct vc_data *conp, struct display *p,
int c, int fgx, int bgx, int yy, int xx)
{
u8 *cdat;
struct rivafb_info *rinfo = (struct rivafb_info *)(p->fb_info);
int w, h;
volatile u32 *d;
u32 cdat2;
int i, j, cnt;
w = fontwidth(p);
h = fontheight(p);
if (w <= 8)
cdat = p->fontdata + (c & p->charmask) * h;
else
cdat = p->fontdata + ((c & p->charmask) * h << 1);
RIVA_FIFO_FREE(rinfo->riva, Bitmap, 7);
rinfo->riva.Bitmap->ClipE.TopLeft = (yy << 16) | (xx & 0xFFFF);
rinfo->riva.Bitmap->ClipE.BottomRight = ((yy+h) << 16) | ((xx+w) & 0xffff);
rinfo->riva.Bitmap->Color0E = bgx;
rinfo->riva.Bitmap->Color1E = fgx;
rinfo->riva.Bitmap->WidthHeightInE = (h << 16) | 32;
rinfo->riva.Bitmap->WidthHeightOutE = (h << 16) | 32;
rinfo->riva.Bitmap->PointE = (yy << 16) | (xx & 0xFFFF);
d = &rinfo->riva.Bitmap->MonochromeData01E;
for (i = h; i > 0; i-=16) {
if (i >= 16)
cnt = 16;
else
cnt = i;
RIVA_FIFO_FREE(rinfo->riva, Bitmap, cnt);
for (j = 0; j < cnt; j++) {
if (w <= 8)
cdat2 = *cdat++;
else {
cdat2 = *(u16*)cdat;
cdat += sizeof(u16);
}
fbcon_reverse_order(&cdat2);
d[j] = cdat2;
}
}
}
static void
cyber2000_accel_clear(struct vc_data *conp, struct display *p, int sy, int sx,
int height, int width)
{
struct cfb_info *cfb = (struct cfb_info *)p->fb_info;
struct fb_var_screeninfo *var = &p->fb_info->var;
u_long dst;
u_int fw, fh;
u32 bgx = attr_bgcol_ec(p, conp);
fw = fontwidth(p);
fh = fontheight(p);
dst = sx * fw + sy * var->xres_virtual * fh;
width = width * fw - 1;
height = height * fh - 1;
cyber2000_accel_wait(cfb);
cyber2000fb_writeb(0x00, CO_REG_CONTROL, cfb);
cyber2000fb_writeb(0x03, CO_REG_FORE_MIX, cfb);
cyber2000fb_writew(width, CO_REG_WIDTH, cfb);
cyber2000fb_writew(height, CO_REG_HEIGHT, cfb);
switch (var->bits_per_pixel) {
case 15:
case 16:
bgx = ((u16 *)p->dispsw_data)[bgx];
case 8:
cyber2000fb_writel(dst, CO_REG_DEST_PTR, cfb);
break;
case 24:
cyber2000fb_writel(dst * 3, CO_REG_DEST_PTR, cfb);
cyber2000fb_writeb(dst, CO_REG_X_PHASE, cfb);
bgx = ((u32 *)p->dispsw_data)[bgx];
break;
}
cyber2000fb_writel(bgx, CO_REG_FOREGROUND, cfb);
cyber2000fb_writew(CO_CMD_L_PATTERN_FGCOL, CO_REG_CMD_L, cfb);
cyber2000fb_writew(0x0800, CO_REG_CMD_H, cfb);
}
static void i810_accel_revc(struct display *p, int xx, int yy)
{
struct blit_data rect;
int depth, c, fg;
if (i810_accel->lockup || not_safe())
return;
c = scr_readw((u16 *) p->conp->vc_pos);
fg = (int) attr_fgcol(p,c);
depth = (p->var.bits_per_pixel + 7) >> 3;
switch (depth) {
case 1:
rect.fg = fg;
rect.blit_bpp = BPP8;
break;
case 2:
rect.fg = (int) ((u16 *)p->dispsw_data)[fg];
rect.blit_bpp = BPP16;
break;
case 3:
rect.fg = ((int *)p->dispsw_data)[fg];
rect.blit_bpp = BPP24;
break;
}
rect.dpitch = p->next_line;
rect.dwidth = fontwidth(p)*depth;
rect.dheight = fontheight(p);
rect.d_addr = (i810_accel->fb_offset << 12) +
(yy * rect.dheight * p->next_line) +
(xx * rect.dwidth);
rect.rop = XOR_ROP;
color_blit(&rect);
}
static void sun3fb_cursor(struct display *p, int mode, int x, int y)
{
struct fb_info_sbusfb *fb = sbusfbinfod(p);
switch (mode) {
case CM_ERASE:
fb->cursor.mode &= ~CURSOR_BLINK;
fb->cursor.enable = 0;
(*fb->setcursor)(fb);
break;
case CM_MOVE:
case CM_DRAW:
if (fb->cursor.mode & CURSOR_SHAPE) {
fb->cursor.size.fbx = fontwidth(p);
fb->cursor.size.fby = fontheight(p);
fb->cursor.chot.fbx = 0;
fb->cursor.chot.fby = 0;
fb->cursor.enable = 1;
memset (fb->cursor.bits, 0, sizeof (fb->cursor.bits));
fb->cursor.bits[0][fontheight(p) - 2] = (0xffffffff << (32 - fontwidth(p)));
fb->cursor.bits[1][fontheight(p) - 2] = (0xffffffff << (32 - fontwidth(p)));
fb->cursor.bits[0][fontheight(p) - 1] = (0xffffffff << (32 - fontwidth(p)));
fb->cursor.bits[1][fontheight(p) - 1] = (0xffffffff << (32 - fontwidth(p)));
(*fb->setcursormap) (fb, hw_cursor_cmap, hw_cursor_cmap, hw_cursor_cmap);
(*fb->setcurshape) (fb);
}
fb->cursor.mode = CURSOR_BLINK;
if (fontwidthlog(p))
fb->cursor.cpos.fbx = (x << fontwidthlog(p)) + fb->x_margin;
else
fb->cursor.cpos.fbx = (x * fontwidth(p)) + fb->x_margin;
if (fontheightlog(p))
fb->cursor.cpos.fby = (y << fontheightlog(p)) + fb->y_margin;
else
fb->cursor.cpos.fby = (y * fontheight(p)) + fb->y_margin;
(*fb->setcursor)(fb);
break;
}
}
static editor neweditor(void)
{
int x, y, w, h, w0, h0;
editor c;
menuitem m;
textbox t;
long flags;
font editorfn = (consolefn ? consolefn : FixedFont);
EditorData p = neweditordata(0, NULL);
DWORD rand;
w = (pagercol + 1)*fontwidth(editorfn);
h = (pagerrow + 1)*fontheight(editorfn) + 1;
#ifdef USE_MDI
if(ismdi()) {
RECT *pR = RgetMDIsize();
w0 = pR->right;
h0 = pR->bottom;
} else {
#endif
w0 = devicewidth(NULL);
h0 = deviceheight(NULL);
#ifdef USE_MDI
}
#endif
x = (w0 - w) / 2; x = x > 20 ? x : 20;
y = (h0 - h) / 2; y = y > 20 ? y : 20;
rand = GetTickCount();
w0 = 0.4*x; h0 = 0.4*y;
w0 = w0 > 20 ? w0 : 20;
h0 = h0 > 20 ? h0 : 20;
x += (rand % w0) - w0/2;
y += ((rand/w0) % h0) - h0/2;
flags = StandardWindow | Menubar;
#ifdef USE_MDI
if (ismdi()) flags |= Document;
#endif
c = (editor) newwindow("", rect(x, y, w, h), flags);
t = newrichtextarea(NULL, rect(0, 0, w, h));
setdata(c, t);
setdata(t, p);
gsetcursor(c, ArrowCursor);
setforeground(c, guiColors[editorfg]);
setbackground(c, guiColors[editorbg]);
setbackground(t, guiColors[editorbg]);
#ifdef USE_MDI
if (ismdi() && (RguiMDI & RW_TOOLBAR)) {
int btsize = 24;
rect r = rect(2, 2, btsize, btsize);
control tb, bt;
addto(c);
MCHECK(tb = newtoolbar(btsize + 4));
addto(tb);
MCHECK(bt = newtoolbutton(open_image, r, menueditoropen));
MCHECK(addtooltip(bt, G_("Open script")));
setdata(bt, c);
r.x += (btsize + 1) ;
MCHECK(bt = newtoolbutton(save_image, r, menueditorsave));
MCHECK(addtooltip(bt, G_("Save script")));
setdata(bt, c);
r.x += (btsize + 6);
MCHECK(bt = newtoolbutton(copy1_image, r, menueditorrun));
MCHECK(addtooltip(bt, G_("Run line or selection")));
setdata(bt, t);
r.x += (btsize + 6);
MCHECK(bt = newtoolbutton(console_image, r, editorconsole));
MCHECK(addtooltip(bt, G_("Return focus to Console")));
r.x += (btsize + 6);
MCHECK(bt = newtoolbutton(print_image, r, editorprint));
MCHECK(addtooltip(bt, G_("Print script")));
setdata(bt, t);
MCHECK(addtooltip(bt, G_("Print")));
}
#endif
addto(c);
/* Right-click context menu */
MCHECK(m = gpopup(editormenuact, EditorPopup));
setdata(m, t);
setdata(EditorPopup[0].m, t);
setdata(EditorPopup[2].m, t);
setdata(p->mpopcut = EditorPopup[4].m, t);
setdata(p->mpopcopy = EditorPopup[5].m, t);
setdata(EditorPopup[6].m, t);
setdata(p->mpopdelete = EditorPopup[7].m, t);
setdata(EditorPopup[9].m, t);
addto(c);
MCHECK(m = newmenubar(editormenuact));
setdata(m, t);
MCHECK(newmenu(G_("File")));
MCHECK(m = newmenuitem(G_("New script"), 'N', menueditornew));
setdata(m, c);
MCHECK(m = newmenuitem(G_("Open script..."), 'O', menueditoropen));
setdata(m, c);
MCHECK(m = newmenuitem(G_("Save"), 'S', menueditorsave));
setdata(m, c);
MCHECK(m = newmenuitem(G_("Save as..."), 0, menueditorsaveas));
setdata(m, c);
MCHECK(m = newmenuitem("-", 0, NULL));
MCHECK(m = newmenuitem(G_("Print..."), 0, editorprint));
setdata(m, t);
MCHECK(m = newmenuitem("-", 0, NULL));
MCHECK(m = newmenuitem(G_("Close script"), 0, menueditorclose));
setdata(m, c);
MCHECK(newmenu(G_("Edit")));
MCHECK(m = newmenuitem(G_("Undo"), 'Z', editorundo));
setdata(m, t);
MCHECK(m = newmenuitem("-", 0, NULL));
MCHECK(p->mcut = newmenuitem(G_("Cut"), 'X', editorcut));
setdata(p->mcut, t);
MCHECK(p->mcopy = newmenuitem(G_("Copy"), 'C', editorcopy));
setdata(p->mcopy, t);
MCHECK(m = newmenuitem(G_("Paste"), 'V', editorpaste));
setdata(m, t);
MCHECK(p->mdelete = newmenuitem(G_("Delete"), 0, editordelete));
setdata(p->mdelete, t);
MCHECK(m = newmenuitem(G_("Select all"), 'A', editorselectall));
setdata(m, t);
MCHECK(newmenuitem(G_("Clear console"), 'L', menuclear));
MCHECK(m = newmenuitem("-", 0, NULL));
MCHECK(m = newmenuitem(G_("Run line or selection"), 'R', menueditorrun));
setdata(m, t);
MCHECK(m = newmenuitem(G_("Run all"), 0, editorrunall));
setdata(m, t);
MCHECK(m = newmenuitem("-", 0, NULL));
MCHECK(p->mfind = newmenuitem(G_("Find..."), 'F', editorfind));
setdata(p->mfind, t);
MCHECK(p->mreplace = newmenuitem(G_("Replace..."), 'H', editorreplace));
setdata(p->mreplace, t);
MCHECK(m = newmenuitem("-", 0, NULL));
MCHECK(newmenuitem(G_("GUI preferences..."), 0, menuconfig));
/* Packages menu should go here */
p->pmenu = (PkgMenuItems) malloc(sizeof(struct structPkgMenuItems));
RguiPackageMenu(p->pmenu);
#ifdef USE_MDI
newmdimenu(); /* Create and fill the 'Window' menu */
#endif
MCHECK(m = newmenu(G_("Help")));
MCHECK(newmenuitem(G_("Editor"), 0, menueditorhelp));
MCHECK(newmenuitem("-", 0, NULL));
p->hmenu = (HelpMenuItems) malloc(sizeof(struct structHelpMenuItems));
RguiCommonHelp(m, p->hmenu);
settextfont(t, editorfn);
setforeground(t, guiColors[editorfg]);
setresize(c, editorresize);
setclose(c, editorclose);
setdel(c, editordel);
setdel(t, textboxdel);
setonfocus(c, editorfocus);
setkeyaction(t, editorcontrolkeydown);
setkeydown(t, editorasciikeydown);
/* Store pointer to new editor in global array */
REditors[neditors] = c;
++neditors;
return c;
}
void applyGUI(Gui newGUI)
{
rect r = getrect(RConsole);
ConsoleData p = (ConsoleData) getdata(RConsole);
int havenewfont = 0;
struct structGUI curGUI;
getActive(&curGUI);
if(!has_changed(&curGUI, newGUI)) return;
if(newGUI->MDI != curGUI.MDI || newGUI->toolbar != curGUI.toolbar ||
newGUI->statusbar != curGUI.statusbar)
askok(G_("The overall console properties cannot be changed\non a running console.\n\nSave the preferences and restart Rgui to apply them.\n"));
if(strcmp(newGUI->language, curGUI.language)) {
char *buf = malloc(50);
askok(G_("The language for menus cannot be changed on a\n running console.\n\nSave the preferences and restart Rgui to apply to menus.\n"));
snprintf(buf, 50, "LANGUAGE=%s", newGUI->language);
putenv(buf);
}
/* Set a new font? */
if(strcmp(newGUI->font, curGUI.font) ||
newGUI->pointsize != curGUI.pointsize ||
strcmp(newGUI->style, curGUI.style))
{
char msg[LF_FACESIZE + 128];
int sty = Plain;
if(newGUI->tt_font) strcpy(fontname, "TT "); else strcpy(fontname, "");
strcat(fontname, newGUI->font);
if (!strcmp(newGUI->style, "bold")) sty = Bold;
if (!strcmp(newGUI->style, "italic")) sty = Italic;
pointsize = newGUI->pointsize;
fontsty = sty;
/* Don't delete font: open pagers may be using it */
if (strcmp(fontname, "FixedFont"))
consolefn = gnewfont(NULL, fontname, fontsty, pointsize, 0.0, 1);
else consolefn = FixedFont;
if (!consolefn) {
snprintf(msg, LF_FACESIZE + 128,
G_("Font %s-%d-%d not found.\nUsing system fixed font"),
fontname, fontsty | FixedWidth, pointsize);
R_ShowMessage(msg);
consolefn = FixedFont;
}
/* if (!ghasfixedwidth(consolefn)) {
sprintf(msg,
G_("Font %s-%d-%d has variable width.\nUsing system fixed font"),
fontname, fontsty, pointsize);
R_ShowMessage(msg);
consolefn = FixedFont;
} */
p->f = consolefn;
FH = fontheight(p->f);
FW = fontwidth(p->f);
havenewfont = 1;
}
/* resize console, possibly with new font */
if (consoler != newGUI->crows || consolec != newGUI->ccols || havenewfont) {
char buf[20];
consoler = newGUI->crows;
consolec = newGUI->ccols;
r.width = (consolec + 1) * FW;
r.height = (consoler + 1) * FH;
resize(RConsole, r);
snprintf(buf, 20, "%d", ROWS); settext(f_crows, buf);
snprintf(buf, 20, "%d", COLS); settext(f_ccols, buf);
}
if (p->lbuf->dim != newGUI->cbb || p->lbuf->ms != newGUI->cbl)
xbufgrow(p->lbuf, newGUI->cbb, newGUI->cbl);
/* Set colours and redraw */
for (int i=0; i<numGuiColors; i++)
p->guiColors[i] = guiColors[i] = newGUI->guiColors[i];
drawconsole(RConsole, r);
if(haveusedapager &&
(newGUI->prows != curGUI.prows || newGUI->pcols != curGUI.pcols))
askok(G_("Changes in pager size will not apply to any open pagers"));
pagerrow = newGUI->prows;
pagercol = newGUI->pcols;
if(newGUI->pagerMultiple != pagerMultiple) {
if(!haveusedapager ||
askokcancel(G_("Do not change pager type if any pager is open\nProceed?"))
== YES)
pagerMultiple = newGUI->pagerMultiple;
if(pagerMultiple) {
check(rb_mwin); uncheck(rb_swin);
} else {check(rb_swin); uncheck(rb_mwin);}
}
setWidthOnResize = newGUI->setWidthOnResize;
consolebuffered = newGUI->buffered;
Rwin_graphicsx = newGUI->grx;
Rwin_graphicsy = newGUI->gry;
p->cursor_blink = newGUI->cursor_blink;
}
static void leo_putcs(struct vc_data *conp, struct display *p, const unsigned short *s,
int count, int yy, int xx)
{
struct fb_info_sbusfb *fb = (struct fb_info_sbusfb *)p->fb_info;
register struct leo_lc_ss0_usr *us = fb->s.leo.lc_ss0_usr;
register struct leo_ld *ss = (struct leo_ld *) fb->s.leo.ld_ss0;
unsigned long flags;
int i, x, y;
u8 *fd1, *fd2, *fd3, *fd4;
u16 c;
u32 *u;
spin_lock_irqsave(&fb->lock, flags);
do {
i = sbus_readl(&us->csr);
} while (i & 0x20000000);
c = scr_readw(s);
sbus_writel(attr_fgcol(p, c) << 24, &ss->fg);
sbus_writel(attr_bgcol(p, c) << 24, &ss->bg);
sbus_writel(0xFFFFFFFF<<(32-fontwidth(p)), &us->fontmsk);
if (fontwidthlog(p))
x = (xx << fontwidthlog(p));
else
x = xx * fontwidth(p);
if (fontheightlog(p))
y = yy << (fontheightlog(p) + 11);
else
y = (yy * fontheight(p)) << 11;
u = ((u32 *)p->screen_base) + y + x;
if (fontwidth(p) <= 8) {
sbus_writel(0xFFFFFFFF<<(32-4*fontwidth(p)), &us->fontmsk);
x = 4*fontwidth(p) - fontheight(p)*2048;
while (count >= 4) {
count -= 4;
if (fontheightlog(p)) {
fd1 = p->fontdata + ((scr_readw(s++) & p->charmask) << fontheightlog(p));
fd2 = p->fontdata + ((scr_readw(s++) & p->charmask) << fontheightlog(p));
fd3 = p->fontdata + ((scr_readw(s++) & p->charmask) << fontheightlog(p));
fd4 = p->fontdata + ((scr_readw(s++) & p->charmask) << fontheightlog(p));
} else {
fd1 = p->fontdata + ((scr_readw(s++) & p->charmask) * fontheight(p));
fd2 = p->fontdata + ((scr_readw(s++) & p->charmask) * fontheight(p));
fd3 = p->fontdata + ((scr_readw(s++) & p->charmask) * fontheight(p));
fd4 = p->fontdata + ((scr_readw(s++) & p->charmask) * fontheight(p));
}
if (fontwidth(p) == 8) {
for (i = 0; i < fontheight(p); i++, u += 2048) {
u32 val;
val = ((u32)*fd4++) | ((((u32)*fd3++) | ((((u32)*fd2++) | (((u32)*fd1++)
<< 8)) << 8)) << 8);
sbus_writel(val, u);
}
u += x;
} else {
for (i = 0; i < fontheight(p); i++, u += 2048) {
u32 val;
val = (((u32)*fd4++) | ((((u32)*fd3++) | ((((u32)*fd2++) | (((u32)*fd1++)
<< fontwidth(p))) << fontwidth(p))) << fontwidth(p))) << (24 - 3 * fontwidth(p));
sbus_writel(val, u);
}
u += x;
}
}
} else {
sbus_writel(0xFFFFFFFF<<(32-2*fontwidth(p)), &us->fontmsk);
x = 2*fontwidth(p) - fontheight(p)*2048;
while (count >= 2) {
count -= 2;
if (fontheightlog(p)) {
fd1 = p->fontdata + ((scr_readw(s++) & p->charmask) << (fontheightlog(p) + 1));
fd2 = p->fontdata + ((scr_readw(s++) & p->charmask) << (fontheightlog(p) + 1));
} else {
fd1 = p->fontdata + (((scr_readw(s++) & p->charmask) * fontheight(p)) << 1);
fd2 = p->fontdata + (((scr_readw(s++) & p->charmask) * fontheight(p)) << 1);
}
for (i = 0; i < fontheight(p); i++, u += 2048) {
u32 val;
val = ((((u32)*(u16 *)fd1) << fontwidth(p)) | ((u32)*(u16 *)fd2)) << (16 - fontwidth(p));
sbus_writel(val, u);
fd1 += 2; fd2 += 2;
}
u += x;
}
}
sbus_writel(0xFFFFFFFF<<(32-fontwidth(p)), &us->fontmsk);
x = fontwidth(p) - fontheight(p)*2048;
while (count) {
count--;
if (fontheightlog(p))
i = ((scr_readw(s++) & p->charmask) << fontheightlog(p));
else
i = ((scr_readw(s++) & p->charmask) * fontheight(p));
if (fontwidth(p) <= 8) {
fd1 = p->fontdata + i;
for (i = 0; i < fontheight(p); i++, u += 2048) {
u32 val = *fd1++ << 24;
sbus_writel(val, u);
}
} else {
fd1 = p->fontdata + (i << 1);
for (i = 0; i < fontheight(p); i++, u += 2048) {
u32 val = *(u16 *)fd1 << 16;
sbus_writel(val, u);
fd1 += 2;
}
}
u += x;
}
spin_unlock_irqrestore(&fb->lock, flags);
}
static void i810_accel_putcs(struct vc_data *conp, struct display *p,
const unsigned short *s, int count, int yy, int xx)
{
struct blit_data text;
int depth, c, d_addr, s_pitch, d_pitch, f_width, cell;
char *s_addr;
void (*move_data)(void *dst, void *src, int dpitch, int spitch, int size);
if (i810_accel->lockup || not_safe())
return;
c = scr_readw(s);
depth = (p->var.bits_per_pixel + 7) >> 3;
switch (depth) {
case 1:
text.fg = (int) attr_fgcol(p,c);
text.bg = (int) attr_bgcol(p,c);
text.blit_bpp = BPP8;
break;
case 2:
text.bg = (int) ((u16 *)p->dispsw_data)[attr_bgcol(p, c)];
text.fg = (int) ((u16 *)p->dispsw_data)[attr_fgcol(p, c)];
text.blit_bpp = BPP16;
break;
case 3:
text.fg = ((int *) p->dispsw_data)[attr_fgcol(p, c)];
text.bg = ((int *) p->dispsw_data)[attr_bgcol(p, c)];
text.blit_bpp = BPP24;
}
f_width = (fontwidth(p) + 7) & ~7;
switch (f_width) {
case 8:
move_data = i810fb_moveb;
break;
case 16:
move_data = i810fb_movew;
break;
case 32:
move_data = i810fb_movel;
break;
default:
move_data = i810fb_move;
break;
}
s_pitch = f_width >> 3;
d_pitch = ((s_pitch * count) + 1) & ~1;
text.dwidth = f_width * depth * count;
text.dheight = fontheight(p);
text.dpitch = p->next_line;
text.dsize = ((d_pitch * text.dheight) + 7) & ~7;
text.dsize >>= 2;
text.rop = PAT_COPY_ROP;
text.d_addr = (i810_accel->fb_offset << 12) + (yy * text.dheight * p->next_line) +
(xx * f_width * depth);
text.s_addr[0] = d_addr = i810_accel->text_buffer;
cell = s_pitch * text.dheight;
if (s_pitch == 1 && count > 3) {
int i, d_addr0;
char *s1, *s2, *s3, *s4;
while (count > 3) {
s1 = p->fontdata + (scr_readw(s++) & p->charmask) * cell;
s2 = p->fontdata + (scr_readw(s++) & p->charmask) * cell;
s3 = p->fontdata + (scr_readw(s++) & p->charmask) * cell;
s4 = p->fontdata + (scr_readw(s++) & p->charmask) * cell;
d_addr0 = d_addr;
for (i = text.dheight; i--; ) {
*(unsigned long *) d_addr0 =
(unsigned long) ((*s1++ & 0xff) |
(*s2++ & 0xff) << 8 |
(*s3++ & 0xff) << 16 |
(*s4++ & 0xff) << 24 );
d_addr0 += d_pitch;
}
d_addr += 4;
count -= 4;
}
}
while (count--) {
c = scr_readw(s++) & p->charmask;
s_addr = p->fontdata + (c * cell);
move_data((void *) d_addr, s_addr, d_pitch, s_pitch, text.dheight);
d_addr += s_pitch;
}
mono_src_copy_imm_blit(&text);
}
