[PATCH TO TEST] VESA [1024x768] mode support for FreeBSD-CURRENT
Deng XueFeng
dsnofe at msn.com
Thu Aug 26 18:59:51 PDT 2004
First to thanks Sascha Wildner <saw at online.de>.
he hack syscons to make dfbsd support 1024x768(16/24/32) syscons,
then I ported that to current. and it works well with my ati MOBILITY
7500[T31]/9200 [NX7000].
To make console support 1024x768; just type
#vidcontrol MODE_279
The originer patch can be get from dfbsd's maillist.
and the attachment is against with FreeBSD CURRENT and 5.3
enjoy it!
NOTE:
current-vidcontrol.1 current-vidcontrol.c is taken from dfbsd. which
is include
Sascha's patch.
_________________________________________________________________
ÓëÁª»úµÄÅóÓѽøÐн»Á÷£¬ÇëʹÓà MSN Messenger: http://messenger.msn.com/cn
-------------- next part --------------
diff -cur ../syscons.orig/scvesactl.c ./scvesactl.c
--- ../syscons.orig/scvesactl.c Thu Aug 26 21:04:46 2004
+++ ./scvesactl.c Thu Aug 26 20:37:38 2004
@@ -105,6 +105,17 @@
return ENODEV;
mode = (cmd & 0xff) + M_VESA_BASE;
return sc_set_graphics_mode(scp, tp, mode);
+ default:
+ if (IOCGROUP(cmd) == 'V') {
+ if (!(scp->sc->adp->va_flags & V_ADP_MODECHANGE))
+ return ENODEV;
+
+ mode = (cmd & 0xff) + M_VESA_BASE;
+
+ if ((mode > M_VESA_FULL_1280) &&
+ (mode < M_VESA_MODE_MAX))
+ return sc_set_graphics_mode(scp, tp, mode);
+ }
}
if (prev_user_ioctl)
diff -cur ../syscons.orig/scvgarndr.c ./scvgarndr.c
--- ../syscons.orig/scvgarndr.c Thu Aug 26 21:04:46 2004
+++ ./scvgarndr.c Thu Aug 26 20:37:32 2004
@@ -155,6 +155,37 @@
#endif
#endif
+#ifdef SC_PIXEL_MODE
+static uint32_t vga_palette32[16] = {
+ 0x000000, 0x0000ad, 0x00ad00, 0x00adad,
+ 0xad0000, 0xad00ad, 0xad5200, 0xadadad,
+ 0x525252, 0x5252ff, 0x52ff52, 0x52ffff,
+ 0xff5252, 0xff52ff, 0xffff52, 0xffffff
+};
+
+static uint16_t vga_palette16[16] = {
+ 0x0000, 0x0016, 0x0560, 0x0576, 0xb000, 0xb016, 0xb2a0, 0xb576,
+ 0x52aa, 0x52bf, 0x57ea, 0x57ff, 0xfaaa, 0xfabf, 0xffea, 0xffff
+};
+
+static uint16_t vga_palette15[16] = {
+ 0x0000, 0x0016, 0x02c0, 0x02d6, 0x5800, 0x5816, 0x5940, 0x5ad6,
+ 0x294a, 0x295f, 0x2bea, 0x2bff, 0x7d4a, 0x7d5f, 0x7fea, 0x7fff
+};
+
+#define VIDEO_MEMORY_POS(scp, pos, x) \
+ scp->sc->adp->va_window + \
+ x * scp->xoff + \
+ scp->yoff * scp->font_size * scp->sc->adp->va_line_width + \
+ x * (pos % scp->xsize) + \
+ scp->font_size * scp->sc->adp->va_line_width * (pos / scp->xsize)
+
+#ifndef SC_NO_CUTPASTE
+static uint32_t mouse_buf32[256];
+static uint16_t mouse_buf16[256];
+#endif
+#endif
+
static void
vga_nop(scr_stat *scp, ...)
{
@@ -431,7 +462,29 @@
/* pixel (raster text) mode renderer */
static void
-vga_pxlclear(scr_stat *scp, int c, int attr)
+vga_pxlclear_direct(scr_stat *scp, int c, int attr)
+{
+ vm_offset_t p;
+ int line_width;
+ int pixel_size;
+ int lines;
+ int i;
+
+ line_width = scp->sc->adp->va_line_width;
+ pixel_size = scp->sc->adp->va_info.vi_pixel_size;
+ lines = scp->ysize * scp->font_size;
+ p = scp->sc->adp->va_window +
+ line_width * scp->yoff * scp->font_size +
+ scp->xoff * 8 * pixel_size;
+
+ for (i = 0; i < lines; ++i) {
+ bzero_io((void *)p, scp->xsize * 8 * pixel_size);
+ p += line_width;
+ }
+}
+
+static void
+vga_pxlclear_planar(scr_stat *scp, int c, int attr)
{
vm_offset_t p;
int line_width;
@@ -457,7 +510,121 @@
}
static void
-vga_pxlborder(scr_stat *scp, int color)
+vga_pxlclear(scr_stat *scp, int c, int attr)
+{
+ switch (scp->sc->adp->va_info.vi_mem_model) {
+ case V_INFO_MM_DIRECT:
+ vga_pxlclear_direct(scp, c, attr);
+ break;
+ case V_INFO_MM_PLANAR:
+ vga_pxlclear_planar(scp, c, attr);
+ break;
+ }
+}
+
+static void
+vga_pxlborder_direct(scr_stat *scp, int color, int bpp)
+{
+ vm_offset_t s;
+ vm_offset_t e;
+ vm_offset_t f;
+ int line_width;
+ int pixel_size;
+ int x;
+ int y;
+ int i;
+
+ line_width = scp->sc->adp->va_line_width;
+ pixel_size = scp->sc->adp->va_info.vi_pixel_size;
+
+ if (scp->yoff > 0) {
+ s = scp->sc->adp->va_window;
+ e = s + line_width * scp->yoff * scp->font_size;
+
+ for (f = s; f < e; f += pixel_size) {
+ switch (bpp) {
+ case 32:
+ writel(f, vga_palette32[color]);
+ break;
+ case 16:
+ writew(f, vga_palette16[color]);
+ break;
+ case 15:
+ writew(f, vga_palette15[color]);
+ break;
+ }
+ }
+ }
+
+ y = (scp->yoff + scp->ysize) * scp->font_size;
+
+ if (scp->ypixel > y) {
+ s = scp->sc->adp->va_window + line_width * y;
+ e = s + line_width * (scp->ypixel - y);
+
+ for (f = s; f < e; f += pixel_size) {
+ switch (bpp) {
+ case 32:
+ writel(f, vga_palette32[color]);
+ break;
+ case 16:
+ writew(f, vga_palette16[color]);
+ break;
+ case 15:
+ writew(f, vga_palette15[color]);
+ break;
+ }
+ }
+ }
+
+ y = scp->yoff * scp->font_size;
+ x = scp->xpixel / 8 - scp->xoff - scp->xsize;
+
+ for (i = 0; i < scp->ysize * scp->font_size; ++i) {
+ if (scp->xoff > 0) {
+ s = scp->sc->adp->va_window + line_width * (y + i);
+ e = s + scp->xoff * 8 * pixel_size;
+
+ for (f = s; f < e; f += pixel_size) {
+ switch (bpp) {
+ case 32:
+ writel(f, vga_palette32[color]);
+ break;
+ case 16:
+ writew(f, vga_palette16[color]);
+ break;
+ case 15:
+ writew(f, vga_palette15[color]);
+ break;
+ }
+ }
+ }
+
+ if (x > 0) {
+ s = scp->sc->adp->va_window + line_width * (y + i) +
+ scp->xoff * 8 * pixel_size +
+ scp->xsize * 8 * pixel_size;
+ e = s + x * 8 * pixel_size;
+
+ for (f = s; f < e; f += pixel_size) {
+ switch (bpp) {
+ case 32:
+ writel(f, vga_palette32[color]);
+ break;
+ case 16:
+ writew(f, vga_palette16[color]);
+ break;
+ case 15:
+ writew(f, vga_palette15[color]);
+ break;
+ }
+ }
+ }
+ }
+}
+
+static void
+vga_pxlborder_planar(scr_stat *scp, int color)
{
vm_offset_t p;
int line_width;
@@ -492,6 +659,27 @@
outw(GDCIDX, 0x0001); /* set/reset enable */
}
+static void
+vga_pxlborder(scr_stat *scp, int color)
+{
+ int bpp;
+
+ switch (scp->sc->adp->va_info.vi_mem_model) {
+ case V_INFO_MM_DIRECT:
+ bpp = scp->sc->adp->va_info.vi_depth;
+
+ if ((bpp == 16) &&
+ (scp->sc->adp->va_info.vi_pixel_fsizes[1] == 5))
+ bpp = 15;
+
+ vga_pxlborder_direct(scp, color, bpp);
+ break;
+ case V_INFO_MM_PLANAR:
+ vga_pxlborder_planar(scp, color);
+ break;
+ }
+}
+
static void
vga_egadraw(scr_stat *scp, int from, int count, int flip)
{
@@ -505,12 +693,9 @@
int a;
u_char c;
+ d = VIDEO_MEMORY_POS(scp, from, 1);
+
line_width = scp->sc->adp->va_line_width;
- d = scp->sc->adp->va_window
- + scp->xoff
- + scp->yoff*scp->font_size*line_width
- + (from%scp->xsize)
- + scp->font_size*line_width*(from/scp->xsize);
outw(GDCIDX, 0x0005); /* read mode 0, write mode 0 */
outw(GDCIDX, 0x0003); /* data rotate/function select */
@@ -554,8 +739,87 @@
outw(GDCIDX, 0xff08); /* bit mask */
}
-static void
-vga_vgadraw(scr_stat *scp, int from, int count, int flip)
+static void
+vga_vgadraw_direct(scr_stat *scp, int from, int count, int flip, int bpp)
+{
+ vm_offset_t d = 0;
+ vm_offset_t e;
+ u_char *f;
+ u_short col1, col2, idx;
+ int line_width;
+ int i, j, k;
+ int a;
+
+ switch (bpp) {
+ case 32:
+ d = VIDEO_MEMORY_POS(scp, from, 32);
+ break;
+ case 16:
+ /* FALLTHROUGH */
+ case 15:
+ d = VIDEO_MEMORY_POS(scp, from, 16);
+ break;
+ }
+
+ line_width = scp->sc->adp->va_line_width;
+
+ if (from + count > scp->xsize * scp->ysize)
+ count = scp->xsize * scp->ysize - from;
+
+ for (i = from; count-- > 0; ++i) {
+ a = sc_vtb_geta(&scp->vtb, i);
+
+ if (flip) {
+ col1 = (((a & 0x7000) >> 4) | (a & 0x0800)) >> 8;
+ col2 = (((a & 0x8000) >> 4) | (a & 0x0700)) >> 8;
+ } else {
+ col1 = (a & 0x0f00) >> 8;
+ col2 = (a & 0xf000) >> 12;
+ }
+
+ e = d;
+ f = &(scp->font[sc_vtb_getc(&scp->vtb, i) * scp->font_size]);
+
+ for (j = 0; j < scp->font_size; ++j, ++f) {
+ for (k = 7; k >= 0; --k) {
+ idx = *f & (1 << (7 - k)) ?
+ col1 : col2;
+
+ switch (bpp) {
+ case 32:
+ writel(e + 4 * k, vga_palette32[idx]);
+ break;
+ case 16:
+ writew(e + 2 * k, vga_palette16[idx]);
+ break;
+ case 15:
+ writew(e + 2 * k, vga_palette15[idx]);
+ break;
+ }
+ }
+
+ e += line_width;
+ }
+
+ switch (bpp) {
+ case 32:
+ d += 32;
+ break;
+ case 16:
+ /* FALLTHROUGH */
+ case 15:
+ d += 16;
+ break;
+ }
+
+ if ((i % scp->xsize) == scp->xsize - 1)
+ d += scp->xoff * 16 * scp->sc->adp->va_info.vi_pixel_size +
+ (scp->font_size - 1) * line_width;
+ }
+}
+
+static void
+vga_vgadraw_planar(scr_stat *scp, int from, int count, int flip)
{
vm_offset_t d;
vm_offset_t e;
@@ -567,12 +831,8 @@
int a;
u_char c;
+ d = VIDEO_MEMORY_POS(scp, from, 1);
line_width = scp->sc->adp->va_line_width;
- d = scp->sc->adp->va_window
- + scp->xoff
- + scp->yoff*scp->font_size*line_width
- + (from%scp->xsize)
- + scp->font_size*line_width*(from/scp->xsize);
outw(GDCIDX, 0x0305); /* read mode 0, write mode 3 */
outw(GDCIDX, 0x0003); /* data rotate/function select */
@@ -618,6 +878,27 @@
}
static void
+vga_vgadraw(scr_stat *scp, int from, int count, int flip)
+{
+ int bpp;
+
+ switch (scp->sc->adp->va_info.vi_mem_model) {
+ case V_INFO_MM_DIRECT:
+ bpp = scp->sc->adp->va_info.vi_depth;
+
+ if ((bpp == 16) &&
+ (scp->sc->adp->va_info.vi_pixel_fsizes[1] == 5))
+ bpp = 15;
+
+ vga_vgadraw_direct(scp, from, count, flip, bpp);
+ break;
+ case V_INFO_MM_PLANAR:
+ vga_vgadraw_planar(scp, from, count, flip);
+ break;
+ }
+}
+
+static void
vga_pxlcursor_shape(scr_stat *scp, int base, int height, int blink)
{
if (base < 0 || base >= scp->font_size)
@@ -630,7 +911,69 @@
}
static void
-draw_pxlcursor(scr_stat *scp, int at, int on, int flip)
+draw_pxlcursor_direct(scr_stat *scp, int at, int on, int flip, int bpp)
+{
+ vm_offset_t d = 0;
+ u_char *f;
+ int line_width;
+ int height;
+ int col1, col2, idx;
+ int a;
+ int i, j;
+
+ line_width = scp->sc->adp->va_line_width;
+
+ switch (bpp) {
+ case 32:
+ d = VIDEO_MEMORY_POS(scp, at, 32) +
+ (scp->font_size - scp->curs_attr.base - 1) * line_width;
+ break;
+ case 16:
+ /* FALLTHROUGH */
+ case 15:
+ d = VIDEO_MEMORY_POS(scp, at, 16) +
+ (scp->font_size - scp->curs_attr.base - 1) * line_width;
+ break;
+ }
+
+ a = sc_vtb_geta(&scp->vtb, at);
+
+ if (flip) {
+ col1 = ((on) ? (a & 0x0f00) : ((a & 0xf000) >> 4)) >> 8;
+ col2 = ((on) ? ((a & 0xf000) >> 4) : (a & 0x0f00)) >> 8;
+ } else {
+ col1 = ((on) ? ((a & 0xf000) >> 4) : (a & 0x0f00)) >> 8;
+ col2 = ((on) ? (a & 0x0f00) : ((a & 0xf000) >> 4)) >> 8;
+ }
+
+ f = &(scp->font[sc_vtb_getc(&scp->vtb, at) * scp->font_size +
+ scp->font_size - scp->curs_attr.base - 1]);
+
+ height = imin(scp->curs_attr.height, scp->font_size);
+
+ for (i = 0; i < height; ++i, --f) {
+ for (j = 7; j >= 0; --j) {
+ idx = *f & (1 << (7 - j)) ? col1 : col2;
+
+ switch (bpp) {
+ case 32:
+ writel(d + 4 * j, vga_palette32[idx]);
+ break;
+ case 16:
+ writew(d + 2 * j, vga_palette16[idx]);
+ break;
+ case 15:
+ writew(d + 2 * j, vga_palette15[idx]);
+ break;
+ }
+ }
+
+ d -= line_width;
+ }
+}
+
+static void
+draw_pxlcursor_planar(scr_stat *scp, int at, int on, int flip)
{
vm_offset_t d;
u_char *f;
@@ -642,13 +985,9 @@
u_char c;
line_width = scp->sc->adp->va_line_width;
- d = scp->sc->adp->va_window
- + scp->xoff
- + scp->yoff*scp->font_size*line_width
- + (at%scp->xsize)
- + scp->font_size*line_width*(at/scp->xsize)
- + (scp->font_size - scp->curs_attr.base - 1)*line_width;
+ d = VIDEO_MEMORY_POS(scp, at, 1) +
+ (scp->font_size - scp->curs_attr.base - 1) * line_width;
outw(GDCIDX, 0x0005); /* read mode 0, write mode 0 */
outw(GDCIDX, 0x0003); /* data rotate/function select */
outw(GDCIDX, 0x0f01); /* set/reset enable */
@@ -681,6 +1020,27 @@
outw(GDCIDX, 0xff08); /* bit mask */
}
+static void
+draw_pxlcursor(scr_stat *scp, int at, int on, int flip)
+{
+ int bpp;
+
+ switch (scp->sc->adp->va_info.vi_mem_model) {
+ case V_INFO_MM_DIRECT:
+ bpp = scp->sc->adp->va_info.vi_depth;
+
+ if ((bpp == 16) &&
+ (scp->sc->adp->va_info.vi_pixel_fsizes[1] == 5))
+ bpp = 15;
+
+ draw_pxlcursor_direct(scp, at, on, flip, bpp);
+ break;
+ case V_INFO_MM_PLANAR:
+ draw_pxlcursor_planar(scp, at, on, flip);
+ break;
+ }
+}
+
static int pxlblinkrate = 0;
static void
@@ -726,7 +1086,87 @@
#ifndef SC_NO_CUTPASTE
static void
-draw_pxlmouse(scr_stat *scp, int x, int y)
+draw_pxlmouse_direct(scr_stat *scp, int x, int y, int bpp)
+{
+ vm_offset_t p;
+ int line_width, pixel_size;
+ int xend, yend;
+ static int x_old = 0, xend_old = 0;
+ static int y_old = 0, yend_old = 0;
+ int i, j;
+ uint32_t *u32;
+ uint16_t *u16;
+
+ line_width = scp->sc->adp->va_line_width;
+ pixel_size = scp->sc->adp->va_info.vi_pixel_size;
+
+ xend = imin(x + 16, scp->xpixel);
+ yend = imin(y + 16, scp->ypixel);
+
+ p = scp->sc->adp->va_window + y_old * line_width + x_old * pixel_size;
+
+ for (i = 0; i < (yend_old - y_old); i++) {
+ for (j = (xend_old - x_old - 1); j >= 0; j--) {
+ switch (bpp) {
+ case 32:
+ u32 = (uint32_t*)(p + j * pixel_size);
+ writel(u32, mouse_buf32[i * 16 + j]);
+ break;
+ case 16:
+ /* FALLTHROUGH */
+ case 15:
+ u16 = (uint16_t*)(p + j * pixel_size);
+ writew(u16, mouse_buf16[i * 16 + j]);
+ break;
+ }
+ }
+
+ p += line_width;
+ }
+
+ p = scp->sc->adp->va_window + y * line_width + x * pixel_size;
+
+ for (i = 0; i < (yend - y); i++) {
+ for (j = (xend - x - 1); j >= 0; j--) {
+ switch (bpp) {
+ case 32:
+ u32 = (uint32_t*)(p + j * pixel_size);
+ mouse_buf32[i * 16 + j] = *u32;
+ if (mouse_or_mask[i] & (1 << (15 - j)))
+ writel(u32, vga_palette32[15]);
+ else if (mouse_and_mask[i] & (1 << (15 - j)))
+ writel(u32, 0);
+ break;
+ case 16:
+ u16 = (uint16_t*)(p + j * pixel_size);
+ mouse_buf16[i * 16 + j] = *u16;
+ if (mouse_or_mask[i] & (1 << (15 - j)))
+ writew(u16, vga_palette16[15]);
+ else if (mouse_and_mask[i] & (1 << (15 - j)))
+ writew(u16, 0);
+ break;
+ case 15:
+ u16 = (uint16_t*)(p + j * pixel_size);
+ mouse_buf16[i * 16 + j] = *u16;
+ if (mouse_or_mask[i] & (1 << (15 - j)))
+ writew(u16, vga_palette15[15]);
+ else if (mouse_and_mask[i] & (1 << (15 - j)))
+ writew(u16, 0);
+ break;
+ }
+ }
+
+ p += line_width;
+ }
+
+ x_old = x;
+ y_old = y;
+ xend_old = xend;
+ yend_old = yend;
+}
+
+static void
+draw_pxlmouse_planar(scr_stat *scp, int x, int y)
{
vm_offset_t p;
int line_width;
@@ -801,7 +1241,28 @@
}
static void
-remove_pxlmouse(scr_stat *scp, int x, int y)
+draw_pxlmouse(scr_stat *scp, int x, int y)
+{
+ int bpp;
+
+ switch (scp->sc->adp->va_info.vi_mem_model) {
+ case V_INFO_MM_DIRECT:
+ bpp = scp->sc->adp->va_info.vi_depth;
+
+ if ((bpp == 16) &&
+ (scp->sc->adp->va_info.vi_pixel_fsizes[1] == 5))
+ bpp = 15;
+
+ draw_pxlmouse_direct(scp, x, y, bpp);
+ break;
+ case V_INFO_MM_PLANAR:
+ draw_pxlmouse_planar(scp, x, y);
+ break;
+ }
+}
+
+static void
+remove_pxlmouse_planar(scr_stat *scp, int x, int y)
{
vm_offset_t p;
int col, row;
@@ -856,6 +1317,19 @@
outw(GDCIDX, 0x0000); /* set/reset */
outw(GDCIDX, 0x0001); /* set/reset enable */
}
+
+static void
+remove_pxlmouse(scr_stat *scp, int x, int y)
+{
+ switch (scp->sc->adp->va_info.vi_mem_model) {
+ case V_INFO_MM_PLANAR:
+ remove_pxlmouse_planar(scp, x, y);
+ break;
+ default:
+ break;
+ }
+}
+
static void
vga_pxlmouse(scr_stat *scp, int x, int y, int on)
diff -cur ../syscons.orig/scvidctl.c ./scvidctl.c
--- ../syscons.orig/scvidctl.c Thu Aug 26 21:04:46 2004
+++ ./scvidctl.c Thu Aug 26 20:37:26 2004
@@ -367,16 +367,29 @@
if ((info.vi_width < xsize*8) || (info.vi_height < ysize*fontsize))
return EINVAL;
- /* only 16 color, 4 plane modes are supported XXX */
- if ((info.vi_depth != 4) || (info.vi_planes != 4))
- return ENODEV;
-
/*
- * set_pixel_mode() currently does not support video modes whose
- * memory size is larger than 64K. Because such modes require
- * bank switching to access the entire screen. XXX
+ * We currently support the following graphic modes:
+ *
+ * - 800x600 16 color planar mode
+ * - 16 and 32 bit linear modes
*/
- if (info.vi_width*info.vi_height/8 > info.vi_window_size)
+
+ if (info.vi_mem_model == V_INFO_MM_PLANAR) {
+ if (info.vi_planes != 4)
+ return ENODEV;
+
+ /*
+ * set_pixel_mode() currently does not support video modes whose
+ * memory size is larger than 64K. Because such modes require
+ * bank switching to access the entire screen. XXX
+ */
+
+ if (info.vi_width * info.vi_height / 8 > info.vi_window_size)
+ return ENODEV;
+ } else if (info.vi_mem_model == V_INFO_MM_DIRECT) {
+ if ((info.vi_depth != 16) && (info.vi_depth != 32))
+ return ENODEV;
+ } else
return ENODEV;
/* stop screen saver, etc */
-------------- next part --------------
.\"
.\" vidcontrol - a utility for manipulating the syscons video driver
.\"
.\" 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.
.\"
.\" @(#)vidcontrol.1
.\" $FreeBSD: src/usr.sbin/vidcontrol/vidcontrol.1,v 1.24.2.14 2002/09/15
22:31:50 dd Exp $
.\" $DragonFly: src/usr.sbin/vidcontrol/vidcontrol.1,v 1.3 2004/04/25
06:35:32 dillon Exp $
.\"
.Dd May 27, 2002
.Dt VIDCONTROL 1
.Os
.Sh NAME
.Nm vidcontrol
.Nd system console control and configuration utility
.Sh SYNOPSIS
.Nm
.Op Fl CdLPpx
.Op Fl b Ar color
.Op Fl c Ar appearance
.Oo
.Fl f
.Op Ar size
.Ar file
.Oc
.Op Fl g Ar geometry
.Op Fl h Ar size
.Op Fl i Cm adapter | mode
.Op Fl l Ar screen_map
.Op Fl M Ar char
.Op Fl m Cm on | off
.Op Fl r Ar foreground Ar background
.Op Fl S Cm on | off
.Op Fl s Ar number
.Op Fl t Ar N | Cm off
.Op Ar mode
.Op Ar foreground Op Ar background
.Op Cm show
.Sh DESCRIPTION
The
.Nm
command is used to set various options for the
.Xr syscons 4
console driver,
such as video mode, colors, cursor shape, screen output map, font and screen
saver timeout.
.Pp
The following command line options are supported:
.Bl -tag -width indent
.It Ar mode
Select a new video mode.
The modes currently recognized are:
.Ar 80x25 ,
.Ar 80x30 ,
.Ar 80x43 ,
.Ar 80x50 ,
.Ar 80x60 ,
.Ar 132x25 ,
.Ar 132x30 ,
.Ar 132x43 ,
.Ar 132x50 ,
.Ar 132x60 ,
.Ar VGA_40x25 ,
.Ar VGA_80x25 ,
.Ar VGA_80x30 ,
.Ar VGA_80x50 ,
.Ar VGA_80x60 ,
.Ar VGA_90x25 ,
.Ar VGA_90x30 ,
.Ar VGA_90x43 ,
.Ar VGA_90x50 ,
.Ar VGA_90x60 ,
.Ar EGA_80x25 ,
.Ar EGA_80x43 ,
.Ar VESA_132x25 ,
.Ar VESA_132x43 ,
.Ar VESA_132x50 ,
.Ar VESA_132x60 .
.\"The graphic mode
.\".Ar VGA_320x200
.\"and
The raster text mode
.Ar VESA_800x600
can also be chosen.
Alternatively, a mode can be specified with its number by using a mode name
of
the form
.Ar MODE_<NUMBER> .
A list of valid mode numbers can be obtained with the
.Fl i Cm mode
option. See
.Sx Video Mode Support
below.
.It Ar foreground Op Ar background
Change colors when displaying text.
Specify the foreground color
(e.g.\&
.Dq vidcontrol white ) ,
or both a foreground and background colors
(e.g.\&
.Dq vidcontrol yellow blue ) .
Use the
.Cm show
command below to see available colors.
.It Cm show
See the supported colors on a given platform.
.It Fl b Ar color
Set border color to
.Ar color .
This option may not be always supported by the video driver.
.It Fl C
Clear the history buffer.
.It Fl c Cm normal | blink | destructive
Change the cursor appearance.
The cursor is either an inverting block
.Pq Cm normal
that can optionally
.Cm blink ,
or it can be like the old hardware cursor
.Pq Cm destructive .
The latter is actually a simulation.
.It Fl d
Print out current output screen map.
.It Xo
.Fl f
.Op Ar size
.Ar file
.Xc
Load font
.Ar file
for
.Ar size
(currently, only
.Cm 8x8 ,
.Cm 8x14
or
.Cm 8x16 ) .
The font file can be either uuencoded or in raw binary format.
You can also use the menu-driven
.Xr vidfont 1
command to load the font of your choice.
.Pp
.Ar Size
may be omitted, in this case
.Nm
will try to guess it from the size of font file.
.Pp
Note that older video cards, such as MDA and CGA, do not support
software font.
See also
.Sx Video Mode Support
and
.Sx EXAMPLES
below and the man page for
.Xr syscons 4 .
.It Fl g Ar geometry
Set the
.Ar geometry
of the text mode for the modes with selectable
geometry.
Currently only raster modes, such as
.Ar VESA_800x600 ,
support this option.
See also
.Sx Video Mode Support
and
.Sx EXAMPLES
below.
.It Fl h Ar size
Set the size of the history (scrollback) buffer to
.Ar size
lines.
.It Fl i Cm adapter
Shows info about the current video adapter.
.It Fl i Cm mode
Shows the possible video modes with the current video hardware.
.It Fl l Ar screen_map
Install screen output map file from
.Ar screen_map .
See also
.Xr syscons 4 .
.It Fl L
Install default screen output map.
.It Fl M Ar char
Sets the base character used to render the mouse pointer to
.Ar char .
.It Fl m Cm on | off
Switch the mouse pointer
.Cm on
or
.Cm off .
Used together with the
.Xr moused 8
daemon for text mode cut & paste functionality.
.It Fl p
Capture the current contents of the video buffer corresponding
to the terminal device referred to by standard input.
The
.Nm
utility writes contents of the video buffer to the standard
output in a raw binary format.
For details about that
format see
.Sx Format of Video Buffer Dump
below.
.It Fl P
Same as
.Fl p ,
but dump contents of the video buffer in a plain text format
ignoring nonprintable characters and information about text
attributes.
.It Fl r Ar foreground background
Change reverse mode colors to
.Ar foreground
and
.Ar background .
.It Fl S Cm on | off
Turn vty switching on or off.
When vty switching is off,
attempts to switch to a different virtual terminal will fail.
(The default is to permit vty switching.)
.It Fl s Ar number
Set the current vty to
.Ar number .
.It Fl t Ar N | Cm off
Set the screensaver timeout to
.Ar N
seconds, or turns it
.Cm off .
.It Fl x
Use hexadecimal digits for output.
.El
.Ss Video Mode Support
Note that not all modes listed above may be supported by the video
hardware.
You can verify which mode is supported by the video hardware, using the
.Fl i Cm mode
option.
.Pp
The VESA BIOS support must be linked to the kernel
or loaded as a KLD module if you wish to use VESA video modes
or 132 column modes
(see
.Xr vga 4 ) .
.Pp
You need to compile your kernel with the
.Ar VGA_WIDTH90
option if you wish to use VGA 90 column modes
(see
.Xr vga 4 ) .
.Pp
Video modes other than 25 and 30 line modes may require specific size of
font.
Use
.Fl f
option above to load a font file to the kernel.
If the required size of font has not been loaded to the kernel,
.Nm
will fail if the user attempts to set a new video mode.
.Pp
.Bl -column "25 line modes" "8x16 (VGA), 8x14 (EGA)" -compact
.Sy Modes Ta Sy Font size
.Li 25 line modes Ta 8x16 (VGA), 8x14 (EGA)
.Li 30 line modes Ta 8x16
.Li 43 line modes Ta 8x8
.Li 50 line modes Ta 8x8
.Li 60 line modes Ta 8x8
.El
.Pp
It is better to always load all three sizes (8x8, 8x14 and 8x16)
of the same font.
.Pp
You may set variables in
.Pa /etc/rc.conf
or
.Pa /etc/rc.conf.local
so that desired font files will be automatically loaded
when the system starts up.
See below.
.Pp
If you want to use any of the raster text modes you need to recompile your
kernel with the
.Dv SC_PIXEL_MODE
option.
See
.Xr syscons 4
for more details on this kernel option.
.Ss Format of Video Buffer Dump
The
.Nm
utility uses the
.Xr syscons 4
.Dv CONS_SCRSHOT
.Xr ioctl 2
to capture the current contents of the video buffer.
The
.Nm
utility writes version and additional information to the standard
output, followed by the contents of the terminal device.
.Pp
PC video memory is typically arranged in two byte tuples,
one per character position.
In each tuple, the first byte
will be the character code, and the second byte is the
character's color attribute.
.Pp
The color attribute byte is further broken down in to the
low nibble, which specifies which of 16 different foreground
colors is active, and the high nibble, which specifies which
of 16 different background colors is active.
.Pp
.Bl -hang -offset indent -compact
.It 0
Black
.It 1
Blue
.It 2
Green
.It 3
Cyan
.It 4
Red
.It 5
Magenta
.It 6
Brown
.It 7
White
.It 8
Grey
.It 9
Light Blue
.It 10
Light Green
.It 11
Light Cyan
.It 12
Light Red
.It 13
Light Magenta
.It 14
Yellow
.It 15
White
.El
.Pp
It can be seen that the last 8 colors are brighter
versions of the first 8.
.Pp
For example, the two bytes
.Pp
.Dl "65 158"
.Pp
specify an uppercase A (character code 65), in
yellow (low nibble 15) on a light blue background
(high nibble 9).
.Pp
The
.Nm
output contains a small header which includes additional
information which may be useful to utilities processing
the output.
.Pp
The first 10 bytes are always arranged as follows:
.Bl -column "Byte range" "Contents" -offset indent
.It Sy "Byte Range Contents"
.It "1 thru 8 Literal text" Dq Li SCRSHOT_
.It "9 File format version number"
.It "10 Remaining number of bytes in the header"
.El
.Pp
Subsequent bytes depend on the version number.
.Bl -column "Version" "13 and up" -offset indent
.It Sy "Version Byte Meaning"
.It "1 11 Terminal width, in characters"
.It " 12 Terminal depth, in characters"
.It " 13 and up The snapshot data"
.El
.Pp
So a dump of an 80x25 screen would start (in hex)
.Bd -literal -offset indent
53 43 52 53 48 4f 54 5f 01 02 50 19
----------------------- -- -- -- --
| | | | ` 25 decimal
| | | `--- 80 decimal
| | `------ 2 remaining bytes of header data
| `--------- File format version 1
`------------------------ Literal "SCRSHOT_"
.Ed
.Sh VIDEO OUTPUT CONFIGURATION
.Ss Boot Time Configuration
You may set the following variables in
.Pa /etc/rc.conf
or
.Pa /etc/rc.conf.local
in order to configure the video output at boot time.
.Pp
.Bl -tag -width foo_bar_var -compact
.It Ar blanktime
Sets the timeout value for the
.Fl t
option.
.It Ar font8x16 , font8x14 , font8x8
Specifies font files for the
.Fl f
option.
.It Ar scrnmap
Specifies a screen output map file for the
.Fl l
option.
.El
.Pp
See
.Xr rc.conf 5
for more details.
.Ss Driver Configuration
The video card driver may let you change default configuration
options, such as the default font, so that you do not need to set up
the options at boot time.
See video card driver manuals, (e.g.\&
.Xr vga 4 )
for details.
.Sh FILES
.Bl -tag -width /usr/share/syscons/scrnmaps/foo-bar -compact
.It Pa /usr/share/syscons/fonts/*
font files.
.It Pa /usr/share/syscons/scrnmaps/*
screen output map files.
.El
.Sh EXAMPLES
If you want to load
.Pa /usr/share/syscons/fonts/iso-8x16.fnt
to the kernel, run
.Nm
as:
.Pp
.Dl vidcontrol -f 8x16 /usr/share/syscons/fonts/iso-8x16.fnt
.Pp
So long as the font file is in
.Pa /usr/share/syscons/fonts ,
you may abbreviate the file name as
.Pa iso-8x16 :
.Pp
.Dl vidcontrol -f 8x16 iso-8x16
.Pp
Furthermore, you can also omit font size
.Dq Li 8x16 :
.Pp
.Dl vidcontrol -f iso-8x16
.Pp
Moreover, the suffix specifying the font size can be also omitted; in
this case,
.Nm
will use the size of the currently displayed font to construct the
suffix:
.Pp
.Dl vidcontrol -f iso
.Pp
Likewise, you can also abbreviate the screen output map file name for
the
.Fl l
option if the file is found in
.Pa /usr/share/syscons/scrnmaps .
.Pp
.Dl vidcontrol -l iso-8859-1_to_cp437
.Pp
The above command will load
.Pa /usr/share/syscons/scrnmaps/iso-8859-1_to_cp437.scm .
.Pp
The following command will set-up a 100x37 raster text mode (useful for
some LCD models):
.Pp
.Dl vidcontrol -g 100x37 VESA_800x600
.Pp
The following command will capture the contents of the first virtual
terminal, and redirect the output to the
.Pa shot.scr
file:
.Pp
.Dl vidcontrol -p < /dev/ttyv0 > shot.scr
.Pp
The following command will dump contents of the fourth virtual terminal
to the standard output in the human readable format:
.Pp
.Dl vidcontrol -P < /dev/ttyv3
.Sh SEE ALSO
.Xr kbdcontrol 1 ,
.Xr vidfont 1 ,
.Xr keyboard 4 ,
.Xr screen 4 ,
.Xr syscons 4 ,
.Xr vga 4 ,
.Xr rc.conf 5 ,
.Xr kldload 8 ,
.Xr moused 8 ,
.Xr watch 8
.Pp
The various
.Li scr2*
utilities in the
.Li graphics
and
.Li textproc
categories of the
.Em "Ports Collection" .
.Sh AUTHORS
.An S\(/oren Schmidt Aq sos at FreeBSD.org
.An Sascha Wildner
-------------- next part --------------
/*-
* Copyright (c) 1994-1996 Søren Schmidt
* All rights reserved.
*
* 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,
* in this position and unchanged.
* 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.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software withough specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*
* $FreeBSD: src/usr.sbin/vidcontrol/vidcontrol.c,v 1.32.2.7 2002/09/15
22:31:50 dd Exp $
* $DragonFly: src/usr.sbin/vidcontrol/vidcontrol.c,v 1.6 2004/04/26 19:57:18
dillon Exp $
*/
#include <ctype.h>
#include <err.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/fbio.h>
#include <sys/consio.h>
#include <sys/errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "path.h"
#include "decode.h"
#define DATASIZE(x) ((x).w * (x).h * 256 / 8)
#define DUMP_RAW 0
#define DUMP_TXT 1
#define DUMP_FMT_REV 1
char legal_colors[16][16] = {
"black", "blue", "green", "cyan",
"red", "magenta", "brown", "white",
"grey", "lightblue", "lightgreen", "lightcyan",
"lightred", "lightmagenta", "yellow", "lightwhite"
};
struct {
int active_vty;
vid_info_t console_info;
unsigned char screen_map[256];
int video_mode_number;
struct video_info video_mode_info;
} cur_info;
int hex = 0;
int number;
int vesa_cols;
int vesa_rows;
int font_height;
int colors_changed;
int video_mode_changed;
int normal_fore_color, normal_back_color,
revers_fore_color, revers_back_color;
char letter;
struct vid_info info;
struct video_info new_mode_info;
/*
* Initialize revert data.
*
* NOTE: the following parameters are not yet saved/restored:
*
* screen saver timeout
* cursor type
* mouse character and mouse show/hide state
* vty switching on/off state
* history buffer size
* history contents
* font maps
*/
void
init()
{
if (ioctl(0, VT_GETACTIVE, &cur_info.active_vty) == -1)
errc(1, errno, "getting active vty");
cur_info.console_info.size = sizeof(cur_info.console_info);
if (ioctl(0, CONS_GETINFO, &cur_info.console_info) == -1)
errc(1, errno, "getting console information");
if (ioctl(0, GIO_SCRNMAP, &cur_info.screen_map) == -1)
errc(1, errno, "getting screen map");
if (ioctl(0, CONS_GET, &cur_info.video_mode_number) == -1)
errc(1, errno, "getting video mode number");
cur_info.video_mode_info.vi_mode = cur_info.video_mode_number;
if (ioctl(0, CONS_MODEINFO, &cur_info.video_mode_info) == -1)
errc(1, errno, "getting video mode parameters");
normal_fore_color = cur_info.console_info.mv_norm.fore;
normal_back_color = cur_info.console_info.mv_norm.back;
revers_fore_color = cur_info.console_info.mv_rev.fore;
revers_back_color = cur_info.console_info.mv_rev.back;
}
/*
* If something goes wrong along the way we call revert() to go back to the
* console state we came from (which is assumed to be working).
*
* NOTE: please also read the comments of init().
*/
void
revert()
{
int size[3];
ioctl(0, VT_ACTIVATE, (caddr_t) (long) cur_info.active_vty);
fprintf(stderr, "[=%dA", cur_info.console_info.mv_ovscan);
fprintf(stderr, "[=%dF", cur_info.console_info.mv_norm.fore);
fprintf(stderr, "[=%dG", cur_info.console_info.mv_norm.back);
fprintf(stderr, "[=%dH", cur_info.console_info.mv_rev.fore);
fprintf(stderr, "[=%dI", cur_info.console_info.mv_rev.back);
ioctl(0, PIO_SCRNMAP, &cur_info.screen_map);
if (cur_info.video_mode_number >= M_VESA_BASE)
ioctl(0, _IO('V', cur_info.video_mode_number - M_VESA_BASE), NULL);
else
ioctl(0, _IO('S', cur_info.video_mode_number), NULL);
if (cur_info.video_mode_info.vi_flags & V_INFO_GRAPHICS) {
size[0] = cur_info.video_mode_info.vi_width / 8;
size[1] = cur_info.video_mode_info.vi_height /
cur_info.console_info.font_size;
size[2] = cur_info.console_info.font_size;
ioctl(0, KDRASTER, size);
}
}
/*
* Print a short usage string describing all options, then exit.
*/
static void
usage(void)
{
fprintf(stderr,
"usage: vidcontrol [-CdLPpx] [-b color] [-c appearance] [-f
[size]"
" file]\n"
" [-g geometry] [-h size] [-i adapter | mode]
[-l"
" screen_map]\n"
" [-M char] [-m on | off] [-r foreground"
" background]\n"
" [-S on | off] [-s number] [-t N | off]
[mode]\n"
" [foreground [background]] [show]\n");
exit(1);
}
/*
* Retrieve the next argument from the command line (for options that require
* more than one argument).
*/
char *
nextarg(int ac, char **av, int *indp, int oc, int strict)
{
if (*indp < ac)
return(av[(*indp)++]);
if (strict != 0) {
revert();
errx(1, "option requires two arguments -- %c", oc);
}
return(NULL);
}
/*
* Guess which file to open. Try to open each combination of a specified set
* of file name components.
*/
FILE *
openguess(char *a[], char *b[], char *c[], char *d[], char **name)
{
FILE *f;
int i, j, k, l;
for (i = 0; a[i] != NULL; i++) {
for (j = 0; b[j] != NULL; j++) {
for (k = 0; c[k] != NULL; k++) {
for (l = 0; d[l] != NULL; l++) {
asprintf(name, "%s%s%s%s", a[i], b[j], c[k], d[l]);
f = fopen(*name, "r");
if (f != NULL)
return (f);
free(*name);
}
}
}
}
return (NULL);
}
/*
* Load a screenmap from a file and set it.
*/
void
load_scrnmap(char *filename)
{
FILE *fd;
int size;
char *name;
scrmap_t scrnmap;
char *a[] = {"", SCRNMAP_PATH, NULL};
char *b[] = {filename, NULL};
char *c[] = {"", ".scm", NULL};
char *d[] = {"", NULL};
fd = openguess(a, b, c, d, &name);
if (fd == NULL) {
revert();
errx(1, "screenmap file not found");
}
size = sizeof(scrnmap);
if (decode(fd, (char *)&scrnmap, size) != size) {
rewind(fd);
if (fread(&scrnmap, 1, size, fd) != size) {
fclose(fd);
revert();
errx(1, "bad screenmap file");
}
}
if (ioctl(0, PIO_SCRNMAP, &scrnmap) == -1) {
revert();
errc(1, errno, "loading screenmap");
}
fclose(fd);
}
/*
* Set the default screenmap.
*/
void
load_default_scrnmap(void)
{
scrmap_t scrnmap;
int i;
for (i = 0; i < 256; i++)
*((char*)&scrnmap + i) = i;
if (ioctl(0, PIO_SCRNMAP, &scrnmap) == -1) {
revert();
errc(1, errno, "loading default screenmap");
}
}
/*
* Print the current screenmap to stdout.
*/
void
print_scrnmap(void)
{
unsigned char map[256];
int i;
if (ioctl(0, GIO_SCRNMAP, &map) == -1) {
revert();
errc(1, errno, "getting screenmap");
}
for (i=0; i<sizeof(map); i++) {
if (i > 0 && i % 16 == 0)
fprintf(stdout, "\n");
if (hex)
fprintf(stdout, " %02x", map[i]);
else
fprintf(stdout, " %03d", map[i]);
}
fprintf(stdout, "\n");
}
/*
* Determine a file's size.
*/
int
fsize(FILE *file)
{
struct stat sb;
if (fstat(fileno(file), &sb) == 0)
return sb.st_size;
else
return -1;
}
/*
* Load a font from file and set it.
*/
void
load_font(char *type, char *filename)
{
FILE *fd;
int h, i, size, w;
unsigned long io = 0; /* silence stupid gcc(1) in the Wall mode */
char *name, *fontmap, size_sufx[6];
char *a[] = {"", FONT_PATH, NULL};
char *b[] = {filename, NULL};
char *c[] = {"", size_sufx, NULL};
char *d[] = {"", ".fnt", NULL};
vid_info_t info;
struct sizeinfo {
int w;
int h;
unsigned long io;
} sizes[] = {{8, 16, PIO_FONT8x16},
{8, 14, PIO_FONT8x14},
{8, 8, PIO_FONT8x8},
{0, 0, 0}};
info.size = sizeof(info);
if (ioctl(0, CONS_GETINFO, &info) == -1) {
revert();
errc(1, errno, "obtaining current video mode parameters");
}
snprintf(size_sufx, sizeof(size_sufx), "-8x%d", info.font_size);
fd = openguess(a, b, c, d, &name);
if (fd == NULL) {
revert();
errx(1, "%s: can't load font file", filename);
}
if (type != NULL) {
size = 0;
if (sscanf(type, "%dx%d", &w, &h) == 2)
for (i = 0; sizes[i].w != 0; i++) {
if (sizes[i].w == w && sizes[i].h == h) {
size = DATASIZE(sizes[i]);
io = sizes[i].io;
font_height = sizes[i].h;
}
}
if (size == 0) {
fclose(fd);
revert();
errx(1, "%s: bad font size specification", type);
}
} else {
/* Apply heuristics */
int j;
int dsize[2];
size = DATASIZE(sizes[0]);
fontmap = (char*) malloc(size);
dsize[0] = decode(fd, fontmap, size);
dsize[1] = fsize(fd);
free(fontmap);
size = 0;
for (j = 0; j < 2; j++) {
for (i = 0; sizes[i].w != 0; i++) {
if (DATASIZE(sizes[i]) == dsize[j]) {
size = dsize[j];
io = sizes[i].io;
font_height = sizes[i].h;
j = 2; /* XXX */
break;
}
}
}
if (size == 0) {
fclose(fd);
revert();
errx(1, "%s: can't guess font size", filename);
}
rewind(fd);
}
fontmap = (char*) malloc(size);
if (decode(fd, fontmap, size) != size) {
rewind(fd);
if (fsize(fd) != size || fread(fontmap, 1, size, fd) != size) {
fclose(fd);
free(fontmap);
revert();
errx(1, "%s: bad font file", filename);
}
}
if (ioctl(0, io, fontmap) == -1) {
revert();
errc(1, errno, "loading font");
}
fclose(fd);
free(fontmap);
}
/*
* Set the timeout for the screensaver.
*/
void
set_screensaver_timeout(char *arg)
{
int nsec;
if (!strcmp(arg, "off")) {
nsec = 0;
} else {
nsec = atoi(arg);
if ((*arg == '\0') || (nsec < 1)) {
revert();
errx(1, "argument must be a positive number");
}
}
if (ioctl(0, CONS_BLANKTIME, &nsec) == -1) {
revert();
errc(1, errno, "setting screensaver period");
}
}
/*
* Set the cursor's shape/type.
*/
void
set_cursor_type(char *appearance)
{
int type;
if (!strcmp(appearance, "normal"))
type = 0;
else if (!strcmp(appearance, "blink"))
type = 1;
else if (!strcmp(appearance, "destructive"))
type = 3;
else {
revert();
errx(1, "argument to -c must be normal, blink or destructive");
}
if (ioctl(0, CONS_CURSORTYPE, &type) == -1) {
revert();
errc(1, errno, "setting cursor type");
}
}
/*
* Set the video mode.
*/
void
video_mode(int argc, char **argv, int *index)
{
static struct {
char *name;
unsigned long mode;
unsigned long mode_num;
} modes[] = {{ "80x25", SW_TEXT_80x25, M_TEXT_80x25 },
{ "80x30", SW_TEXT_80x30, M_TEXT_80x30 },
{ "80x43", SW_TEXT_80x43, M_TEXT_80x43 },
{ "80x50", SW_TEXT_80x50, M_TEXT_80x50 },
{ "80x60", SW_TEXT_80x60, M_TEXT_80x60 },
{ "132x25", SW_TEXT_132x25, M_TEXT_132x25 },
{ "132x30", SW_TEXT_132x30, M_TEXT_132x30 },
{ "132x43", SW_TEXT_132x43, M_TEXT_132x43 },
{ "132x50", SW_TEXT_132x50, M_TEXT_132x50 },
{ "132x60", SW_TEXT_132x60, M_TEXT_132x60 },
{ "VGA_40x25", SW_VGA_C40x25, M_VGA_C40x25 },
{ "VGA_80x25", SW_VGA_C80x25, M_VGA_C80x25 },
{ "VGA_80x30", SW_VGA_C80x30, M_VGA_C80x30 },
{ "VGA_80x50", SW_VGA_C80x50, M_VGA_C80x50 },
{ "VGA_80x60", SW_VGA_C80x60, M_VGA_C80x60 },
#ifdef SW_VGA_C90x25
{ "VGA_90x25", SW_VGA_C90x25, M_VGA_C90x25 },
{ "VGA_90x30", SW_VGA_C90x30, M_VGA_C90x30 },
{ "VGA_90x43", SW_VGA_C90x43, M_VGA_C90x43 },
{ "VGA_90x50", SW_VGA_C90x50, M_VGA_C90x50 },
{ "VGA_90x60", SW_VGA_C90x60, M_VGA_C90x60 },
#endif
{ "VGA_320x200", SW_VGA_CG320, M_CG320 },
{ "EGA_80x25", SW_ENH_C80x25, M_ENH_C80x25 },
{ "EGA_80x43", SW_ENH_C80x43, M_ENH_C80x43 },
{ "VESA_132x25", SW_VESA_C132x25, M_VESA_C132x25 },
{ "VESA_132x43", SW_VESA_C132x43, M_VESA_C132x43 },
{ "VESA_132x50", SW_VESA_C132x50, M_VESA_C132x50 },
{ "VESA_132x60", SW_VESA_C132x60, M_VESA_C132x60 },
{ "VESA_800x600", SW_VESA_800x600, M_VESA_800x600 },
{ NULL },
};
int new_mode_num = 0;
unsigned long mode = 0;
int size[3];
int i;
/*
* Parse the video mode argument...
*/
if (*index < argc) {
if (!strncmp(argv[*index], "MODE_", 5)) {
if (!isnumber(argv[*index][5]))
errx(1, "invalid video mode number");
new_mode_num = atoi(&argv[*index][5]);
} else {
for (i = 0; modes[i].name != NULL; ++i) {
if (!strcmp(argv[*index], modes[i].name)) {
mode = modes[i].mode;
new_mode_num = modes[i].mode_num;
break;
}
}
if (modes[i].name == NULL)
errx(1, "invalid video mode name");
}
/*
* Collect enough information about the new video mode...
*/
new_mode_info.vi_mode = new_mode_num;
if (ioctl(0, CONS_MODEINFO, &new_mode_info) == -1) {
revert();
errc(1, errno, "obtaining new video mode parameters");
}
if (mode == 0) {
if (new_mode_num >= M_VESA_BASE)
mode = _IO('V', new_mode_num - M_VESA_BASE);
else
mode = _IO('S', new_mode_num);
}
/*
* Try setting the new mode.
*/
if (ioctl(0, mode, NULL) == -1) {
revert();
errc(1, errno, "setting video mode");
}
/*
* For raster modes it's not enough to just set the mode. We also
* need to explicitly set the raster mode.
*/
if (new_mode_info.vi_flags & V_INFO_GRAPHICS) {
/* font size */
if (font_height == 0)
font_height = cur_info.console_info.font_size;
size[2] = font_height;
/* adjust columns */
if ((vesa_cols * 8 > new_mode_info.vi_width) ||
(vesa_cols <= 0)
) {
size[0] = new_mode_info.vi_width / 8;
} else {
size[0] = vesa_cols;
}
/* adjust rows */
if ((vesa_rows * font_height > new_mode_info.vi_height) ||
(vesa_rows <= 0)
) {
size[1] = new_mode_info.vi_height / font_height;
} else {
size[1] = vesa_rows;
}
/* set raster mode */
if (ioctl(0, KDRASTER, size)) {
revert();
errc(1, errno, "activating raster display");
}
}
video_mode_changed = 1;
(*index)++;
}
return;
}
/*
* Return the number for a specified color name.
*/
int
get_color_number(char *color)
{
int i;
for (i=0; i<16; i++) {
if (!strcmp(color, legal_colors[i]))
return i;
}
return -1;
}
/*
* Get normal text and background colors.
*/
void
get_normal_colors(int argc, char **argv, int *index)
{
int color;
if (*index < argc && (color = get_color_number(argv[*index])) != -1) {
(*index)++;
normal_fore_color = color;
colors_changed = 1;
if (*index < argc && (color = get_color_number(argv[*index])) != -1)
{
(*index)++;
normal_back_color = color;
}
}
}
/*
* Get reverse text and background colors.
*/
void
get_reverse_colors(int argc, char **argv, int *index)
{
int color;
if ((color = get_color_number(argv[*(index)-1])) != -1) {
revers_fore_color = color;
colors_changed = 1;
if (*index < argc && (color = get_color_number(argv[*index])) != -1)
{
(*index)++;
revers_back_color = color;
}
}
}
/*
* Set normal and reverse foreground and background colors.
*/
void
set_colors()
{
fprintf(stderr, "[=%dF", normal_fore_color);
fprintf(stderr, "[=%dG", normal_back_color);
fprintf(stderr, "[=%dH", revers_fore_color);
fprintf(stderr, "[=%dI", revers_back_color);
}
/*
* Switch to virtual terminal #arg.
*/
void
set_console(char *arg)
{
int n;
if(!arg || strspn(arg,"0123456789") != strlen(arg)) {
revert();
errx(1, "bad console number");
}
n = atoi(arg);
if (n < 1 || n > 16) {
revert();
errx(1, "console number out of range");
} else if (ioctl(0, VT_ACTIVATE, (caddr_t) (long) n) == -1) {
revert();
errc(1, errno, "switching vty");
}
}
/*
* Sets the border color.
*/
void
set_border_color(char *arg)
{
int color;
if ((color = get_color_number(arg)) != -1)
fprintf(stderr, "[=%dA", color);
else
usage();
}
void
set_mouse_char(char *arg)
{
struct mouse_info mouse;
long l;
l = strtol(arg, NULL, 0);
if ((l < 0) || (l > UCHAR_MAX)) {
revert();
errx(1, "argument to -M must be 0 through %d", UCHAR_MAX);
}
mouse.operation = MOUSE_MOUSECHAR;
mouse.u.mouse_char = (int)l;
if (ioctl(0, CONS_MOUSECTL, &mouse) == -1) {
revert();
errc(1, errno, "setting mouse character");
}
}
/*
* Show/hide the mouse.
*/
void
set_mouse(char *arg)
{
struct mouse_info mouse;
if (!strcmp(arg, "on")) {
mouse.operation = MOUSE_SHOW;
} else if (!strcmp(arg, "off")) {
mouse.operation = MOUSE_HIDE;
} else {
revert();
errx(1, "argument to -m must be either on or off");
}
if (ioctl(0, CONS_MOUSECTL, &mouse) == -1) {
revert();
errc(1, errno, "%sing the mouse",
mouse.operation == MOUSE_SHOW ? "show" : "hid");
}
}
void
set_lockswitch(char *arg)
{
int data;
if (!strcmp(arg, "off")) {
data = 0x01;
} else if (!strcmp(arg, "on")) {
data = 0x02;
} else {
revert();
errx(1, "argument to -S must be either on or off");
}
if (ioctl(0, VT_LOCKSWITCH, &data) == -1) {
revert();
errc(1, errno, "turning %s vty switching",
data == 0x01 ? "off" : "on");
}
}
/*
* Return the adapter name for a specified type.
*/
static char
*adapter_name(int type)
{
static struct {
int type;
char *name;
} names[] = {{ KD_MONO, "MDA" },
{ KD_HERCULES, "Hercules" },
{ KD_CGA, "CGA" },
{ KD_EGA, "EGA" },
{ KD_VGA, "VGA" },
{ KD_PC98, "PC-98xx" },
{ KD_TGA, "TGA" },
{ -1, "Unknown" },
};
int i;
for (i = 0; names[i].type != -1; ++i) {
if (names[i].type == type)
break;
}
return names[i].name;
}
/*
* Show graphics adapter information.
*/
void
show_adapter_info(void)
{
struct video_adapter_info ad;
ad.va_index = 0;
if (ioctl(0, CONS_ADPINFO, &ad) == -1) {
revert();
errc(1, errno, "obtaining adapter information");
}
printf("fb%d:\n", ad.va_index);
printf(" %.*s%d, type:%s%s (%d), flags:0x%x\n",
(int)sizeof(ad.va_name), ad.va_name, ad.va_unit,
(ad.va_flags & V_ADP_VESA) ? "VESA " : "",
adapter_name(ad.va_type), ad.va_type, ad.va_flags);
printf(" initial mode:%d, current mode:%d, BIOS mode:%d\n",
ad.va_initial_mode, ad.va_mode, ad.va_initial_bios_mode);
printf(" frame buffer window:0x%x, buffer size:0x%x\n",
ad.va_window, ad.va_buffer_size);
printf(" window size:0x%x, origin:0x%x\n",
ad.va_window_size, ad.va_window_orig);
printf(" display start address (%d, %d), scan line width:%d\n",
ad.va_disp_start.x, ad.va_disp_start.y, ad.va_line_width);
printf(" reserved:0x%x\n", ad.va_unused0);
}
/*
* Show video mode information.
*/
void
show_mode_info(void)
{
struct video_info info;
char buf[80];
int mode;
int c;
printf(" mode# flags type size "
"font window linear buffer\n");
printf("---------------------------------------"
"---------------------------------------\n");
for (mode = 0; mode < M_VESA_MODE_MAX; ++mode) {
info.vi_mode = mode;
if (ioctl(0, CONS_MODEINFO, &info))
continue;
if (info.vi_mode != mode)
continue;
printf("%3d (0x%03x)", mode, mode);
printf(" 0x%08x", info.vi_flags);
if (info.vi_flags & V_INFO_GRAPHICS) {
c = 'G';
snprintf(buf, sizeof(buf), "%dx%dx%d %d",
info.vi_width, info.vi_height,
info.vi_depth, info.vi_planes);
} else {
c = 'T';
snprintf(buf, sizeof(buf), "%dx%d",
info.vi_width, info.vi_height);
}
printf(" %c %-15s", c, buf);
snprintf(buf, sizeof(buf), "%dx%d",
info.vi_cwidth, info.vi_cheight);
printf(" %-5s", buf);
printf(" 0x%05x %2dk %2dk",
info.vi_window, (int)info.vi_window_size / 1024,
(int)info.vi_window_gran/1024);
printf(" 0x%08x %dk\n",
info.vi_buffer, (int)info.vi_buffer_size / 1024);
}
}
void
show_info(char *arg)
{
if (!strcmp(arg, "adapter")) {
show_adapter_info();
} else if (!strcmp(arg, "mode")) {
show_mode_info();
} else {
revert();
errx(1, "argument to -i must be either adapter or mode");
}
}
void
test_frame(void)
{
int i;
fprintf(stdout, "[=0G\n\n");
for (i = 0; i < 8; i++) {
fprintf(stdout, "[=15F[=0G %2d [=%dF%-16s"
"[=15F[=0G %2d [=%dF%-16s "
"[=15F %2d [=%dGBACKGROUND[=0G\n",
i, i, legal_colors[i], i+8, i+8,
legal_colors[i+8], i, i);
}
fprintf(stdout, "[=%dF[=%dG[=%dH[=%dI\n",
info.mv_norm.fore, info.mv_norm.back,
info.mv_rev.fore, info.mv_rev.back);
}
/*
* Snapshot the video memory of that terminal, using the CONS_SCRSHOT
* ioctl, and writes the results to stdout either in the special
* binary format (see manual page for details), or in the plain
* text format.
*/
void
dump_screen(int mode)
{
scrshot_t shot;
vid_info_t info;
info.size = sizeof(info);
if (ioctl(0, CONS_GETINFO, &info) == -1) {
revert();
errc(1, errno, "obtaining current video mode parameters");
}
shot.buf = alloca(info.mv_csz * info.mv_rsz * sizeof(u_int16_t));
if (shot.buf == NULL) {
revert();
errx(1, "failed to allocate memory for dump");
}
shot.xsize = info.mv_csz;
shot.ysize = info.mv_rsz;
if (ioctl(0, CONS_SCRSHOT, &shot) == -1) {
revert();
errc(1, errno, "dumping screen");
}
if (mode == DUMP_RAW) {
printf("SCRSHOT_%c%c%c%c", DUMP_FMT_REV, 2,
shot.xsize, shot.ysize);
fflush(stdout);
(void)write(STDOUT_FILENO, shot.buf,
shot.xsize * shot.ysize * sizeof(u_int16_t));
} else {
char *line;
int x, y;
u_int16_t ch;
line = alloca(shot.xsize + 1);
if (line == NULL) {
revert();
errx(1, "failed to allocate memory for line buffer");
}
for (y = 0; y < shot.ysize; y++) {
for (x = 0; x < shot.xsize; x++) {
ch = shot.buf[x + (y * shot.xsize)];
ch &= 0xff;
if (isprint(ch) == 0)
ch = ' ';
line[x] = (char)ch;
}
/* Trim trailing spaces */
do {
line[x--] = '\0';
} while (line[x] == ' ' && x != 0);
puts(line);
}
fflush(stdout);
}
return;
}
/*
* Set the console history buffer size.
*/
void
set_history(char *opt)
{
int size;
size = atoi(opt);
if ((*opt == '\0') || size < 0) {
revert();
errx(1, "argument must be a positive number");
}
if (ioctl(0, CONS_HISTORY, &size) == -1) {
revert();
errc(1, errno, "setting history buffer size");
}
}
/*
* Clear the console history buffer.
*/
void
clear_history(void)
{
if (ioctl(0, CONS_CLRHIST) == -1) {
revert();
errc(1, errno, "clearing history buffer");
}
}
int
main(int argc, char **argv)
{
char *font, *type;
int opt;
if (argc == 1)
usage();
init();
info.size = sizeof(info);
if (ioctl(0, CONS_GETINFO, &info) == -1)
err(1, "must be on a virtual console");
while((opt = getopt(argc, argv, "b:Cc:df:g:h:i:l:LM:m:pPr:S:s:t:x")) !=
-1) {
switch(opt) {
case 'b':
set_border_color(optarg);
break;
case 'C':
clear_history();
break;
case 'c':
set_cursor_type(optarg);
break;
case 'd':
print_scrnmap();
break;
case 'f':
type = optarg;
font = nextarg(argc, argv, &optind, 'f', 0);
if (font == NULL) {
type = NULL;
font = optarg;
}
load_font(type, font);
break;
case 'g':
if (sscanf(optarg, "%dx%d", &vesa_cols, &vesa_rows) != 2) {
revert();
warnx("incorrect geometry: %s", optarg);
usage();
}
break;
case 'h':
set_history(optarg);
break;
case 'i':
show_info(optarg);
break;
case 'l':
load_scrnmap(optarg);
break;
case 'L':
load_default_scrnmap();
break;
case 'M':
set_mouse_char(optarg);
break;
case 'm':
set_mouse(optarg);
break;
case 'p':
dump_screen(DUMP_RAW);
break;
case 'P':
dump_screen(DUMP_TXT);
break;
case 'r':
get_reverse_colors(argc, argv, &optind);
break;
case 'S':
set_lockswitch(optarg);
break;
case 's':
set_console(optarg);
break;
case 't':
set_screensaver_timeout(optarg);
break;
case 'x':
hex = 1;
break;
default:
usage();
}
}
video_mode(argc, argv, &optind);
get_normal_colors(argc, argv, &optind);
if (colors_changed || video_mode_changed) {
if (!(new_mode_info.vi_flags & V_INFO_GRAPHICS)) {
if ((normal_back_color < 8) && (revers_back_color < 8)) {
set_colors();
} else {
revert();
errx(1, "background colors for text video modes must be <
8");
}
} else {
set_colors();
}
}
if (optind < argc && !strcmp(argv[optind], "show")) {
test_frame();
optind++;
}
if ((optind != argc) || (argc == 1))
usage();
return 0;
}
More information about the freebsd-current
mailing list