2009-09-09 07:45:08 +00:00
|
|
|
/*-
|
2017-11-27 14:52:40 +00:00
|
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
|
|
*
|
2009-09-09 07:45:08 +00:00
|
|
|
* Copyright (c) 1998 Kazutaka YOKOTA and Michael Smith
|
2013-08-28 19:06:22 +00:00
|
|
|
* Copyright (c) 2009-2013 Jung-uk Kim <jkim@FreeBSD.org>
|
2009-09-09 07:45:08 +00:00
|
|
|
* 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 as
|
|
|
|
* the first lines of this file unmodified.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
|
|
#include "opt_vga.h"
|
|
|
|
#include "opt_vesa.h"
|
|
|
|
|
|
|
|
#ifndef VGA_NO_MODE_CHANGE
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
2009-10-19 20:58:10 +00:00
|
|
|
#include <sys/bus.h>
|
2009-09-09 07:45:08 +00:00
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/kernel.h>
|
2010-08-07 05:46:04 +00:00
|
|
|
#include <sys/lock.h>
|
2009-09-09 07:45:08 +00:00
|
|
|
#include <sys/module.h>
|
|
|
|
#include <sys/malloc.h>
|
2010-08-07 05:46:04 +00:00
|
|
|
#include <sys/mutex.h>
|
2009-09-09 07:45:08 +00:00
|
|
|
#include <sys/fbio.h>
|
2010-08-25 22:09:02 +00:00
|
|
|
#include <sys/sysctl.h>
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
#include <vm/vm.h>
|
|
|
|
#include <vm/vm_extern.h>
|
|
|
|
#include <vm/vm_kern.h>
|
|
|
|
#include <vm/vm_param.h>
|
|
|
|
#include <vm/pmap.h>
|
|
|
|
|
2009-09-21 08:17:57 +00:00
|
|
|
#include <machine/pc/bios.h>
|
2009-09-09 09:50:31 +00:00
|
|
|
#include <dev/fb/vesa.h>
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
#include <dev/fb/fbreg.h>
|
|
|
|
#include <dev/fb/vgareg.h>
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
#include <dev/pci/pcivar.h>
|
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
#include <isa/isareg.h>
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-23 20:49:14 +00:00
|
|
|
#include <compat/x86bios/x86bios.h>
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2010-08-25 22:09:02 +00:00
|
|
|
#define VESA_BIOS_OFFSET 0xc0000
|
|
|
|
#define VESA_PALETTE_SIZE (256 * 4)
|
2009-09-09 07:45:08 +00:00
|
|
|
#define VESA_VIA_CLE266 "VIA CLE266\r\n"
|
|
|
|
|
|
|
|
#ifndef VESA_DEBUG
|
|
|
|
#define VESA_DEBUG 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* VESA video adapter state buffer stub */
|
|
|
|
struct adp_state {
|
|
|
|
int sig;
|
|
|
|
#define V_STATE_SIG 0x61736576
|
|
|
|
u_char regs[1];
|
|
|
|
};
|
|
|
|
typedef struct adp_state adp_state_t;
|
|
|
|
|
2010-08-07 05:46:04 +00:00
|
|
|
static struct mtx vesa_lock;
|
2016-07-23 14:38:09 +00:00
|
|
|
MTX_SYSINIT(vesa_lock, &vesa_lock, "VESA lock", MTX_DEF);
|
2010-08-07 05:46:04 +00:00
|
|
|
|
2012-02-23 19:05:57 +00:00
|
|
|
static int vesa_state;
|
2012-03-16 23:54:23 +00:00
|
|
|
static void *vesa_state_buf;
|
|
|
|
static uint32_t vesa_state_buf_offs;
|
2013-08-28 17:58:30 +00:00
|
|
|
static size_t vesa_state_buf_size;
|
2010-07-13 19:48:20 +00:00
|
|
|
|
2012-03-16 23:54:23 +00:00
|
|
|
static u_char *vesa_palette;
|
|
|
|
static uint32_t vesa_palette_offs;
|
2010-08-25 22:09:02 +00:00
|
|
|
|
2012-03-17 00:00:33 +00:00
|
|
|
static void *vesa_vmem_buf;
|
2013-03-27 18:06:28 +00:00
|
|
|
static size_t vesa_vmem_max;
|
2012-03-17 00:00:33 +00:00
|
|
|
|
2012-03-16 23:54:23 +00:00
|
|
|
static void *vesa_bios;
|
|
|
|
static uint32_t vesa_bios_offs;
|
|
|
|
static uint32_t vesa_bios_int10;
|
|
|
|
static size_t vesa_bios_size;
|
2010-07-13 19:48:20 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
/* VESA video adapter */
|
2012-03-16 23:54:23 +00:00
|
|
|
static video_adapter_t *vesa_adp;
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2011-11-07 15:43:11 +00:00
|
|
|
static SYSCTL_NODE(_debug, OID_AUTO, vesa, CTLFLAG_RD, NULL, "VESA debugging");
|
2012-03-16 23:54:23 +00:00
|
|
|
static int vesa_shadow_rom;
|
2010-08-25 22:09:02 +00:00
|
|
|
SYSCTL_INT(_debug_vesa, OID_AUTO, shadow_rom, CTLFLAG_RDTUN, &vesa_shadow_rom,
|
2010-09-02 17:22:12 +00:00
|
|
|
0, "Enable video BIOS shadow");
|
2010-08-25 22:09:02 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
/* VESA functions */
|
|
|
|
#if 0
|
|
|
|
static int vesa_nop(void);
|
|
|
|
#endif
|
|
|
|
static int vesa_error(void);
|
|
|
|
static vi_probe_t vesa_probe;
|
|
|
|
static vi_init_t vesa_init;
|
|
|
|
static vi_get_info_t vesa_get_info;
|
|
|
|
static vi_query_mode_t vesa_query_mode;
|
|
|
|
static vi_set_mode_t vesa_set_mode;
|
|
|
|
static vi_save_font_t vesa_save_font;
|
|
|
|
static vi_load_font_t vesa_load_font;
|
|
|
|
static vi_show_font_t vesa_show_font;
|
|
|
|
static vi_save_palette_t vesa_save_palette;
|
|
|
|
static vi_load_palette_t vesa_load_palette;
|
|
|
|
static vi_set_border_t vesa_set_border;
|
|
|
|
static vi_save_state_t vesa_save_state;
|
|
|
|
static vi_load_state_t vesa_load_state;
|
|
|
|
static vi_set_win_org_t vesa_set_origin;
|
|
|
|
static vi_read_hw_cursor_t vesa_read_hw_cursor;
|
|
|
|
static vi_set_hw_cursor_t vesa_set_hw_cursor;
|
|
|
|
static vi_set_hw_cursor_shape_t vesa_set_hw_cursor_shape;
|
|
|
|
static vi_blank_display_t vesa_blank_display;
|
|
|
|
static vi_mmap_t vesa_mmap;
|
|
|
|
static vi_ioctl_t vesa_ioctl;
|
|
|
|
static vi_clear_t vesa_clear;
|
|
|
|
static vi_fill_rect_t vesa_fill_rect;
|
|
|
|
static vi_bitblt_t vesa_bitblt;
|
|
|
|
static vi_diag_t vesa_diag;
|
|
|
|
static int vesa_bios_info(int level);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
static video_switch_t vesavidsw = {
|
|
|
|
vesa_probe,
|
|
|
|
vesa_init,
|
|
|
|
vesa_get_info,
|
|
|
|
vesa_query_mode,
|
|
|
|
vesa_set_mode,
|
|
|
|
vesa_save_font,
|
|
|
|
vesa_load_font,
|
|
|
|
vesa_show_font,
|
|
|
|
vesa_save_palette,
|
|
|
|
vesa_load_palette,
|
|
|
|
vesa_set_border,
|
|
|
|
vesa_save_state,
|
|
|
|
vesa_load_state,
|
|
|
|
vesa_set_origin,
|
|
|
|
vesa_read_hw_cursor,
|
|
|
|
vesa_set_hw_cursor,
|
|
|
|
vesa_set_hw_cursor_shape,
|
|
|
|
vesa_blank_display,
|
|
|
|
vesa_mmap,
|
|
|
|
vesa_ioctl,
|
|
|
|
vesa_clear,
|
|
|
|
vesa_fill_rect,
|
|
|
|
vesa_bitblt,
|
|
|
|
vesa_error,
|
|
|
|
vesa_error,
|
|
|
|
vesa_diag,
|
|
|
|
};
|
|
|
|
|
|
|
|
static video_switch_t *prevvidsw;
|
|
|
|
|
|
|
|
/* VESA BIOS video modes */
|
|
|
|
#define VESA_MAXMODES 64
|
|
|
|
#define EOT (-1)
|
|
|
|
#define NA (-2)
|
|
|
|
|
|
|
|
#define MODE_TABLE_DELTA 8
|
|
|
|
|
2012-03-16 23:54:23 +00:00
|
|
|
static int vesa_vmode_max;
|
|
|
|
static video_info_t *vesa_vmode;
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2012-03-16 23:54:23 +00:00
|
|
|
static int vesa_init_done;
|
|
|
|
static struct vesa_info *vesa_adp_info;
|
|
|
|
static u_int16_t *vesa_vmodetab;
|
|
|
|
static char *vesa_oemstr;
|
|
|
|
static char *vesa_venderstr;
|
|
|
|
static char *vesa_prodstr;
|
|
|
|
static char *vesa_revstr;
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
/* local macros and functions */
|
|
|
|
#define BIOS_SADDRTOLADDR(p) ((((p) & 0xffff0000) >> 12) + ((p) & 0x0000ffff))
|
|
|
|
|
|
|
|
static int int10_set_mode(int mode);
|
2009-10-19 20:58:10 +00:00
|
|
|
static int vesa_bios_post(void);
|
2010-06-23 23:34:56 +00:00
|
|
|
static int vesa_bios_get_mode(int mode, struct vesa_mode *vmode, int flags);
|
2009-09-09 07:45:08 +00:00
|
|
|
static int vesa_bios_set_mode(int mode);
|
2010-02-23 21:51:14 +00:00
|
|
|
#if 0
|
2009-09-09 07:45:08 +00:00
|
|
|
static int vesa_bios_get_dac(void);
|
2010-02-23 21:51:14 +00:00
|
|
|
#endif
|
2009-09-09 07:45:08 +00:00
|
|
|
static int vesa_bios_set_dac(int bits);
|
|
|
|
static int vesa_bios_save_palette(int start, int colors, u_char *palette,
|
|
|
|
int bits);
|
|
|
|
static int vesa_bios_save_palette2(int start, int colors, u_char *r, u_char *g,
|
|
|
|
u_char *b, int bits);
|
|
|
|
static int vesa_bios_load_palette(int start, int colors, u_char *palette,
|
|
|
|
int bits);
|
|
|
|
static int vesa_bios_load_palette2(int start, int colors, u_char *r, u_char *g,
|
|
|
|
u_char *b, int bits);
|
|
|
|
#define STATE_SIZE 0
|
|
|
|
#define STATE_SAVE 1
|
|
|
|
#define STATE_LOAD 2
|
2013-08-28 17:58:30 +00:00
|
|
|
static size_t vesa_bios_state_buf_size(int);
|
2010-07-13 19:48:20 +00:00
|
|
|
static int vesa_bios_save_restore(int code, void *p);
|
2010-03-25 17:51:05 +00:00
|
|
|
#ifdef MODE_TABLE_BROKEN
|
2009-09-09 07:45:08 +00:00
|
|
|
static int vesa_bios_get_line_length(void);
|
2010-03-25 17:51:05 +00:00
|
|
|
#endif
|
2009-09-09 07:45:08 +00:00
|
|
|
static int vesa_bios_set_line_length(int pixel, int *bytes, int *lines);
|
|
|
|
#if 0
|
|
|
|
static int vesa_bios_get_start(int *x, int *y);
|
|
|
|
#endif
|
|
|
|
static int vesa_bios_set_start(int x, int y);
|
|
|
|
static int vesa_map_gen_mode_num(int type, int color, int mode);
|
|
|
|
static int vesa_translate_flags(u_int16_t vflags);
|
|
|
|
static int vesa_translate_mmodel(u_int8_t vmodel);
|
2010-03-23 23:10:17 +00:00
|
|
|
static int vesa_get_bpscanline(struct vesa_mode *vmode);
|
2009-09-09 07:45:08 +00:00
|
|
|
static int vesa_bios_init(void);
|
2012-03-16 23:54:23 +00:00
|
|
|
static void vesa_bios_uninit(void);
|
2009-09-09 07:45:08 +00:00
|
|
|
static void vesa_clear_modes(video_info_t *info, int color);
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
static int vesa_get_origin(video_adapter_t *adp, off_t *offset);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* INT 10 BIOS calls */
|
|
|
|
static int
|
|
|
|
int10_set_mode(int mode)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AL = mode;
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_bios_post(void)
|
|
|
|
{
|
|
|
|
x86regs_t regs;
|
|
|
|
devclass_t dc;
|
|
|
|
device_t *devs;
|
|
|
|
device_t dev;
|
|
|
|
int count, i, is_pci;
|
|
|
|
|
2010-08-25 22:09:02 +00:00
|
|
|
if (x86bios_get_orm(vesa_bios_offs) == NULL)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
|
|
|
|
|
|
|
dev = NULL;
|
|
|
|
is_pci = 0;
|
|
|
|
|
|
|
|
/* Find the matching PCI video controller. */
|
|
|
|
dc = devclass_find("vgapci");
|
|
|
|
if (dc != NULL && devclass_get_devices(dc, &devs, &count) == 0) {
|
2010-05-18 18:28:17 +00:00
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
if (device_get_flags(devs[i]) != 0 &&
|
2010-08-25 22:09:02 +00:00
|
|
|
x86bios_match_device(vesa_bios_offs, devs[i])) {
|
2010-05-18 18:28:17 +00:00
|
|
|
dev = devs[i];
|
2009-10-19 20:58:10 +00:00
|
|
|
is_pci = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
free(devs, M_TEMP);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Try VGA if a PCI device is not found. */
|
|
|
|
if (dev == NULL) {
|
|
|
|
dc = devclass_find(VGA_DRIVER_NAME);
|
|
|
|
if (dc != NULL)
|
|
|
|
dev = devclass_get_device(dc, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bootverbose)
|
|
|
|
printf("%s: calling BIOS POST\n",
|
|
|
|
dev == NULL ? "VESA" : device_get_nameunit(dev));
|
|
|
|
|
|
|
|
x86bios_init_regs(®s);
|
|
|
|
if (is_pci) {
|
|
|
|
regs.R_AH = pci_get_bus(dev);
|
|
|
|
regs.R_AL = (pci_get_slot(dev) << 3) |
|
|
|
|
(pci_get_function(dev) & 0x07);
|
|
|
|
}
|
|
|
|
regs.R_DL = 0x80;
|
2010-08-25 22:09:02 +00:00
|
|
|
x86bios_call(®s, X86BIOS_PHYSTOSEG(vesa_bios_offs + 3),
|
|
|
|
X86BIOS_PHYSTOOFF(vesa_bios_offs + 3));
|
2009-10-23 18:41:00 +00:00
|
|
|
|
|
|
|
if (x86bios_get_intr(0x10) == 0)
|
|
|
|
return (1);
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* VESA BIOS calls */
|
|
|
|
static int
|
2010-06-23 23:34:56 +00:00
|
|
|
vesa_bios_get_mode(int mode, struct vesa_mode *vmode, int flags)
|
2009-09-09 07:45:08 +00:00
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-10-19 20:58:10 +00:00
|
|
|
uint32_t offs;
|
|
|
|
void *buf;
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2010-06-23 23:34:56 +00:00
|
|
|
buf = x86bios_alloc(&offs, sizeof(*vmode), flags);
|
2009-10-19 20:58:10 +00:00
|
|
|
if (buf == NULL)
|
|
|
|
return (1);
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f01;
|
|
|
|
regs.R_CX = mode;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
regs.R_ES = X86BIOS_PHYSTOSEG(offs);
|
|
|
|
regs.R_DI = X86BIOS_PHYSTOOFF(offs);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if (regs.R_AX != 0x004f) {
|
|
|
|
x86bios_free(buf, sizeof(*vmode));
|
|
|
|
return (1);
|
2009-09-21 08:17:57 +00:00
|
|
|
}
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
bcopy(buf, vmode, sizeof(*vmode));
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_free(buf, sizeof(*vmode));
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
static int
|
|
|
|
vesa_bios_set_mode(int mode)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f02;
|
|
|
|
regs.R_BX = mode;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (regs.R_AX != 0x004f);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
2010-02-23 21:51:14 +00:00
|
|
|
#if 0
|
2009-09-09 07:45:08 +00:00
|
|
|
static int
|
|
|
|
vesa_bios_get_dac(void)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f08;
|
|
|
|
regs.R_BL = 1;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if (regs.R_AX != 0x004f)
|
|
|
|
return (6);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (regs.R_BH);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2010-02-23 21:51:14 +00:00
|
|
|
#endif
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_bios_set_dac(int bits)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f08;
|
|
|
|
/* regs.R_BL = 0; */
|
|
|
|
regs.R_BH = bits;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if (regs.R_AX != 0x004f)
|
|
|
|
return (6);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (regs.R_BH);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_bios_save_palette(int start, int colors, u_char *palette, int bits)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-09-09 07:45:08 +00:00
|
|
|
int i;
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f09;
|
|
|
|
regs.R_BL = 1;
|
|
|
|
regs.R_CX = colors;
|
|
|
|
regs.R_DX = start;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2010-07-13 19:48:20 +00:00
|
|
|
regs.R_ES = X86BIOS_PHYSTOSEG(vesa_palette_offs);
|
|
|
|
regs.R_DI = X86BIOS_PHYSTOOFF(vesa_palette_offs);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2010-08-07 05:46:04 +00:00
|
|
|
bits = 8 - bits;
|
|
|
|
mtx_lock(&vesa_lock);
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2010-08-07 05:46:04 +00:00
|
|
|
if (regs.R_AX != 0x004f) {
|
|
|
|
mtx_unlock(&vesa_lock);
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
2010-08-07 05:46:04 +00:00
|
|
|
}
|
2009-09-09 07:45:08 +00:00
|
|
|
for (i = 0; i < colors; ++i) {
|
2010-07-13 19:48:20 +00:00
|
|
|
palette[i * 3] = vesa_palette[i * 4 + 2] << bits;
|
|
|
|
palette[i * 3 + 1] = vesa_palette[i * 4 + 1] << bits;
|
|
|
|
palette[i * 3 + 2] = vesa_palette[i * 4] << bits;
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2010-08-07 05:46:04 +00:00
|
|
|
mtx_unlock(&vesa_lock);
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_bios_save_palette2(int start, int colors, u_char *r, u_char *g, u_char *b,
|
|
|
|
int bits)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-09-09 07:45:08 +00:00
|
|
|
int i;
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f09;
|
|
|
|
regs.R_BL = 1;
|
|
|
|
regs.R_CX = colors;
|
|
|
|
regs.R_DX = start;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2010-07-13 19:48:20 +00:00
|
|
|
regs.R_ES = X86BIOS_PHYSTOSEG(vesa_palette_offs);
|
|
|
|
regs.R_DI = X86BIOS_PHYSTOOFF(vesa_palette_offs);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2010-08-07 05:46:04 +00:00
|
|
|
bits = 8 - bits;
|
|
|
|
mtx_lock(&vesa_lock);
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2010-08-07 05:46:04 +00:00
|
|
|
if (regs.R_AX != 0x004f) {
|
|
|
|
mtx_unlock(&vesa_lock);
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
2010-08-07 05:46:04 +00:00
|
|
|
}
|
2009-09-09 07:45:08 +00:00
|
|
|
for (i = 0; i < colors; ++i) {
|
2010-07-13 19:48:20 +00:00
|
|
|
r[i] = vesa_palette[i * 4 + 2] << bits;
|
|
|
|
g[i] = vesa_palette[i * 4 + 1] << bits;
|
|
|
|
b[i] = vesa_palette[i * 4] << bits;
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2010-08-07 05:46:04 +00:00
|
|
|
mtx_unlock(&vesa_lock);
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_bios_load_palette(int start, int colors, u_char *palette, int bits)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-09-09 07:45:08 +00:00
|
|
|
int i;
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f09;
|
|
|
|
/* regs.R_BL = 0; */
|
|
|
|
regs.R_CX = colors;
|
|
|
|
regs.R_DX = start;
|
|
|
|
|
2010-07-13 19:48:20 +00:00
|
|
|
regs.R_ES = X86BIOS_PHYSTOSEG(vesa_palette_offs);
|
|
|
|
regs.R_DI = X86BIOS_PHYSTOOFF(vesa_palette_offs);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
bits = 8 - bits;
|
2010-08-07 05:46:04 +00:00
|
|
|
mtx_lock(&vesa_lock);
|
2009-09-09 07:45:08 +00:00
|
|
|
for (i = 0; i < colors; ++i) {
|
2010-07-13 19:48:20 +00:00
|
|
|
vesa_palette[i * 4] = palette[i * 3 + 2] >> bits;
|
|
|
|
vesa_palette[i * 4 + 1] = palette[i * 3 + 1] >> bits;
|
|
|
|
vesa_palette[i * 4 + 2] = palette[i * 3] >> bits;
|
|
|
|
vesa_palette[i * 4 + 3] = 0;
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2010-08-07 05:46:04 +00:00
|
|
|
mtx_unlock(&vesa_lock);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (regs.R_AX != 0x004f);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_bios_load_palette2(int start, int colors, u_char *r, u_char *g, u_char *b,
|
|
|
|
int bits)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-09-09 07:45:08 +00:00
|
|
|
int i;
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f09;
|
|
|
|
/* regs.R_BL = 0; */
|
|
|
|
regs.R_CX = colors;
|
|
|
|
regs.R_DX = start;
|
|
|
|
|
2010-07-13 19:48:20 +00:00
|
|
|
regs.R_ES = X86BIOS_PHYSTOSEG(vesa_palette_offs);
|
|
|
|
regs.R_DI = X86BIOS_PHYSTOOFF(vesa_palette_offs);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
bits = 8 - bits;
|
2010-08-07 05:46:04 +00:00
|
|
|
mtx_lock(&vesa_lock);
|
2009-09-09 07:45:08 +00:00
|
|
|
for (i = 0; i < colors; ++i) {
|
2010-07-13 19:48:20 +00:00
|
|
|
vesa_palette[i * 4] = b[i] >> bits;
|
|
|
|
vesa_palette[i * 4 + 1] = g[i] >> bits;
|
|
|
|
vesa_palette[i * 4 + 2] = r[i] >> bits;
|
|
|
|
vesa_palette[i * 4 + 3] = 0;
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2010-08-07 05:46:04 +00:00
|
|
|
mtx_unlock(&vesa_lock);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (regs.R_AX != 0x004f);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
2013-08-28 17:58:30 +00:00
|
|
|
static size_t
|
2012-02-23 19:05:57 +00:00
|
|
|
vesa_bios_state_buf_size(int state)
|
2009-09-09 07:45:08 +00:00
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f04;
|
|
|
|
/* regs.R_DL = STATE_SIZE; */
|
2012-02-23 19:05:57 +00:00
|
|
|
regs.R_CX = state;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if (regs.R_AX != 0x004f)
|
|
|
|
return (0);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (regs.R_BX * 64);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2010-07-13 19:48:20 +00:00
|
|
|
vesa_bios_save_restore(int code, void *p)
|
2009-09-09 07:45:08 +00:00
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if (code != STATE_SAVE && code != STATE_LOAD)
|
|
|
|
return (1);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f04;
|
|
|
|
regs.R_DL = code;
|
2012-02-23 19:05:57 +00:00
|
|
|
regs.R_CX = vesa_state;
|
2009-10-19 20:58:10 +00:00
|
|
|
|
2010-07-13 19:48:20 +00:00
|
|
|
regs.R_ES = X86BIOS_PHYSTOSEG(vesa_state_buf_offs);
|
|
|
|
regs.R_BX = X86BIOS_PHYSTOOFF(vesa_state_buf_offs);
|
2009-10-19 20:58:10 +00:00
|
|
|
|
2010-08-07 05:46:04 +00:00
|
|
|
mtx_lock(&vesa_lock);
|
2009-10-19 20:58:10 +00:00
|
|
|
switch (code) {
|
|
|
|
case STATE_SAVE:
|
|
|
|
x86bios_intr(®s, 0x10);
|
2012-04-04 21:38:26 +00:00
|
|
|
if (regs.R_AX == 0x004f)
|
|
|
|
bcopy(vesa_state_buf, p, vesa_state_buf_size);
|
2009-10-19 20:58:10 +00:00
|
|
|
break;
|
|
|
|
case STATE_LOAD:
|
2010-07-13 19:48:20 +00:00
|
|
|
bcopy(p, vesa_state_buf, vesa_state_buf_size);
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
|
|
|
break;
|
|
|
|
}
|
2010-08-07 05:46:04 +00:00
|
|
|
mtx_unlock(&vesa_lock);
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (regs.R_AX != 0x004f);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
2010-03-25 17:51:05 +00:00
|
|
|
#ifdef MODE_TABLE_BROKEN
|
2009-09-09 07:45:08 +00:00
|
|
|
static int
|
|
|
|
vesa_bios_get_line_length(void)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f06;
|
|
|
|
regs.R_BL = 1;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if (regs.R_AX != 0x004f)
|
|
|
|
return (-1);
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (regs.R_BX);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2010-03-25 17:51:05 +00:00
|
|
|
#endif
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_bios_set_line_length(int pixel, int *bytes, int *lines)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f06;
|
|
|
|
/* regs.R_BL = 0; */
|
|
|
|
regs.R_CX = pixel;
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
#if VESA_DEBUG > 1
|
2009-09-21 08:17:57 +00:00
|
|
|
printf("bx:%d, cx:%d, dx:%d\n", regs.R_BX, regs.R_CX, regs.R_DX);
|
2009-09-09 07:45:08 +00:00
|
|
|
#endif
|
2009-10-19 20:58:10 +00:00
|
|
|
if (regs.R_AX != 0x004f)
|
|
|
|
return (-1);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if (bytes != NULL)
|
2009-09-21 08:17:57 +00:00
|
|
|
*bytes = regs.R_BX;
|
2009-10-19 20:58:10 +00:00
|
|
|
if (lines != NULL)
|
2009-09-21 08:17:57 +00:00
|
|
|
*lines = regs.R_DX;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
static int
|
|
|
|
vesa_bios_get_start(int *x, int *y)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f07;
|
|
|
|
regs.R_BL = 1;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if (regs.R_AX != 0x004f)
|
|
|
|
return (-1);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-21 08:17:57 +00:00
|
|
|
*x = regs.R_CX;
|
|
|
|
*y = regs.R_DX;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_bios_set_start(int x, int y)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f07;
|
|
|
|
regs.R_BL = 0x80;
|
|
|
|
regs.R_CX = x;
|
|
|
|
regs.R_DX = y;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (regs.R_AX != 0x004f);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* map a generic video mode to a known mode */
|
|
|
|
static int
|
|
|
|
vesa_map_gen_mode_num(int type, int color, int mode)
|
|
|
|
{
|
|
|
|
static struct {
|
|
|
|
int from;
|
|
|
|
int to;
|
|
|
|
} mode_map[] = {
|
|
|
|
{ M_TEXT_132x25, M_VESA_C132x25 },
|
|
|
|
{ M_TEXT_132x43, M_VESA_C132x43 },
|
|
|
|
{ M_TEXT_132x50, M_VESA_C132x50 },
|
|
|
|
{ M_TEXT_132x60, M_VESA_C132x60 },
|
|
|
|
};
|
|
|
|
int i;
|
|
|
|
|
2016-04-21 19:40:10 +00:00
|
|
|
for (i = 0; i < nitems(mode_map); ++i) {
|
2009-09-09 07:45:08 +00:00
|
|
|
if (mode_map[i].from == mode)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (mode_map[i].to);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2009-10-19 20:58:10 +00:00
|
|
|
return (mode);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_translate_flags(u_int16_t vflags)
|
|
|
|
{
|
|
|
|
static struct {
|
|
|
|
u_int16_t mask;
|
|
|
|
int set;
|
|
|
|
int reset;
|
|
|
|
} ftable[] = {
|
|
|
|
{ V_MODECOLOR, V_INFO_COLOR, 0 },
|
|
|
|
{ V_MODEGRAPHICS, V_INFO_GRAPHICS, 0 },
|
|
|
|
{ V_MODELFB, V_INFO_LINEAR, 0 },
|
2009-11-03 20:22:09 +00:00
|
|
|
{ V_MODENONVGA, V_INFO_NONVGA, 0 },
|
2009-09-09 07:45:08 +00:00
|
|
|
};
|
|
|
|
int flags;
|
|
|
|
int i;
|
|
|
|
|
2016-04-21 19:40:10 +00:00
|
|
|
for (flags = 0, i = 0; i < nitems(ftable); ++i) {
|
2009-09-09 07:45:08 +00:00
|
|
|
flags |= (vflags & ftable[i].mask) ?
|
|
|
|
ftable[i].set : ftable[i].reset;
|
|
|
|
}
|
2009-10-19 20:58:10 +00:00
|
|
|
return (flags);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_translate_mmodel(u_int8_t vmodel)
|
|
|
|
{
|
|
|
|
static struct {
|
|
|
|
u_int8_t vmodel;
|
|
|
|
int mmodel;
|
|
|
|
} mtable[] = {
|
|
|
|
{ V_MMTEXT, V_INFO_MM_TEXT },
|
|
|
|
{ V_MMCGA, V_INFO_MM_CGA },
|
|
|
|
{ V_MMHGC, V_INFO_MM_HGC },
|
|
|
|
{ V_MMEGA, V_INFO_MM_PLANAR },
|
|
|
|
{ V_MMPACKED, V_INFO_MM_PACKED },
|
|
|
|
{ V_MMDIRCOLOR, V_INFO_MM_DIRECT },
|
|
|
|
};
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; mtable[i].mmodel >= 0; ++i) {
|
|
|
|
if (mtable[i].vmodel == vmodel)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (mtable[i].mmodel);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2009-10-19 20:58:10 +00:00
|
|
|
return (V_INFO_MM_OTHER);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
2010-03-23 23:10:17 +00:00
|
|
|
static int
|
|
|
|
vesa_get_bpscanline(struct vesa_mode *vmode)
|
|
|
|
{
|
|
|
|
int bpsl;
|
|
|
|
|
|
|
|
if ((vmode->v_modeattr & V_MODEGRAPHICS) != 0) {
|
|
|
|
/* Find the minimum length. */
|
|
|
|
switch (vmode->v_bpp / vmode->v_planes) {
|
|
|
|
case 1:
|
|
|
|
bpsl = vmode->v_width / 8;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
bpsl = vmode->v_width / 4;
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
bpsl = vmode->v_width / 2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
bpsl = vmode->v_width * ((vmode->v_bpp + 7) / 8);
|
|
|
|
bpsl /= vmode->v_planes;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Use VBE 3.0 information if it looks sane. */
|
|
|
|
if ((vmode->v_modeattr & V_MODELFB) != 0 &&
|
|
|
|
vesa_adp_info->v_version >= 0x0300 &&
|
|
|
|
vmode->v_linbpscanline > bpsl)
|
|
|
|
return (vmode->v_linbpscanline);
|
|
|
|
|
|
|
|
/* Return the minimum if the mode table looks absurd. */
|
|
|
|
if (vmode->v_bpscanline < bpsl)
|
|
|
|
return (bpsl);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (vmode->v_bpscanline);
|
|
|
|
}
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
#define VESA_MAXSTR 256
|
|
|
|
|
|
|
|
#define VESA_STRCPY(dst, src) do { \
|
|
|
|
char *str; \
|
|
|
|
int i; \
|
|
|
|
dst = malloc(VESA_MAXSTR, M_DEVBUF, M_WAITOK); \
|
|
|
|
str = x86bios_offset(BIOS_SADDRTOLADDR(src)); \
|
|
|
|
for (i = 0; i < VESA_MAXSTR - 1 && str[i] != '\0'; i++) \
|
|
|
|
dst[i] = str[i]; \
|
|
|
|
dst[i] = '\0'; \
|
|
|
|
} while (0)
|
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
static int
|
|
|
|
vesa_bios_init(void)
|
|
|
|
{
|
|
|
|
struct vesa_mode vmode;
|
2010-04-07 21:38:42 +00:00
|
|
|
struct vesa_info *buf;
|
2009-09-09 07:45:08 +00:00
|
|
|
video_info_t *p;
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-09-25 18:08:38 +00:00
|
|
|
size_t bsize;
|
2010-02-06 00:52:42 +00:00
|
|
|
size_t msize;
|
2009-10-19 20:58:10 +00:00
|
|
|
void *vmbuf;
|
2010-08-25 22:09:02 +00:00
|
|
|
uint8_t *vbios;
|
2009-10-19 20:58:10 +00:00
|
|
|
uint32_t offs;
|
|
|
|
uint16_t vers;
|
2009-09-09 07:45:08 +00:00
|
|
|
int is_via_cle266;
|
|
|
|
int modes;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (vesa_init_done)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2010-08-25 22:09:02 +00:00
|
|
|
vesa_bios_offs = VESA_BIOS_OFFSET;
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
/*
|
|
|
|
* If the VBE real mode interrupt vector is not found, try BIOS POST.
|
|
|
|
*/
|
2010-08-25 22:09:02 +00:00
|
|
|
vesa_bios_int10 = x86bios_get_intr(0x10);
|
|
|
|
if (vesa_bios_int10 == 0) {
|
2009-10-19 20:58:10 +00:00
|
|
|
if (vesa_bios_post() != 0)
|
|
|
|
return (1);
|
2010-08-25 22:09:02 +00:00
|
|
|
vesa_bios_int10 = x86bios_get_intr(0x10);
|
|
|
|
if (vesa_bios_int10 == 0)
|
|
|
|
return (1);
|
2009-10-19 20:58:10 +00:00
|
|
|
}
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2010-08-25 22:09:02 +00:00
|
|
|
/*
|
|
|
|
* Shadow video ROM.
|
|
|
|
*/
|
2010-08-31 20:21:52 +00:00
|
|
|
offs = vesa_bios_int10;
|
2010-08-25 22:09:02 +00:00
|
|
|
if (vesa_shadow_rom) {
|
|
|
|
vbios = x86bios_get_orm(vesa_bios_offs);
|
|
|
|
if (vbios != NULL) {
|
|
|
|
vesa_bios_size = vbios[2] * 512;
|
2010-09-13 19:58:46 +00:00
|
|
|
if (((VESA_BIOS_OFFSET << 12) & 0xffff0000) ==
|
|
|
|
(vesa_bios_int10 & 0xffff0000) &&
|
|
|
|
vesa_bios_size > (vesa_bios_int10 & 0xffff)) {
|
2010-08-31 20:21:52 +00:00
|
|
|
vesa_bios = x86bios_alloc(&vesa_bios_offs,
|
|
|
|
vesa_bios_size, M_WAITOK);
|
2012-03-16 23:54:23 +00:00
|
|
|
bcopy(vbios, vesa_bios, vesa_bios_size);
|
2010-09-13 19:58:46 +00:00
|
|
|
offs = ((vesa_bios_offs << 12) & 0xffff0000) +
|
|
|
|
(vesa_bios_int10 & 0xffff);
|
2010-08-31 20:21:52 +00:00
|
|
|
x86bios_set_intr(0x10, offs);
|
2010-09-13 19:58:46 +00:00
|
|
|
}
|
2010-08-31 20:21:52 +00:00
|
|
|
}
|
|
|
|
if (vesa_bios == NULL)
|
2010-08-25 22:09:02 +00:00
|
|
|
printf("VESA: failed to shadow video ROM\n");
|
|
|
|
}
|
|
|
|
if (bootverbose)
|
|
|
|
printf("VESA: INT 0x10 vector 0x%04x:0x%04x\n",
|
2010-08-25 22:48:18 +00:00
|
|
|
(offs >> 16) & 0xffff, offs & 0xffff);
|
2010-08-25 22:09:02 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f00;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2010-06-23 17:20:51 +00:00
|
|
|
vmbuf = x86bios_alloc(&offs, sizeof(*buf), M_WAITOK);
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
regs.R_ES = X86BIOS_PHYSTOSEG(offs);
|
|
|
|
regs.R_DI = X86BIOS_PHYSTOOFF(offs);
|
|
|
|
|
|
|
|
bcopy("VBE2", vmbuf, 4); /* try for VBE2 data */
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if (regs.R_AX != 0x004f || bcmp("VESA", vmbuf, 4) != 0)
|
|
|
|
goto fail;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2010-04-07 21:38:42 +00:00
|
|
|
vesa_adp_info = buf = malloc(sizeof(*buf), M_DEVBUF, M_WAITOK);
|
|
|
|
bcopy(vmbuf, buf, sizeof(*buf));
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
if (bootverbose) {
|
|
|
|
printf("VESA: information block\n");
|
2010-04-07 21:38:42 +00:00
|
|
|
hexdump(buf, sizeof(*buf), NULL, HD_OMIT_CHARS);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2009-10-19 20:58:10 +00:00
|
|
|
|
2010-04-07 21:38:42 +00:00
|
|
|
vers = buf->v_version = le16toh(buf->v_version);
|
|
|
|
buf->v_oemstr = le32toh(buf->v_oemstr);
|
|
|
|
buf->v_flags = le32toh(buf->v_flags);
|
|
|
|
buf->v_modetable = le32toh(buf->v_modetable);
|
|
|
|
buf->v_memsize = le16toh(buf->v_memsize);
|
|
|
|
buf->v_revision = le16toh(buf->v_revision);
|
|
|
|
buf->v_venderstr = le32toh(buf->v_venderstr);
|
|
|
|
buf->v_prodstr = le32toh(buf->v_prodstr);
|
|
|
|
buf->v_revstr = le32toh(buf->v_revstr);
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
if (vers < 0x0102) {
|
2009-09-09 07:45:08 +00:00
|
|
|
printf("VESA: VBE version %d.%d is not supported; "
|
2010-02-03 22:20:57 +00:00
|
|
|
"version 1.2 or later is required.\n",
|
|
|
|
((vers & 0xf000) >> 12) * 10 + ((vers & 0x0f00) >> 8),
|
|
|
|
((vers & 0x00f0) >> 4) * 10 + (vers & 0x000f));
|
2010-07-06 18:08:55 +00:00
|
|
|
goto fail;
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
2010-04-07 21:38:42 +00:00
|
|
|
VESA_STRCPY(vesa_oemstr, buf->v_oemstr);
|
2009-10-19 20:58:10 +00:00
|
|
|
if (vers >= 0x0200) {
|
2010-04-07 21:38:42 +00:00
|
|
|
VESA_STRCPY(vesa_venderstr, buf->v_venderstr);
|
|
|
|
VESA_STRCPY(vesa_prodstr, buf->v_prodstr);
|
|
|
|
VESA_STRCPY(vesa_revstr, buf->v_revstr);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2009-10-19 20:58:10 +00:00
|
|
|
is_via_cle266 = strncmp(vesa_oemstr, VESA_VIA_CLE266,
|
|
|
|
sizeof(VESA_VIA_CLE266)) == 0;
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2010-04-07 21:38:42 +00:00
|
|
|
if (buf->v_modetable == 0)
|
2009-10-19 20:58:10 +00:00
|
|
|
goto fail;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2010-04-07 21:38:42 +00:00
|
|
|
msize = (size_t)buf->v_memsize * 64 * 1024;
|
2010-02-06 00:52:42 +00:00
|
|
|
|
2010-04-07 21:38:42 +00:00
|
|
|
vesa_vmodetab = x86bios_offset(BIOS_SADDRTOLADDR(buf->v_modetable));
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2010-02-03 22:20:57 +00:00
|
|
|
for (i = 0, modes = 0; (i < (M_VESA_MODE_MAX - M_VESA_BASE + 1)) &&
|
|
|
|
(vesa_vmodetab[i] != 0xffff); ++i) {
|
2009-10-19 20:58:10 +00:00
|
|
|
vesa_vmodetab[i] = le16toh(vesa_vmodetab[i]);
|
2010-06-23 23:34:56 +00:00
|
|
|
if (vesa_bios_get_mode(vesa_vmodetab[i], &vmode, M_WAITOK))
|
2009-09-09 07:45:08 +00:00
|
|
|
continue;
|
|
|
|
|
2009-10-23 18:41:00 +00:00
|
|
|
vmode.v_modeattr = le16toh(vmode.v_modeattr);
|
|
|
|
vmode.v_wgran = le16toh(vmode.v_wgran);
|
|
|
|
vmode.v_wsize = le16toh(vmode.v_wsize);
|
|
|
|
vmode.v_waseg = le16toh(vmode.v_waseg);
|
|
|
|
vmode.v_wbseg = le16toh(vmode.v_wbseg);
|
|
|
|
vmode.v_posfunc = le32toh(vmode.v_posfunc);
|
|
|
|
vmode.v_bpscanline = le16toh(vmode.v_bpscanline);
|
|
|
|
vmode.v_width = le16toh(vmode.v_width);
|
|
|
|
vmode.v_height = le16toh(vmode.v_height);
|
|
|
|
vmode.v_lfb = le32toh(vmode.v_lfb);
|
|
|
|
vmode.v_offscreen = le32toh(vmode.v_offscreen);
|
|
|
|
vmode.v_offscreensize = le16toh(vmode.v_offscreensize);
|
|
|
|
vmode.v_linbpscanline = le16toh(vmode.v_linbpscanline);
|
|
|
|
vmode.v_maxpixelclock = le32toh(vmode.v_maxpixelclock);
|
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
/* reject unsupported modes */
|
|
|
|
#if 0
|
2010-02-03 22:20:57 +00:00
|
|
|
if ((vmode.v_modeattr &
|
|
|
|
(V_MODESUPP | V_MODEOPTINFO | V_MODENONVGA)) !=
|
|
|
|
(V_MODESUPP | V_MODEOPTINFO))
|
2009-09-09 07:45:08 +00:00
|
|
|
continue;
|
|
|
|
#else
|
|
|
|
if ((vmode.v_modeattr & V_MODEOPTINFO) == 0) {
|
|
|
|
#if VESA_DEBUG > 1
|
2010-02-03 22:20:57 +00:00
|
|
|
printf("Rejecting VESA %s mode: %d x %d x %d bpp "
|
|
|
|
" attr = %x\n",
|
|
|
|
vmode.v_modeattr & V_MODEGRAPHICS ?
|
|
|
|
"graphics" : "text",
|
2009-09-09 07:45:08 +00:00
|
|
|
vmode.v_width, vmode.v_height, vmode.v_bpp,
|
|
|
|
vmode.v_modeattr);
|
|
|
|
#endif
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-03-23 23:10:17 +00:00
|
|
|
bsize = vesa_get_bpscanline(&vmode) * vmode.v_height;
|
2010-02-06 00:52:42 +00:00
|
|
|
if ((vmode.v_modeattr & V_MODEGRAPHICS) != 0)
|
|
|
|
bsize *= vmode.v_planes;
|
|
|
|
|
|
|
|
/* Does it have enough memory to support this mode? */
|
|
|
|
if (msize < bsize) {
|
|
|
|
#if VESA_DEBUG > 1
|
|
|
|
printf("Rejecting VESA %s mode: %d x %d x %d bpp "
|
|
|
|
" attr = %x, not enough memory\n",
|
|
|
|
vmode.v_modeattr & V_MODEGRAPHICS ?
|
|
|
|
"graphics" : "text",
|
|
|
|
vmode.v_width, vmode.v_height, vmode.v_bpp,
|
|
|
|
vmode.v_modeattr);
|
|
|
|
#endif
|
|
|
|
continue;
|
|
|
|
}
|
2013-03-27 18:06:28 +00:00
|
|
|
if (bsize > vesa_vmem_max)
|
|
|
|
vesa_vmem_max = bsize;
|
2010-02-06 00:52:42 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
/* expand the array if necessary */
|
|
|
|
if (modes >= vesa_vmode_max) {
|
|
|
|
vesa_vmode_max += MODE_TABLE_DELTA;
|
2010-02-03 22:20:57 +00:00
|
|
|
p = malloc(sizeof(*vesa_vmode) * (vesa_vmode_max + 1),
|
|
|
|
M_DEVBUF, M_WAITOK);
|
2009-09-09 07:45:08 +00:00
|
|
|
#if VESA_DEBUG > 1
|
|
|
|
printf("vesa_bios_init(): modes:%d, vesa_mode_max:%d\n",
|
2010-02-03 22:20:57 +00:00
|
|
|
modes, vesa_vmode_max);
|
2009-09-09 07:45:08 +00:00
|
|
|
#endif
|
|
|
|
if (modes > 0) {
|
|
|
|
bcopy(vesa_vmode, p, sizeof(*vesa_vmode)*modes);
|
|
|
|
free(vesa_vmode, M_DEVBUF);
|
|
|
|
}
|
|
|
|
vesa_vmode = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if VESA_DEBUG > 1
|
|
|
|
printf("Found VESA %s mode: %d x %d x %d bpp\n",
|
|
|
|
vmode.v_modeattr & V_MODEGRAPHICS ? "graphics" : "text",
|
|
|
|
vmode.v_width, vmode.v_height, vmode.v_bpp);
|
|
|
|
#endif
|
|
|
|
if (is_via_cle266) {
|
|
|
|
if ((vmode.v_width & 0xff00) >> 8 == vmode.v_height - 1) {
|
|
|
|
vmode.v_width &= 0xff;
|
|
|
|
vmode.v_waseg = 0xb8000 >> 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* copy some fields */
|
|
|
|
bzero(&vesa_vmode[modes], sizeof(vesa_vmode[modes]));
|
|
|
|
vesa_vmode[modes].vi_mode = vesa_vmodetab[i];
|
|
|
|
vesa_vmode[modes].vi_width = vmode.v_width;
|
|
|
|
vesa_vmode[modes].vi_height = vmode.v_height;
|
|
|
|
vesa_vmode[modes].vi_depth = vmode.v_bpp;
|
|
|
|
vesa_vmode[modes].vi_planes = vmode.v_planes;
|
|
|
|
vesa_vmode[modes].vi_cwidth = vmode.v_cwidth;
|
|
|
|
vesa_vmode[modes].vi_cheight = vmode.v_cheight;
|
2010-02-03 22:20:57 +00:00
|
|
|
vesa_vmode[modes].vi_window = (vm_offset_t)vmode.v_waseg << 4;
|
2009-09-09 07:45:08 +00:00
|
|
|
/* XXX window B */
|
2010-02-03 22:20:57 +00:00
|
|
|
vesa_vmode[modes].vi_window_size = vmode.v_wsize * 1024;
|
|
|
|
vesa_vmode[modes].vi_window_gran = vmode.v_wgran * 1024;
|
2010-02-06 00:52:42 +00:00
|
|
|
if (vmode.v_modeattr & V_MODELFB)
|
2009-09-09 07:45:08 +00:00
|
|
|
vesa_vmode[modes].vi_buffer = vmode.v_lfb;
|
2010-02-06 00:52:42 +00:00
|
|
|
vesa_vmode[modes].vi_buffer_size = bsize;
|
2010-02-03 22:20:57 +00:00
|
|
|
vesa_vmode[modes].vi_mem_model =
|
|
|
|
vesa_translate_mmodel(vmode.v_memmodel);
|
2010-02-23 01:02:11 +00:00
|
|
|
switch (vesa_vmode[modes].vi_mem_model) {
|
|
|
|
case V_INFO_MM_DIRECT:
|
|
|
|
if ((vmode.v_modeattr & V_MODELFB) != 0 &&
|
|
|
|
vers >= 0x0300) {
|
|
|
|
vesa_vmode[modes].vi_pixel_fields[0] =
|
|
|
|
vmode.v_linredfieldpos;
|
|
|
|
vesa_vmode[modes].vi_pixel_fields[1] =
|
|
|
|
vmode.v_lingreenfieldpos;
|
|
|
|
vesa_vmode[modes].vi_pixel_fields[2] =
|
|
|
|
vmode.v_linbluefieldpos;
|
|
|
|
vesa_vmode[modes].vi_pixel_fields[3] =
|
|
|
|
vmode.v_linresfieldpos;
|
|
|
|
vesa_vmode[modes].vi_pixel_fsizes[0] =
|
|
|
|
vmode.v_linredmasksize;
|
|
|
|
vesa_vmode[modes].vi_pixel_fsizes[1] =
|
|
|
|
vmode.v_lingreenmasksize;
|
|
|
|
vesa_vmode[modes].vi_pixel_fsizes[2] =
|
|
|
|
vmode.v_linbluemasksize;
|
|
|
|
vesa_vmode[modes].vi_pixel_fsizes[3] =
|
|
|
|
vmode.v_linresmasksize;
|
|
|
|
} else {
|
|
|
|
vesa_vmode[modes].vi_pixel_fields[0] =
|
|
|
|
vmode.v_redfieldpos;
|
|
|
|
vesa_vmode[modes].vi_pixel_fields[1] =
|
|
|
|
vmode.v_greenfieldpos;
|
|
|
|
vesa_vmode[modes].vi_pixel_fields[2] =
|
|
|
|
vmode.v_bluefieldpos;
|
|
|
|
vesa_vmode[modes].vi_pixel_fields[3] =
|
|
|
|
vmode.v_resfieldpos;
|
|
|
|
vesa_vmode[modes].vi_pixel_fsizes[0] =
|
|
|
|
vmode.v_redmasksize;
|
|
|
|
vesa_vmode[modes].vi_pixel_fsizes[1] =
|
|
|
|
vmode.v_greenmasksize;
|
|
|
|
vesa_vmode[modes].vi_pixel_fsizes[2] =
|
|
|
|
vmode.v_bluemasksize;
|
|
|
|
vesa_vmode[modes].vi_pixel_fsizes[3] =
|
|
|
|
vmode.v_resmasksize;
|
|
|
|
}
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case V_INFO_MM_PACKED:
|
2010-02-03 22:20:57 +00:00
|
|
|
vesa_vmode[modes].vi_pixel_size = (vmode.v_bpp + 7) / 8;
|
2010-02-23 01:02:11 +00:00
|
|
|
break;
|
|
|
|
}
|
2010-02-03 22:20:57 +00:00
|
|
|
vesa_vmode[modes].vi_flags =
|
|
|
|
vesa_translate_flags(vmode.v_modeattr) | V_INFO_VESA;
|
2009-09-25 18:08:38 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
++modes;
|
|
|
|
}
|
2016-05-17 19:00:09 +00:00
|
|
|
if (vesa_vmode != NULL)
|
|
|
|
vesa_vmode[modes].vi_mode = EOT;
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
if (bootverbose)
|
|
|
|
printf("VESA: %d mode(s) found\n", modes);
|
|
|
|
|
2012-03-16 23:54:23 +00:00
|
|
|
if (modes == 0)
|
2009-10-19 20:58:10 +00:00
|
|
|
goto fail;
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2010-04-07 21:38:42 +00:00
|
|
|
x86bios_free(vmbuf, sizeof(*buf));
|
2010-07-13 19:48:20 +00:00
|
|
|
|
2012-02-23 19:05:57 +00:00
|
|
|
/* Probe supported save/restore states. */
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
if (vesa_bios_state_buf_size(1 << i) > 0)
|
|
|
|
vesa_state |= 1 << i;
|
|
|
|
if (vesa_state != 0)
|
|
|
|
vesa_state_buf_size = vesa_bios_state_buf_size(vesa_state);
|
2010-07-13 19:48:20 +00:00
|
|
|
vesa_palette = x86bios_alloc(&vesa_palette_offs,
|
|
|
|
VESA_PALETTE_SIZE + vesa_state_buf_size, M_WAITOK);
|
|
|
|
if (vesa_state_buf_size > 0) {
|
|
|
|
vesa_state_buf = vesa_palette + VESA_PALETTE_SIZE;
|
|
|
|
vesa_state_buf_offs = vesa_palette_offs + VESA_PALETTE_SIZE;
|
|
|
|
}
|
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
return (0);
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
fail:
|
2012-03-16 23:54:23 +00:00
|
|
|
x86bios_free(vmbuf, sizeof(buf));
|
|
|
|
vesa_bios_uninit();
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
vesa_bios_uninit(void)
|
|
|
|
{
|
|
|
|
|
2010-08-25 22:09:02 +00:00
|
|
|
if (vesa_bios != NULL) {
|
|
|
|
x86bios_set_intr(0x10, vesa_bios_int10);
|
|
|
|
vesa_bios_offs = VESA_BIOS_OFFSET;
|
|
|
|
x86bios_free(vesa_bios, vesa_bios_size);
|
|
|
|
vesa_bios = NULL;
|
|
|
|
}
|
2010-04-07 21:38:42 +00:00
|
|
|
if (vesa_adp_info != NULL) {
|
|
|
|
free(vesa_adp_info, M_DEVBUF);
|
|
|
|
vesa_adp_info = NULL;
|
|
|
|
}
|
2009-10-19 20:58:10 +00:00
|
|
|
if (vesa_oemstr != NULL) {
|
|
|
|
free(vesa_oemstr, M_DEVBUF);
|
|
|
|
vesa_oemstr = NULL;
|
|
|
|
}
|
|
|
|
if (vesa_venderstr != NULL) {
|
|
|
|
free(vesa_venderstr, M_DEVBUF);
|
|
|
|
vesa_venderstr = NULL;
|
|
|
|
}
|
|
|
|
if (vesa_prodstr != NULL) {
|
|
|
|
free(vesa_prodstr, M_DEVBUF);
|
|
|
|
vesa_prodstr = NULL;
|
|
|
|
}
|
|
|
|
if (vesa_revstr != NULL) {
|
|
|
|
free(vesa_revstr, M_DEVBUF);
|
|
|
|
vesa_revstr = NULL;
|
|
|
|
}
|
2012-03-16 23:54:23 +00:00
|
|
|
if (vesa_vmode != NULL) {
|
|
|
|
free(vesa_vmode, M_DEVBUF);
|
|
|
|
vesa_vmode = NULL;
|
|
|
|
}
|
|
|
|
if (vesa_palette != NULL) {
|
|
|
|
x86bios_free(vesa_palette,
|
|
|
|
VESA_PALETTE_SIZE + vesa_state_buf_size);
|
|
|
|
vesa_palette = NULL;
|
|
|
|
}
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
vesa_clear_modes(video_info_t *info, int color)
|
|
|
|
{
|
|
|
|
while (info->vi_mode != EOT) {
|
|
|
|
if ((info->vi_flags & V_INFO_COLOR) != color)
|
|
|
|
info->vi_mode = NA;
|
|
|
|
++info;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* entry points */
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_configure(int flags)
|
|
|
|
{
|
|
|
|
video_adapter_t *adp;
|
|
|
|
int adapters;
|
|
|
|
int error;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (vesa_init_done)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
if (flags & VIO_PROBE_ONLY)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the VESA module has already been loaded, abort loading
|
|
|
|
* the module this time.
|
|
|
|
*/
|
|
|
|
for (i = 0; (adp = vid_get_adapter(i)) != NULL; ++i) {
|
|
|
|
if (adp->va_flags & V_ADP_VESA)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (ENXIO);
|
2009-09-09 07:45:08 +00:00
|
|
|
if (adp->va_type == KD_VGA)
|
|
|
|
break;
|
|
|
|
}
|
2009-10-19 20:58:10 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
/*
|
|
|
|
* The VGA adapter is not found. This is because either
|
|
|
|
* 1) the VGA driver has not been initialized, or 2) the VGA card
|
|
|
|
* is not present. If 1) is the case, we shall defer
|
|
|
|
* initialization for now and try again later.
|
|
|
|
*/
|
|
|
|
if (adp == NULL) {
|
2016-07-23 14:38:09 +00:00
|
|
|
vga_sub_configure = vesa_configure;
|
2009-10-19 20:58:10 +00:00
|
|
|
return (ENODEV);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* count number of registered adapters */
|
|
|
|
for (++i; vid_get_adapter(i) != NULL; ++i)
|
|
|
|
;
|
|
|
|
adapters = i;
|
|
|
|
|
|
|
|
/* call VESA BIOS */
|
|
|
|
vesa_adp = adp;
|
|
|
|
if (vesa_bios_init()) {
|
|
|
|
vesa_adp = NULL;
|
2009-10-19 20:58:10 +00:00
|
|
|
return (ENXIO);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
vesa_adp->va_flags |= V_ADP_VESA;
|
|
|
|
|
|
|
|
/* remove conflicting modes if we have more than one adapter */
|
|
|
|
if (adapters > 1) {
|
|
|
|
vesa_clear_modes(vesa_vmode,
|
|
|
|
(vesa_adp->va_flags & V_ADP_COLOR) ?
|
|
|
|
V_INFO_COLOR : 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((error = vesa_load_ioctl()) == 0) {
|
|
|
|
prevvidsw = vidsw[vesa_adp->va_index];
|
|
|
|
vidsw[vesa_adp->va_index] = &vesavidsw;
|
|
|
|
vesa_init_done = TRUE;
|
|
|
|
} else {
|
|
|
|
vesa_adp = NULL;
|
2009-10-19 20:58:10 +00:00
|
|
|
return (error);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
static int
|
|
|
|
vesa_nop(void)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_error(void)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return (1);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_probe(int unit, video_adapter_t **adpp, void *arg, int flags)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return ((*prevvidsw->probe)(unit, adpp, arg, flags));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_init(int unit, video_adapter_t *adp, int flags)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return ((*prevvidsw->init)(unit, adp, flags));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_get_info(video_adapter_t *adp, int mode, video_info_t *info)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if ((*prevvidsw->get_info)(adp, mode, info) == 0)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
if (adp != vesa_adp)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
mode = vesa_map_gen_mode_num(vesa_adp->va_type,
|
|
|
|
vesa_adp->va_flags & V_ADP_COLOR, mode);
|
|
|
|
for (i = 0; vesa_vmode[i].vi_mode != EOT; ++i) {
|
|
|
|
if (vesa_vmode[i].vi_mode == NA)
|
|
|
|
continue;
|
|
|
|
if (vesa_vmode[i].vi_mode == mode) {
|
|
|
|
*info = vesa_vmode[i];
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
}
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_query_mode(video_adapter_t *adp, video_info_t *info)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if ((*prevvidsw->query_mode)(adp, info) == 0)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
if (adp != vesa_adp)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (ENODEV);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
for (i = 0; vesa_vmode[i].vi_mode != EOT; ++i) {
|
|
|
|
if ((info->vi_width != 0)
|
|
|
|
&& (info->vi_width != vesa_vmode[i].vi_width))
|
|
|
|
continue;
|
|
|
|
if ((info->vi_height != 0)
|
|
|
|
&& (info->vi_height != vesa_vmode[i].vi_height))
|
|
|
|
continue;
|
|
|
|
if ((info->vi_cwidth != 0)
|
|
|
|
&& (info->vi_cwidth != vesa_vmode[i].vi_cwidth))
|
|
|
|
continue;
|
|
|
|
if ((info->vi_cheight != 0)
|
|
|
|
&& (info->vi_cheight != vesa_vmode[i].vi_cheight))
|
|
|
|
continue;
|
|
|
|
if ((info->vi_depth != 0)
|
|
|
|
&& (info->vi_depth != vesa_vmode[i].vi_depth))
|
|
|
|
continue;
|
|
|
|
if ((info->vi_planes != 0)
|
|
|
|
&& (info->vi_planes != vesa_vmode[i].vi_planes))
|
|
|
|
continue;
|
|
|
|
/* pixel format, memory model */
|
|
|
|
if ((info->vi_flags != 0)
|
|
|
|
&& (info->vi_flags != vesa_vmode[i].vi_flags))
|
|
|
|
continue;
|
|
|
|
*info = vesa_vmode[i];
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2009-10-19 20:58:10 +00:00
|
|
|
return (ENODEV);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_set_mode(video_adapter_t *adp, int mode)
|
|
|
|
{
|
|
|
|
video_info_t info;
|
|
|
|
|
|
|
|
if (adp != vesa_adp)
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->set_mode)(adp, mode));
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
mode = vesa_map_gen_mode_num(adp->va_type,
|
|
|
|
adp->va_flags & V_ADP_COLOR, mode);
|
|
|
|
#if VESA_DEBUG > 0
|
|
|
|
printf("VESA: set_mode(): %d(%x) -> %d(%x)\n",
|
|
|
|
adp->va_mode, adp->va_mode, mode, mode);
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* If the current mode is a VESA mode and the new mode is not,
|
|
|
|
* restore the state of the adapter first by setting one of the
|
|
|
|
* standard VGA mode, so that non-standard, extended SVGA registers
|
|
|
|
* are set to the state compatible with the standard VGA modes.
|
|
|
|
* Otherwise (*prevvidsw->set_mode)() may not be able to set up
|
|
|
|
* the new mode correctly.
|
|
|
|
*/
|
|
|
|
if (VESA_MODE(adp->va_mode)) {
|
2009-11-03 20:22:09 +00:00
|
|
|
if (!VESA_MODE(mode) &&
|
|
|
|
(*prevvidsw->get_info)(adp, mode, &info) == 0) {
|
2010-02-23 21:51:14 +00:00
|
|
|
if ((adp->va_flags & V_ADP_DAC8) != 0) {
|
|
|
|
vesa_bios_set_dac(6);
|
|
|
|
adp->va_flags &= ~V_ADP_DAC8;
|
|
|
|
}
|
2009-09-09 07:45:08 +00:00
|
|
|
int10_set_mode(adp->va_initial_bios_mode);
|
|
|
|
if (adp->va_info.vi_flags & V_INFO_LINEAR)
|
2013-03-27 18:06:28 +00:00
|
|
|
pmap_unmapdev(adp->va_buffer, vesa_vmem_max);
|
2009-09-09 07:45:08 +00:00
|
|
|
/*
|
|
|
|
* Once (*prevvidsw->get_info)() succeeded,
|
|
|
|
* (*prevvidsw->set_mode)() below won't fail...
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we may not need to handle this mode after all... */
|
2009-11-03 20:22:09 +00:00
|
|
|
if (!VESA_MODE(mode) && (*prevvidsw->set_mode)(adp, mode) == 0)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
/* is the new mode supported? */
|
|
|
|
if (vesa_get_info(adp, mode, &info))
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
2009-09-09 07:45:08 +00:00
|
|
|
/* assert(VESA_MODE(mode)); */
|
|
|
|
|
|
|
|
#if VESA_DEBUG > 0
|
|
|
|
printf("VESA: about to set a VESA mode...\n");
|
|
|
|
#endif
|
Reset the DAC to 6-bit mode before calling the BIOS to set the screen
mode. This works around bugs in at least 2 Intel BIOSes for our
subsequent setting of the DAC back to 8-bit mode. The bug caused dark
(mostly 1/4-intensity) colors for all except the first setting to a
VESA graphics mode (including for settings to the current mode).
Remove restoration (with less bits) of the palette in vesa_unload()
after resetting the DAC to 6-bit mode. Depend on the BIOS to keep
the palette consistent with the DAC for the simpler reset case like
we do everywhere else in places that are actually important.
Setting the video mode should reset everything to defaults, although
we usually don't want that. Even the buggy BIOSes set the DAC to the
default 6-bit mode, and set the palette to a default that matches the
DAC. We don't undo the reset for most things, but we do undo it for
the DAC (more precisely, we change to an 8-bit DAC if possible, and
this is the only way that we set to an 8-bit DAC; it is accidental
that if the DAC was in 8-bit mode from a previous mode switch then
setting it to 8-bit mode is an undo). The buggy BIOSes are confused
by our setting of the DAC to 8-bit mode in the "undo" case. They
should multiply palette entries by 4 to match, but they actually leave
all palette entries except #2 (green) and #248-255 (unused) untouched.
Green is mysteriously scaled from 0x2a to 0x6a, and #248-255 are scaled
correctly.
Our support for the 8-bit DAC had almost no effect except to enable
bugs. Syscons barely supports 16 colors, so it doesn't benefit much
from having a palette with 16 million colors instead of only 256K.
Applications can manage the palette using FBIO_{GET,SET}PALETTE, but
the palette managed by this is only used in the less interesting modes
(text and non-truecolor graphics modes up to 8 bits wide), and the
kernel loses the changes on any mode switch (including to another vt
in a different mode).
2017-04-02 08:39:32 +00:00
|
|
|
/*
|
|
|
|
* The mode change should reset the palette format to 6 bits, so
|
|
|
|
* we must reset V_ADP_DAC8. Some BIOSes do an incomplete reset
|
|
|
|
* if we call them with an 8-bit palette, so reset directly.
|
|
|
|
*/
|
|
|
|
if (adp->va_flags & V_ADP_DAC8) {
|
|
|
|
vesa_bios_set_dac(6);
|
|
|
|
adp->va_flags &= ~V_ADP_DAC8;
|
|
|
|
}
|
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
/* don't use the linear frame buffer for text modes. XXX */
|
|
|
|
if (!(info.vi_flags & V_INFO_GRAPHICS))
|
|
|
|
info.vi_flags &= ~V_INFO_LINEAR;
|
|
|
|
|
2012-02-16 22:46:00 +00:00
|
|
|
if ((info.vi_flags & V_INFO_LINEAR) != 0)
|
|
|
|
mode |= 0x4000;
|
2012-03-16 19:22:29 +00:00
|
|
|
if (vesa_bios_set_mode(mode | 0x8000))
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2010-02-23 21:51:14 +00:00
|
|
|
if ((vesa_adp_info->v_flags & V_DAC8) != 0 &&
|
|
|
|
(info.vi_flags & V_INFO_GRAPHICS) != 0 &&
|
|
|
|
vesa_bios_set_dac(8) > 6)
|
|
|
|
adp->va_flags |= V_ADP_DAC8;
|
2009-11-03 20:22:09 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
if (adp->va_info.vi_flags & V_INFO_LINEAR)
|
2013-03-27 18:06:28 +00:00
|
|
|
pmap_unmapdev(adp->va_buffer, vesa_vmem_max);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
#if VESA_DEBUG > 0
|
|
|
|
printf("VESA: mode set!\n");
|
|
|
|
#endif
|
2012-02-16 22:46:00 +00:00
|
|
|
vesa_adp->va_mode = mode & 0x1ff; /* Mode number is 9-bit. */
|
2009-09-09 07:45:08 +00:00
|
|
|
vesa_adp->va_flags &= ~V_ADP_COLOR;
|
|
|
|
vesa_adp->va_flags |=
|
|
|
|
(info.vi_flags & V_INFO_COLOR) ? V_ADP_COLOR : 0;
|
|
|
|
vesa_adp->va_crtc_addr =
|
|
|
|
(vesa_adp->va_flags & V_ADP_COLOR) ? COLOR_CRTC : MONO_CRTC;
|
2010-03-23 23:10:17 +00:00
|
|
|
|
2017-04-20 13:46:55 +00:00
|
|
|
vesa_adp->va_flags &= ~V_ADP_CWIDTH9;
|
2010-03-23 23:10:17 +00:00
|
|
|
vesa_adp->va_line_width = info.vi_buffer_size / info.vi_height;
|
|
|
|
if ((info.vi_flags & V_INFO_GRAPHICS) != 0)
|
|
|
|
vesa_adp->va_line_width /= info.vi_planes;
|
|
|
|
|
2010-03-25 17:51:05 +00:00
|
|
|
#ifdef MODE_TABLE_BROKEN
|
2010-03-23 23:10:17 +00:00
|
|
|
/* If VBE function returns bigger bytes per scan line, use it. */
|
2010-03-25 17:51:05 +00:00
|
|
|
{
|
|
|
|
int bpsl = vesa_bios_get_line_length();
|
|
|
|
if (bpsl > vesa_adp->va_line_width) {
|
|
|
|
vesa_adp->va_line_width = bpsl;
|
|
|
|
info.vi_buffer_size = bpsl * info.vi_height;
|
|
|
|
if ((info.vi_flags & V_INFO_GRAPHICS) != 0)
|
|
|
|
info.vi_buffer_size *= info.vi_planes;
|
|
|
|
}
|
2010-03-23 23:10:17 +00:00
|
|
|
}
|
2010-03-25 17:51:05 +00:00
|
|
|
#endif
|
2010-03-23 23:10:17 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
if (info.vi_flags & V_INFO_LINEAR) {
|
|
|
|
#if VESA_DEBUG > 1
|
|
|
|
printf("VESA: setting up LFB\n");
|
|
|
|
#endif
|
|
|
|
vesa_adp->va_buffer =
|
2010-02-05 18:00:24 +00:00
|
|
|
(vm_offset_t)pmap_mapdev_attr(info.vi_buffer,
|
2013-03-27 18:06:28 +00:00
|
|
|
vesa_vmem_max, PAT_WRITE_COMBINING);
|
2009-09-09 07:45:08 +00:00
|
|
|
vesa_adp->va_window = vesa_adp->va_buffer;
|
2010-02-06 00:52:42 +00:00
|
|
|
vesa_adp->va_window_size = info.vi_buffer_size / info.vi_planes;
|
|
|
|
vesa_adp->va_window_gran = info.vi_buffer_size / info.vi_planes;
|
2009-09-09 07:45:08 +00:00
|
|
|
} else {
|
|
|
|
vesa_adp->va_buffer = 0;
|
2010-02-03 22:07:50 +00:00
|
|
|
vesa_adp->va_window = (vm_offset_t)x86bios_offset(info.vi_window);
|
2009-09-09 07:45:08 +00:00
|
|
|
vesa_adp->va_window_size = info.vi_window_size;
|
|
|
|
vesa_adp->va_window_gran = info.vi_window_gran;
|
|
|
|
}
|
2010-02-06 00:52:42 +00:00
|
|
|
vesa_adp->va_buffer_size = info.vi_buffer_size;
|
2009-09-09 07:45:08 +00:00
|
|
|
vesa_adp->va_window_orig = 0;
|
|
|
|
vesa_adp->va_disp_start.x = 0;
|
|
|
|
vesa_adp->va_disp_start.y = 0;
|
|
|
|
#if VESA_DEBUG > 0
|
2009-09-25 18:08:38 +00:00
|
|
|
printf("vesa_set_mode(): vi_width:%d, line_width:%d\n",
|
|
|
|
info.vi_width, vesa_adp->va_line_width);
|
2009-09-09 07:45:08 +00:00
|
|
|
#endif
|
|
|
|
bcopy(&info, &vesa_adp->va_info, sizeof(vesa_adp->va_info));
|
|
|
|
|
|
|
|
/* move hardware cursor out of the way */
|
|
|
|
(*vidsw[vesa_adp->va_index]->set_hw_cursor)(vesa_adp, -1, -1);
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_save_font(video_adapter_t *adp, int page, int fontsize, int fontwidth,
|
|
|
|
u_char *data, int ch, int count)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return ((*prevvidsw->save_font)(adp, page, fontsize, fontwidth, data,
|
|
|
|
ch, count));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_load_font(video_adapter_t *adp, int page, int fontsize, int fontwidth,
|
|
|
|
u_char *data, int ch, int count)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return ((*prevvidsw->load_font)(adp, page, fontsize, fontwidth, data,
|
|
|
|
ch, count));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_show_font(video_adapter_t *adp, int page)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return ((*prevvidsw->show_font)(adp, page));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_save_palette(video_adapter_t *adp, u_char *palette)
|
|
|
|
{
|
|
|
|
int bits;
|
|
|
|
|
2010-03-23 22:50:22 +00:00
|
|
|
if (adp == vesa_adp && VESA_MODE(adp->va_mode)) {
|
2010-02-23 21:51:14 +00:00
|
|
|
bits = (adp->va_flags & V_ADP_DAC8) != 0 ? 8 : 6;
|
2010-03-23 22:50:22 +00:00
|
|
|
if (vesa_bios_save_palette(0, 256, palette, bits) == 0)
|
|
|
|
return (0);
|
2010-01-27 17:00:42 +00:00
|
|
|
}
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->save_palette)(adp, palette));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_load_palette(video_adapter_t *adp, u_char *palette)
|
|
|
|
{
|
|
|
|
int bits;
|
|
|
|
|
2010-03-23 22:50:22 +00:00
|
|
|
if (adp == vesa_adp && VESA_MODE(adp->va_mode)) {
|
2010-02-23 21:51:14 +00:00
|
|
|
bits = (adp->va_flags & V_ADP_DAC8) != 0 ? 8 : 6;
|
2010-03-23 22:50:22 +00:00
|
|
|
if (vesa_bios_load_palette(0, 256, palette, bits) == 0)
|
|
|
|
return (0);
|
2010-01-27 17:00:42 +00:00
|
|
|
}
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->load_palette)(adp, palette));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_set_border(video_adapter_t *adp, int color)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return ((*prevvidsw->set_border)(adp, color));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_save_state(video_adapter_t *adp, void *p, size_t size)
|
|
|
|
{
|
2013-08-28 19:06:22 +00:00
|
|
|
void *buf;
|
2012-03-17 00:00:33 +00:00
|
|
|
size_t bsize;
|
2009-10-19 20:58:10 +00:00
|
|
|
|
2012-04-04 22:02:54 +00:00
|
|
|
if (adp != vesa_adp || (size == 0 && vesa_state_buf_size == 0))
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->save_state)(adp, p, size));
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2012-04-04 22:02:54 +00:00
|
|
|
bsize = offsetof(adp_state_t, regs) + vesa_state_buf_size;
|
2009-09-09 07:45:08 +00:00
|
|
|
if (size == 0)
|
2012-04-04 22:02:54 +00:00
|
|
|
return (bsize);
|
|
|
|
if (vesa_state_buf_size > 0 && size < bsize)
|
2012-02-23 20:54:22 +00:00
|
|
|
return (EINVAL);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2013-08-28 18:13:37 +00:00
|
|
|
if (vesa_vmem_buf != NULL) {
|
|
|
|
free(vesa_vmem_buf, M_DEVBUF);
|
|
|
|
vesa_vmem_buf = NULL;
|
|
|
|
}
|
2013-08-28 19:06:22 +00:00
|
|
|
if (VESA_MODE(adp->va_mode)) {
|
|
|
|
buf = (void *)adp->va_buffer;
|
|
|
|
if (buf != NULL) {
|
|
|
|
bsize = adp->va_buffer_size;
|
|
|
|
vesa_vmem_buf = malloc(bsize, M_DEVBUF, M_NOWAIT);
|
|
|
|
if (vesa_vmem_buf != NULL)
|
|
|
|
bcopy(buf, vesa_vmem_buf, bsize);
|
|
|
|
}
|
2013-08-28 18:13:37 +00:00
|
|
|
}
|
2012-04-04 22:02:54 +00:00
|
|
|
if (vesa_state_buf_size == 0)
|
|
|
|
return ((*prevvidsw->save_state)(adp, p, size));
|
2009-09-09 07:45:08 +00:00
|
|
|
((adp_state_t *)p)->sig = V_STATE_SIG;
|
2010-07-13 19:48:20 +00:00
|
|
|
return (vesa_bios_save_restore(STATE_SAVE, ((adp_state_t *)p)->regs));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_load_state(video_adapter_t *adp, void *p)
|
|
|
|
{
|
2013-08-28 19:06:22 +00:00
|
|
|
void *buf;
|
2012-03-17 00:00:33 +00:00
|
|
|
size_t bsize;
|
2012-04-04 22:02:54 +00:00
|
|
|
int error, mode;
|
2009-10-19 20:58:10 +00:00
|
|
|
|
2012-02-23 20:54:22 +00:00
|
|
|
if (adp != vesa_adp)
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->load_state)(adp, p));
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2009-11-05 22:58:50 +00:00
|
|
|
/* Try BIOS POST to restore a sane state. */
|
|
|
|
(void)vesa_bios_post();
|
2013-08-28 20:10:56 +00:00
|
|
|
bsize = adp->va_buffer_size;
|
2012-02-16 22:51:44 +00:00
|
|
|
mode = adp->va_mode;
|
2012-04-04 22:02:54 +00:00
|
|
|
error = vesa_set_mode(adp, adp->va_initial_mode);
|
2012-02-23 18:59:32 +00:00
|
|
|
if (mode != adp->va_initial_mode)
|
2012-04-04 22:02:54 +00:00
|
|
|
error = vesa_set_mode(adp, mode);
|
2009-10-19 20:58:10 +00:00
|
|
|
|
2012-03-19 17:14:12 +00:00
|
|
|
if (vesa_vmem_buf != NULL) {
|
2013-08-28 19:06:22 +00:00
|
|
|
if (error == 0 && VESA_MODE(mode)) {
|
|
|
|
buf = (void *)adp->va_buffer;
|
2013-08-28 20:10:56 +00:00
|
|
|
if (buf != NULL)
|
2013-08-28 19:06:22 +00:00
|
|
|
bcopy(vesa_vmem_buf, buf, bsize);
|
2012-04-04 22:02:54 +00:00
|
|
|
}
|
2012-03-17 00:00:33 +00:00
|
|
|
free(vesa_vmem_buf, M_DEVBUF);
|
2013-08-28 18:13:37 +00:00
|
|
|
vesa_vmem_buf = NULL;
|
2012-03-17 00:00:33 +00:00
|
|
|
}
|
2012-04-04 22:02:54 +00:00
|
|
|
if (((adp_state_t *)p)->sig != V_STATE_SIG)
|
|
|
|
return ((*prevvidsw->load_state)(adp, p));
|
2010-07-13 19:48:20 +00:00
|
|
|
return (vesa_bios_save_restore(STATE_LOAD, ((adp_state_t *)p)->regs));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
static int
|
|
|
|
vesa_get_origin(video_adapter_t *adp, off_t *offset)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f05;
|
|
|
|
regs.R_BL = 0x10;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-21 08:17:57 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if (regs.R_AX != 0x004f)
|
|
|
|
return (1);
|
2009-09-21 08:53:26 +00:00
|
|
|
*offset = regs.DX * adp->va_window_gran;
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_set_origin(video_adapter_t *adp, off_t offset)
|
|
|
|
{
|
2009-09-21 08:17:57 +00:00
|
|
|
x86regs_t regs;
|
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
/*
|
|
|
|
* This function should return as quickly as possible to
|
|
|
|
* maintain good performance of the system. For this reason,
|
|
|
|
* error checking is kept minimal and let the VESA BIOS to
|
|
|
|
* detect error.
|
|
|
|
*/
|
|
|
|
if (adp != vesa_adp)
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->set_win_org)(adp, offset));
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
/* if this is a linear frame buffer, do nothing */
|
|
|
|
if (adp->va_info.vi_flags & V_INFO_LINEAR)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
/* XXX */
|
|
|
|
if (adp->va_window_gran == 0)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f05;
|
|
|
|
regs.R_DX = offset / adp->va_window_gran;
|
|
|
|
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if (regs.R_AX != 0x004f)
|
|
|
|
return (1);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
x86bios_init_regs(®s);
|
|
|
|
regs.R_AX = 0x4f05;
|
|
|
|
regs.R_BL = 1;
|
|
|
|
regs.R_DX = offset / adp->va_window_gran;
|
2009-09-24 19:24:42 +00:00
|
|
|
x86bios_intr(®s, 0x10);
|
2009-09-09 09:50:31 +00:00
|
|
|
|
2016-04-30 14:41:18 +00:00
|
|
|
adp->va_window_orig = rounddown(offset, adp->va_window_gran);
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0); /* XXX */
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_read_hw_cursor(video_adapter_t *adp, int *col, int *row)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return ((*prevvidsw->read_hw_cursor)(adp, col, row));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_set_hw_cursor(video_adapter_t *adp, int col, int row)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return ((*prevvidsw->set_hw_cursor)(adp, col, row));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_set_hw_cursor_shape(video_adapter_t *adp, int base, int height,
|
|
|
|
int celsize, int blink)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return ((*prevvidsw->set_hw_cursor_shape)(adp, base, height, celsize,
|
|
|
|
blink));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_blank_display(video_adapter_t *adp, int mode)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
/* XXX: use VESA DPMS */
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->blank_display)(adp, mode));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2009-12-29 21:51:28 +00:00
|
|
|
vesa_mmap(video_adapter_t *adp, vm_ooffset_t offset, vm_paddr_t *paddr,
|
|
|
|
int prot, vm_memattr_t *memattr)
|
2009-09-09 07:45:08 +00:00
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
#if VESA_DEBUG > 0
|
2009-12-29 21:51:28 +00:00
|
|
|
printf("vesa_mmap(): window:0x%tx, buffer:0x%tx, offset:0x%jx\n",
|
2009-09-09 07:45:08 +00:00
|
|
|
adp->va_info.vi_window, adp->va_info.vi_buffer, offset);
|
|
|
|
#endif
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if ((adp == vesa_adp) &&
|
|
|
|
(adp->va_info.vi_flags & V_INFO_LINEAR) != 0) {
|
2009-09-09 07:45:08 +00:00
|
|
|
/* va_window_size == va_buffer_size/vi_planes */
|
|
|
|
/* XXX: is this correct? */
|
|
|
|
if (offset > adp->va_window_size - PAGE_SIZE)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (-1);
|
2009-09-09 07:45:08 +00:00
|
|
|
*paddr = adp->va_info.vi_buffer + offset;
|
2017-04-20 15:18:15 +00:00
|
|
|
#ifdef VM_MEMATTR_WRITE_COMBINING
|
|
|
|
*memattr = VM_MEMATTR_WRITE_COMBINING;
|
|
|
|
#endif
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2009-12-29 21:51:28 +00:00
|
|
|
return ((*prevvidsw->mmap)(adp, offset, paddr, prot, memattr));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_clear(video_adapter_t *adp)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return ((*prevvidsw->clear)(adp));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_fill_rect(video_adapter_t *adp, int val, int x, int y, int cx, int cy)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
|
|
|
return ((*prevvidsw->fill_rect)(adp, val, x, y, cx, cy));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_bitblt(video_adapter_t *adp,...)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
/* FIXME */
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
get_palette(video_adapter_t *adp, int base, int count,
|
|
|
|
u_char *red, u_char *green, u_char *blue, u_char *trans)
|
|
|
|
{
|
|
|
|
u_char *r;
|
|
|
|
u_char *g;
|
|
|
|
u_char *b;
|
|
|
|
int bits;
|
|
|
|
int error;
|
|
|
|
|
2010-01-27 17:00:42 +00:00
|
|
|
if (base < 0 || base >= 256 || count < 0 || count > 256)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
2009-09-09 07:45:08 +00:00
|
|
|
if ((base + count) > 256)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
2010-01-27 17:00:42 +00:00
|
|
|
if (!VESA_MODE(adp->va_mode))
|
|
|
|
return (1);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2010-02-23 21:51:14 +00:00
|
|
|
bits = (adp->va_flags & V_ADP_DAC8) != 0 ? 8 : 6;
|
2009-11-03 20:22:09 +00:00
|
|
|
r = malloc(count * 3, M_DEVBUF, M_WAITOK);
|
2009-09-09 07:45:08 +00:00
|
|
|
g = r + count;
|
|
|
|
b = g + count;
|
|
|
|
error = vesa_bios_save_palette2(base, count, r, g, b, bits);
|
|
|
|
if (error == 0) {
|
|
|
|
copyout(r, red, count);
|
|
|
|
copyout(g, green, count);
|
|
|
|
copyout(b, blue, count);
|
|
|
|
if (trans != NULL) {
|
|
|
|
bzero(r, count);
|
|
|
|
copyout(r, trans, count);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(r, M_DEVBUF);
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (error);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
set_palette(video_adapter_t *adp, int base, int count,
|
|
|
|
u_char *red, u_char *green, u_char *blue, u_char *trans)
|
|
|
|
{
|
|
|
|
u_char *r;
|
|
|
|
u_char *g;
|
|
|
|
u_char *b;
|
|
|
|
int bits;
|
|
|
|
int error;
|
|
|
|
|
2010-01-27 17:00:42 +00:00
|
|
|
if (base < 0 || base >= 256 || count < 0 || count > 256)
|
|
|
|
return (1);
|
|
|
|
if ((base + count) > 256)
|
|
|
|
return (1);
|
|
|
|
if (!VESA_MODE(adp->va_mode))
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2010-02-23 21:51:14 +00:00
|
|
|
bits = (adp->va_flags & V_ADP_DAC8) != 0 ? 8 : 6;
|
2009-11-03 20:22:09 +00:00
|
|
|
r = malloc(count * 3, M_DEVBUF, M_WAITOK);
|
2009-09-09 07:45:08 +00:00
|
|
|
g = r + count;
|
|
|
|
b = g + count;
|
|
|
|
copyin(red, r, count);
|
|
|
|
copyin(green, g, count);
|
|
|
|
copyin(blue, b, count);
|
|
|
|
|
|
|
|
error = vesa_bios_load_palette2(base, count, r, g, b, bits);
|
|
|
|
free(r, M_DEVBUF);
|
|
|
|
|
2009-11-03 20:22:09 +00:00
|
|
|
return (error);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_ioctl(video_adapter_t *adp, u_long cmd, caddr_t arg)
|
|
|
|
{
|
|
|
|
int bytes;
|
|
|
|
|
|
|
|
if (adp != vesa_adp)
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->ioctl)(adp, cmd, arg));
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case FBIO_SETWINORG: /* set frame buffer window origin */
|
|
|
|
if (!VESA_MODE(adp->va_mode))
|
|
|
|
return (*prevvidsw->ioctl)(adp, cmd, arg);
|
|
|
|
return (vesa_set_origin(adp, *(off_t *)arg) ? ENODEV : 0);
|
|
|
|
|
|
|
|
case FBIO_SETDISPSTART: /* set display start address */
|
|
|
|
if (!VESA_MODE(adp->va_mode))
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->ioctl)(adp, cmd, arg));
|
2009-09-09 07:45:08 +00:00
|
|
|
if (vesa_bios_set_start(((video_display_start_t *)arg)->x,
|
|
|
|
((video_display_start_t *)arg)->y))
|
2009-10-19 20:58:10 +00:00
|
|
|
return (ENODEV);
|
2009-09-09 07:45:08 +00:00
|
|
|
adp->va_disp_start.x = ((video_display_start_t *)arg)->x;
|
|
|
|
adp->va_disp_start.y = ((video_display_start_t *)arg)->y;
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
case FBIO_SETLINEWIDTH: /* set line length in pixel */
|
|
|
|
if (!VESA_MODE(adp->va_mode))
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->ioctl)(adp, cmd, arg));
|
2009-09-09 07:45:08 +00:00
|
|
|
if (vesa_bios_set_line_length(*(u_int *)arg, &bytes, NULL))
|
2009-10-19 20:58:10 +00:00
|
|
|
return (ENODEV);
|
2009-09-09 07:45:08 +00:00
|
|
|
adp->va_line_width = bytes;
|
|
|
|
#if VESA_DEBUG > 1
|
|
|
|
printf("new line width:%d\n", adp->va_line_width);
|
|
|
|
#endif
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
case FBIO_GETPALETTE: /* get color palette */
|
|
|
|
if (get_palette(adp, ((video_color_palette_t *)arg)->index,
|
|
|
|
((video_color_palette_t *)arg)->count,
|
|
|
|
((video_color_palette_t *)arg)->red,
|
|
|
|
((video_color_palette_t *)arg)->green,
|
|
|
|
((video_color_palette_t *)arg)->blue,
|
|
|
|
((video_color_palette_t *)arg)->transparent))
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->ioctl)(adp, cmd, arg));
|
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
|
|
|
|
case FBIO_SETPALETTE: /* set color palette */
|
|
|
|
if (set_palette(adp, ((video_color_palette_t *)arg)->index,
|
|
|
|
((video_color_palette_t *)arg)->count,
|
|
|
|
((video_color_palette_t *)arg)->red,
|
|
|
|
((video_color_palette_t *)arg)->green,
|
|
|
|
((video_color_palette_t *)arg)->blue,
|
|
|
|
((video_color_palette_t *)arg)->transparent))
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->ioctl)(adp, cmd, arg));
|
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
case FBIOGETCMAP: /* get color palette */
|
|
|
|
if (get_palette(adp, ((struct fbcmap *)arg)->index,
|
|
|
|
((struct fbcmap *)arg)->count,
|
|
|
|
((struct fbcmap *)arg)->red,
|
|
|
|
((struct fbcmap *)arg)->green,
|
|
|
|
((struct fbcmap *)arg)->blue, NULL))
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->ioctl)(adp, cmd, arg));
|
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
case FBIOPUTCMAP: /* set color palette */
|
|
|
|
if (set_palette(adp, ((struct fbcmap *)arg)->index,
|
|
|
|
((struct fbcmap *)arg)->count,
|
|
|
|
((struct fbcmap *)arg)->red,
|
|
|
|
((struct fbcmap *)arg)->green,
|
|
|
|
((struct fbcmap *)arg)->blue, NULL))
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->ioctl)(adp, cmd, arg));
|
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
default:
|
2009-10-19 20:58:10 +00:00
|
|
|
return ((*prevvidsw->ioctl)(adp, cmd, arg));
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_diag(video_adapter_t *adp, int level)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/* call the previous handler first */
|
|
|
|
error = (*prevvidsw->diag)(adp, level);
|
|
|
|
if (error)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (error);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
if (adp != vesa_adp)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (1);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
if (level <= 0)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_bios_info(int level)
|
|
|
|
{
|
|
|
|
#if VESA_DEBUG > 1
|
|
|
|
struct vesa_mode vmode;
|
|
|
|
int i;
|
|
|
|
#endif
|
2009-10-19 20:58:10 +00:00
|
|
|
uint16_t vers;
|
|
|
|
|
|
|
|
vers = vesa_adp_info->v_version;
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
if (bootverbose) {
|
|
|
|
/* general adapter information */
|
|
|
|
printf(
|
|
|
|
"VESA: v%d.%d, %dk memory, flags:0x%x, mode table:%p (%x)\n",
|
2009-10-19 20:58:10 +00:00
|
|
|
(vers >> 12) * 10 + ((vers & 0x0f00) >> 8),
|
|
|
|
((vers & 0x00f0) >> 4) * 10 + (vers & 0x000f),
|
2009-09-09 07:45:08 +00:00
|
|
|
vesa_adp_info->v_memsize * 64, vesa_adp_info->v_flags,
|
|
|
|
vesa_vmodetab, vesa_adp_info->v_modetable);
|
|
|
|
|
|
|
|
/* OEM string */
|
|
|
|
if (vesa_oemstr != NULL)
|
|
|
|
printf("VESA: %s\n", vesa_oemstr);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (level <= 0)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
if (vers >= 0x0200 && bootverbose) {
|
2009-09-09 07:45:08 +00:00
|
|
|
/* vender name, product name, product revision */
|
|
|
|
printf("VESA: %s %s %s\n",
|
|
|
|
(vesa_venderstr != NULL) ? vesa_venderstr : "unknown",
|
|
|
|
(vesa_prodstr != NULL) ? vesa_prodstr : "unknown",
|
|
|
|
(vesa_revstr != NULL) ? vesa_revstr : "?");
|
|
|
|
}
|
|
|
|
|
|
|
|
#if VESA_DEBUG > 1
|
|
|
|
/* mode information */
|
|
|
|
for (i = 0;
|
|
|
|
(i < (M_VESA_MODE_MAX - M_VESA_BASE + 1))
|
|
|
|
&& (vesa_vmodetab[i] != 0xffff); ++i) {
|
2010-06-23 23:34:56 +00:00
|
|
|
if (vesa_bios_get_mode(vesa_vmodetab[i], &vmode, M_NOWAIT))
|
2009-09-09 07:45:08 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/* print something for diagnostic purpose */
|
|
|
|
printf("VESA: mode:0x%03x, flags:0x%04x",
|
|
|
|
vesa_vmodetab[i], vmode.v_modeattr);
|
|
|
|
if (vmode.v_modeattr & V_MODEOPTINFO) {
|
|
|
|
if (vmode.v_modeattr & V_MODEGRAPHICS) {
|
|
|
|
printf(", G %dx%dx%d %d, ",
|
|
|
|
vmode.v_width, vmode.v_height,
|
|
|
|
vmode.v_bpp, vmode.v_planes);
|
|
|
|
} else {
|
|
|
|
printf(", T %dx%d, ",
|
|
|
|
vmode.v_width, vmode.v_height);
|
|
|
|
}
|
|
|
|
printf("font:%dx%d, ",
|
|
|
|
vmode.v_cwidth, vmode.v_cheight);
|
|
|
|
printf("pages:%d, mem:%d",
|
|
|
|
vmode.v_ipages + 1, vmode.v_memmodel);
|
|
|
|
}
|
|
|
|
if (vmode.v_modeattr & V_MODELFB) {
|
|
|
|
printf("\nVESA: LFB:0x%x, off:0x%x, off_size:0x%x",
|
|
|
|
vmode.v_lfb, vmode.v_offscreen,
|
|
|
|
vmode.v_offscreensize*1024);
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
printf("VESA: window A:0x%x (%x), window B:0x%x (%x), ",
|
|
|
|
vmode.v_waseg, vmode.v_waattr,
|
|
|
|
vmode.v_wbseg, vmode.v_wbattr);
|
|
|
|
printf("size:%dk, gran:%dk\n",
|
|
|
|
vmode.v_wsize, vmode.v_wgran);
|
|
|
|
}
|
|
|
|
#endif /* VESA_DEBUG > 1 */
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* module loading */
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_load(void)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (vesa_init_done)
|
2009-10-19 20:58:10 +00:00
|
|
|
return (0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
/* locate a VGA adapter */
|
|
|
|
vesa_adp = NULL;
|
2016-07-23 14:38:09 +00:00
|
|
|
error = vesa_configure(0);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
if (error == 0)
|
|
|
|
vesa_bios_info(bootverbose);
|
|
|
|
|
2019-11-13 15:31:31 +00:00
|
|
|
/* Don't return ENODEV, the upper layers will whine. */
|
|
|
|
if (error == ENODEV) {
|
|
|
|
error = 0;
|
|
|
|
vesa_adp = NULL;
|
|
|
|
}
|
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (error);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_unload(void)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2019-11-13 15:31:31 +00:00
|
|
|
/* The driver never initialized, so make it easy to unload. */
|
|
|
|
if (vesa_adp == NULL)
|
|
|
|
return (0);
|
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
/* if the adapter is currently in a VESA mode, don't unload */
|
2019-11-13 15:31:31 +00:00
|
|
|
if (VESA_MODE(vesa_adp->va_mode))
|
2009-10-19 20:58:10 +00:00
|
|
|
return (EBUSY);
|
2009-09-09 07:45:08 +00:00
|
|
|
/*
|
|
|
|
* FIXME: if there is at least one vty which is in a VESA mode,
|
|
|
|
* we shouldn't be unloading! XXX
|
|
|
|
*/
|
|
|
|
|
|
|
|
if ((error = vesa_unload_ioctl()) == 0) {
|
|
|
|
if (vesa_adp != NULL) {
|
2010-02-23 21:51:14 +00:00
|
|
|
if ((vesa_adp->va_flags & V_ADP_DAC8) != 0) {
|
|
|
|
vesa_bios_set_dac(6);
|
|
|
|
vesa_adp->va_flags &= ~V_ADP_DAC8;
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
vesa_adp->va_flags &= ~V_ADP_VESA;
|
|
|
|
vidsw[vesa_adp->va_index] = prevvidsw;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-16 23:54:23 +00:00
|
|
|
vesa_bios_uninit();
|
2010-08-07 05:46:04 +00:00
|
|
|
|
2009-10-19 20:58:10 +00:00
|
|
|
return (error);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vesa_mod_event(module_t mod, int type, void *data)
|
|
|
|
{
|
2009-10-19 20:58:10 +00:00
|
|
|
|
2009-09-09 07:45:08 +00:00
|
|
|
switch (type) {
|
|
|
|
case MOD_LOAD:
|
2009-10-19 20:58:10 +00:00
|
|
|
return (vesa_load());
|
2009-09-09 07:45:08 +00:00
|
|
|
case MOD_UNLOAD:
|
2009-10-19 20:58:10 +00:00
|
|
|
return (vesa_unload());
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
2009-10-19 20:58:10 +00:00
|
|
|
return (EOPNOTSUPP);
|
2009-09-09 07:45:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static moduledata_t vesa_mod = {
|
|
|
|
"vesa",
|
|
|
|
vesa_mod_event,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
DECLARE_MODULE(vesa, vesa_mod, SI_SUB_DRIVERS, SI_ORDER_MIDDLE);
|
2009-09-21 08:17:57 +00:00
|
|
|
MODULE_DEPEND(vesa, x86bios, 1, 1, 1);
|
2009-09-09 07:45:08 +00:00
|
|
|
|
|
|
|
#endif /* VGA_NO_MODE_CHANGE */
|