xref: /netbsd-src/sbin/wsconsctl/display.c (revision 7d8ccb8ed09fff77ff0a670e8a7472737206e9e9)

/*	$NetBSD: display.c,v 1.19 2024/10/20 13:49:41 mlelstv Exp $ */

/*-
 * Copyright (c) 1998, 2004 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Juergen Hannken-Illjes.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/ioctl.h>
#include <sys/time.h>

#include <dev/wscons/wsconsio.h>

#include <err.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "wsconsctl.h"

static int border;
static int dpytype;
static struct wsdisplay_usefontdata font;
static struct wsdisplay_getfont gfont;
static char fontname_buf[256];
static struct wsdisplay_param backlight;
static struct wsdisplay_param brightness;
static struct wsdisplay_param contrast;
static struct wsdisplay_scroll_data scroll_l;
static struct wsdisplayio_edid_info edid_info;
static int msg_default_attrs, msg_default_bg, msg_default_fg;
static int msg_kernel_attrs, msg_kernel_bg, msg_kernel_fg;
static int splash_enable, splash_progress;

struct field display_field_tab[] = {
    { "border",			&border,	FMT_COLOR,	0 },
    { "type",			&dpytype,	FMT_DPYTYPE,	FLG_RDONLY },
    { "font",			&font.name,	FMT_STRING,	0 },
    { "backlight",		&backlight.curval,  FMT_UINT,	0 },
    { "brightness",		&brightness.curval, FMT_UINT,	FLG_MODIFY },
    { "contrast",		&contrast.curval,   FMT_UINT,	FLG_MODIFY },
    { "scroll.fastlines",	&scroll_l.fastlines, FMT_UINT,	FLG_MODIFY },
    { "scroll.slowlines",	&scroll_l.slowlines, FMT_UINT,	FLG_MODIFY },
    { "edid",			&edid_info, FMT_EDID,		FLG_RDONLY|FLG_NOAUTO },
    { "msg.default.attrs",	&msg_default_attrs, FMT_ATTRS,	0 },
    { "msg.default.bg",		&msg_default_bg, FMT_COLOR,	0 },
    { "msg.default.fg",		&msg_default_fg, FMT_COLOR,	0 },
    { "msg.kernel.attrs",	&msg_kernel_attrs, FMT_ATTRS,	0 },
    { "msg.kernel.bg",		&msg_kernel_bg, FMT_COLOR,	0 },
    { "msg.kernel.fg",		&msg_kernel_fg, FMT_COLOR,	0 },
    { "splash.enable",		&splash_enable, FMT_UINT,	FLG_WRONLY },
    { "splash.progress",	&splash_progress, FMT_UINT,	FLG_WRONLY },
};

int display_field_tab_len = sizeof(display_field_tab) /
	sizeof(display_field_tab[0]);

static int
display_get_edid(int fd, struct wsdisplayio_edid_info *ei)
{
	size_t sz = 256;
	int res;

	while (sz <= 65536) {
		ei->buffer_size = sz;
		ei->edid_data = malloc(sz);
		if (ei->edid_data == NULL) {
			res = -1;
			break;
		}

		res = ioctl(fd, WSDISPLAYIO_GET_EDID, ei);
		if (res == 0 || errno != EAGAIN)
			break;

		free(ei->edid_data);
		ei->edid_data = NULL;
		sz *= 2;
	}

	return res;
}

void
display_get_values(int fd)
{
	if (field_by_value(&font.name)->flags & FLG_GET) {
		gfont.gf_name = fontname_buf;
		gfont.gf_size = sizeof(fontname_buf);
		font.name = gfont.gf_name;
		if (ioctl(fd, WSDISPLAYIO_GFONT, &gfont) < 0)
			field_disable_by_value(&font.name);
	}

	if (field_by_value(&dpytype)->flags & FLG_GET)
		if (ioctl(fd, WSDISPLAYIO_GTYPE, &dpytype) < 0)
			err(EXIT_FAILURE, "WSDISPLAYIO_GTYPE");

	if (field_by_value(&border)->flags & FLG_GET)
		if (ioctl(fd, WSDISPLAYIO_GBORDER, &border) < 0)
			field_disable_by_value(&border);

	if (field_by_value(&backlight.curval)->flags & FLG_GET) {
		backlight.param = WSDISPLAYIO_PARAM_BACKLIGHT;
		if (ioctl(fd, WSDISPLAYIO_GETPARAM, &backlight) < 0)
			field_disable_by_value(&backlight.curval);
	}

	if (field_by_value(&brightness.curval)->flags & FLG_GET) {
		brightness.param = WSDISPLAYIO_PARAM_BRIGHTNESS;
		if (ioctl(fd, WSDISPLAYIO_GETPARAM, &brightness))
			field_disable_by_value(&brightness.curval);
	}

	if (field_by_value(&contrast.curval)->flags & FLG_GET) {
		contrast.param = WSDISPLAYIO_PARAM_CONTRAST;
		if (ioctl(fd, WSDISPLAYIO_GETPARAM, &contrast))
			field_disable_by_value(&contrast.curval);
	}

	if (field_by_value(&msg_default_attrs)->flags & FLG_GET ||
	    field_by_value(&msg_default_bg)->flags & FLG_GET ||
	    field_by_value(&msg_default_fg)->flags & FLG_GET ||
	    field_by_value(&msg_kernel_attrs)->flags & FLG_GET ||
	    field_by_value(&msg_kernel_bg)->flags & FLG_GET ||
	    field_by_value(&msg_kernel_fg)->flags & FLG_GET) {
		struct wsdisplay_msgattrs ma;

		if (ioctl(fd, WSDISPLAYIO_GMSGATTRS, &ma) < 0) {
			field_disable_by_value(&msg_default_attrs);
			field_disable_by_value(&msg_default_bg);
			field_disable_by_value(&msg_default_fg);
			field_disable_by_value(&msg_kernel_attrs);
			field_disable_by_value(&msg_kernel_bg);
			field_disable_by_value(&msg_kernel_fg);
		} else {
			msg_default_attrs = ma.default_attrs;
			if (ma.default_attrs & WSATTR_WSCOLORS) {
				msg_default_bg = ma.default_bg;
				msg_default_fg = ma.default_fg;
			} else
				msg_default_bg = msg_default_fg = -1;

			msg_kernel_attrs = ma.kernel_attrs;
			if (ma.kernel_attrs & WSATTR_WSCOLORS) {
				msg_kernel_bg = ma.kernel_bg;
				msg_kernel_fg = ma.kernel_fg;
			} else
				msg_kernel_bg = msg_kernel_fg = -1;
		}
	}

	if (field_by_value(&scroll_l.fastlines)->flags & FLG_GET ||
	    field_by_value(&scroll_l.slowlines)->flags & FLG_GET) {
		if (ioctl(fd, WSDISPLAYIO_DGSCROLL, &scroll_l) < 0) {
			field_disable_by_value(&scroll_l.fastlines);
			field_disable_by_value(&scroll_l.slowlines);
		}
	}

	if (field_by_value(&edid_info)->flags & FLG_GET) {
		if (display_get_edid(fd, &edid_info) < 0)
			field_disable_by_value(&edid_info);
	}
}

void
display_put_values(int fd)
{

	if (field_by_value(&font.name)->flags & FLG_SET) {
		if (ioctl(fd, WSDISPLAYIO_SFONT, &font) < 0)
			err(EXIT_FAILURE, "WSDISPLAYIO_SFONT");
		pr_field(field_by_value(&font.name), " -> ");
	}

	if (field_by_value(&border)->flags & FLG_SET) {
		if (ioctl(fd, WSDISPLAYIO_SBORDER, &border) < 0)
			err(EXIT_FAILURE, "WSDISPLAYIO_SBORDER");
		pr_field(field_by_value(&border), " -> ");
	}

	if (field_by_value(&backlight.curval)->flags & FLG_SET) {
		backlight.param = WSDISPLAYIO_PARAM_BACKLIGHT;
		if (ioctl(fd, WSDISPLAYIO_SETPARAM, &backlight) < 0)
			err(EXIT_FAILURE, "WSDISPLAYIO_PARAM_BACKLIGHT");
		pr_field(field_by_value(&backlight.curval), " -> ");
	}

	if (field_by_value(&brightness.curval)->flags & FLG_SET) {
		brightness.param = WSDISPLAYIO_PARAM_BRIGHTNESS;
		if (ioctl(fd, WSDISPLAYIO_SETPARAM, &brightness) < 0)
			err(EXIT_FAILURE, "WSDISPLAYIO_PARAM_BRIGHTNESS");
		pr_field(field_by_value(&brightness.curval), " -> ");
	}

	if (field_by_value(&contrast.curval)->flags & FLG_SET) {
		contrast.param = WSDISPLAYIO_PARAM_CONTRAST;
		if (ioctl(fd, WSDISPLAYIO_SETPARAM, &contrast) < 0)
			err(EXIT_FAILURE, "WSDISPLAYIO_PARAM_CONTRAST");
		pr_field(field_by_value(&contrast.curval), " -> ");
	}

	if (field_by_value(&splash_enable)->flags & FLG_SET) {
		if (ioctl(fd, WSDISPLAYIO_SSPLASH, &splash_enable) < 0)
			err(EXIT_FAILURE, "WSDISPLAYIO_SSPLASH");
		pr_field(field_by_value(&splash_enable), " -> ");
	}

	if (field_by_value(&splash_progress)->flags & FLG_SET) {
		if (ioctl(fd, WSDISPLAYIO_SPROGRESS, &splash_progress) < 0)
			err(EXIT_FAILURE, "WSDISPLAYIO_SPROGRESS");
		pr_field(field_by_value(&splash_progress), " -> ");
	}

	if (field_by_value(&msg_default_attrs)->flags & FLG_SET ||
	    field_by_value(&msg_default_bg)->flags & FLG_SET ||
	    field_by_value(&msg_default_fg)->flags & FLG_SET ||
	    field_by_value(&msg_kernel_attrs)->flags & FLG_SET ||
	    field_by_value(&msg_kernel_bg)->flags & FLG_SET ||
	    field_by_value(&msg_kernel_fg)->flags & FLG_SET) {
		struct wsdisplay_msgattrs ma;

		if (ioctl(fd, WSDISPLAYIO_GMSGATTRS, &ma) < 0)
			err(EXIT_FAILURE, "WSDISPLAYIO_GMSGATTRS");

		if (field_by_value(&msg_default_attrs)->flags & FLG_SET) {
			ma.default_attrs = msg_default_attrs;
			pr_field(field_by_value(&msg_default_attrs), " -> ");
		}
		if (ma.default_attrs & WSATTR_WSCOLORS) {
			if (field_by_value(&msg_default_bg)->flags & FLG_SET) {
				ma.default_bg = msg_default_bg;
				pr_field(field_by_value(&msg_default_bg),
				    " -> ");
			}
			if (field_by_value(&msg_default_fg)->flags & FLG_SET) {
				ma.default_fg = msg_default_fg;
				pr_field(field_by_value(&msg_default_fg),
				    " -> ");
			}
		}

		if (field_by_value(&msg_kernel_attrs)->flags & FLG_SET) {
			ma.kernel_attrs = msg_kernel_attrs;
			pr_field(field_by_value(&msg_kernel_attrs), " -> ");
		}
		if (ma.default_attrs & WSATTR_WSCOLORS) {
			if (field_by_value(&msg_kernel_bg)->flags & FLG_SET) {
				ma.kernel_bg = msg_kernel_bg;
				pr_field(field_by_value(&msg_kernel_bg),
				    " -> ");
			}
			if (field_by_value(&msg_kernel_fg)->flags & FLG_SET) {
				ma.kernel_fg = msg_kernel_fg;
				pr_field(field_by_value(&msg_kernel_fg),
				    " -> ");
			}
		}

		if (ioctl(fd, WSDISPLAYIO_SMSGATTRS, &ma) < 0)
			err(EXIT_FAILURE, "WSDISPLAYIO_SMSGATTRS");
	}

	scroll_l.which = 0;
	if (field_by_value(&scroll_l.fastlines)->flags & FLG_SET)
		scroll_l.which |= WSDISPLAY_SCROLL_DOFASTLINES;
	if (field_by_value(&scroll_l.slowlines)->flags & FLG_SET)
		scroll_l.which |= WSDISPLAY_SCROLL_DOSLOWLINES;
	if (scroll_l.which != 0 &&
	    ioctl(fd, WSDISPLAYIO_DSSCROLL, &scroll_l) < 0)
		err(EXIT_FAILURE, "WSDISPLAYIO_DSSCROLL");
	if (scroll_l.which & WSDISPLAY_SCROLL_DOFASTLINES)
		pr_field(field_by_value(&scroll_l.fastlines), " -> ");
	if (scroll_l.which & WSDISPLAY_SCROLL_DOSLOWLINES)
		pr_field(field_by_value(&scroll_l.slowlines), " -> ");
}