Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	sbin/wsconsctl/display.c	Lines:	0	116	0.0 %
Date:	2017-11-07	Branches:	0	86	0.0 %


/*	$OpenBSD: display.c,v 1.20 2015/05/08 19:12:51 miod Exp $	*/
/*	$NetBSD: display.c,v 1.1 1998/12/28 14:01:16 hannken Exp $ */

/*-
 * Copyright (c) 1998 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 <errno.h>
#include <fcntl.h>
#include <err.h>
#include <stdio.h>
#include <string.h>
#include "wsconsctl.h"

u_int dpytype;
u_int width, height, depth;
int focus;
struct field_pc brightness, contrast, backlight;
int burnon, burnoff, vblank, kbdact, msact, outact;
char fontname[WSFONT_NAME_SIZE];
struct wsdisplay_emultype emuls;
struct wsdisplay_screentype screens;

struct field display_field_tab[] = {
    { "type",		&dpytype,	FMT_DPYTYPE,	FLG_RDONLY },
    { "width",		&width,		FMT_UINT,	FLG_RDONLY },
    { "height",		&height,	FMT_UINT,	FLG_RDONLY },
    { "depth",		&depth,		FMT_UINT,	FLG_RDONLY },
    { "emulations",	&emuls,		FMT_EMUL,	FLG_RDONLY },
    { "screentypes",	&screens,	FMT_SCREEN,	FLG_RDONLY },
    { "focus",		&focus,		FMT_INT,	FLG_NORDBACK },
    { "brightness",	&brightness,	FMT_PC,		FLG_MODIFY|FLG_INIT },
    { "contrast",	&contrast,	FMT_PC,		FLG_MODIFY|FLG_INIT },
    { "backlight",	&backlight,	FMT_PC,		FLG_MODIFY|FLG_INIT },
    /* screen burner section, outact MUST BE THE LAST, see the set_values */
    { "screen_on",	&burnon,	FMT_UINT,	FLG_MODIFY|FLG_INIT },
    { "screen_off",	&burnoff,	FMT_UINT,	FLG_MODIFY|FLG_INIT },
    { "vblank",		&vblank,	FMT_BOOL,	FLG_MODIFY|FLG_INIT },
    { "kbdact",		&kbdact,	FMT_BOOL,	FLG_MODIFY|FLG_INIT },
    { "msact",		&msact,		FMT_BOOL,	FLG_MODIFY|FLG_INIT },
    { "outact",		&outact,	FMT_BOOL,	FLG_MODIFY|FLG_INIT },
    { "font",		fontname,	FMT_STRING,	FLG_WRONLY },
    { NULL }
};

#define	fillioctl(n)	{ cmd = n; cmd_str = #n; }

void
display_get_values(int fd)
{
	struct wsdisplay_addscreendata gscr;
	struct wsdisplay_param param;
	struct wsdisplay_burner burners;
	struct wsdisplay_fbinfo fbinfo;
	struct field *pf;
	const char *cmd_str;
	void *ptr;
	unsigned long cmd;
	int bon = 0, fbon = 0;

	focus = gscr.idx = -1;
	for (pf = display_field_tab; pf->name; pf++) {

		if (!(pf->flags & FLG_GET) || pf->flags & FLG_DEAD)
			continue;

		ptr = pf->valp;

		if (ptr == &dpytype) {
			fillioctl(WSDISPLAYIO_GTYPE);
		} else if (ptr == &focus) {
			fillioctl(WSDISPLAYIO_GETSCREEN);
			ptr = &gscr;
		} else if (ptr == &emuls) {
			fillioctl(WSDISPLAYIO_GETEMULTYPE);
			emuls.idx=0;
		} else if (ptr == &screens) {
			fillioctl(WSDISPLAYIO_GETSCREENTYPE);
			screens.idx=0;
		} else if (ptr == &brightness) {
			ptr = &param;
			param.param = WSDISPLAYIO_PARAM_BRIGHTNESS;
		} else if (ptr == &contrast) {
			ptr = &param;
			param.param = WSDISPLAYIO_PARAM_CONTRAST;
		} else if (ptr == &backlight) {
			ptr = &param;
			param.param = WSDISPLAYIO_PARAM_BACKLIGHT;
		} else if (ptr == &burnon || ptr == &burnoff ||
			   ptr == &vblank || ptr == &kbdact ||
			   ptr == &outact || ptr == &msact) {
			fillioctl(WSDISPLAYIO_GBURNER);
			ptr = &burners;
			if (!bon)
				bzero(&burners, sizeof(burners));
		} else if (ptr == &height || ptr == &width ||
			   ptr == &depth) {
			fillioctl(WSDISPLAYIO_GINFO);
			ptr = &fbinfo;
			if (!fbon)
				bzero(&fbinfo, sizeof(fbinfo));
		} else
			cmd = 0;

		if (ptr == &param) {
			fillioctl(WSDISPLAYIO_GETPARAM);
		}

		if ((cmd != WSDISPLAYIO_GBURNER && cmd != WSDISPLAYIO_GINFO) ||
		    (cmd == WSDISPLAYIO_GBURNER && !bon) ||
		    (cmd == WSDISPLAYIO_GINFO && !fbon)) {
			errno = ENOTTY;
			if (!cmd || ioctl(fd, cmd, ptr) < 0) {
				if (errno == ENOTTY) {
					pf->flags |= FLG_DEAD;
					continue;
				} else
					warn("%s", cmd_str);
			}
		}

		if (ptr == &burners) {
			if (!bon) {
				burnon = burners.on;
				burnoff = burners.off;
				vblank = burners.flags & WSDISPLAY_BURN_VBLANK;
				kbdact = burners.flags & WSDISPLAY_BURN_KBD;
				msact = burners.flags & WSDISPLAY_BURN_MOUSE;
				outact = burners.flags & WSDISPLAY_BURN_OUTPUT;
			}
			bon++;
		} else if (ptr == &fbinfo) {
			if (!fbon) {
				width = fbinfo.width;
				height = fbinfo.height;
				depth = fbinfo.depth;
			}
			fbon++;
		} else if (ptr == &emuls) {
			emuls.idx=fd;
		} else if (ptr == &screens) {
			screens.idx=fd;
		} else if (ptr == &param) {
			struct field_pc *pc = pf->valp;

			pc->min = param.min;
			pc->cur = param.curval;
			pc->max = param.max;
		} else if (ptr == &gscr)
			focus = gscr.idx;
	}
}

int
display_put_values(int fd)
{
	struct wsdisplay_param param;
	struct wsdisplay_burner burners;
	struct wsdisplay_font font;
	struct field *pf;
	const char *cmd_str;
	void *ptr;
	unsigned long cmd;
	int id;

	for (pf = display_field_tab; pf->name; pf++) {

		if (!(pf->flags & FLG_SET) || pf->flags & FLG_DEAD)
			continue;

		ptr = pf->valp;

		if (ptr == &focus) {
			fillioctl(WSDISPLAYIO_SETSCREEN);
		} else if (ptr == &brightness) {
			ptr = &param;
			id = WSDISPLAYIO_PARAM_BRIGHTNESS;
		} else if (ptr == &contrast) {
			ptr = &param;
			id = WSDISPLAYIO_PARAM_CONTRAST;
		} else if (ptr == &backlight) {
			ptr = &param;
			id = WSDISPLAYIO_PARAM_BACKLIGHT;
		} else if (ptr == &burnon || ptr == &burnoff ||
			   ptr == &vblank || ptr == &kbdact ||
			   ptr == &outact || ptr == &msact) {

			bzero(&burners, sizeof(burners));
			burners.on = burnon;
			burners.off = burnoff;
			if (vblank)
				burners.flags |= WSDISPLAY_BURN_VBLANK;
			else
				burners.flags &= ~WSDISPLAY_BURN_VBLANK;
			if (kbdact)
				burners.flags |= WSDISPLAY_BURN_KBD;
			else
				burners.flags &= ~WSDISPLAY_BURN_KBD;
			if (msact)
				burners.flags |= WSDISPLAY_BURN_MOUSE;
			else
				burners.flags &= ~WSDISPLAY_BURN_MOUSE;
			if (outact)
				burners.flags |= WSDISPLAY_BURN_OUTPUT;
			else
				burners.flags &= ~WSDISPLAY_BURN_OUTPUT;

			fillioctl(WSDISPLAYIO_SBURNER);
			ptr = &burners;
		} else if (ptr == fontname) {
			bzero(&font, sizeof(font));
			strlcpy(font.name, ptr, sizeof font.name);
			fillioctl(WSDISPLAYIO_USEFONT);
		} else
			cmd = 0;

		if (ptr == &param) {
			struct field_pc *pc = pf->valp;

			bzero(&param, sizeof(param));
			param.param = id;
			param.min = pc->min;
			param.curval = pc->cur;
			param.max = pc->max;
			fillioctl(WSDISPLAYIO_SETPARAM);
		}

		errno = ENOTTY;
		if (!cmd || ioctl(fd, cmd, ptr) < 0) {
			if (errno == ENOTTY) {
				pf->flags |= FLG_DEAD;
				continue;
			} else {
				warn("%s", cmd_str);
				return 1;
			}
		}
	}

	return 0;
}

char *
display_next_device(int index)
{
	static char devname[20];

	if (index > 7)
		return (NULL);

	snprintf(devname, sizeof(devname), "/dev/tty%c0", index + 'C');
	return (devname);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: display.c,v 1.20 2015/05/08 19:12:51 miod Exp $ */
2			/* $NetBSD: display.c,v 1.1 1998/12/28 14:01:16 hannken Exp $ */
3
4			/*-
5			* Copyright (c) 1998 The NetBSD Foundation, Inc.
6			* All rights reserved.
7			*
8			* This code is derived from software contributed to The NetBSD Foundation
9			* by Juergen Hannken-Illjes.
10			*
11			* Redistribution and use in source and binary forms, with or without
12			* modification, are permitted provided that the following conditions
13			* are met:
14			* 1. Redistributions of source code must retain the above copyright
15			* notice, this list of conditions and the following disclaimer.
16			* 2. Redistributions in binary form must reproduce the above copyright
17			* notice, this list of conditions and the following disclaimer in the
18			* documentation and/or other materials provided with the distribution.
19			*
20			* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21			* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22			* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23			* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24			* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25			* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26			* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27			* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28			* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29			* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30			* POSSIBILITY OF SUCH DAMAGE.
31			*/
32
33			#include <sys/ioctl.h>
34			#include <sys/time.h>
35			#include <dev/wscons/wsconsio.h>
36			#include <errno.h>
37			#include <fcntl.h>
38			#include <err.h>
39			#include <stdio.h>
40			#include <string.h>
41			#include "wsconsctl.h"
42
43			u_int dpytype;
44			u_int width, height, depth;
45			int focus;
46			struct field_pc brightness, contrast, backlight;
47			int burnon, burnoff, vblank, kbdact, msact, outact;
48			char fontname[WSFONT_NAME_SIZE];
49			struct wsdisplay_emultype emuls;
50			struct wsdisplay_screentype screens;
51
52			struct field display_field_tab[] = {
53			{ "type", &dpytype, FMT_DPYTYPE, FLG_RDONLY },
54			{ "width", &width, FMT_UINT, FLG_RDONLY },
55			{ "height", &height, FMT_UINT, FLG_RDONLY },
56			{ "depth", &depth, FMT_UINT, FLG_RDONLY },
57			{ "emulations", &emuls, FMT_EMUL, FLG_RDONLY },
58			{ "screentypes", &screens, FMT_SCREEN, FLG_RDONLY },
59			{ "focus", &focus, FMT_INT, FLG_NORDBACK },
60			{ "brightness", &brightness, FMT_PC, FLG_MODIFY\|FLG_INIT },
61			{ "contrast", &contrast, FMT_PC, FLG_MODIFY\|FLG_INIT },
62			{ "backlight", &backlight, FMT_PC, FLG_MODIFY\|FLG_INIT },
63			/* screen burner section, outact MUST BE THE LAST, see the set_values */
64			{ "screen_on", &burnon, FMT_UINT, FLG_MODIFY\|FLG_INIT },
65			{ "screen_off", &burnoff, FMT_UINT, FLG_MODIFY\|FLG_INIT },
66			{ "vblank", &vblank, FMT_BOOL, FLG_MODIFY\|FLG_INIT },
67			{ "kbdact", &kbdact, FMT_BOOL, FLG_MODIFY\|FLG_INIT },
68			{ "msact", &msact, FMT_BOOL, FLG_MODIFY\|FLG_INIT },
69			{ "outact", &outact, FMT_BOOL, FLG_MODIFY\|FLG_INIT },
70			{ "font", fontname, FMT_STRING, FLG_WRONLY },
71			{ NULL }
72			};
73
74			#define fillioctl(n) { cmd = n; cmd_str = #n; }
75
76			void
77			display_get_values(int fd)
78			{
79			struct wsdisplay_addscreendata gscr;
80			struct wsdisplay_param param;
81			struct wsdisplay_burner burners;
82			struct wsdisplay_fbinfo fbinfo;
83			struct field *pf;
84			const char *cmd_str;
85			void *ptr;
86			unsigned long cmd;
87			int bon = 0, fbon = 0;
88
89			focus = gscr.idx = -1;
90			for (pf = display_field_tab; pf->name; pf++) {
91
92			if (!(pf->flags & FLG_GET) \|\| pf->flags & FLG_DEAD)
93			continue;
94
95			ptr = pf->valp;
96
97			if (ptr == &dpytype) {
98			fillioctl(WSDISPLAYIO_GTYPE);
99			} else if (ptr == &focus) {
100			fillioctl(WSDISPLAYIO_GETSCREEN);
101			ptr = &gscr;
102			} else if (ptr == &emuls) {
103			fillioctl(WSDISPLAYIO_GETEMULTYPE);
104			emuls.idx=0;
105			} else if (ptr == &screens) {
106			fillioctl(WSDISPLAYIO_GETSCREENTYPE);
107			screens.idx=0;
108			} else if (ptr == &brightness) {
109			ptr = &param;
110			param.param = WSDISPLAYIO_PARAM_BRIGHTNESS;
111			} else if (ptr == &contrast) {
112			ptr = &param;
113			param.param = WSDISPLAYIO_PARAM_CONTRAST;
114			} else if (ptr == &backlight) {
115			ptr = &param;
116			param.param = WSDISPLAYIO_PARAM_BACKLIGHT;
117			} else if (ptr == &burnon \|\| ptr == &burnoff \|\|
118			ptr == &vblank \|\| ptr == &kbdact \|\|
119			ptr == &outact \|\| ptr == &msact) {
120			fillioctl(WSDISPLAYIO_GBURNER);
121			ptr = &burners;
122			if (!bon)
123			bzero(&burners, sizeof(burners));
124			} else if (ptr == &height \|\| ptr == &width \|\|
125			ptr == &depth) {
126			fillioctl(WSDISPLAYIO_GINFO);
127			ptr = &fbinfo;
128			if (!fbon)
129			bzero(&fbinfo, sizeof(fbinfo));
130			} else
131			cmd = 0;
132
133			if (ptr == &param) {
134			fillioctl(WSDISPLAYIO_GETPARAM);
135			}
136
137			if ((cmd != WSDISPLAYIO_GBURNER && cmd != WSDISPLAYIO_GINFO) \|\|
138			(cmd == WSDISPLAYIO_GBURNER && !bon) \|\|
139			(cmd == WSDISPLAYIO_GINFO && !fbon)) {
140			errno = ENOTTY;
141			if (!cmd \|\| ioctl(fd, cmd, ptr) < 0) {
142			if (errno == ENOTTY) {
143			pf->flags \|= FLG_DEAD;
144			continue;
145			} else
146			warn("%s", cmd_str);
147			}
148			}
149
150			if (ptr == &burners) {
151			if (!bon) {
152			burnon = burners.on;
153			burnoff = burners.off;
154			vblank = burners.flags & WSDISPLAY_BURN_VBLANK;
155			kbdact = burners.flags & WSDISPLAY_BURN_KBD;
156			msact = burners.flags & WSDISPLAY_BURN_MOUSE;
157			outact = burners.flags & WSDISPLAY_BURN_OUTPUT;
158			}
159			bon++;
160			} else if (ptr == &fbinfo) {
161			if (!fbon) {
162			width = fbinfo.width;
163			height = fbinfo.height;
164			depth = fbinfo.depth;
165			}
166			fbon++;
167			} else if (ptr == &emuls) {
168			emuls.idx=fd;
169			} else if (ptr == &screens) {
170			screens.idx=fd;
171			} else if (ptr == &param) {
172			struct field_pc *pc = pf->valp;
173
174			pc->min = param.min;
175			pc->cur = param.curval;
176			pc->max = param.max;
177			} else if (ptr == &gscr)
178			focus = gscr.idx;
179			}
180			}
181
182			int
183			display_put_values(int fd)
184			{
185			struct wsdisplay_param param;
186			struct wsdisplay_burner burners;
187			struct wsdisplay_font font;
188			struct field *pf;
189			const char *cmd_str;
190			void *ptr;
191			unsigned long cmd;
192			int id;
193
194			for (pf = display_field_tab; pf->name; pf++) {
195
196			if (!(pf->flags & FLG_SET) \|\| pf->flags & FLG_DEAD)
197			continue;
198
199			ptr = pf->valp;
200
201			if (ptr == &focus) {
202			fillioctl(WSDISPLAYIO_SETSCREEN);
203			} else if (ptr == &brightness) {
204			ptr = &param;
205			id = WSDISPLAYIO_PARAM_BRIGHTNESS;
206			} else if (ptr == &contrast) {
207			ptr = &param;
208			id = WSDISPLAYIO_PARAM_CONTRAST;
209			} else if (ptr == &backlight) {
210			ptr = &param;
211			id = WSDISPLAYIO_PARAM_BACKLIGHT;
212			} else if (ptr == &burnon \|\| ptr == &burnoff \|\|
213			ptr == &vblank \|\| ptr == &kbdact \|\|
214			ptr == &outact \|\| ptr == &msact) {
215
216			bzero(&burners, sizeof(burners));
217			burners.on = burnon;
218			burners.off = burnoff;
219			if (vblank)
220			burners.flags \|= WSDISPLAY_BURN_VBLANK;
221			else
222			burners.flags &= ~WSDISPLAY_BURN_VBLANK;
223			if (kbdact)
224			burners.flags \|= WSDISPLAY_BURN_KBD;
225			else
226			burners.flags &= ~WSDISPLAY_BURN_KBD;
227			if (msact)
228			burners.flags \|= WSDISPLAY_BURN_MOUSE;
229			else
230			burners.flags &= ~WSDISPLAY_BURN_MOUSE;
231			if (outact)
232			burners.flags \|= WSDISPLAY_BURN_OUTPUT;
233			else
234			burners.flags &= ~WSDISPLAY_BURN_OUTPUT;
235
236			fillioctl(WSDISPLAYIO_SBURNER);
237			ptr = &burners;
238			} else if (ptr == fontname) {
239			bzero(&font, sizeof(font));
240			strlcpy(font.name, ptr, sizeof font.name);
241			fillioctl(WSDISPLAYIO_USEFONT);
242			} else
243			cmd = 0;
244
245			if (ptr == &param) {
246			struct field_pc *pc = pf->valp;
247
248			bzero(&param, sizeof(param));
249			param.param = id;
250			param.min = pc->min;
251			param.curval = pc->cur;
252			param.max = pc->max;
253			fillioctl(WSDISPLAYIO_SETPARAM);
254			}
255
256			errno = ENOTTY;
257			if (!cmd \|\| ioctl(fd, cmd, ptr) < 0) {
258			if (errno == ENOTTY) {
259			pf->flags \|= FLG_DEAD;
260			continue;
261			} else {
262			warn("%s", cmd_str);
263			return 1;
264			}
265			}
266			}
267
268			return 0;
269			}
270
271			char *
272			display_next_device(int index)
273			{
274			static char devname[20];
275
276			if (index > 7)
277			return (NULL);
278
279			snprintf(devname, sizeof(devname), "/dev/tty%c0", index + 'C');
280			return (devname);
281			}