License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 17:07:57 +03:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2005-04-17 02:20:36 +04:00
|
|
|
#ifndef _LINUX_FB_H
|
|
|
|
#define _LINUX_FB_H
|
|
|
|
|
2010-08-02 23:05:41 +04:00
|
|
|
#include <linux/kgdb.h>
|
2012-10-13 13:46:48 +04:00
|
|
|
#include <uapi/linux/fb.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
#define FBIO_CURSOR _IOWR('F', 0x08, struct fb_cursor_user)
|
|
|
|
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <linux/list.h>
|
2006-08-14 10:24:26 +04:00
|
|
|
#include <linux/backlight.h>
|
2010-05-16 19:27:03 +04:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <asm/io.h>
|
|
|
|
|
|
|
|
struct vm_area_struct;
|
|
|
|
struct fb_info;
|
|
|
|
struct device;
|
|
|
|
struct file;
|
2012-11-14 13:55:04 +04:00
|
|
|
struct videomode;
|
2012-11-14 14:12:38 +04:00
|
|
|
struct device_node;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Definitions below are used in the parsed monitor specs */
|
|
|
|
#define FB_DPMS_ACTIVE_OFF 1
|
|
|
|
#define FB_DPMS_SUSPEND 2
|
|
|
|
#define FB_DPMS_STANDBY 4
|
|
|
|
|
|
|
|
#define FB_DISP_DDI 1
|
|
|
|
#define FB_DISP_ANA_700_300 2
|
|
|
|
#define FB_DISP_ANA_714_286 4
|
|
|
|
#define FB_DISP_ANA_1000_400 8
|
|
|
|
#define FB_DISP_ANA_700_000 16
|
|
|
|
|
|
|
|
#define FB_DISP_MONO 32
|
|
|
|
#define FB_DISP_RGB 64
|
|
|
|
#define FB_DISP_MULTI 128
|
|
|
|
#define FB_DISP_UNKNOWN 256
|
|
|
|
|
|
|
|
#define FB_SIGNAL_NONE 0
|
|
|
|
#define FB_SIGNAL_BLANK_BLANK 1
|
|
|
|
#define FB_SIGNAL_SEPARATE 2
|
|
|
|
#define FB_SIGNAL_COMPOSITE 4
|
|
|
|
#define FB_SIGNAL_SYNC_ON_GREEN 8
|
|
|
|
#define FB_SIGNAL_SERRATION_ON 16
|
|
|
|
|
|
|
|
#define FB_MISC_PRIM_COLOR 1
|
|
|
|
#define FB_MISC_1ST_DETAIL 2 /* First Detailed Timing is preferred */
|
2014-03-27 02:35:37 +04:00
|
|
|
#define FB_MISC_HDMI 4
|
2005-04-17 02:20:36 +04:00
|
|
|
struct fb_chroma {
|
|
|
|
__u32 redx; /* in fraction of 1024 */
|
|
|
|
__u32 greenx;
|
|
|
|
__u32 bluex;
|
|
|
|
__u32 whitex;
|
|
|
|
__u32 redy;
|
|
|
|
__u32 greeny;
|
|
|
|
__u32 bluey;
|
|
|
|
__u32 whitey;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fb_monspecs {
|
|
|
|
struct fb_chroma chroma;
|
|
|
|
struct fb_videomode *modedb; /* mode database */
|
|
|
|
__u8 manufacturer[4]; /* Manufacturer */
|
|
|
|
__u8 monitor[14]; /* Monitor String */
|
|
|
|
__u8 serial_no[14]; /* Serial Number */
|
|
|
|
__u8 ascii[14]; /* ? */
|
|
|
|
__u32 modedb_len; /* mode database length */
|
|
|
|
__u32 model; /* Monitor Model */
|
|
|
|
__u32 serial; /* Serial Number - Integer */
|
|
|
|
__u32 year; /* Year manufactured */
|
|
|
|
__u32 week; /* Week Manufactured */
|
|
|
|
__u32 hfmin; /* hfreq lower limit (Hz) */
|
|
|
|
__u32 hfmax; /* hfreq upper limit (Hz) */
|
|
|
|
__u32 dclkmin; /* pixelclock lower limit (Hz) */
|
|
|
|
__u32 dclkmax; /* pixelclock upper limit (Hz) */
|
|
|
|
__u16 input; /* display type - see FB_DISP_* */
|
|
|
|
__u16 dpms; /* DPMS support - see FB_DPMS_ */
|
|
|
|
__u16 signal; /* Signal Type - see FB_SIGNAL_* */
|
|
|
|
__u16 vfmin; /* vfreq lower limit (Hz) */
|
|
|
|
__u16 vfmax; /* vfreq upper limit (Hz) */
|
|
|
|
__u16 gamma; /* Gamma - in fractions of 100 */
|
|
|
|
__u16 gtf : 1; /* supports GTF */
|
|
|
|
__u16 misc; /* Misc flags - see FB_MISC_* */
|
|
|
|
__u8 version; /* EDID version... */
|
|
|
|
__u8 revision; /* ...and revision */
|
|
|
|
__u8 max_x; /* Maximum horizontal size (cm) */
|
|
|
|
__u8 max_y; /* Maximum vertical size (cm) */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fb_cmap_user {
|
|
|
|
__u32 start; /* First entry */
|
|
|
|
__u32 len; /* Number of entries */
|
|
|
|
__u16 __user *red; /* Red values */
|
|
|
|
__u16 __user *green;
|
|
|
|
__u16 __user *blue;
|
|
|
|
__u16 __user *transp; /* transparency, can be NULL */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fb_image_user {
|
|
|
|
__u32 dx; /* Where to place image */
|
|
|
|
__u32 dy;
|
|
|
|
__u32 width; /* Size of image */
|
|
|
|
__u32 height;
|
|
|
|
__u32 fg_color; /* Only used when a mono bitmap */
|
|
|
|
__u32 bg_color;
|
|
|
|
__u8 depth; /* Depth of the image */
|
|
|
|
const char __user *data; /* Pointer to image data */
|
|
|
|
struct fb_cmap_user cmap; /* color map info */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fb_cursor_user {
|
|
|
|
__u16 set; /* what to set */
|
|
|
|
__u16 enable; /* cursor on/off */
|
|
|
|
__u16 rop; /* bitop operation */
|
|
|
|
const char __user *mask; /* cursor mask bits */
|
|
|
|
struct fbcurpos hot; /* cursor hot spot */
|
|
|
|
struct fb_image_user image; /* Cursor image */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Register/unregister for framebuffer events
|
|
|
|
*/
|
|
|
|
|
2020-07-29 16:41:44 +03:00
|
|
|
/* The resolution of the passed in fb_info about to change */
|
2005-04-17 02:20:36 +04:00
|
|
|
#define FB_EVENT_MODE_CHANGE 0x01
|
2019-05-28 12:02:41 +03:00
|
|
|
|
|
|
|
#ifdef CONFIG_GUMSTIX_AM200EPD
|
|
|
|
/* only used by mach-pxa/am200epd.c */
|
2005-04-17 02:20:36 +04:00
|
|
|
#define FB_EVENT_FB_REGISTERED 0x05
|
2006-06-26 11:27:09 +04:00
|
|
|
#define FB_EVENT_FB_UNREGISTERED 0x06
|
2019-05-28 12:02:41 +03:00
|
|
|
#endif
|
|
|
|
|
2019-05-28 12:02:55 +03:00
|
|
|
/* A display blank is requested */
|
2006-06-26 11:27:09 +04:00
|
|
|
#define FB_EVENT_BLANK 0x09
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
struct fb_event {
|
|
|
|
struct fb_info *info;
|
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
2007-05-08 11:39:37 +04:00
|
|
|
struct fb_blit_caps {
|
|
|
|
u32 x;
|
|
|
|
u32 y;
|
|
|
|
u32 len;
|
|
|
|
u32 flags;
|
|
|
|
};
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2015-11-25 06:11:48 +03:00
|
|
|
#ifdef CONFIG_FB_NOTIFY
|
2005-04-17 02:20:36 +04:00
|
|
|
extern int fb_register_client(struct notifier_block *nb);
|
|
|
|
extern int fb_unregister_client(struct notifier_block *nb);
|
2006-07-30 14:04:17 +04:00
|
|
|
extern int fb_notifier_call_chain(unsigned long val, void *v);
|
2015-11-25 06:11:48 +03:00
|
|
|
#else
|
|
|
|
static inline int fb_register_client(struct notifier_block *nb)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline int fb_unregister_client(struct notifier_block *nb)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline int fb_notifier_call_chain(unsigned long val, void *v)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* Pixmap structure definition
|
|
|
|
*
|
|
|
|
* The purpose of this structure is to translate data
|
|
|
|
* from the hardware independent format of fbdev to what
|
|
|
|
* format the hardware needs.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define FB_PIXMAP_DEFAULT 1 /* used internally by fbcon */
|
|
|
|
#define FB_PIXMAP_SYSTEM 2 /* memory is in system RAM */
|
|
|
|
#define FB_PIXMAP_IO 4 /* memory is iomapped */
|
|
|
|
#define FB_PIXMAP_SYNC 256 /* set if GPU can DMA */
|
|
|
|
|
|
|
|
struct fb_pixmap {
|
|
|
|
u8 *addr; /* pointer to memory */
|
|
|
|
u32 size; /* size of buffer in bytes */
|
|
|
|
u32 offset; /* current offset to buffer */
|
|
|
|
u32 buf_align; /* byte alignment of each bitmap */
|
|
|
|
u32 scan_align; /* alignment per scanline */
|
2005-06-22 04:16:58 +04:00
|
|
|
u32 access_align; /* alignment per read/write (bits) */
|
2005-04-17 02:20:36 +04:00
|
|
|
u32 flags; /* see FB_PIXMAP_* */
|
2007-05-08 11:39:09 +04:00
|
|
|
u32 blit_x; /* supported bit block dimensions (1-32)*/
|
|
|
|
u32 blit_y; /* Format: blit_x = 1 << (width - 1) */
|
|
|
|
/* blit_y = 1 << (height - 1) */
|
|
|
|
/* if 0, will be set to 0xffffffff (all)*/
|
2005-04-17 02:20:36 +04:00
|
|
|
/* access methods */
|
2005-06-22 04:16:58 +04:00
|
|
|
void (*writeio)(struct fb_info *info, void __iomem *dst, void *src, unsigned int size);
|
|
|
|
void (*readio) (struct fb_info *info, void *dst, void __iomem *src, unsigned int size);
|
2005-04-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
|
2007-05-08 11:37:37 +04:00
|
|
|
#ifdef CONFIG_FB_DEFERRED_IO
|
|
|
|
struct fb_deferred_io {
|
|
|
|
/* delay between mkwrite and deferred handler */
|
|
|
|
unsigned long delay;
|
|
|
|
struct mutex lock; /* mutex that protects the page list */
|
|
|
|
struct list_head pagelist; /* list of touched pages */
|
|
|
|
/* callback */
|
2012-04-28 14:19:10 +04:00
|
|
|
void (*first_io)(struct fb_info *info);
|
2007-05-08 11:37:37 +04:00
|
|
|
void (*deferred_io)(struct fb_info *info, struct list_head *pagelist);
|
|
|
|
};
|
|
|
|
#endif
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Frame buffer operations
|
|
|
|
*
|
|
|
|
* LOCKING NOTE: those functions must _ALL_ be called with the console
|
2006-06-30 20:20:44 +04:00
|
|
|
* semaphore held, this is the only suitable locking mechanism we have
|
2005-04-17 02:20:36 +04:00
|
|
|
* in 2.6. Some may be called at interrupt time at this point though.
|
2010-08-02 23:05:41 +04:00
|
|
|
*
|
|
|
|
* The exception to this is the debug related hooks. Putting the fb
|
|
|
|
* into a debug state (e.g. flipping to the kernel console) and restoring
|
|
|
|
* it must be done in a lock-free manner, so low level drivers should
|
|
|
|
* keep track of the initial console (if applicable) and may need to
|
|
|
|
* perform direct, unlocked hardware writes in these hooks.
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
struct fb_ops {
|
|
|
|
/* open/release and usage marking */
|
|
|
|
struct module *owner;
|
|
|
|
int (*fb_open)(struct fb_info *info, int user);
|
|
|
|
int (*fb_release)(struct fb_info *info, int user);
|
|
|
|
|
|
|
|
/* For framebuffers with strange non linear layouts or that do not
|
|
|
|
* work with normal memory mapped access
|
|
|
|
*/
|
2007-05-08 11:39:02 +04:00
|
|
|
ssize_t (*fb_read)(struct fb_info *info, char __user *buf,
|
|
|
|
size_t count, loff_t *ppos);
|
|
|
|
ssize_t (*fb_write)(struct fb_info *info, const char __user *buf,
|
|
|
|
size_t count, loff_t *ppos);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* checks var and eventually tweaks it to something supported,
|
|
|
|
* DO NOT MODIFY PAR */
|
|
|
|
int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);
|
|
|
|
|
|
|
|
/* set the video mode according to info->var */
|
|
|
|
int (*fb_set_par)(struct fb_info *info);
|
|
|
|
|
|
|
|
/* set color register */
|
|
|
|
int (*fb_setcolreg)(unsigned regno, unsigned red, unsigned green,
|
|
|
|
unsigned blue, unsigned transp, struct fb_info *info);
|
|
|
|
|
2005-05-01 19:59:22 +04:00
|
|
|
/* set color registers in batch */
|
|
|
|
int (*fb_setcmap)(struct fb_cmap *cmap, struct fb_info *info);
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* blank display */
|
|
|
|
int (*fb_blank)(int blank, struct fb_info *info);
|
|
|
|
|
|
|
|
/* pan display */
|
|
|
|
int (*fb_pan_display)(struct fb_var_screeninfo *var, struct fb_info *info);
|
|
|
|
|
|
|
|
/* Draws a rectangle */
|
|
|
|
void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect);
|
|
|
|
/* Copy data from area to another */
|
|
|
|
void (*fb_copyarea) (struct fb_info *info, const struct fb_copyarea *region);
|
|
|
|
/* Draws a image to the display */
|
|
|
|
void (*fb_imageblit) (struct fb_info *info, const struct fb_image *image);
|
|
|
|
|
|
|
|
/* Draws cursor */
|
|
|
|
int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor);
|
|
|
|
|
|
|
|
/* wait for blit idle, optional */
|
|
|
|
int (*fb_sync)(struct fb_info *info);
|
|
|
|
|
|
|
|
/* perform fb specific ioctl (optional) */
|
2006-01-15 00:21:25 +03:00
|
|
|
int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,
|
|
|
|
unsigned long arg);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* Handle 32bit compat ioctl (optional) */
|
2006-01-15 00:21:25 +03:00
|
|
|
int (*fb_compat_ioctl)(struct fb_info *info, unsigned cmd,
|
|
|
|
unsigned long arg);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* perform fb specific mmap */
|
2006-01-15 00:21:25 +03:00
|
|
|
int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);
|
2005-12-13 09:17:16 +03:00
|
|
|
|
2007-05-08 11:39:37 +04:00
|
|
|
/* get capability given var */
|
|
|
|
void (*fb_get_caps)(struct fb_info *info, struct fb_blit_caps *caps,
|
|
|
|
struct fb_var_screeninfo *var);
|
2009-06-17 02:34:38 +04:00
|
|
|
|
|
|
|
/* teardown any resources to do with this framebuffer */
|
|
|
|
void (*fb_destroy)(struct fb_info *info);
|
2010-08-02 23:05:41 +04:00
|
|
|
|
|
|
|
/* called at KDB enter and leave time to prepare the console */
|
|
|
|
int (*fb_debug_enter)(struct fb_info *info);
|
|
|
|
int (*fb_debug_leave)(struct fb_info *info);
|
2005-04-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_FB_TILEBLITTING
|
|
|
|
#define FB_TILE_CURSOR_NONE 0
|
|
|
|
#define FB_TILE_CURSOR_UNDERLINE 1
|
|
|
|
#define FB_TILE_CURSOR_LOWER_THIRD 2
|
|
|
|
#define FB_TILE_CURSOR_LOWER_HALF 3
|
|
|
|
#define FB_TILE_CURSOR_TWO_THIRDS 4
|
|
|
|
#define FB_TILE_CURSOR_BLOCK 5
|
|
|
|
|
|
|
|
struct fb_tilemap {
|
|
|
|
__u32 width; /* width of each tile in pixels */
|
|
|
|
__u32 height; /* height of each tile in scanlines */
|
|
|
|
__u32 depth; /* color depth of each tile */
|
|
|
|
__u32 length; /* number of tiles in the map */
|
2005-09-13 12:25:44 +04:00
|
|
|
const __u8 *data; /* actual tile map: a bitmap array, packed
|
2005-04-17 02:20:36 +04:00
|
|
|
to the nearest byte */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fb_tilerect {
|
|
|
|
__u32 sx; /* origin in the x-axis */
|
|
|
|
__u32 sy; /* origin in the y-axis */
|
|
|
|
__u32 width; /* number of tiles in the x-axis */
|
|
|
|
__u32 height; /* number of tiles in the y-axis */
|
|
|
|
__u32 index; /* what tile to use: index to tile map */
|
|
|
|
__u32 fg; /* foreground color */
|
|
|
|
__u32 bg; /* background color */
|
|
|
|
__u32 rop; /* raster operation */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fb_tilearea {
|
|
|
|
__u32 sx; /* source origin in the x-axis */
|
|
|
|
__u32 sy; /* source origin in the y-axis */
|
|
|
|
__u32 dx; /* destination origin in the x-axis */
|
|
|
|
__u32 dy; /* destination origin in the y-axis */
|
|
|
|
__u32 width; /* number of tiles in the x-axis */
|
|
|
|
__u32 height; /* number of tiles in the y-axis */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fb_tileblit {
|
|
|
|
__u32 sx; /* origin in the x-axis */
|
|
|
|
__u32 sy; /* origin in the y-axis */
|
|
|
|
__u32 width; /* number of tiles in the x-axis */
|
|
|
|
__u32 height; /* number of tiles in the y-axis */
|
|
|
|
__u32 fg; /* foreground color */
|
|
|
|
__u32 bg; /* background color */
|
|
|
|
__u32 length; /* number of tiles to draw */
|
|
|
|
__u32 *indices; /* array of indices to tile map */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fb_tilecursor {
|
|
|
|
__u32 sx; /* cursor position in the x-axis */
|
|
|
|
__u32 sy; /* cursor position in the y-axis */
|
|
|
|
__u32 mode; /* 0 = erase, 1 = draw */
|
|
|
|
__u32 shape; /* see FB_TILE_CURSOR_* */
|
|
|
|
__u32 fg; /* foreground color */
|
|
|
|
__u32 bg; /* background color */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fb_tile_ops {
|
|
|
|
/* set tile characteristics */
|
|
|
|
void (*fb_settile)(struct fb_info *info, struct fb_tilemap *map);
|
|
|
|
|
|
|
|
/* all dimensions from hereon are in terms of tiles */
|
|
|
|
|
|
|
|
/* move a rectangular region of tiles from one area to another*/
|
|
|
|
void (*fb_tilecopy)(struct fb_info *info, struct fb_tilearea *area);
|
|
|
|
/* fill a rectangular region with a tile */
|
|
|
|
void (*fb_tilefill)(struct fb_info *info, struct fb_tilerect *rect);
|
|
|
|
/* copy an array of tiles */
|
|
|
|
void (*fb_tileblit)(struct fb_info *info, struct fb_tileblit *blit);
|
|
|
|
/* cursor */
|
|
|
|
void (*fb_tilecursor)(struct fb_info *info,
|
|
|
|
struct fb_tilecursor *cursor);
|
2007-05-08 11:39:16 +04:00
|
|
|
/* get maximum length of the tile map */
|
|
|
|
int (*fb_get_tilemax)(struct fb_info *info);
|
2005-04-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
#endif /* CONFIG_FB_TILEBLITTING */
|
|
|
|
|
|
|
|
/* FBINFO_* = fb_info.flags bit flags */
|
2017-08-01 18:33:02 +03:00
|
|
|
#define FBINFO_DEFAULT 0
|
2005-04-17 02:20:36 +04:00
|
|
|
#define FBINFO_HWACCEL_DISABLED 0x0002
|
|
|
|
/* When FBINFO_HWACCEL_DISABLED is set:
|
|
|
|
* Hardware acceleration is turned off. Software implementations
|
|
|
|
* of required functions (copyarea(), fillrect(), and imageblit())
|
|
|
|
* takes over; acceleration engine should be in a quiescent state */
|
|
|
|
|
|
|
|
/* hints */
|
2009-12-03 18:31:56 +03:00
|
|
|
#define FBINFO_VIRTFB 0x0004 /* FB is System RAM, not device. */
|
2005-04-17 02:20:36 +04:00
|
|
|
#define FBINFO_PARTIAL_PAN_OK 0x0040 /* otw use pan only for double-buffering */
|
|
|
|
#define FBINFO_READS_FAST 0x0080 /* soft-copy faster than rendering */
|
|
|
|
|
|
|
|
/* hardware supported ops */
|
|
|
|
/* semantics: when a bit is set, it indicates that the operation is
|
|
|
|
* accelerated by hardware.
|
|
|
|
* required functions will still work even if the bit is not set.
|
|
|
|
* optional functions may not even exist if the flag bit is not set.
|
|
|
|
*/
|
|
|
|
#define FBINFO_HWACCEL_NONE 0x0000
|
|
|
|
#define FBINFO_HWACCEL_COPYAREA 0x0100 /* required */
|
|
|
|
#define FBINFO_HWACCEL_FILLRECT 0x0200 /* required */
|
|
|
|
#define FBINFO_HWACCEL_IMAGEBLIT 0x0400 /* required */
|
|
|
|
#define FBINFO_HWACCEL_ROTATE 0x0800 /* optional */
|
|
|
|
#define FBINFO_HWACCEL_XPAN 0x1000 /* optional */
|
|
|
|
#define FBINFO_HWACCEL_YPAN 0x2000 /* optional */
|
|
|
|
#define FBINFO_HWACCEL_YWRAP 0x4000 /* optional */
|
|
|
|
|
|
|
|
#define FBINFO_MISC_TILEBLITTING 0x20000 /* use tile blitting */
|
|
|
|
|
2005-12-13 09:17:19 +03:00
|
|
|
/* A driver may set this flag to indicate that it does want a set_par to be
|
|
|
|
* called every time when fbcon_switch is executed. The advantage is that with
|
2006-03-28 13:56:53 +04:00
|
|
|
* this flag set you can really be sure that set_par is always called before
|
2011-03-31 05:57:33 +04:00
|
|
|
* any of the functions dependent on the correct hardware state or altering
|
2005-12-13 09:17:19 +03:00
|
|
|
* that state, even if you are using some broken X releases. The disadvantage
|
|
|
|
* is that it introduces unwanted delays to every console switch if set_par
|
|
|
|
* is slow. It is a good idea to try this flag in the drivers initialization
|
|
|
|
* code whenever there is a bug report related to switching between X and the
|
|
|
|
* framebuffer console.
|
|
|
|
*/
|
|
|
|
#define FBINFO_MISC_ALWAYS_SETPAR 0x40000
|
|
|
|
|
2010-06-23 05:35:41 +04:00
|
|
|
/* where the fb is a firmware driver, and can be replaced with a proper one */
|
|
|
|
#define FBINFO_MISC_FIRMWARE 0x80000
|
2008-04-28 13:14:49 +04:00
|
|
|
/*
|
|
|
|
* Host and GPU endianness differ.
|
|
|
|
*/
|
|
|
|
#define FBINFO_FOREIGN_ENDIAN 0x100000
|
|
|
|
/*
|
|
|
|
* Big endian math. This is the same flags as above, but with different
|
|
|
|
* meaning, it is set by the fb subsystem depending FOREIGN_ENDIAN flag
|
|
|
|
* and host endianness. Drivers should not use this flag.
|
|
|
|
*/
|
|
|
|
#define FBINFO_BE_MATH 0x100000
|
2018-08-22 11:54:04 +03:00
|
|
|
/*
|
|
|
|
* Hide smem_start in the FBIOGET_FSCREENINFO IOCTL. This is used by modern DRM
|
|
|
|
* drivers to stop userspace from trying to share buffers behind the kernel's
|
|
|
|
* back. Instead dma-buf based buffer sharing should be used.
|
|
|
|
*/
|
|
|
|
#define FBINFO_HIDE_SMEM_START 0x200000
|
|
|
|
|
2008-04-28 13:14:49 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
struct fb_info {
|
2011-05-12 01:49:36 +04:00
|
|
|
atomic_t count;
|
2005-04-17 02:20:36 +04:00
|
|
|
int node;
|
|
|
|
int flags;
|
2017-11-25 22:35:47 +03:00
|
|
|
/*
|
|
|
|
* -1 by default, set to a FB_ROTATE_* value by the driver, if it knows
|
|
|
|
* a lcd is not mounted upright and fbcon should rotate to compensate.
|
|
|
|
*/
|
|
|
|
int fbcon_rotate_hint;
|
2008-10-19 07:27:51 +04:00
|
|
|
struct mutex lock; /* Lock for open/release/ioctl funcs */
|
2009-06-30 22:41:29 +04:00
|
|
|
struct mutex mm_lock; /* Lock for fb_mmap and smem_* fields */
|
2005-04-17 02:20:36 +04:00
|
|
|
struct fb_var_screeninfo var; /* Current var */
|
|
|
|
struct fb_fix_screeninfo fix; /* Current fix */
|
|
|
|
struct fb_monspecs monspecs; /* Current Monitor specs */
|
|
|
|
struct work_struct queue; /* Framebuffer event queue */
|
|
|
|
struct fb_pixmap pixmap; /* Image hardware mapper */
|
|
|
|
struct fb_pixmap sprite; /* Cursor hardware mapper */
|
|
|
|
struct fb_cmap cmap; /* Current cmap */
|
|
|
|
struct list_head modelist; /* mode list */
|
|
|
|
struct fb_videomode *mode; /* current mode */
|
2006-06-25 16:47:08 +04:00
|
|
|
|
2018-12-20 21:13:07 +03:00
|
|
|
#if IS_ENABLED(CONFIG_FB_BACKLIGHT)
|
2006-06-25 16:47:08 +04:00
|
|
|
/* assigned backlight device */
|
2020-07-29 16:41:44 +03:00
|
|
|
/* set before framebuffer registration,
|
2007-02-10 17:10:33 +03:00
|
|
|
remove after unregister */
|
2006-06-25 16:47:08 +04:00
|
|
|
struct backlight_device *bl_dev;
|
|
|
|
|
|
|
|
/* Backlight level curve */
|
2020-07-29 16:41:44 +03:00
|
|
|
struct mutex bl_curve_mutex;
|
2006-06-25 16:47:08 +04:00
|
|
|
u8 bl_curve[FB_BACKLIGHT_LEVELS];
|
|
|
|
#endif
|
2007-05-08 11:37:37 +04:00
|
|
|
#ifdef CONFIG_FB_DEFERRED_IO
|
|
|
|
struct delayed_work deferred_work;
|
|
|
|
struct fb_deferred_io *fbdefio;
|
|
|
|
#endif
|
2006-06-25 16:47:08 +04:00
|
|
|
|
2019-12-03 19:38:47 +03:00
|
|
|
const struct fb_ops *fbops;
|
2006-09-14 18:30:59 +04:00
|
|
|
struct device *device; /* This is the parent */
|
|
|
|
struct device *dev; /* This is this fb device */
|
2006-10-03 12:14:50 +04:00
|
|
|
int class_flag; /* private sysfs flags */
|
2005-04-17 02:20:36 +04:00
|
|
|
#ifdef CONFIG_FB_TILEBLITTING
|
|
|
|
struct fb_tile_ops *tileops; /* Tile Blitting */
|
|
|
|
#endif
|
2015-10-07 10:20:12 +03:00
|
|
|
union {
|
|
|
|
char __iomem *screen_base; /* Virtual address */
|
|
|
|
char *screen_buffer;
|
|
|
|
};
|
2020-07-29 16:41:44 +03:00
|
|
|
unsigned long screen_size; /* Amount of ioremapped VRAM or 0 */
|
|
|
|
void *pseudo_palette; /* Fake palette of 16 colors */
|
2005-04-17 02:20:36 +04:00
|
|
|
#define FBINFO_STATE_RUNNING 0
|
|
|
|
#define FBINFO_STATE_SUSPENDED 1
|
|
|
|
u32 state; /* Hardware state i.e suspend */
|
|
|
|
void *fbcon_par; /* fbcon use-only private area */
|
|
|
|
/* From here on everything is device dependent */
|
2009-06-17 02:34:38 +04:00
|
|
|
void *par;
|
2011-03-31 05:57:33 +04:00
|
|
|
/* we need the PCI or similar aperture base/size not
|
2009-06-17 02:34:38 +04:00
|
|
|
smem_start/size as smem_start may just be an object
|
|
|
|
allocated inside the aperture so may not actually overlap */
|
2010-05-16 19:27:03 +04:00
|
|
|
struct apertures_struct {
|
|
|
|
unsigned int count;
|
|
|
|
struct aperture {
|
|
|
|
resource_size_t base;
|
|
|
|
resource_size_t size;
|
|
|
|
} ranges[0];
|
|
|
|
} *apertures;
|
2013-02-04 17:37:21 +04:00
|
|
|
|
|
|
|
bool skip_vt_switch; /* no VT switch on suspend/resume required */
|
2005-04-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
|
2010-05-16 19:27:03 +04:00
|
|
|
static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
|
2020-06-17 20:56:47 +03:00
|
|
|
struct apertures_struct *a;
|
|
|
|
|
|
|
|
a = kzalloc(struct_size(a, ranges, max_num), GFP_KERNEL);
|
2010-07-15 12:39:47 +04:00
|
|
|
if (!a)
|
|
|
|
return NULL;
|
2010-05-16 19:27:03 +04:00
|
|
|
a->count = max_num;
|
|
|
|
return a;
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#define FBINFO_FLAG_DEFAULT FBINFO_DEFAULT
|
|
|
|
|
|
|
|
/* This will go away
|
|
|
|
* fbset currently hacks in FB_ACCELF_TEXT into var.accel_flags
|
|
|
|
* when it wants to turn the acceleration engine on. This is
|
|
|
|
* really a separate operation, and should be modified via sysfs.
|
|
|
|
* But for now, we leave it broken with the following define
|
|
|
|
*/
|
|
|
|
#define STUPID_ACCELF_TEXT_SHIT
|
|
|
|
|
|
|
|
// This will go away
|
|
|
|
#if defined(__sparc__)
|
|
|
|
|
|
|
|
/* We map all of our framebuffers such that big-endian accesses
|
|
|
|
* are what we want, so the following is sufficient.
|
|
|
|
*/
|
|
|
|
|
|
|
|
// This will go away
|
|
|
|
#define fb_readb sbus_readb
|
|
|
|
#define fb_readw sbus_readw
|
|
|
|
#define fb_readl sbus_readl
|
|
|
|
#define fb_readq sbus_readq
|
|
|
|
#define fb_writeb sbus_writeb
|
|
|
|
#define fb_writew sbus_writew
|
|
|
|
#define fb_writel sbus_writel
|
|
|
|
#define fb_writeq sbus_writeq
|
|
|
|
#define fb_memset sbus_memset_io
|
fbmem: fix fb_read, fb_write unaligned accesses
fb_{read,write} access the framebuffer using lots of fb_{read,write}l's
but don't check that the file position is aligned which can cause problems
on some architectures which do not support unaligned accesses.
Since the operations are essentially memcpy_{from,to}io, new
fb_memcpy_{from,to}fb macros have been defined and these are used instead.
For Sparc, fb_{read,write} macros use sbus_{read,write}, so this defines
new sbus_memcpy_{from,to}io functions the same as memcpy_{from,to}io but
using sbus_{read,write}b instead of {read,write}b.
Signed-off-by: James Hogan <james@albanarts.com>
Acked-by: David S. Miller <davem@davemloft.net>
Acked-by: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-10-28 02:33:28 +04:00
|
|
|
#define fb_memcpy_fromfb sbus_memcpy_fromio
|
|
|
|
#define fb_memcpy_tofb sbus_memcpy_toio
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-01-04 18:53:50 +03:00
|
|
|
#elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) || \
|
|
|
|
defined(__hppa__) || defined(__sh__) || defined(__powerpc__) || \
|
2018-03-09 19:02:41 +03:00
|
|
|
defined(__arm__) || defined(__aarch64__)
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
#define fb_readb __raw_readb
|
|
|
|
#define fb_readw __raw_readw
|
|
|
|
#define fb_readl __raw_readl
|
|
|
|
#define fb_readq __raw_readq
|
|
|
|
#define fb_writeb __raw_writeb
|
|
|
|
#define fb_writew __raw_writew
|
|
|
|
#define fb_writel __raw_writel
|
|
|
|
#define fb_writeq __raw_writeq
|
|
|
|
#define fb_memset memset_io
|
fbmem: fix fb_read, fb_write unaligned accesses
fb_{read,write} access the framebuffer using lots of fb_{read,write}l's
but don't check that the file position is aligned which can cause problems
on some architectures which do not support unaligned accesses.
Since the operations are essentially memcpy_{from,to}io, new
fb_memcpy_{from,to}fb macros have been defined and these are used instead.
For Sparc, fb_{read,write} macros use sbus_{read,write}, so this defines
new sbus_memcpy_{from,to}io functions the same as memcpy_{from,to}io but
using sbus_{read,write}b instead of {read,write}b.
Signed-off-by: James Hogan <james@albanarts.com>
Acked-by: David S. Miller <davem@davemloft.net>
Acked-by: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-10-28 02:33:28 +04:00
|
|
|
#define fb_memcpy_fromfb memcpy_fromio
|
|
|
|
#define fb_memcpy_tofb memcpy_toio
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
#define fb_readb(addr) (*(volatile u8 *) (addr))
|
|
|
|
#define fb_readw(addr) (*(volatile u16 *) (addr))
|
|
|
|
#define fb_readl(addr) (*(volatile u32 *) (addr))
|
|
|
|
#define fb_readq(addr) (*(volatile u64 *) (addr))
|
|
|
|
#define fb_writeb(b,addr) (*(volatile u8 *) (addr) = (b))
|
|
|
|
#define fb_writew(b,addr) (*(volatile u16 *) (addr) = (b))
|
|
|
|
#define fb_writel(b,addr) (*(volatile u32 *) (addr) = (b))
|
|
|
|
#define fb_writeq(b,addr) (*(volatile u64 *) (addr) = (b))
|
|
|
|
#define fb_memset memset
|
fbmem: fix fb_read, fb_write unaligned accesses
fb_{read,write} access the framebuffer using lots of fb_{read,write}l's
but don't check that the file position is aligned which can cause problems
on some architectures which do not support unaligned accesses.
Since the operations are essentially memcpy_{from,to}io, new
fb_memcpy_{from,to}fb macros have been defined and these are used instead.
For Sparc, fb_{read,write} macros use sbus_{read,write}, so this defines
new sbus_memcpy_{from,to}io functions the same as memcpy_{from,to}io but
using sbus_{read,write}b instead of {read,write}b.
Signed-off-by: James Hogan <james@albanarts.com>
Acked-by: David S. Miller <davem@davemloft.net>
Acked-by: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-10-28 02:33:28 +04:00
|
|
|
#define fb_memcpy_fromfb memcpy
|
|
|
|
#define fb_memcpy_tofb memcpy
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2005-12-13 09:17:21 +03:00
|
|
|
#endif
|
|
|
|
|
2008-04-28 13:14:49 +04:00
|
|
|
#define FB_LEFT_POS(p, bpp) (fb_be_math(p) ? (32 - (bpp)) : 0)
|
|
|
|
#define FB_SHIFT_HIGH(p, val, bits) (fb_be_math(p) ? (val) >> (bits) : \
|
|
|
|
(val) << (bits))
|
|
|
|
#define FB_SHIFT_LOW(p, val, bits) (fb_be_math(p) ? (val) << (bits) : \
|
|
|
|
(val) >> (bits))
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* `Generic' versions of the frame buffer device operations
|
|
|
|
*/
|
|
|
|
|
2020-07-29 16:41:44 +03:00
|
|
|
extern int fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var);
|
|
|
|
extern int fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern int fb_blank(struct fb_info *info, int blank);
|
2020-07-29 16:41:44 +03:00
|
|
|
extern void cfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect);
|
|
|
|
extern void cfb_copyarea(struct fb_info *info, const struct fb_copyarea *area);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void cfb_imageblit(struct fb_info *info, const struct fb_image *image);
|
2007-05-08 11:38:57 +04:00
|
|
|
/*
|
|
|
|
* Drawing operations where framebuffer is in system RAM
|
|
|
|
*/
|
|
|
|
extern void sys_fillrect(struct fb_info *info, const struct fb_fillrect *rect);
|
|
|
|
extern void sys_copyarea(struct fb_info *info, const struct fb_copyarea *area);
|
|
|
|
extern void sys_imageblit(struct fb_info *info, const struct fb_image *image);
|
2007-05-08 11:39:03 +04:00
|
|
|
extern ssize_t fb_sys_read(struct fb_info *info, char __user *buf,
|
|
|
|
size_t count, loff_t *ppos);
|
|
|
|
extern ssize_t fb_sys_write(struct fb_info *info, const char __user *buf,
|
|
|
|
size_t count, loff_t *ppos);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* drivers/video/fbmem.c */
|
|
|
|
extern int register_framebuffer(struct fb_info *fb_info);
|
2019-05-28 12:02:49 +03:00
|
|
|
extern void unregister_framebuffer(struct fb_info *fb_info);
|
2019-08-22 12:06:43 +03:00
|
|
|
extern int remove_conflicting_pci_framebuffers(struct pci_dev *pdev,
|
2018-09-01 17:08:45 +03:00
|
|
|
const char *name);
|
2013-12-16 19:57:39 +04:00
|
|
|
extern int remove_conflicting_framebuffers(struct apertures_struct *a,
|
|
|
|
const char *name, bool primary);
|
2005-11-09 08:39:10 +03:00
|
|
|
extern int fb_prepare_logo(struct fb_info *fb_info, int rotate);
|
|
|
|
extern int fb_show_logo(struct fb_info *fb_info, int rotate);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size);
|
2005-06-22 04:17:07 +04:00
|
|
|
extern void fb_pad_unaligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 idx,
|
2005-04-17 02:20:36 +04:00
|
|
|
u32 height, u32 shift_high, u32 shift_low, u32 mod);
|
2005-06-22 04:17:07 +04:00
|
|
|
extern void fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch, u32 height);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void fb_set_suspend(struct fb_info *info, int state);
|
2005-09-10 00:04:37 +04:00
|
|
|
extern int fb_get_color_depth(struct fb_var_screeninfo *var,
|
|
|
|
struct fb_fix_screeninfo *fix);
|
2013-06-18 18:23:05 +04:00
|
|
|
extern int fb_get_options(const char *name, char **option);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern int fb_new_modelist(struct fb_info *info);
|
|
|
|
|
|
|
|
extern struct fb_info *registered_fb[FB_MAX];
|
|
|
|
extern int num_registered_fb;
|
2019-01-16 19:42:35 +03:00
|
|
|
extern bool fb_center_logo;
|
2019-08-27 14:09:21 +03:00
|
|
|
extern int fb_logo_count;
|
2007-06-01 11:46:46 +04:00
|
|
|
extern struct class *fb_class;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2018-07-24 20:11:26 +03:00
|
|
|
#define for_each_registered_fb(i) \
|
|
|
|
for (i = 0; i < FB_MAX; i++) \
|
|
|
|
if (!registered_fb[i]) {} else
|
|
|
|
|
2019-05-28 12:02:47 +03:00
|
|
|
static inline void lock_fb_info(struct fb_info *info)
|
|
|
|
{
|
|
|
|
mutex_lock(&info->lock);
|
|
|
|
}
|
2009-02-05 02:12:03 +03:00
|
|
|
|
|
|
|
static inline void unlock_fb_info(struct fb_info *info)
|
|
|
|
{
|
|
|
|
mutex_unlock(&info->lock);
|
|
|
|
}
|
|
|
|
|
2005-09-10 00:10:04 +04:00
|
|
|
static inline void __fb_pad_aligned_buffer(u8 *dst, u32 d_pitch,
|
|
|
|
u8 *src, u32 s_pitch, u32 height)
|
|
|
|
{
|
2014-05-01 23:32:35 +04:00
|
|
|
u32 i, j;
|
2005-09-10 00:10:04 +04:00
|
|
|
|
|
|
|
d_pitch -= s_pitch;
|
|
|
|
|
|
|
|
for (i = height; i--; ) {
|
|
|
|
/* s_pitch is a few bytes at the most, memcpy is suboptimal */
|
|
|
|
for (j = 0; j < s_pitch; j++)
|
|
|
|
*dst++ = *src++;
|
|
|
|
dst += d_pitch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-08 11:37:37 +04:00
|
|
|
/* drivers/video/fb_defio.c */
|
2016-04-28 18:18:34 +03:00
|
|
|
int fb_deferred_io_mmap(struct fb_info *info, struct vm_area_struct *vma);
|
2007-05-08 11:37:37 +04:00
|
|
|
extern void fb_deferred_io_init(struct fb_info *info);
|
2021-06-01 17:30:30 +03:00
|
|
|
extern void fb_deferred_io_open(struct fb_info *info,
|
|
|
|
struct inode *inode,
|
|
|
|
struct file *file);
|
2007-05-08 11:37:37 +04:00
|
|
|
extern void fb_deferred_io_cleanup(struct fb_info *info);
|
2011-07-17 04:44:56 +04:00
|
|
|
extern int fb_deferred_io_fsync(struct file *file, loff_t start,
|
|
|
|
loff_t end, int datasync);
|
2007-05-08 11:37:37 +04:00
|
|
|
|
2008-04-28 13:14:49 +04:00
|
|
|
static inline bool fb_be_math(struct fb_info *info)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_FB_FOREIGN_ENDIAN
|
|
|
|
#if defined(CONFIG_FB_BOTH_ENDIAN)
|
|
|
|
return info->flags & FBINFO_BE_MATH;
|
|
|
|
#elif defined(CONFIG_FB_BIG_ENDIAN)
|
|
|
|
return true;
|
|
|
|
#elif defined(CONFIG_FB_LITTLE_ENDIAN)
|
|
|
|
return false;
|
|
|
|
#endif /* CONFIG_FB_BOTH_ENDIAN */
|
|
|
|
#else
|
|
|
|
#ifdef __BIG_ENDIAN
|
|
|
|
return true;
|
|
|
|
#else
|
|
|
|
return false;
|
|
|
|
#endif /* __BIG_ENDIAN */
|
|
|
|
#endif /* CONFIG_FB_FOREIGN_ENDIAN */
|
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* drivers/video/fbsysfs.c */
|
|
|
|
extern struct fb_info *framebuffer_alloc(size_t size, struct device *dev);
|
|
|
|
extern void framebuffer_release(struct fb_info *info);
|
2006-09-14 18:30:59 +04:00
|
|
|
extern int fb_init_device(struct fb_info *fb_info);
|
|
|
|
extern void fb_cleanup_device(struct fb_info *head);
|
2006-06-25 16:47:08 +04:00
|
|
|
extern void fb_bl_default_curve(struct fb_info *fb_info, u8 off, u8 min, u8 max);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* drivers/video/fbmon.c */
|
|
|
|
#define FB_MAXTIMINGS 0
|
|
|
|
#define FB_VSYNCTIMINGS 1
|
|
|
|
#define FB_HSYNCTIMINGS 2
|
|
|
|
#define FB_DCLKTIMINGS 3
|
|
|
|
#define FB_IGNOREMON 0x100
|
|
|
|
|
|
|
|
#define FB_MODE_IS_UNKNOWN 0
|
|
|
|
#define FB_MODE_IS_DETAILED 1
|
|
|
|
#define FB_MODE_IS_STANDARD 2
|
|
|
|
#define FB_MODE_IS_VESA 4
|
|
|
|
#define FB_MODE_IS_CALCULATED 8
|
|
|
|
#define FB_MODE_IS_FIRST 16
|
|
|
|
#define FB_MODE_IS_FROM_VAR 32
|
|
|
|
|
|
|
|
extern int fbmon_dpms(const struct fb_info *fb_info);
|
|
|
|
extern int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var,
|
|
|
|
struct fb_info *info);
|
|
|
|
extern int fb_validate_mode(const struct fb_var_screeninfo *var,
|
|
|
|
struct fb_info *info);
|
|
|
|
extern int fb_parse_edid(unsigned char *edid, struct fb_var_screeninfo *var);
|
2005-09-10 00:04:34 +04:00
|
|
|
extern const unsigned char *fb_firmware_edid(struct device *device);
|
|
|
|
extern void fb_edid_to_monspecs(unsigned char *edid,
|
|
|
|
struct fb_monspecs *specs);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void fb_destroy_modedb(struct fb_videomode *modedb);
|
2005-09-10 00:09:58 +04:00
|
|
|
extern int fb_find_mode_cvt(struct fb_videomode *mode, int margins, int rb);
|
2006-10-03 12:14:42 +04:00
|
|
|
extern unsigned char *fb_ddc_read(struct i2c_adapter *adapter);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-11-14 14:12:38 +04:00
|
|
|
extern int of_get_fb_videomode(struct device_node *np,
|
|
|
|
struct fb_videomode *fb,
|
|
|
|
int index);
|
2012-11-14 13:55:04 +04:00
|
|
|
extern int fb_videomode_from_videomode(const struct videomode *vm,
|
|
|
|
struct fb_videomode *fbmode);
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
/* drivers/video/modedb.c */
|
2015-01-14 06:04:25 +03:00
|
|
|
#define VESA_MODEDB_SIZE 43
|
2015-01-14 06:04:26 +03:00
|
|
|
#define DMT_SIZE 0x50
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void fb_var_to_videomode(struct fb_videomode *mode,
|
2007-02-12 11:55:19 +03:00
|
|
|
const struct fb_var_screeninfo *var);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void fb_videomode_to_var(struct fb_var_screeninfo *var,
|
2007-02-12 11:55:19 +03:00
|
|
|
const struct fb_videomode *mode);
|
|
|
|
extern int fb_mode_is_equal(const struct fb_videomode *mode1,
|
|
|
|
const struct fb_videomode *mode2);
|
|
|
|
extern int fb_add_videomode(const struct fb_videomode *mode,
|
|
|
|
struct list_head *head);
|
|
|
|
extern void fb_delete_videomode(const struct fb_videomode *mode,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct list_head *head);
|
2007-02-12 11:55:19 +03:00
|
|
|
extern const struct fb_videomode *fb_match_mode(const struct fb_var_screeninfo *var,
|
|
|
|
struct list_head *head);
|
|
|
|
extern const struct fb_videomode *fb_find_best_mode(const struct fb_var_screeninfo *var,
|
|
|
|
struct list_head *head);
|
|
|
|
extern const struct fb_videomode *fb_find_nearest_mode(const struct fb_videomode *mode,
|
|
|
|
struct list_head *head);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void fb_destroy_modelist(struct list_head *head);
|
2007-02-12 11:55:19 +03:00
|
|
|
extern void fb_videomode_to_modelist(const struct fb_videomode *modedb, int num,
|
2005-04-17 02:20:36 +04:00
|
|
|
struct list_head *head);
|
2007-02-12 11:55:19 +03:00
|
|
|
extern const struct fb_videomode *fb_find_best_display(const struct fb_monspecs *specs,
|
|
|
|
struct list_head *head);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* drivers/video/fbcmap.c */
|
|
|
|
extern int fb_alloc_cmap(struct fb_cmap *cmap, int len, int transp);
|
2010-11-16 12:11:02 +03:00
|
|
|
extern int fb_alloc_cmap_gfp(struct fb_cmap *cmap, int len, int transp, gfp_t flags);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void fb_dealloc_cmap(struct fb_cmap *cmap);
|
2006-12-08 13:40:27 +03:00
|
|
|
extern int fb_copy_cmap(const struct fb_cmap *from, struct fb_cmap *to);
|
|
|
|
extern int fb_cmap_to_user(const struct fb_cmap *from, struct fb_cmap_user *to);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern int fb_set_cmap(struct fb_cmap *cmap, struct fb_info *fb_info);
|
|
|
|
extern int fb_set_user_cmap(struct fb_cmap_user *cmap, struct fb_info *fb_info);
|
2006-12-08 13:40:27 +03:00
|
|
|
extern const struct fb_cmap *fb_default_cmap(int len);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void fb_invert_cmaps(void);
|
|
|
|
|
|
|
|
struct fb_videomode {
|
|
|
|
const char *name; /* optional */
|
|
|
|
u32 refresh; /* optional */
|
|
|
|
u32 xres;
|
|
|
|
u32 yres;
|
|
|
|
u32 pixclock;
|
|
|
|
u32 left_margin;
|
|
|
|
u32 right_margin;
|
|
|
|
u32 upper_margin;
|
|
|
|
u32 lower_margin;
|
|
|
|
u32 hsync_len;
|
|
|
|
u32 vsync_len;
|
|
|
|
u32 sync;
|
|
|
|
u32 vmode;
|
|
|
|
u32 flag;
|
|
|
|
};
|
|
|
|
|
2015-01-14 06:04:26 +03:00
|
|
|
struct dmt_videomode {
|
|
|
|
u32 dmt_id;
|
|
|
|
u32 std_2byte_code;
|
|
|
|
u32 cvt_3byte_code;
|
|
|
|
const struct fb_videomode *mode;
|
|
|
|
};
|
|
|
|
|
2007-10-16 12:29:51 +04:00
|
|
|
extern const char *fb_mode_option;
|
2005-04-17 02:20:36 +04:00
|
|
|
extern const struct fb_videomode vesa_modes[];
|
2015-01-14 06:04:26 +03:00
|
|
|
extern const struct dmt_videomode dmt_modes[];
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
struct fb_modelist {
|
|
|
|
struct list_head list;
|
|
|
|
struct fb_videomode mode;
|
|
|
|
};
|
|
|
|
|
|
|
|
extern int fb_find_mode(struct fb_var_screeninfo *var,
|
|
|
|
struct fb_info *info, const char *mode_option,
|
|
|
|
const struct fb_videomode *db,
|
|
|
|
unsigned int dbsize,
|
|
|
|
const struct fb_videomode *default_mode,
|
|
|
|
unsigned int default_bpp);
|
|
|
|
|
2013-09-20 05:35:54 +04:00
|
|
|
/* Convenience logging macros */
|
|
|
|
#define fb_err(fb_info, fmt, ...) \
|
|
|
|
pr_err("fb%d: " fmt, (fb_info)->node, ##__VA_ARGS__)
|
|
|
|
#define fb_notice(info, fmt, ...) \
|
|
|
|
pr_notice("fb%d: " fmt, (fb_info)->node, ##__VA_ARGS__)
|
|
|
|
#define fb_warn(fb_info, fmt, ...) \
|
|
|
|
pr_warn("fb%d: " fmt, (fb_info)->node, ##__VA_ARGS__)
|
|
|
|
#define fb_info(fb_info, fmt, ...) \
|
|
|
|
pr_info("fb%d: " fmt, (fb_info)->node, ##__VA_ARGS__)
|
|
|
|
#define fb_dbg(fb_info, fmt, ...) \
|
|
|
|
pr_debug("fb%d: " fmt, (fb_info)->node, ##__VA_ARGS__)
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif /* _LINUX_FB_H */
|