[linux-2.6-block.git] / include / linux / screen_info.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _SCREEN_INFO_H
#define _SCREEN_INFO_H

#include <uapi/linux/screen_info.h>

#include <linux/bits.h>

/**
 * SCREEN_INFO_MAX_RESOURCES - maximum number of resources per screen_info
 */
#define SCREEN_INFO_MAX_RESOURCES	3

struct pci_dev;
struct resource;

static inline bool __screen_info_has_lfb(unsigned int type)
{
	return (type == VIDEO_TYPE_VLFB) || (type == VIDEO_TYPE_EFI);
}

static inline u64 __screen_info_lfb_base(const struct screen_info *si)
{
	u64 lfb_base = si->lfb_base;

	if (si->capabilities & VIDEO_CAPABILITY_64BIT_BASE)
		lfb_base |= (u64)si->ext_lfb_base << 32;

	return lfb_base;
}

static inline void __screen_info_set_lfb_base(struct screen_info *si, u64 lfb_base)
{
	si->lfb_base = lfb_base & GENMASK_ULL(31, 0);
	si->ext_lfb_base = (lfb_base & GENMASK_ULL(63, 32)) >> 32;

	if (si->ext_lfb_base)
		si->capabilities |= VIDEO_CAPABILITY_64BIT_BASE;
	else
		si->capabilities &= ~VIDEO_CAPABILITY_64BIT_BASE;
}

static inline u64 __screen_info_lfb_size(const struct screen_info *si, unsigned int type)
{
	u64 lfb_size = si->lfb_size;

	if (type == VIDEO_TYPE_VLFB)
		lfb_size <<= 16;
	return lfb_size;
}

static inline bool __screen_info_vbe_mode_nonvga(const struct screen_info *si)
{
	/*
	 * VESA modes typically run on VGA hardware. Set bit 5 signals that this
	 * is not the case. Drivers can then not make use of VGA resources. See
	 * Sec 4.4 of the VBE 2.0 spec.
	 */
	return si->vesa_attributes & BIT(5);
}

static inline unsigned int __screen_info_video_type(unsigned int type)
{
	switch (type) {
	case VIDEO_TYPE_MDA:
	case VIDEO_TYPE_CGA:
	case VIDEO_TYPE_EGAM:
	case VIDEO_TYPE_EGAC:
	case VIDEO_TYPE_VGAC:
	case VIDEO_TYPE_VLFB:
	case VIDEO_TYPE_PICA_S3:
	case VIDEO_TYPE_MIPS_G364:
	case VIDEO_TYPE_SGI:
	case VIDEO_TYPE_TGAC:
	case VIDEO_TYPE_SUN:
	case VIDEO_TYPE_SUNPCI:
	case VIDEO_TYPE_PMAC:
	case VIDEO_TYPE_EFI:
		return type;
	default:
		return 0;
	}
}

/**
 * screen_info_video_type() - Decodes the video type from struct screen_info
 * @si: an instance of struct screen_info
 *
 * Returns:
 * A VIDEO_TYPE_ constant representing si's type of video display, or 0 otherwise.
 */
static inline unsigned int screen_info_video_type(const struct screen_info *si)
{
	unsigned int type;

	// check if display output is on
	if (!si->orig_video_isVGA)
		return 0;

	// check for a known VIDEO_TYPE_ constant
	type = __screen_info_video_type(si->orig_video_isVGA);
	if (type)
		return si->orig_video_isVGA;

	// check if text mode has been initialized
	if (!si->orig_video_lines || !si->orig_video_cols)
		return 0;

	// 80x25 text, mono
	if (si->orig_video_mode == 0x07) {
		if ((si->orig_video_ega_bx & 0xff) != 0x10)
			return VIDEO_TYPE_EGAM;
		else
			return VIDEO_TYPE_MDA;
	}

	// EGA/VGA, 16 colors
	if ((si->orig_video_ega_bx & 0xff) != 0x10) {
		if (si->orig_video_isVGA)
			return VIDEO_TYPE_VGAC;
		else
			return VIDEO_TYPE_EGAC;
	}

	// the rest...
	return VIDEO_TYPE_CGA;
}

ssize_t screen_info_resources(const struct screen_info *si, struct resource *r, size_t num);

#if defined(CONFIG_PCI)
void screen_info_apply_fixups(void);
struct pci_dev *screen_info_pci_dev(const struct screen_info *si);
#else
static inline void screen_info_apply_fixups(void)
{ }
static inline struct pci_dev *screen_info_pci_dev(const struct screen_info *si)
{
	return NULL;
}
#endif

extern struct screen_info screen_info;

#endif /* _SCREEN_INFO_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
7e7f358c BG	2	#ifndef _SCREEN_INFO_H
	3	#define _SCREEN_INFO_H
	4
607ca46e	5	#include <uapi/linux/screen_info.h>
7e7f358c	6
78aa89d1 TZ	7	#include <linux/bits.h>
78aa89d1 TZ	8
75fa9b7e TZ	9	/**
	10	* SCREEN_INFO_MAX_RESOURCES - maximum number of resources per screen_info
	11	*/
	12	#define SCREEN_INFO_MAX_RESOURCES 3
	13
036105e3	14	struct pci_dev;
75fa9b7e TZ	15	struct resource;
	16
	17	static inline bool __screen_info_has_lfb(unsigned int type)
	18	{
	19	return (type == VIDEO_TYPE_VLFB) \|\| (type == VIDEO_TYPE_EFI);
	20	}
	21
	22	static inline u64 __screen_info_lfb_base(const struct screen_info *si)
	23	{
	24	u64 lfb_base = si->lfb_base;
	25
	26	if (si->capabilities & VIDEO_CAPABILITY_64BIT_BASE)
	27	lfb_base \|= (u64)si->ext_lfb_base << 32;
	28
	29	return lfb_base;
	30	}
	31
78aa89d1 TZ	32	static inline void __screen_info_set_lfb_base(struct screen_info *si, u64 lfb_base)
	33	{
	34	si->lfb_base = lfb_base & GENMASK_ULL(31, 0);
	35	si->ext_lfb_base = (lfb_base & GENMASK_ULL(63, 32)) >> 32;
	36
	37	if (si->ext_lfb_base)
	38	si->capabilities \|= VIDEO_CAPABILITY_64BIT_BASE;
	39	else
	40	si->capabilities &= ~VIDEO_CAPABILITY_64BIT_BASE;
	41	}
	42
75fa9b7e TZ	43	static inline u64 __screen_info_lfb_size(const struct screen_info *si, unsigned int type)
	44	{
	45	u64 lfb_size = si->lfb_size;
	46
	47	if (type == VIDEO_TYPE_VLFB)
	48	lfb_size <<= 16;
	49	return lfb_size;
	50	}
	51
c2bc958b TZ	52	static inline bool __screen_info_vbe_mode_nonvga(const struct screen_info *si)
	53	{
	54	/*
	55	* VESA modes typically run on VGA hardware. Set bit 5 signals that this
	56	* is not the case. Drivers can then not make use of VGA resources. See
	57	* Sec 4.4 of the VBE 2.0 spec.
	58	*/
	59	return si->vesa_attributes & BIT(5);
	60	}
	61
75fa9b7e TZ	62	static inline unsigned int __screen_info_video_type(unsigned int type)
	63	{
	64	switch (type) {
	65	case VIDEO_TYPE_MDA:
	66	case VIDEO_TYPE_CGA:
	67	case VIDEO_TYPE_EGAM:
	68	case VIDEO_TYPE_EGAC:
	69	case VIDEO_TYPE_VGAC:
	70	case VIDEO_TYPE_VLFB:
	71	case VIDEO_TYPE_PICA_S3:
	72	case VIDEO_TYPE_MIPS_G364:
	73	case VIDEO_TYPE_SGI:
	74	case VIDEO_TYPE_TGAC:
	75	case VIDEO_TYPE_SUN:
	76	case VIDEO_TYPE_SUNPCI:
	77	case VIDEO_TYPE_PMAC:
	78	case VIDEO_TYPE_EFI:
	79	return type;
	80	default:
	81	return 0;
	82	}
	83	}
	84
	85	/**
	86	* screen_info_video_type() - Decodes the video type from struct screen_info
	87	* @si: an instance of struct screen_info
	88	*
	89	* Returns:
	90	* A VIDEO_TYPE_ constant representing si's type of video display, or 0 otherwise.
	91	*/
	92	static inline unsigned int screen_info_video_type(const struct screen_info *si)
	93	{
	94	unsigned int type;
	95
	96	// check if display output is on
	97	if (!si->orig_video_isVGA)
	98	return 0;
	99
	100	// check for a known VIDEO_TYPE_ constant
	101	type = __screen_info_video_type(si->orig_video_isVGA);
	102	if (type)
	103	return si->orig_video_isVGA;
	104
	105	// check if text mode has been initialized
	106	if (!si->orig_video_lines \|\| !si->orig_video_cols)
	107	return 0;
	108
	109	// 80x25 text, mono
	110	if (si->orig_video_mode == 0x07) {
	111	if ((si->orig_video_ega_bx & 0xff) != 0x10)
	112	return VIDEO_TYPE_EGAM;
	113	else
	114	return VIDEO_TYPE_MDA;
	115	}
	116
	117	// EGA/VGA, 16 colors
	118	if ((si->orig_video_ega_bx & 0xff) != 0x10) {
	119	if (si->orig_video_isVGA)
	120	return VIDEO_TYPE_VGAC;
	121	else
	122	return VIDEO_TYPE_EGAC;
	123	}
	124
	125	// the rest...
126	return VIDEO_TYPE_CGA;
127	}
128
129	ssize_t screen_info_resources(const struct screen_info si, struct resource r, size_t num);
130
036105e3	131	#if defined(CONFIG_PCI)
78aa89d1	132	void screen_info_apply_fixups(void);
036105e3 TZ	133	struct pci_dev screen_info_pci_dev(const struct screen_info si);
036105e3 TZ	134	#else
78aa89d1 TZ	135	static inline void screen_info_apply_fixups(void)
78aa89d1 TZ	136	{ }
036105e3 TZ	137	static inline struct pci_dev screen_info_pci_dev(const struct screen_info si)
	138	{
	139	return NULL;
	140	}
	141	#endif
	142
ee8e7cfe RR	143	extern struct screen_info screen_info;
ee8e7cfe RR	144
7e7f358c	145	#endif /* _SCREEN_INFO_H */