1219888Sed/*- 2219888Sed * Copyright (c) 2005 Marcel Moolenaar 3219888Sed * All rights reserved. 4219888Sed * 5219888Sed * Copyright (c) 2009 The FreeBSD Foundation 6219888Sed * All rights reserved. 7219888Sed * 8219888Sed * Portions of this software were developed by Ed Schouten 9219888Sed * under sponsorship from the FreeBSD Foundation. 10219888Sed * 11219888Sed * Redistribution and use in source and binary forms, with or without 12219888Sed * modification, are permitted provided that the following conditions 13219888Sed * are met: 14219888Sed * 1. Redistributions of source code must retain the above copyright 15219888Sed * notice, this list of conditions and the following disclaimer. 16219888Sed * 2. Redistributions in binary form must reproduce the above copyright 17219888Sed * notice, this list of conditions and the following disclaimer in the 18219888Sed * documentation and/or other materials provided with the distribution. 19219888Sed * 20219888Sed * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 21219888Sed * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22219888Sed * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23219888Sed * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 24219888Sed * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25219888Sed * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26219888Sed * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27219888Sed * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28219888Sed * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29219888Sed * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30219888Sed * SUCH DAMAGE. 31219888Sed */ 32219888Sed 33219888Sed#include <sys/cdefs.h> 34219888Sed__FBSDID("$FreeBSD: releng/10.2/sys/dev/vt/hw/vga/vt_vga.c 271769 2014-09-18 14:38:18Z dumbbell $"); 35219888Sed 36219888Sed#include <sys/param.h> 37219888Sed#include <sys/kernel.h> 38219888Sed#include <sys/systm.h> 39219888Sed 40219888Sed#include <dev/vt/vt.h> 41267622Sray#include <dev/vt/hw/vga/vt_vga_reg.h> 42219888Sed 43219888Sed#include <machine/bus.h> 44219888Sed 45219888Sed#if defined(__amd64__) || defined(__i386__) 46219888Sed#include <vm/vm.h> 47219888Sed#include <vm/pmap.h> 48219888Sed#include <machine/pmap.h> 49219888Sed#include <machine/vmparam.h> 50219888Sed#endif /* __amd64__ || __i386__ */ 51219888Sed 52219888Sedstruct vga_softc { 53219888Sed bus_space_tag_t vga_fb_tag; 54219888Sed bus_space_handle_t vga_fb_handle; 55219888Sed bus_space_tag_t vga_reg_tag; 56219888Sed bus_space_handle_t vga_reg_handle; 57271128Semaste int vga_wmode; 58271128Semaste term_color_t vga_curfg, vga_curbg; 59219888Sed}; 60219888Sed 61219888Sed/* Convenience macros. */ 62219888Sed#define MEM_READ1(sc, ofs) \ 63219888Sed bus_space_read_1(sc->vga_fb_tag, sc->vga_fb_handle, ofs) 64219888Sed#define MEM_WRITE1(sc, ofs, val) \ 65219888Sed bus_space_write_1(sc->vga_fb_tag, sc->vga_fb_handle, ofs, val) 66219888Sed#define REG_READ1(sc, reg) \ 67219888Sed bus_space_read_1(sc->vga_reg_tag, sc->vga_reg_handle, reg) 68219888Sed#define REG_WRITE1(sc, reg, val) \ 69219888Sed bus_space_write_1(sc->vga_reg_tag, sc->vga_reg_handle, reg, val) 70219888Sed 71219888Sed#define VT_VGA_WIDTH 640 72219888Sed#define VT_VGA_HEIGHT 480 73219888Sed#define VT_VGA_MEMSIZE (VT_VGA_WIDTH * VT_VGA_HEIGHT / 8) 74219888Sed 75271128Semaste/* 76271128Semaste * VGA is designed to handle 8 pixels at a time (8 pixels in one byte of 77271128Semaste * memory). 78271128Semaste */ 79271128Semaste#define VT_VGA_PIXELS_BLOCK 8 80271128Semaste 81271128Semaste/* 82271128Semaste * We use an off-screen addresses to: 83271128Semaste * o store the background color; 84271128Semaste * o store pixels pattern. 85271128Semaste * Those addresses are then loaded in the latches once. 86271128Semaste */ 87271128Semaste#define VT_VGA_BGCOLOR_OFFSET VT_VGA_MEMSIZE 88271128Semaste 89265403Sraystatic vd_probe_t vga_probe; 90219888Sedstatic vd_init_t vga_init; 91219888Sedstatic vd_blank_t vga_blank; 92271128Semastestatic vd_bitblt_text_t vga_bitblt_text; 93271128Semastestatic vd_bitblt_bmp_t vga_bitblt_bitmap; 94261585Sraystatic vd_drawrect_t vga_drawrect; 95261585Sraystatic vd_setpixel_t vga_setpixel; 96260450Sraystatic vd_postswitch_t vga_postswitch; 97219888Sed 98219888Sedstatic const struct vt_driver vt_vga_driver = { 99265403Sray .vd_name = "vga", 100265403Sray .vd_probe = vga_probe, 101219888Sed .vd_init = vga_init, 102219888Sed .vd_blank = vga_blank, 103271128Semaste .vd_bitblt_text = vga_bitblt_text, 104271128Semaste .vd_bitblt_bmp = vga_bitblt_bitmap, 105261585Sray .vd_drawrect = vga_drawrect, 106261585Sray .vd_setpixel = vga_setpixel, 107260450Sray .vd_postswitch = vga_postswitch, 108256145Sray .vd_priority = VD_PRIORITY_GENERIC, 109219888Sed}; 110219888Sed 111219888Sed/* 112219888Sed * Driver supports both text mode and graphics mode. Make sure the 113219888Sed * buffer is always big enough to support both. 114219888Sed */ 115219888Sedstatic struct vga_softc vga_conssoftc; 116265403SrayVT_DRIVER_DECLARE(vt_vga, vt_vga_driver); 117219888Sed 118219888Sedstatic inline void 119271128Semastevga_setwmode(struct vt_device *vd, int wmode) 120219888Sed{ 121219888Sed struct vga_softc *sc = vd->vd_softc; 122219888Sed 123271128Semaste if (sc->vga_wmode == wmode) 124271128Semaste return; 125219888Sed 126271128Semaste REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_MODE); 127271128Semaste REG_WRITE1(sc, VGA_GC_DATA, wmode); 128271128Semaste sc->vga_wmode = wmode; 129219888Sed 130271128Semaste switch (wmode) { 131271128Semaste case 3: 132271128Semaste /* Re-enable all plans. */ 133271128Semaste REG_WRITE1(sc, VGA_SEQ_ADDRESS, VGA_SEQ_MAP_MASK); 134271128Semaste REG_WRITE1(sc, VGA_SEQ_DATA, VGA_SEQ_MM_EM3 | VGA_SEQ_MM_EM2 | 135271128Semaste VGA_SEQ_MM_EM1 | VGA_SEQ_MM_EM0); 136271128Semaste break; 137271128Semaste } 138219888Sed} 139219888Sed 140219888Sedstatic inline void 141271128Semastevga_setfg(struct vt_device *vd, term_color_t color) 142219888Sed{ 143219888Sed struct vga_softc *sc = vd->vd_softc; 144219888Sed 145271128Semaste vga_setwmode(vd, 3); 146219888Sed 147271128Semaste if (sc->vga_curfg == color) 148271128Semaste return; 149261585Sray 150271128Semaste REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_SET_RESET); 151271128Semaste REG_WRITE1(sc, VGA_GC_DATA, color); 152271128Semaste sc->vga_curfg = color; 153261585Sray} 154261585Sray 155219888Sedstatic inline void 156271128Semastevga_setbg(struct vt_device *vd, term_color_t color) 157219888Sed{ 158271128Semaste struct vga_softc *sc = vd->vd_softc; 159219888Sed 160271128Semaste vga_setwmode(vd, 3); 161219888Sed 162271128Semaste if (sc->vga_curbg == color) 163263885Sray return; 164263885Sray 165271128Semaste REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_SET_RESET); 166271128Semaste REG_WRITE1(sc, VGA_GC_DATA, color); 167263885Sray 168271128Semaste /* 169271128Semaste * Write 8 pixels using the background color to an off-screen 170271128Semaste * byte in the video memory. 171271128Semaste */ 172271128Semaste MEM_WRITE1(sc, VT_VGA_BGCOLOR_OFFSET, 0xff); 173263885Sray 174271128Semaste /* 175271128Semaste * Read those 8 pixels back to load the background color in the 176271128Semaste * latches register. 177271128Semaste */ 178271128Semaste MEM_READ1(sc, VT_VGA_BGCOLOR_OFFSET); 179219888Sed 180271128Semaste sc->vga_curbg = color; 181219888Sed 182271128Semaste /* 183271128Semaste * The Set/Reset register doesn't contain the fg color anymore, 184271128Semaste * store an invalid color. 185271128Semaste */ 186271128Semaste sc->vga_curfg = 0xff; 187219888Sed} 188219888Sed 189219888Sed/* 190219888Sed * Binary searchable table for Unicode to CP437 conversion. 191219888Sed */ 192219888Sed 193219888Sedstruct unicp437 { 194219888Sed uint16_t unicode_base; 195219888Sed uint8_t cp437_base; 196219888Sed uint8_t length; 197219888Sed}; 198219888Sed 199219888Sedstatic const struct unicp437 cp437table[] = { 200219888Sed { 0x0020, 0x20, 0x5e }, { 0x00a0, 0x20, 0x00 }, 201219888Sed { 0x00a1, 0xad, 0x00 }, { 0x00a2, 0x9b, 0x00 }, 202219888Sed { 0x00a3, 0x9c, 0x00 }, { 0x00a5, 0x9d, 0x00 }, 203219888Sed { 0x00a7, 0x15, 0x00 }, { 0x00aa, 0xa6, 0x00 }, 204219888Sed { 0x00ab, 0xae, 0x00 }, { 0x00ac, 0xaa, 0x00 }, 205219888Sed { 0x00b0, 0xf8, 0x00 }, { 0x00b1, 0xf1, 0x00 }, 206219888Sed { 0x00b2, 0xfd, 0x00 }, { 0x00b5, 0xe6, 0x00 }, 207219888Sed { 0x00b6, 0x14, 0x00 }, { 0x00b7, 0xfa, 0x00 }, 208219888Sed { 0x00ba, 0xa7, 0x00 }, { 0x00bb, 0xaf, 0x00 }, 209219888Sed { 0x00bc, 0xac, 0x00 }, { 0x00bd, 0xab, 0x00 }, 210219888Sed { 0x00bf, 0xa8, 0x00 }, { 0x00c4, 0x8e, 0x01 }, 211219888Sed { 0x00c6, 0x92, 0x00 }, { 0x00c7, 0x80, 0x00 }, 212219888Sed { 0x00c9, 0x90, 0x00 }, { 0x00d1, 0xa5, 0x00 }, 213219888Sed { 0x00d6, 0x99, 0x00 }, { 0x00dc, 0x9a, 0x00 }, 214219888Sed { 0x00df, 0xe1, 0x00 }, { 0x00e0, 0x85, 0x00 }, 215219888Sed { 0x00e1, 0xa0, 0x00 }, { 0x00e2, 0x83, 0x00 }, 216219888Sed { 0x00e4, 0x84, 0x00 }, { 0x00e5, 0x86, 0x00 }, 217219888Sed { 0x00e6, 0x91, 0x00 }, { 0x00e7, 0x87, 0x00 }, 218219888Sed { 0x00e8, 0x8a, 0x00 }, { 0x00e9, 0x82, 0x00 }, 219219888Sed { 0x00ea, 0x88, 0x01 }, { 0x00ec, 0x8d, 0x00 }, 220219888Sed { 0x00ed, 0xa1, 0x00 }, { 0x00ee, 0x8c, 0x00 }, 221219888Sed { 0x00ef, 0x8b, 0x00 }, { 0x00f0, 0xeb, 0x00 }, 222219888Sed { 0x00f1, 0xa4, 0x00 }, { 0x00f2, 0x95, 0x00 }, 223219888Sed { 0x00f3, 0xa2, 0x00 }, { 0x00f4, 0x93, 0x00 }, 224219888Sed { 0x00f6, 0x94, 0x00 }, { 0x00f7, 0xf6, 0x00 }, 225219888Sed { 0x00f8, 0xed, 0x00 }, { 0x00f9, 0x97, 0x00 }, 226219888Sed { 0x00fa, 0xa3, 0x00 }, { 0x00fb, 0x96, 0x00 }, 227219888Sed { 0x00fc, 0x81, 0x00 }, { 0x00ff, 0x98, 0x00 }, 228219888Sed { 0x0192, 0x9f, 0x00 }, { 0x0393, 0xe2, 0x00 }, 229219888Sed { 0x0398, 0xe9, 0x00 }, { 0x03a3, 0xe4, 0x00 }, 230219888Sed { 0x03a6, 0xe8, 0x00 }, { 0x03a9, 0xea, 0x00 }, 231219888Sed { 0x03b1, 0xe0, 0x01 }, { 0x03b4, 0xeb, 0x00 }, 232219888Sed { 0x03b5, 0xee, 0x00 }, { 0x03bc, 0xe6, 0x00 }, 233219888Sed { 0x03c0, 0xe3, 0x00 }, { 0x03c3, 0xe5, 0x00 }, 234219888Sed { 0x03c4, 0xe7, 0x00 }, { 0x03c6, 0xed, 0x00 }, 235219888Sed { 0x03d5, 0xed, 0x00 }, { 0x2010, 0x2d, 0x00 }, 236219888Sed { 0x2014, 0x2d, 0x00 }, { 0x2018, 0x60, 0x00 }, 237219888Sed { 0x2019, 0x27, 0x00 }, { 0x201c, 0x22, 0x00 }, 238219888Sed { 0x201d, 0x22, 0x00 }, { 0x2022, 0x07, 0x00 }, 239219888Sed { 0x203c, 0x13, 0x00 }, { 0x207f, 0xfc, 0x00 }, 240219888Sed { 0x20a7, 0x9e, 0x00 }, { 0x20ac, 0xee, 0x00 }, 241219888Sed { 0x2126, 0xea, 0x00 }, { 0x2190, 0x1b, 0x00 }, 242219888Sed { 0x2191, 0x18, 0x00 }, { 0x2192, 0x1a, 0x00 }, 243219888Sed { 0x2193, 0x19, 0x00 }, { 0x2194, 0x1d, 0x00 }, 244219888Sed { 0x2195, 0x12, 0x00 }, { 0x21a8, 0x17, 0x00 }, 245219888Sed { 0x2202, 0xeb, 0x00 }, { 0x2208, 0xee, 0x00 }, 246219888Sed { 0x2211, 0xe4, 0x00 }, { 0x2212, 0x2d, 0x00 }, 247219888Sed { 0x2219, 0xf9, 0x00 }, { 0x221a, 0xfb, 0x00 }, 248219888Sed { 0x221e, 0xec, 0x00 }, { 0x221f, 0x1c, 0x00 }, 249219888Sed { 0x2229, 0xef, 0x00 }, { 0x2248, 0xf7, 0x00 }, 250219888Sed { 0x2261, 0xf0, 0x00 }, { 0x2264, 0xf3, 0x00 }, 251219888Sed { 0x2265, 0xf2, 0x00 }, { 0x2302, 0x7f, 0x00 }, 252219888Sed { 0x2310, 0xa9, 0x00 }, { 0x2320, 0xf4, 0x00 }, 253219888Sed { 0x2321, 0xf5, 0x00 }, { 0x2500, 0xc4, 0x00 }, 254219888Sed { 0x2502, 0xb3, 0x00 }, { 0x250c, 0xda, 0x00 }, 255219888Sed { 0x2510, 0xbf, 0x00 }, { 0x2514, 0xc0, 0x00 }, 256219888Sed { 0x2518, 0xd9, 0x00 }, { 0x251c, 0xc3, 0x00 }, 257219888Sed { 0x2524, 0xb4, 0x00 }, { 0x252c, 0xc2, 0x00 }, 258219888Sed { 0x2534, 0xc1, 0x00 }, { 0x253c, 0xc5, 0x00 }, 259219888Sed { 0x2550, 0xcd, 0x00 }, { 0x2551, 0xba, 0x00 }, 260219888Sed { 0x2552, 0xd5, 0x00 }, { 0x2553, 0xd6, 0x00 }, 261219888Sed { 0x2554, 0xc9, 0x00 }, { 0x2555, 0xb8, 0x00 }, 262219888Sed { 0x2556, 0xb7, 0x00 }, { 0x2557, 0xbb, 0x00 }, 263219888Sed { 0x2558, 0xd4, 0x00 }, { 0x2559, 0xd3, 0x00 }, 264219888Sed { 0x255a, 0xc8, 0x00 }, { 0x255b, 0xbe, 0x00 }, 265219888Sed { 0x255c, 0xbd, 0x00 }, { 0x255d, 0xbc, 0x00 }, 266219888Sed { 0x255e, 0xc6, 0x01 }, { 0x2560, 0xcc, 0x00 }, 267219888Sed { 0x2561, 0xb5, 0x00 }, { 0x2562, 0xb6, 0x00 }, 268219888Sed { 0x2563, 0xb9, 0x00 }, { 0x2564, 0xd1, 0x01 }, 269219888Sed { 0x2566, 0xcb, 0x00 }, { 0x2567, 0xcf, 0x00 }, 270219888Sed { 0x2568, 0xd0, 0x00 }, { 0x2569, 0xca, 0x00 }, 271219888Sed { 0x256a, 0xd8, 0x00 }, { 0x256b, 0xd7, 0x00 }, 272219888Sed { 0x256c, 0xce, 0x00 }, { 0x2580, 0xdf, 0x00 }, 273219888Sed { 0x2584, 0xdc, 0x00 }, { 0x2588, 0xdb, 0x00 }, 274219888Sed { 0x258c, 0xdd, 0x00 }, { 0x2590, 0xde, 0x00 }, 275219888Sed { 0x2591, 0xb0, 0x02 }, { 0x25a0, 0xfe, 0x00 }, 276219888Sed { 0x25ac, 0x16, 0x00 }, { 0x25b2, 0x1e, 0x00 }, 277219888Sed { 0x25ba, 0x10, 0x00 }, { 0x25bc, 0x1f, 0x00 }, 278219888Sed { 0x25c4, 0x11, 0x00 }, { 0x25cb, 0x09, 0x00 }, 279219888Sed { 0x25d8, 0x08, 0x00 }, { 0x25d9, 0x0a, 0x00 }, 280219888Sed { 0x263a, 0x01, 0x01 }, { 0x263c, 0x0f, 0x00 }, 281219888Sed { 0x2640, 0x0c, 0x00 }, { 0x2642, 0x0b, 0x00 }, 282219888Sed { 0x2660, 0x06, 0x00 }, { 0x2663, 0x05, 0x00 }, 283267310Semaste { 0x2665, 0x03, 0x01 }, { 0x266a, 0x0d, 0x00 }, 284267310Semaste { 0x266c, 0x0e, 0x00 }, 285219888Sed}; 286219888Sed 287219888Sedstatic uint8_t 288219888Sedvga_get_cp437(term_char_t c) 289219888Sed{ 290219888Sed int min, mid, max; 291219888Sed 292219888Sed min = 0; 293219888Sed max = (sizeof(cp437table) / sizeof(struct unicp437)) - 1; 294219888Sed 295219888Sed if (c < cp437table[0].unicode_base || 296219888Sed c > cp437table[max].unicode_base + cp437table[max].length) 297219888Sed return '?'; 298219888Sed 299219888Sed while (max >= min) { 300219888Sed mid = (min + max) / 2; 301219888Sed if (c < cp437table[mid].unicode_base) 302219888Sed max = mid - 1; 303219888Sed else if (c > cp437table[mid].unicode_base + 304219888Sed cp437table[mid].length) 305219888Sed min = mid + 1; 306219888Sed else 307219888Sed return (c - cp437table[mid].unicode_base + 308219888Sed cp437table[mid].cp437_base); 309219888Sed } 310219888Sed 311219888Sed return '?'; 312219888Sed} 313219888Sed 314219888Sedstatic void 315271128Semastevga_blank(struct vt_device *vd, term_color_t color) 316219888Sed{ 317219888Sed struct vga_softc *sc = vd->vd_softc; 318271128Semaste u_int ofs; 319219888Sed 320271128Semaste vga_setfg(vd, color); 321271128Semaste for (ofs = 0; ofs < VT_VGA_MEMSIZE; ofs++) 322271128Semaste MEM_WRITE1(sc, ofs, 0xff); 323271128Semaste} 324271128Semaste 325271128Semastestatic inline void 326271128Semastevga_bitblt_put(struct vt_device *vd, u_long dst, term_color_t color, 327271128Semaste uint8_t v) 328271128Semaste{ 329271128Semaste struct vga_softc *sc = vd->vd_softc; 330271128Semaste 331271128Semaste /* Skip empty writes, in order to avoid palette changes. */ 332271128Semaste if (v != 0x00) { 333271128Semaste vga_setfg(vd, color); 334271128Semaste /* 335271128Semaste * When this MEM_READ1() gets disabled, all sorts of 336271128Semaste * artifacts occur. This is because this read loads the 337271128Semaste * set of 8 pixels that are about to be changed. There 338271128Semaste * is one scenario where we can avoid the read, namely 339271128Semaste * if all pixels are about to be overwritten anyway. 340271128Semaste */ 341271128Semaste if (v != 0xff) { 342271128Semaste MEM_READ1(sc, dst); 343271128Semaste 344271128Semaste /* The bg color was trashed by the reads. */ 345271128Semaste sc->vga_curbg = 0xff; 346271128Semaste } 347271128Semaste MEM_WRITE1(sc, dst, v); 348271128Semaste } 349271128Semaste} 350271128Semaste 351271128Semastestatic void 352271128Semastevga_setpixel(struct vt_device *vd, int x, int y, term_color_t color) 353271128Semaste{ 354271128Semaste 355271769Sdumbbell if (vd->vd_flags & VDF_TEXTMODE) 356271769Sdumbbell return; 357271769Sdumbbell 358271128Semaste vga_bitblt_put(vd, (y * VT_VGA_WIDTH / 8) + (x / 8), color, 359271128Semaste 0x80 >> (x % 8)); 360271128Semaste} 361271128Semaste 362271128Semastestatic void 363271128Semastevga_drawrect(struct vt_device *vd, int x1, int y1, int x2, int y2, int fill, 364271128Semaste term_color_t color) 365271128Semaste{ 366271128Semaste int x, y; 367271128Semaste 368271769Sdumbbell if (vd->vd_flags & VDF_TEXTMODE) 369271769Sdumbbell return; 370271769Sdumbbell 371271128Semaste for (y = y1; y <= y2; y++) { 372271128Semaste if (fill || (y == y1) || (y == y2)) { 373271128Semaste for (x = x1; x <= x2; x++) 374271128Semaste vga_setpixel(vd, x, y, color); 375271128Semaste } else { 376271128Semaste vga_setpixel(vd, x1, y, color); 377271128Semaste vga_setpixel(vd, x2, y, color); 378271128Semaste } 379271128Semaste } 380271128Semaste} 381271128Semaste 382271128Semastestatic void 383271128Semastevga_compute_shifted_pattern(const uint8_t *src, unsigned int bytes, 384271128Semaste unsigned int src_x, unsigned int x_count, unsigned int dst_x, 385271128Semaste uint8_t *pattern, uint8_t *mask) 386271128Semaste{ 387271128Semaste unsigned int n; 388271128Semaste 389271128Semaste n = src_x / 8; 390271128Semaste 391219888Sed /* 392271128Semaste * This mask has bits set, where a pixel (ether 0 or 1) 393271128Semaste * comes from the source bitmap. 394219888Sed */ 395271128Semaste if (mask != NULL) { 396271128Semaste *mask = (0xff 397271128Semaste >> (8 - x_count)) 398271128Semaste << (8 - x_count - dst_x); 399271128Semaste } 400219888Sed 401271128Semaste if (n == (src_x + x_count - 1) / 8) { 402271128Semaste /* All the pixels we want are in the same byte. */ 403271128Semaste *pattern = src[n]; 404271128Semaste if (dst_x >= src_x) 405271128Semaste *pattern >>= (dst_x - src_x % 8); 406271128Semaste else 407271128Semaste *pattern <<= (src_x % 8 - dst_x); 408271128Semaste } else { 409271128Semaste /* The pixels we want are split into two bytes. */ 410271128Semaste if (dst_x >= src_x % 8) { 411271128Semaste *pattern = 412271128Semaste src[n] << (8 - dst_x - src_x % 8) | 413271128Semaste src[n + 1] >> (dst_x - src_x % 8); 414271128Semaste } else { 415271128Semaste *pattern = 416271128Semaste src[n] << (src_x % 8 - dst_x) | 417271128Semaste src[n + 1] >> (8 - src_x % 8 - dst_x); 418271128Semaste } 419271128Semaste } 420271128Semaste} 421271128Semaste 422271128Semastestatic void 423271128Semastevga_copy_bitmap_portion(uint8_t *pattern_2colors, uint8_t *pattern_ncolors, 424271128Semaste const uint8_t *src, const uint8_t *src_mask, unsigned int src_width, 425271128Semaste unsigned int src_x, unsigned int dst_x, unsigned int x_count, 426271128Semaste unsigned int src_y, unsigned int dst_y, unsigned int y_count, 427271128Semaste term_color_t fg, term_color_t bg, int overwrite) 428271128Semaste{ 429271128Semaste unsigned int i, bytes; 430271128Semaste uint8_t pattern, relevant_bits, mask; 431271128Semaste 432271128Semaste bytes = (src_width + 7) / 8; 433271128Semaste 434271128Semaste for (i = 0; i < y_count; ++i) { 435271128Semaste vga_compute_shifted_pattern(src + (src_y + i) * bytes, 436271128Semaste bytes, src_x, x_count, dst_x, &pattern, &relevant_bits); 437271128Semaste 438271128Semaste if (src_mask == NULL) { 439271128Semaste /* 440271128Semaste * No src mask. Consider that all wanted bits 441271128Semaste * from the source are "authoritative". 442271128Semaste */ 443271128Semaste mask = relevant_bits; 444271128Semaste } else { 445271128Semaste /* 446271128Semaste * There's an src mask. We shift it the same way 447271128Semaste * we shifted the source pattern. 448271128Semaste */ 449271128Semaste vga_compute_shifted_pattern( 450271128Semaste src_mask + (src_y + i) * bytes, 451271128Semaste bytes, src_x, x_count, dst_x, 452271128Semaste &mask, NULL); 453271128Semaste 454271128Semaste /* Now, only keep the wanted bits among them. */ 455271128Semaste mask &= relevant_bits; 456271128Semaste } 457271128Semaste 458271128Semaste /* 459271128Semaste * Clear bits from the pattern which must be 460271128Semaste * transparent, according to the source mask. 461271128Semaste */ 462271128Semaste pattern &= mask; 463271128Semaste 464271128Semaste /* Set the bits in the 2-colors array. */ 465271128Semaste if (overwrite) 466271128Semaste pattern_2colors[dst_y + i] &= ~mask; 467271128Semaste pattern_2colors[dst_y + i] |= pattern; 468271128Semaste 469271128Semaste if (pattern_ncolors == NULL) 470271128Semaste continue; 471271128Semaste 472271128Semaste /* 473271128Semaste * Set the same bits in the n-colors array. This one 474271128Semaste * supports transparency, when a given bit is cleared in 475271128Semaste * all colors. 476271128Semaste */ 477271128Semaste if (overwrite) { 478271128Semaste /* 479271128Semaste * Ensure that the pixels used by this bitmap are 480271128Semaste * cleared in other colors. 481271128Semaste */ 482271128Semaste for (int j = 0; j < 16; ++j) 483271128Semaste pattern_ncolors[(dst_y + i) * 16 + j] &= 484271128Semaste ~mask; 485271128Semaste } 486271128Semaste pattern_ncolors[(dst_y + i) * 16 + fg] |= pattern; 487271128Semaste pattern_ncolors[(dst_y + i) * 16 + bg] |= (~pattern & mask); 488271128Semaste } 489271128Semaste} 490271128Semaste 491271128Semastestatic void 492271128Semastevga_bitblt_pixels_block_2colors(struct vt_device *vd, const uint8_t *masks, 493271128Semaste term_color_t fg, term_color_t bg, 494271128Semaste unsigned int x, unsigned int y, unsigned int height) 495271128Semaste{ 496271128Semaste unsigned int i, offset; 497271128Semaste struct vga_softc *sc; 498271128Semaste 499219888Sed /* 500271128Semaste * The great advantage of Write Mode 3 is that we just need 501271128Semaste * to load the foreground in the Set/Reset register, load the 502271128Semaste * background color in the latches register (this is done 503271128Semaste * through a write in offscreen memory followed by a read of 504271128Semaste * that data), then write the pattern to video memory. This 505271128Semaste * pattern indicates if the pixel should use the foreground 506271128Semaste * color (bit set) or the background color (bit cleared). 507219888Sed */ 508219888Sed 509271128Semaste vga_setbg(vd, bg); 510271128Semaste vga_setfg(vd, fg); 511271128Semaste 512271128Semaste sc = vd->vd_softc; 513271128Semaste offset = (VT_VGA_WIDTH * y + x) / 8; 514271128Semaste 515271128Semaste for (i = 0; i < height; ++i, offset += VT_VGA_WIDTH / 8) { 516271128Semaste MEM_WRITE1(sc, offset, masks[i]); 517271128Semaste } 518219888Sed} 519219888Sed 520219888Sedstatic void 521271128Semastevga_bitblt_pixels_block_ncolors(struct vt_device *vd, const uint8_t *masks, 522271128Semaste unsigned int x, unsigned int y, unsigned int height) 523271128Semaste{ 524271128Semaste unsigned int i, j, plan, color, offset; 525271128Semaste struct vga_softc *sc; 526271128Semaste uint8_t mask, plans[height * 4]; 527271128Semaste 528271128Semaste sc = vd->vd_softc; 529271128Semaste 530271128Semaste memset(plans, 0, sizeof(plans)); 531271128Semaste 532271128Semaste /* 533271128Semaste * To write a group of pixels using 3 or more colors, we select 534271128Semaste * Write Mode 0 and write one byte to each plan separately. 535271128Semaste */ 536271128Semaste 537271128Semaste /* 538271128Semaste * We first compute each byte: each plan contains one bit of the 539271128Semaste * color code for each of the 8 pixels. 540271128Semaste * 541271128Semaste * For example, if the 8 pixels are like this: 542271128Semaste * GBBBBBBY 543271128Semaste * where: 544271128Semaste * G (gray) = 0b0111 545271128Semaste * B (black) = 0b0000 546271128Semaste * Y (yellow) = 0b0011 547271128Semaste * 548271128Semaste * The corresponding for bytes are: 549271128Semaste * GBBBBBBY 550271128Semaste * Plan 0: 10000001 = 0x81 551271128Semaste * Plan 1: 10000001 = 0x81 552271128Semaste * Plan 2: 10000000 = 0x80 553271128Semaste * Plan 3: 00000000 = 0x00 554271128Semaste * | | | 555271128Semaste * | | +-> 0b0011 (Y) 556271128Semaste * | +-----> 0b0000 (B) 557271128Semaste * +--------> 0b0111 (G) 558271128Semaste */ 559271128Semaste 560271128Semaste for (i = 0; i < height; ++i) { 561271128Semaste for (color = 0; color < 16; ++color) { 562271128Semaste mask = masks[i * 16 + color]; 563271128Semaste if (mask == 0x00) 564271128Semaste continue; 565271128Semaste 566271128Semaste for (j = 0; j < 8; ++j) { 567271128Semaste if (!((mask >> (7 - j)) & 0x1)) 568271128Semaste continue; 569271128Semaste 570271128Semaste /* The pixel "j" uses color "color". */ 571271128Semaste for (plan = 0; plan < 4; ++plan) 572271128Semaste plans[i * 4 + plan] |= 573271128Semaste ((color >> plan) & 0x1) << (7 - j); 574271128Semaste } 575271128Semaste } 576271128Semaste } 577271128Semaste 578271128Semaste /* 579271128Semaste * The bytes are ready: we now switch to Write Mode 0 and write 580271128Semaste * all bytes, one plan at a time. 581271128Semaste */ 582271128Semaste vga_setwmode(vd, 0); 583271128Semaste 584271128Semaste REG_WRITE1(sc, VGA_SEQ_ADDRESS, VGA_SEQ_MAP_MASK); 585271128Semaste for (plan = 0; plan < 4; ++plan) { 586271128Semaste /* Select plan. */ 587271128Semaste REG_WRITE1(sc, VGA_SEQ_DATA, 1 << plan); 588271128Semaste 589271128Semaste /* Write all bytes for this plan, from Y to Y+height. */ 590271128Semaste for (i = 0; i < height; ++i) { 591271128Semaste offset = (VT_VGA_WIDTH * (y + i) + x) / 8; 592271128Semaste MEM_WRITE1(sc, offset, plans[i * 4 + plan]); 593271128Semaste } 594271128Semaste } 595271128Semaste} 596271128Semaste 597271128Semastestatic void 598271128Semastevga_bitblt_one_text_pixels_block(struct vt_device *vd, 599271128Semaste const struct vt_window *vw, unsigned int x, unsigned int y) 600271128Semaste{ 601271128Semaste const struct vt_buf *vb; 602271128Semaste const struct vt_font *vf; 603271128Semaste unsigned int i, col, row, src_x, x_count; 604271128Semaste unsigned int used_colors_list[16], used_colors; 605271128Semaste uint8_t pattern_2colors[vw->vw_font->vf_height]; 606271128Semaste uint8_t pattern_ncolors[vw->vw_font->vf_height * 16]; 607271128Semaste term_char_t c; 608271128Semaste term_color_t fg, bg; 609271128Semaste const uint8_t *src; 610271128Semaste 611271128Semaste vb = &vw->vw_buf; 612271128Semaste vf = vw->vw_font; 613271128Semaste 614271128Semaste /* 615271128Semaste * The current pixels block. 616271128Semaste * 617271128Semaste * We fill it with portions of characters, because both "grids" 618271128Semaste * may not match. 619271128Semaste * 620271128Semaste * i is the index in this pixels block. 621271128Semaste */ 622271128Semaste 623271128Semaste i = x; 624271128Semaste used_colors = 0; 625271128Semaste memset(used_colors_list, 0, sizeof(used_colors_list)); 626271128Semaste memset(pattern_2colors, 0, sizeof(pattern_2colors)); 627271128Semaste memset(pattern_ncolors, 0, sizeof(pattern_ncolors)); 628271128Semaste 629271128Semaste if (i < vw->vw_draw_area.tr_begin.tp_col) { 630271128Semaste /* 631271128Semaste * i is in the margin used to center the text area on 632271128Semaste * the screen. 633271128Semaste */ 634271128Semaste 635271128Semaste i = vw->vw_draw_area.tr_begin.tp_col; 636271128Semaste } 637271128Semaste 638271128Semaste while (i < x + VT_VGA_PIXELS_BLOCK && 639271128Semaste i < vw->vw_draw_area.tr_end.tp_col) { 640271128Semaste /* 641271128Semaste * Find which character is drawn on this pixel in the 642271128Semaste * pixels block. 643271128Semaste * 644271128Semaste * While here, record what colors it uses. 645271128Semaste */ 646271128Semaste 647271128Semaste col = (i - vw->vw_draw_area.tr_begin.tp_col) / vf->vf_width; 648271128Semaste row = (y - vw->vw_draw_area.tr_begin.tp_row) / vf->vf_height; 649271128Semaste 650271128Semaste c = VTBUF_GET_FIELD(vb, row, col); 651271128Semaste src = vtfont_lookup(vf, c); 652271128Semaste 653271128Semaste vt_determine_colors(c, VTBUF_ISCURSOR(vb, row, col), &fg, &bg); 654271128Semaste if ((used_colors_list[fg] & 0x1) != 0x1) 655271128Semaste used_colors++; 656271128Semaste if ((used_colors_list[bg] & 0x2) != 0x2) 657271128Semaste used_colors++; 658271128Semaste used_colors_list[fg] |= 0x1; 659271128Semaste used_colors_list[bg] |= 0x2; 660271128Semaste 661271128Semaste /* 662271128Semaste * Compute the portion of the character we want to draw, 663271128Semaste * because the pixels block may start in the middle of a 664271128Semaste * character. 665271128Semaste * 666271128Semaste * The first pixel to draw in the character is 667271128Semaste * the current position - 668271128Semaste * the start position of the character 669271128Semaste * 670271128Semaste * The last pixel to draw is either 671271128Semaste * - the last pixel of the character, or 672271128Semaste * - the pixel of the character matching the end of 673271128Semaste * the pixels block 674271128Semaste * whichever comes first. This position is then 675271128Semaste * changed to be relative to the start position of the 676271128Semaste * character. 677271128Semaste */ 678271128Semaste 679271128Semaste src_x = i - 680271128Semaste (col * vf->vf_width + vw->vw_draw_area.tr_begin.tp_col); 681271128Semaste x_count = min(min( 682271128Semaste (col + 1) * vf->vf_width + 683271128Semaste vw->vw_draw_area.tr_begin.tp_col, 684271128Semaste x + VT_VGA_PIXELS_BLOCK), 685271128Semaste vw->vw_draw_area.tr_end.tp_col); 686271128Semaste x_count -= col * vf->vf_width + 687271128Semaste vw->vw_draw_area.tr_begin.tp_col; 688271128Semaste x_count -= src_x; 689271128Semaste 690271128Semaste /* Copy a portion of the character. */ 691271128Semaste vga_copy_bitmap_portion(pattern_2colors, pattern_ncolors, 692271128Semaste src, NULL, vf->vf_width, 693271128Semaste src_x, i % VT_VGA_PIXELS_BLOCK, x_count, 694271128Semaste 0, 0, vf->vf_height, fg, bg, 0); 695271128Semaste 696271128Semaste /* We move to the next portion. */ 697271128Semaste i += x_count; 698271128Semaste } 699271128Semaste 700271128Semaste#ifndef SC_NO_CUTPASTE 701271128Semaste /* 702271128Semaste * Copy the mouse pointer bitmap if it's over the current pixels 703271128Semaste * block. 704271128Semaste * 705271128Semaste * We use the saved cursor position (saved in vt_flush()), because 706271128Semaste * the current position could be different than the one used 707271128Semaste * to mark the area dirty. 708271128Semaste */ 709271128Semaste term_rect_t drawn_area; 710271128Semaste 711271128Semaste drawn_area.tr_begin.tp_col = x; 712271128Semaste drawn_area.tr_begin.tp_row = y; 713271128Semaste drawn_area.tr_end.tp_col = x + VT_VGA_PIXELS_BLOCK; 714271128Semaste drawn_area.tr_end.tp_row = y + vf->vf_height; 715271128Semaste if (vd->vd_mshown && vt_is_cursor_in_area(vd, &drawn_area)) { 716271128Semaste struct vt_mouse_cursor *cursor; 717271128Semaste unsigned int mx, my; 718271128Semaste unsigned int dst_x, src_y, dst_y, y_count; 719271128Semaste 720271128Semaste cursor = vd->vd_mcursor; 721271128Semaste mx = vd->vd_mx_drawn + vw->vw_draw_area.tr_begin.tp_col; 722271128Semaste my = vd->vd_my_drawn + vw->vw_draw_area.tr_begin.tp_row; 723271128Semaste 724271128Semaste /* Compute the portion of the cursor we want to copy. */ 725271128Semaste src_x = x > mx ? x - mx : 0; 726271128Semaste dst_x = mx > x ? mx - x : 0; 727271128Semaste x_count = min(min(min( 728271128Semaste cursor->width - src_x, 729271128Semaste x + VT_VGA_PIXELS_BLOCK - mx), 730271128Semaste vw->vw_draw_area.tr_end.tp_col - mx), 731271128Semaste VT_VGA_PIXELS_BLOCK); 732271128Semaste 733271128Semaste /* 734271128Semaste * The cursor isn't aligned on the Y-axis with 735271128Semaste * characters, so we need to compute the vertical 736271128Semaste * start/count. 737271128Semaste */ 738271128Semaste src_y = y > my ? y - my : 0; 739271128Semaste dst_y = my > y ? my - y : 0; 740271128Semaste y_count = min( 741271128Semaste min(cursor->height - src_y, y + vf->vf_height - my), 742271128Semaste vf->vf_height); 743271128Semaste 744271128Semaste /* Copy the cursor portion. */ 745271128Semaste vga_copy_bitmap_portion(pattern_2colors, pattern_ncolors, 746271128Semaste cursor->map, cursor->mask, cursor->width, 747271128Semaste src_x, dst_x, x_count, src_y, dst_y, y_count, 748271128Semaste vd->vd_mcursor_fg, vd->vd_mcursor_bg, 1); 749271128Semaste 750271128Semaste if ((used_colors_list[vd->vd_mcursor_fg] & 0x1) != 0x1) 751271128Semaste used_colors++; 752271128Semaste if ((used_colors_list[vd->vd_mcursor_bg] & 0x2) != 0x2) 753271128Semaste used_colors++; 754271128Semaste } 755271128Semaste#endif 756271128Semaste 757271128Semaste /* 758271128Semaste * The pixels block is completed, we can now draw it on the 759271128Semaste * screen. 760271128Semaste */ 761271128Semaste if (used_colors == 2) 762271128Semaste vga_bitblt_pixels_block_2colors(vd, pattern_2colors, fg, bg, 763271128Semaste x, y, vf->vf_height); 764271128Semaste else 765271128Semaste vga_bitblt_pixels_block_ncolors(vd, pattern_ncolors, 766271128Semaste x, y, vf->vf_height); 767271128Semaste} 768271128Semaste 769271128Semastestatic void 770271128Semastevga_bitblt_text_gfxmode(struct vt_device *vd, const struct vt_window *vw, 771271128Semaste const term_rect_t *area) 772271128Semaste{ 773271128Semaste const struct vt_font *vf; 774271128Semaste unsigned int col, row; 775271128Semaste unsigned int x1, y1, x2, y2, x, y; 776271128Semaste 777271128Semaste vf = vw->vw_font; 778271128Semaste 779271128Semaste /* 780271128Semaste * Compute the top-left pixel position aligned with the video 781271128Semaste * adapter pixels block size. 782271128Semaste * 783271128Semaste * This is calculated from the top-left column of te dirty area: 784271128Semaste * 785271128Semaste * 1. Compute the top-left pixel of the character: 786271128Semaste * col * font width + x offset 787271128Semaste * 788271128Semaste * NOTE: x offset is used to center the text area on the 789271128Semaste * screen. It's expressed in pixels, not in characters 790271128Semaste * col/row! 791271128Semaste * 792271128Semaste * 2. Find the pixel further on the left marking the start of 793271128Semaste * an aligned pixels block (eg. chunk of 8 pixels): 794271128Semaste * character's x / blocksize * blocksize 795271128Semaste * 796271128Semaste * The division, being made on integers, achieves the 797271128Semaste * alignment. 798271128Semaste * 799271128Semaste * For the Y-axis, we need to compute the character's y 800271128Semaste * coordinate, but we don't need to align it. 801271128Semaste */ 802271128Semaste 803271128Semaste col = area->tr_begin.tp_col; 804271128Semaste row = area->tr_begin.tp_row; 805271128Semaste x1 = (int)((col * vf->vf_width + vw->vw_draw_area.tr_begin.tp_col) 806271128Semaste / VT_VGA_PIXELS_BLOCK) 807271128Semaste * VT_VGA_PIXELS_BLOCK; 808271128Semaste y1 = row * vf->vf_height + vw->vw_draw_area.tr_begin.tp_row; 809271128Semaste 810271128Semaste /* 811271128Semaste * Compute the bottom right pixel position, again, aligned with 812271128Semaste * the pixels block size. 813271128Semaste * 814271128Semaste * The same rules apply, we just add 1 to base the computation 815271128Semaste * on the "right border" of the dirty area. 816271128Semaste */ 817271128Semaste 818271128Semaste col = area->tr_end.tp_col; 819271128Semaste row = area->tr_end.tp_row; 820271128Semaste x2 = (int)((col * vf->vf_width + vw->vw_draw_area.tr_begin.tp_col 821271128Semaste + VT_VGA_PIXELS_BLOCK - 1) 822271128Semaste / VT_VGA_PIXELS_BLOCK) 823271128Semaste * VT_VGA_PIXELS_BLOCK; 824271128Semaste y2 = row * vf->vf_height + vw->vw_draw_area.tr_begin.tp_row; 825271128Semaste 826271128Semaste /* Clip the area to the screen size. */ 827271128Semaste x2 = min(x2, vw->vw_draw_area.tr_end.tp_col); 828271128Semaste y2 = min(y2, vw->vw_draw_area.tr_end.tp_row); 829271128Semaste 830271128Semaste /* 831271128Semaste * Now, we take care of N pixels line at a time (the first for 832271128Semaste * loop, N = font height), and for these lines, draw one pixels 833271128Semaste * block at a time (the second for loop), not a character at a 834271128Semaste * time. 835271128Semaste * 836271128Semaste * Therefore, on the X-axis, characters my be drawn partially if 837271128Semaste * they are not aligned on 8-pixels boundary. 838271128Semaste * 839271128Semaste * However, the operation is repeated for the full height of the 840271128Semaste * font before moving to the next character, because it allows 841271128Semaste * to keep the color settings and write mode, before perhaps 842271128Semaste * changing them with the next one. 843271128Semaste */ 844271128Semaste 845271128Semaste for (y = y1; y < y2; y += vf->vf_height) { 846271128Semaste for (x = x1; x < x2; x += VT_VGA_PIXELS_BLOCK) { 847271128Semaste vga_bitblt_one_text_pixels_block(vd, vw, x, y); 848271128Semaste } 849271128Semaste } 850271128Semaste} 851271128Semaste 852271128Semastestatic void 853271128Semastevga_bitblt_text_txtmode(struct vt_device *vd, const struct vt_window *vw, 854271128Semaste const term_rect_t *area) 855271128Semaste{ 856271128Semaste struct vga_softc *sc; 857271128Semaste const struct vt_buf *vb; 858271128Semaste unsigned int col, row; 859271128Semaste term_char_t c; 860271128Semaste term_color_t fg, bg; 861271128Semaste uint8_t ch, attr; 862271128Semaste 863271128Semaste sc = vd->vd_softc; 864271128Semaste vb = &vw->vw_buf; 865271128Semaste 866271128Semaste for (row = area->tr_begin.tp_row; row < area->tr_end.tp_row; ++row) { 867271128Semaste for (col = area->tr_begin.tp_col; 868271128Semaste col < area->tr_end.tp_col; 869271128Semaste ++col) { 870271128Semaste /* 871271128Semaste * Get next character and its associated fg/bg 872271128Semaste * colors. 873271128Semaste */ 874271128Semaste c = VTBUF_GET_FIELD(vb, row, col); 875271128Semaste vt_determine_colors(c, VTBUF_ISCURSOR(vb, row, col), 876271128Semaste &fg, &bg); 877271128Semaste 878271128Semaste /* 879271128Semaste * Convert character to CP437, which is the 880271128Semaste * character set used by the VGA hardware by 881271128Semaste * default. 882271128Semaste */ 883271128Semaste ch = vga_get_cp437(TCHAR_CHARACTER(c)); 884271128Semaste 885271128Semaste /* Convert colors to VGA attributes. */ 886271128Semaste attr = bg << 4 | fg; 887271128Semaste 888271128Semaste MEM_WRITE1(sc, 0x18000 + (row * 80 + col) * 2 + 0, 889271128Semaste ch); 890271128Semaste MEM_WRITE1(sc, 0x18000 + (row * 80 + col) * 2 + 1, 891271128Semaste attr); 892271128Semaste } 893271128Semaste } 894271128Semaste} 895271128Semaste 896271128Semastestatic void 897271128Semastevga_bitblt_text(struct vt_device *vd, const struct vt_window *vw, 898271128Semaste const term_rect_t *area) 899271128Semaste{ 900271128Semaste 901271128Semaste if (!(vd->vd_flags & VDF_TEXTMODE)) { 902271128Semaste vga_bitblt_text_gfxmode(vd, vw, area); 903271128Semaste } else { 904271128Semaste vga_bitblt_text_txtmode(vd, vw, area); 905271128Semaste } 906271128Semaste} 907271128Semaste 908271128Semastestatic void 909271128Semastevga_bitblt_bitmap(struct vt_device *vd, const struct vt_window *vw, 910271128Semaste const uint8_t *pattern, const uint8_t *mask, 911271128Semaste unsigned int width, unsigned int height, 912271128Semaste unsigned int x, unsigned int y, term_color_t fg, term_color_t bg) 913271128Semaste{ 914271128Semaste unsigned int x1, y1, x2, y2, i, j, src_x, dst_x, x_count; 915271128Semaste uint8_t pattern_2colors; 916271128Semaste 917271128Semaste /* Align coordinates with the 8-pxels grid. */ 918271128Semaste x1 = x / VT_VGA_PIXELS_BLOCK * VT_VGA_PIXELS_BLOCK; 919271128Semaste y1 = y; 920271128Semaste 921271128Semaste x2 = (x + width + VT_VGA_PIXELS_BLOCK - 1) / 922271128Semaste VT_VGA_PIXELS_BLOCK * VT_VGA_PIXELS_BLOCK; 923271128Semaste y2 = y + height; 924271128Semaste x2 = min(x2, vd->vd_width - 1); 925271128Semaste y2 = min(y2, vd->vd_height - 1); 926271128Semaste 927271128Semaste for (j = y1; j < y2; ++j) { 928271128Semaste src_x = 0; 929271128Semaste dst_x = x - x1; 930271128Semaste x_count = VT_VGA_PIXELS_BLOCK - dst_x; 931271128Semaste 932271128Semaste for (i = x1; i < x2; i += VT_VGA_PIXELS_BLOCK) { 933271128Semaste pattern_2colors = 0; 934271128Semaste 935271128Semaste vga_copy_bitmap_portion( 936271128Semaste &pattern_2colors, NULL, 937271128Semaste pattern, mask, width, 938271128Semaste src_x, dst_x, x_count, 939271128Semaste j - y1, 0, 1, fg, bg, 0); 940271128Semaste 941271128Semaste vga_bitblt_pixels_block_2colors(vd, 942271128Semaste &pattern_2colors, fg, bg, 943271128Semaste i, j, 1); 944271128Semaste 945271128Semaste src_x += x_count; 946271128Semaste dst_x = (dst_x + x_count) % VT_VGA_PIXELS_BLOCK; 947271128Semaste x_count = min(width - src_x, VT_VGA_PIXELS_BLOCK); 948271128Semaste } 949271128Semaste } 950271128Semaste} 951271128Semaste 952271128Semastestatic void 953219888Sedvga_initialize_graphics(struct vt_device *vd) 954219888Sed{ 955219888Sed struct vga_softc *sc = vd->vd_softc; 956219888Sed 957219888Sed /* Clock select. */ 958219888Sed REG_WRITE1(sc, VGA_GEN_MISC_OUTPUT_W, VGA_GEN_MO_VSP | VGA_GEN_MO_HSP | 959219888Sed VGA_GEN_MO_PB | VGA_GEN_MO_ER | VGA_GEN_MO_IOA); 960219888Sed /* Set sequencer clocking and memory mode. */ 961219888Sed REG_WRITE1(sc, VGA_SEQ_ADDRESS, VGA_SEQ_CLOCKING_MODE); 962219888Sed REG_WRITE1(sc, VGA_SEQ_DATA, VGA_SEQ_CM_89); 963219888Sed REG_WRITE1(sc, VGA_SEQ_ADDRESS, VGA_SEQ_MEMORY_MODE); 964219888Sed REG_WRITE1(sc, VGA_SEQ_DATA, VGA_SEQ_MM_OE | VGA_SEQ_MM_EM); 965219888Sed 966219888Sed /* Set the graphics controller in graphics mode. */ 967219888Sed REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_MISCELLANEOUS); 968219888Sed REG_WRITE1(sc, VGA_GC_DATA, 0x04 + VGA_GC_MISC_GA); 969219888Sed /* Program the CRT controller. */ 970219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_HORIZ_TOTAL); 971219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0x5f); /* 760 */ 972219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_HORIZ_DISP_END); 973219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0x4f); /* 640 - 8 */ 974219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_START_HORIZ_BLANK); 975219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0x50); /* 640 */ 976219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_END_HORIZ_BLANK); 977219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, VGA_CRTC_EHB_CR + 2); 978219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_START_HORIZ_RETRACE); 979219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0x54); /* 672 */ 980219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_END_HORIZ_RETRACE); 981219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, VGA_CRTC_EHR_EHB + 0); 982219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_VERT_TOTAL); 983219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0x0b); /* 523 */ 984219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_OVERFLOW); 985219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, VGA_CRTC_OF_VT9 | VGA_CRTC_OF_LC8 | 986219888Sed VGA_CRTC_OF_VBS8 | VGA_CRTC_OF_VRS8 | VGA_CRTC_OF_VDE8); 987219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_MAX_SCAN_LINE); 988219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, VGA_CRTC_MSL_LC9); 989219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_VERT_RETRACE_START); 990219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0xea); /* 480 + 10 */ 991219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_VERT_RETRACE_END); 992219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0x0c); 993219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_VERT_DISPLAY_END); 994219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0xdf); /* 480 - 1*/ 995219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_OFFSET); 996219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0x28); 997219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_START_VERT_BLANK); 998219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0xe7); /* 480 + 7 */ 999219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_END_VERT_BLANK); 1000219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0x04); 1001219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_MODE_CONTROL); 1002219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, VGA_CRTC_MC_WB | VGA_CRTC_MC_AW | 1003219888Sed VGA_CRTC_MC_SRS | VGA_CRTC_MC_CMS); 1004219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_LINE_COMPARE); 1005219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0xff); /* 480 + 31 */ 1006219888Sed 1007219888Sed REG_WRITE1(sc, VGA_GEN_FEATURE_CTRL_W, 0); 1008219888Sed 1009219888Sed REG_WRITE1(sc, VGA_SEQ_ADDRESS, VGA_SEQ_MAP_MASK); 1010219888Sed REG_WRITE1(sc, VGA_SEQ_DATA, VGA_SEQ_MM_EM3 | VGA_SEQ_MM_EM2 | 1011219888Sed VGA_SEQ_MM_EM1 | VGA_SEQ_MM_EM0); 1012219888Sed REG_WRITE1(sc, VGA_SEQ_ADDRESS, VGA_SEQ_CHAR_MAP_SELECT); 1013219888Sed REG_WRITE1(sc, VGA_SEQ_DATA, 0); 1014219888Sed 1015219888Sed REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_SET_RESET); 1016219888Sed REG_WRITE1(sc, VGA_GC_DATA, 0); 1017219888Sed REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_ENABLE_SET_RESET); 1018219888Sed REG_WRITE1(sc, VGA_GC_DATA, 0x0f); 1019219888Sed REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_COLOR_COMPARE); 1020219888Sed REG_WRITE1(sc, VGA_GC_DATA, 0); 1021219888Sed REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_DATA_ROTATE); 1022219888Sed REG_WRITE1(sc, VGA_GC_DATA, 0); 1023219888Sed REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_READ_MAP_SELECT); 1024219888Sed REG_WRITE1(sc, VGA_GC_DATA, 0); 1025219888Sed REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_MODE); 1026219888Sed REG_WRITE1(sc, VGA_GC_DATA, 0); 1027219888Sed REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_COLOR_DONT_CARE); 1028219888Sed REG_WRITE1(sc, VGA_GC_DATA, 0x0f); 1029219888Sed REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_BIT_MASK); 1030219888Sed REG_WRITE1(sc, VGA_GC_DATA, 0xff); 1031219888Sed} 1032219888Sed 1033219888Sedstatic void 1034219888Sedvga_initialize(struct vt_device *vd, int textmode) 1035219888Sed{ 1036219888Sed struct vga_softc *sc = vd->vd_softc; 1037219888Sed uint8_t x; 1038219888Sed 1039219888Sed /* Make sure the VGA adapter is not in monochrome emulation mode. */ 1040219888Sed x = REG_READ1(sc, VGA_GEN_MISC_OUTPUT_R); 1041219888Sed REG_WRITE1(sc, VGA_GEN_MISC_OUTPUT_W, x | VGA_GEN_MO_IOA); 1042219888Sed 1043219888Sed /* Unprotect CRTC registers 0-7. */ 1044219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_VERT_RETRACE_END); 1045219888Sed x = REG_READ1(sc, VGA_CRTC_DATA); 1046219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, x & ~VGA_CRTC_VRE_PR); 1047219888Sed 1048219888Sed /* 1049219888Sed * Wait for the vertical retrace. 1050219888Sed * NOTE: this code reads the VGA_GEN_INPUT_STAT_1 register, which has 1051219888Sed * the side-effect of clearing the internal flip-flip of the attribute 1052219888Sed * controller's write register. This means that because this code is 1053219888Sed * here, we know for sure that the first write to the attribute 1054219888Sed * controller will be a write to the address register. Removing this 1055219888Sed * code therefore also removes that guarantee and appropriate measures 1056219888Sed * need to be taken. 1057219888Sed */ 1058219888Sed do { 1059219888Sed x = REG_READ1(sc, VGA_GEN_INPUT_STAT_1); 1060219888Sed x &= VGA_GEN_IS1_VR | VGA_GEN_IS1_DE; 1061219888Sed } while (x != (VGA_GEN_IS1_VR | VGA_GEN_IS1_DE)); 1062219888Sed 1063219888Sed /* Now, disable the sync. signals. */ 1064219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_MODE_CONTROL); 1065219888Sed x = REG_READ1(sc, VGA_CRTC_DATA); 1066219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, x & ~VGA_CRTC_MC_HR); 1067219888Sed 1068219888Sed /* Asynchronous sequencer reset. */ 1069219888Sed REG_WRITE1(sc, VGA_SEQ_ADDRESS, VGA_SEQ_RESET); 1070219888Sed REG_WRITE1(sc, VGA_SEQ_DATA, VGA_SEQ_RST_SR); 1071219888Sed 1072219888Sed if (!textmode) 1073219888Sed vga_initialize_graphics(vd); 1074219888Sed 1075219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_PRESET_ROW_SCAN); 1076219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0); 1077219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_CURSOR_START); 1078219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, VGA_CRTC_CS_COO); 1079219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_CURSOR_END); 1080219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0); 1081219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_START_ADDR_HIGH); 1082219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0); 1083219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_START_ADDR_LOW); 1084219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0); 1085219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_CURSOR_LOC_HIGH); 1086219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0); 1087219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_CURSOR_LOC_LOW); 1088219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, 0x59); 1089219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_UNDERLINE_LOC); 1090219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, VGA_CRTC_UL_UL); 1091219888Sed 1092219888Sed if (textmode) { 1093219888Sed /* Set the attribute controller to blink disable. */ 1094219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_MODE_CONTROL); 1095219888Sed REG_WRITE1(sc, VGA_AC_WRITE, 0); 1096219888Sed } else { 1097219888Sed /* Set the attribute controller in graphics mode. */ 1098219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_MODE_CONTROL); 1099219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_MC_GA); 1100219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_HORIZ_PIXEL_PANNING); 1101219888Sed REG_WRITE1(sc, VGA_AC_WRITE, 0); 1102219888Sed } 1103219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(0)); 1104219888Sed REG_WRITE1(sc, VGA_AC_WRITE, 0); 1105219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(1)); 1106219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_R); 1107219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(2)); 1108219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_G); 1109219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(3)); 1110219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_SG | VGA_AC_PAL_R); 1111219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(4)); 1112219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_B); 1113219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(5)); 1114219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_R | VGA_AC_PAL_B); 1115219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(6)); 1116219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_G | VGA_AC_PAL_B); 1117219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(7)); 1118219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_R | VGA_AC_PAL_G | VGA_AC_PAL_B); 1119219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(8)); 1120219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_SR | VGA_AC_PAL_SG | 1121219888Sed VGA_AC_PAL_SB); 1122219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(9)); 1123219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_SR | VGA_AC_PAL_SG | 1124219888Sed VGA_AC_PAL_SB | VGA_AC_PAL_R); 1125219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(10)); 1126219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_SR | VGA_AC_PAL_SG | 1127219888Sed VGA_AC_PAL_SB | VGA_AC_PAL_G); 1128219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(11)); 1129219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_SR | VGA_AC_PAL_SG | 1130219888Sed VGA_AC_PAL_SB | VGA_AC_PAL_R | VGA_AC_PAL_G); 1131219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(12)); 1132219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_SR | VGA_AC_PAL_SG | 1133219888Sed VGA_AC_PAL_SB | VGA_AC_PAL_B); 1134219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(13)); 1135219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_SR | VGA_AC_PAL_SG | 1136219888Sed VGA_AC_PAL_SB | VGA_AC_PAL_R | VGA_AC_PAL_B); 1137219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(14)); 1138219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_SR | VGA_AC_PAL_SG | 1139219888Sed VGA_AC_PAL_SB | VGA_AC_PAL_G | VGA_AC_PAL_B); 1140219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PALETTE(15)); 1141219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_PAL_SR | VGA_AC_PAL_SG | 1142219888Sed VGA_AC_PAL_SB | VGA_AC_PAL_R | VGA_AC_PAL_G | VGA_AC_PAL_B); 1143219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_OVERSCAN_COLOR); 1144219888Sed REG_WRITE1(sc, VGA_AC_WRITE, 0); 1145219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_COLOR_PLANE_ENABLE); 1146219888Sed REG_WRITE1(sc, VGA_AC_WRITE, 0x0f); 1147219888Sed REG_WRITE1(sc, VGA_AC_WRITE, VGA_AC_COLOR_SELECT); 1148219888Sed REG_WRITE1(sc, VGA_AC_WRITE, 0); 1149219888Sed 1150219888Sed if (!textmode) { 1151219888Sed u_int ofs; 1152219888Sed 1153219888Sed /* 1154219888Sed * Done. Clear the frame buffer. All bit planes are 1155219888Sed * enabled, so a single-paged loop should clear all 1156219888Sed * planes. 1157219888Sed */ 1158219888Sed for (ofs = 0; ofs < VT_VGA_MEMSIZE; ofs++) { 1159219888Sed MEM_WRITE1(sc, ofs, 0); 1160219888Sed } 1161219888Sed } 1162219888Sed 1163219888Sed /* Re-enable the sequencer. */ 1164219888Sed REG_WRITE1(sc, VGA_SEQ_ADDRESS, VGA_SEQ_RESET); 1165219888Sed REG_WRITE1(sc, VGA_SEQ_DATA, VGA_SEQ_RST_SR | VGA_SEQ_RST_NAR); 1166219888Sed /* Re-enable the sync signals. */ 1167219888Sed REG_WRITE1(sc, VGA_CRTC_ADDRESS, VGA_CRTC_MODE_CONTROL); 1168219888Sed x = REG_READ1(sc, VGA_CRTC_DATA); 1169219888Sed REG_WRITE1(sc, VGA_CRTC_DATA, x | VGA_CRTC_MC_HR); 1170219888Sed 1171219888Sed if (!textmode) { 1172219888Sed /* Switch to write mode 3, because we'll mainly do bitblt. */ 1173219888Sed REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_MODE); 1174219888Sed REG_WRITE1(sc, VGA_GC_DATA, 3); 1175271128Semaste sc->vga_wmode = 3; 1176271128Semaste 1177271128Semaste /* 1178271128Semaste * In Write Mode 3, Enable Set/Reset is ignored, but we 1179271128Semaste * use Write Mode 0 to write a group of 8 pixels using 1180271128Semaste * 3 or more colors. In this case, we want to disable 1181271128Semaste * Set/Reset: set Enable Set/Reset to 0. 1182271128Semaste */ 1183219888Sed REG_WRITE1(sc, VGA_GC_ADDRESS, VGA_GC_ENABLE_SET_RESET); 1184271128Semaste REG_WRITE1(sc, VGA_GC_DATA, 0x00); 1185271128Semaste 1186271128Semaste /* 1187271128Semaste * Clear the colors we think are loaded into Set/Reset or 1188271128Semaste * the latches. 1189271128Semaste */ 1190271128Semaste sc->vga_curfg = sc->vga_curbg = 0xff; 1191219888Sed } 1192219888Sed} 1193219888Sed 1194219888Sedstatic int 1195265403Srayvga_probe(struct vt_device *vd) 1196265403Sray{ 1197265403Sray 1198265403Sray return (CN_INTERNAL); 1199265403Sray} 1200265403Sray 1201265403Sraystatic int 1202219888Sedvga_init(struct vt_device *vd) 1203219888Sed{ 1204265403Sray struct vga_softc *sc; 1205265403Sray int textmode; 1206219888Sed 1207265403Sray if (vd->vd_softc == NULL) 1208265403Sray vd->vd_softc = (void *)&vga_conssoftc; 1209265403Sray sc = vd->vd_softc; 1210265403Sray textmode = 0; 1211265403Sray 1212264997Snwhitehorn#if defined(__amd64__) || defined(__i386__) 1213219897Sed sc->vga_fb_tag = X86_BUS_SPACE_MEM; 1214219888Sed sc->vga_fb_handle = KERNBASE + VGA_MEM_BASE; 1215219897Sed sc->vga_reg_tag = X86_BUS_SPACE_IO; 1216219888Sed sc->vga_reg_handle = VGA_REG_BASE; 1217234252Smarcel#elif defined(__ia64__) 1218234252Smarcel sc->vga_fb_tag = IA64_BUS_SPACE_MEM; 1219234252Smarcel sc->vga_fb_handle = IA64_PHYS_TO_RR6(VGA_MEM_BASE); 1220234252Smarcel sc->vga_reg_tag = IA64_BUS_SPACE_IO; 1221234252Smarcel sc->vga_reg_handle = VGA_REG_BASE; 1222219888Sed#else 1223219888Sed# error "Architecture not yet supported!" 1224219888Sed#endif 1225219888Sed 1226219888Sed TUNABLE_INT_FETCH("hw.vga.textmode", &textmode); 1227219888Sed if (textmode) { 1228219888Sed vd->vd_flags |= VDF_TEXTMODE; 1229219888Sed vd->vd_width = 80; 1230219888Sed vd->vd_height = 25; 1231219888Sed } else { 1232219888Sed vd->vd_width = VT_VGA_WIDTH; 1233219888Sed vd->vd_height = VT_VGA_HEIGHT; 1234219888Sed } 1235219888Sed vga_initialize(vd, textmode); 1236219888Sed 1237219888Sed return (CN_INTERNAL); 1238219888Sed} 1239260450Sray 1240260450Sraystatic void 1241260450Srayvga_postswitch(struct vt_device *vd) 1242260450Sray{ 1243260450Sray 1244260450Sray /* Reinit VGA mode, to restore view after app which change mode. */ 1245260450Sray vga_initialize(vd, (vd->vd_flags & VDF_TEXTMODE)); 1246260450Sray /* Ask vt(9) to update chars on visible area. */ 1247260450Sray vd->vd_flags |= VDF_INVALID; 1248260450Sray} 1249