2005-04-16 16:20:36 -06:00
|
|
|
#ifndef _LINUX_FB_H
|
|
|
|
#define _LINUX_FB_H
|
|
|
|
|
2010-08-02 13:05:41 -06:00
|
|
|
#include <linux/kgdb.h>
|
2012-10-13 03:46:48 -06:00
|
|
|
#include <uapi/linux/fb.h>
|
2005-04-16 16:20:36 -06: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 00:24:26 -06:00
|
|
|
#include <linux/backlight.h>
|
2010-05-16 09:27:03 -06:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/io.h>
|
|
|
|
|
|
|
|
struct vm_area_struct;
|
|
|
|
struct fb_info;
|
|
|
|
struct device;
|
|
|
|
struct file;
|
2012-11-14 02:55:04 -07:00
|
|
|
struct videomode;
|
2012-11-14 03:12:38 -07:00
|
|
|
struct device_node;
|
2005-04-16 16:20:36 -06: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-26 16:35:37 -06:00
|
|
|
#define FB_MISC_HDMI 4
|
2005-04-16 16:20:36 -06: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
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* The resolution of the passed in fb_info about to change */
|
|
|
|
#define FB_EVENT_MODE_CHANGE 0x01
|
|
|
|
/* The display on this fb_info is beeing suspended, no access to the
|
|
|
|
* framebuffer is allowed any more after that call returns
|
|
|
|
*/
|
|
|
|
#define FB_EVENT_SUSPEND 0x02
|
|
|
|
/* The display on this fb_info was resumed, you can restore the display
|
|
|
|
* if you own it
|
|
|
|
*/
|
|
|
|
#define FB_EVENT_RESUME 0x03
|
|
|
|
/* An entry from the modelist was removed */
|
|
|
|
#define FB_EVENT_MODE_DELETE 0x04
|
|
|
|
/* A driver registered itself */
|
|
|
|
#define FB_EVENT_FB_REGISTERED 0x05
|
2006-06-26 01:27:09 -06:00
|
|
|
/* A driver unregistered itself */
|
|
|
|
#define FB_EVENT_FB_UNREGISTERED 0x06
|
[PATCH] fbcon: Console Rotation - Prepare fbcon for console rotation
This patch series implements generic code to rotate the console at 90, 180,
and 270 degrees. The implementation is completely done in the framebuffer
console level, thus no changes to the framebuffer layer or to the drivers
are needed.
Console rotation is required by some Sharp-based devices where the natural
orientation of the display is not at 0 degrees. Also, users that have
displays that can pivot will benefit by having a console in portrait mode
if they so desire.
The choice to implement the code in the console layer rather than in the
framebuffer layer is due to the following reasons:
- it's fast
- it does not require driver changes
- it can coexist with devices that can rotate the display at the hardware level
- it complements graphics applications that can do display rotation
The changes to core fbcon are minimal-- recognition of the console
rotation angle so it can swap directions, origins and axes (xres vs yres,
xpanstep vs ypanstep, xoffset vs yoffset, etc) and storage of the rotation
angle per display. The bulk of the code that does the actual drawing to the
screen are placed in separate files. Each angle of rotation has separate
methods (bmove, clear, putcs, cursor, update_start which is derived from
update_var, and clear_margins). To mimimize processing time, the fontdata
are pre-rotated at each console switch (only if the font or the angle has
changed).
The option can be compiled out (CONFIG_FRAMEBUFFER_CONSOLE_ROTATION = n) if
rotation is not needed.
Choosing the rotation angle can be done in several ways:
1. boot option fbcon=rotate:n, where
n = 0 - normal
n = 1 - 90 degrees (clockwise)
n = 2 - 180 degrees (upside down)
n = 3 - 270 degrees (counterclockwise)
2. echo n > /sys/class/graphics/fb[num]/con_rotate
where n is the same as described above. It sets the angle of rotation
of the current console
3 echo n > /sys/class/graphics/fb[num]/con_rotate_all
where n is the same as described above. Globally sets the angle of
rotation.
GOTCHAS:
The option, especially at angles of 90 and 270 degrees, will exercise
the least used code of drivers. Namely, at these angles, panning is done
in the x-axis, so it can reveal bugs in the driver if xpanstep is set
incorrectly. A workaround is to set xpanstep = 0.
Secondly, at these angles, the framebuffer memory access can be
unaligned if (fontheight * bpp) % 32 ~= 0 which can reveal bugs in the drivers
imageblit, fillrect and copyarea functions. (I think cfbfillrect may have
this buglet). A workaround is to use a standard 8x16 font.
Speed:
The scrolling speed difference between 0 and 180 degrees is minimal,
somewhere areound 1-2%. At 90 or 270 degress, speed drops down to a vicinity
of 30-40%. This is understandable because the blit direction is across the
framebuffer "direction." Scrolling will be helped at these angles if xpanstep
is not equal to zero, use of 8x16 fonts, and setting xres_virtual >= xres * 2.
Note: The code is tested on little-endian only, so I don't know if it will
work in big-endian. Please let me know, it will take only less than a minute
of your time.
This patch prepares fbcon for console rotation and contains the following
changes:
- add rotate field in struct fbcon_ops to keep fbcon's current rotation
angle
- add con_rotate field in struct display to store per-display rotation angle
- create a private copy of the current var to fbcon. This will prevent
fbcon from directly manipulating info->var, especially the fields xoffset,
yoffset and vmode.
- add ability to swap pertinent axes (xres, yres; xpanstep, ypanstep; etc)
depending on the rotation angle
- change global update_var() (function that sets the screen start address)
as an fbcon method update_start. This is required because the axes, start
offset, and/or direction can be reversed depending on the rotation angle.
- add fbcon method rotate_font() which will rotate each character bitmap to
the correct angle of rotation.
- add fbcon boot option 'rotate' to select the angle of rotation at bootime.
Currently does nothing until all patches are applied.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-11-08 22:39:09 -07:00
|
|
|
/* CONSOLE-SPECIFIC: get console to framebuffer mapping */
|
2006-06-26 01:27:09 -06:00
|
|
|
#define FB_EVENT_GET_CONSOLE_MAP 0x07
|
[PATCH] fbcon: Console Rotation - Prepare fbcon for console rotation
This patch series implements generic code to rotate the console at 90, 180,
and 270 degrees. The implementation is completely done in the framebuffer
console level, thus no changes to the framebuffer layer or to the drivers
are needed.
Console rotation is required by some Sharp-based devices where the natural
orientation of the display is not at 0 degrees. Also, users that have
displays that can pivot will benefit by having a console in portrait mode
if they so desire.
The choice to implement the code in the console layer rather than in the
framebuffer layer is due to the following reasons:
- it's fast
- it does not require driver changes
- it can coexist with devices that can rotate the display at the hardware level
- it complements graphics applications that can do display rotation
The changes to core fbcon are minimal-- recognition of the console
rotation angle so it can swap directions, origins and axes (xres vs yres,
xpanstep vs ypanstep, xoffset vs yoffset, etc) and storage of the rotation
angle per display. The bulk of the code that does the actual drawing to the
screen are placed in separate files. Each angle of rotation has separate
methods (bmove, clear, putcs, cursor, update_start which is derived from
update_var, and clear_margins). To mimimize processing time, the fontdata
are pre-rotated at each console switch (only if the font or the angle has
changed).
The option can be compiled out (CONFIG_FRAMEBUFFER_CONSOLE_ROTATION = n) if
rotation is not needed.
Choosing the rotation angle can be done in several ways:
1. boot option fbcon=rotate:n, where
n = 0 - normal
n = 1 - 90 degrees (clockwise)
n = 2 - 180 degrees (upside down)
n = 3 - 270 degrees (counterclockwise)
2. echo n > /sys/class/graphics/fb[num]/con_rotate
where n is the same as described above. It sets the angle of rotation
of the current console
3 echo n > /sys/class/graphics/fb[num]/con_rotate_all
where n is the same as described above. Globally sets the angle of
rotation.
GOTCHAS:
The option, especially at angles of 90 and 270 degrees, will exercise
the least used code of drivers. Namely, at these angles, panning is done
in the x-axis, so it can reveal bugs in the driver if xpanstep is set
incorrectly. A workaround is to set xpanstep = 0.
Secondly, at these angles, the framebuffer memory access can be
unaligned if (fontheight * bpp) % 32 ~= 0 which can reveal bugs in the drivers
imageblit, fillrect and copyarea functions. (I think cfbfillrect may have
this buglet). A workaround is to use a standard 8x16 font.
Speed:
The scrolling speed difference between 0 and 180 degrees is minimal,
somewhere areound 1-2%. At 90 or 270 degress, speed drops down to a vicinity
of 30-40%. This is understandable because the blit direction is across the
framebuffer "direction." Scrolling will be helped at these angles if xpanstep
is not equal to zero, use of 8x16 fonts, and setting xres_virtual >= xres * 2.
Note: The code is tested on little-endian only, so I don't know if it will
work in big-endian. Please let me know, it will take only less than a minute
of your time.
This patch prepares fbcon for console rotation and contains the following
changes:
- add rotate field in struct fbcon_ops to keep fbcon's current rotation
angle
- add con_rotate field in struct display to store per-display rotation angle
- create a private copy of the current var to fbcon. This will prevent
fbcon from directly manipulating info->var, especially the fields xoffset,
yoffset and vmode.
- add ability to swap pertinent axes (xres, yres; xpanstep, ypanstep; etc)
depending on the rotation angle
- change global update_var() (function that sets the screen start address)
as an fbcon method update_start. This is required because the axes, start
offset, and/or direction can be reversed depending on the rotation angle.
- add fbcon method rotate_font() which will rotate each character bitmap to
the correct angle of rotation.
- add fbcon boot option 'rotate' to select the angle of rotation at bootime.
Currently does nothing until all patches are applied.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-11-08 22:39:09 -07:00
|
|
|
/* CONSOLE-SPECIFIC: set console to framebuffer mapping */
|
2006-06-26 01:27:09 -06:00
|
|
|
#define FB_EVENT_SET_CONSOLE_MAP 0x08
|
2011-03-30 19:57:33 -06:00
|
|
|
/* A hardware display blank change occurred */
|
2006-06-26 01:27:09 -06:00
|
|
|
#define FB_EVENT_BLANK 0x09
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Private modelist is to be replaced */
|
2006-06-26 01:27:09 -06:00
|
|
|
#define FB_EVENT_NEW_MODELIST 0x0A
|
2005-09-09 14:04:29 -06:00
|
|
|
/* The resolution of the passed in fb_info about to change and
|
|
|
|
all vc's should be changed */
|
2006-06-26 01:27:09 -06:00
|
|
|
#define FB_EVENT_MODE_CHANGE_ALL 0x0B
|
2011-03-30 19:57:33 -06:00
|
|
|
/* A software display blank change occurred */
|
2007-02-09 02:46:45 -07:00
|
|
|
#define FB_EVENT_CONBLANK 0x0C
|
2007-05-08 01:39:37 -06:00
|
|
|
/* Get drawing requirements */
|
|
|
|
#define FB_EVENT_GET_REQ 0x0D
|
2007-07-17 05:05:33 -06:00
|
|
|
/* Unbind from the console if possible */
|
|
|
|
#define FB_EVENT_FB_UNBIND 0x0E
|
2015-09-05 03:22:39 -06:00
|
|
|
/* CONSOLE-SPECIFIC: remap all consoles to new fb - for vga_switcheroo */
|
2010-01-31 22:38:10 -07:00
|
|
|
#define FB_EVENT_REMAP_ALL_CONSOLE 0x0F
|
2012-05-29 16:07:12 -06:00
|
|
|
/* A hardware display blank early change occured */
|
|
|
|
#define FB_EARLY_EVENT_BLANK 0x10
|
|
|
|
/* A hardware display blank revert early change occured */
|
|
|
|
#define FB_R_EARLY_EVENT_BLANK 0x11
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
struct fb_event {
|
|
|
|
struct fb_info *info;
|
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
2007-05-08 01:39:37 -06:00
|
|
|
struct fb_blit_caps {
|
|
|
|
u32 x;
|
|
|
|
u32 y;
|
|
|
|
u32 len;
|
|
|
|
u32 flags;
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-11-24 20:11:48 -07:00
|
|
|
#ifdef CONFIG_FB_NOTIFY
|
2005-04-16 16:20:36 -06:00
|
|
|
extern int fb_register_client(struct notifier_block *nb);
|
|
|
|
extern int fb_unregister_client(struct notifier_block *nb);
|
2006-07-30 04:04:17 -06:00
|
|
|
extern int fb_notifier_call_chain(unsigned long val, void *v);
|
2015-11-24 20:11:48 -07: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-16 16:20:36 -06: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-21 18:16:58 -06:00
|
|
|
u32 access_align; /* alignment per read/write (bits) */
|
2005-04-16 16:20:36 -06:00
|
|
|
u32 flags; /* see FB_PIXMAP_* */
|
2007-05-08 01:39:09 -06: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-16 16:20:36 -06:00
|
|
|
/* access methods */
|
2005-06-21 18:16:58 -06: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-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2007-05-08 01:37:37 -06: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 04:19:10 -06:00
|
|
|
void (*first_io)(struct fb_info *info);
|
2007-05-08 01:37:37 -06:00
|
|
|
void (*deferred_io)(struct fb_info *info, struct list_head *pagelist);
|
|
|
|
};
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Frame buffer operations
|
|
|
|
*
|
|
|
|
* LOCKING NOTE: those functions must _ALL_ be called with the console
|
2006-06-30 10:20:44 -06:00
|
|
|
* semaphore held, this is the only suitable locking mechanism we have
|
2005-04-16 16:20:36 -06:00
|
|
|
* in 2.6. Some may be called at interrupt time at this point though.
|
2010-08-02 13:05:41 -06: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-16 16:20:36 -06: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 01:39:02 -06: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-16 16:20:36 -06: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 09:59:22 -06:00
|
|
|
/* set color registers in batch */
|
|
|
|
int (*fb_setcmap)(struct fb_cmap *cmap, struct fb_info *info);
|
|
|
|
|
2005-04-16 16:20:36 -06: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-14 14:21:25 -07:00
|
|
|
int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,
|
|
|
|
unsigned long arg);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Handle 32bit compat ioctl (optional) */
|
2006-01-14 14:21:25 -07:00
|
|
|
int (*fb_compat_ioctl)(struct fb_info *info, unsigned cmd,
|
|
|
|
unsigned long arg);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* perform fb specific mmap */
|
2006-01-14 14:21:25 -07:00
|
|
|
int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);
|
2005-12-12 23:17:16 -07:00
|
|
|
|
2007-05-08 01:39:37 -06: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-16 16:34:38 -06:00
|
|
|
|
|
|
|
/* teardown any resources to do with this framebuffer */
|
|
|
|
void (*fb_destroy)(struct fb_info *info);
|
2010-08-02 13:05:41 -06: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-16 16:20:36 -06: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 02:25:44 -06:00
|
|
|
const __u8 *data; /* actual tile map: a bitmap array, packed
|
2005-04-16 16:20:36 -06: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 01:39:16 -06:00
|
|
|
/* get maximum length of the tile map */
|
|
|
|
int (*fb_get_tilemax)(struct fb_info *info);
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
#endif /* CONFIG_FB_TILEBLITTING */
|
|
|
|
|
|
|
|
/* FBINFO_* = fb_info.flags bit flags */
|
|
|
|
#define FBINFO_MODULE 0x0001 /* Low-level driver is a module */
|
|
|
|
#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 08:31:56 -07:00
|
|
|
#define FBINFO_VIRTFB 0x0004 /* FB is System RAM, not device. */
|
2005-04-16 16:20:36 -06: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_USEREVENT 0x10000 /* event request
|
|
|
|
from userspace */
|
|
|
|
#define FBINFO_MISC_TILEBLITTING 0x20000 /* use tile blitting */
|
|
|
|
|
2005-12-12 23:17:19 -07: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 02:56:53 -07:00
|
|
|
* this flag set you can really be sure that set_par is always called before
|
2011-03-30 19:57:33 -06:00
|
|
|
* any of the functions dependent on the correct hardware state or altering
|
2005-12-12 23:17:19 -07: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-22 19:35:41 -06:00
|
|
|
/* where the fb is a firmware driver, and can be replaced with a proper one */
|
|
|
|
#define FBINFO_MISC_FIRMWARE 0x80000
|
2008-04-28 03:14:49 -06: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
|
|
|
|
|
2010-06-23 13:56:12 -06:00
|
|
|
/* report to the VT layer that this fb driver can accept forced console
|
|
|
|
output like oopses */
|
|
|
|
#define FBINFO_CAN_FORCE_OUTPUT 0x200000
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct fb_info {
|
2011-05-11 15:49:36 -06:00
|
|
|
atomic_t count;
|
2005-04-16 16:20:36 -06:00
|
|
|
int node;
|
|
|
|
int flags;
|
2008-10-18 21:27:51 -06:00
|
|
|
struct mutex lock; /* Lock for open/release/ioctl funcs */
|
2009-06-30 12:41:29 -06:00
|
|
|
struct mutex mm_lock; /* Lock for fb_mmap and smem_* fields */
|
2005-04-16 16:20:36 -06: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 06:47:08 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_FB_BACKLIGHT
|
|
|
|
/* assigned backlight device */
|
2007-02-10 07:10:33 -07:00
|
|
|
/* set before framebuffer registration,
|
|
|
|
remove after unregister */
|
2006-06-25 06:47:08 -06:00
|
|
|
struct backlight_device *bl_dev;
|
|
|
|
|
|
|
|
/* Backlight level curve */
|
2007-02-10 07:10:33 -07:00
|
|
|
struct mutex bl_curve_mutex;
|
2006-06-25 06:47:08 -06:00
|
|
|
u8 bl_curve[FB_BACKLIGHT_LEVELS];
|
|
|
|
#endif
|
2007-05-08 01:37:37 -06:00
|
|
|
#ifdef CONFIG_FB_DEFERRED_IO
|
|
|
|
struct delayed_work deferred_work;
|
|
|
|
struct fb_deferred_io *fbdefio;
|
|
|
|
#endif
|
2006-06-25 06:47:08 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct fb_ops *fbops;
|
2006-09-14 08:30:59 -06:00
|
|
|
struct device *device; /* This is the parent */
|
|
|
|
struct device *dev; /* This is this fb device */
|
2006-10-03 02:14:50 -06:00
|
|
|
int class_flag; /* private sysfs flags */
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_FB_TILEBLITTING
|
|
|
|
struct fb_tile_ops *tileops; /* Tile Blitting */
|
|
|
|
#endif
|
2015-10-07 01:20:12 -06:00
|
|
|
union {
|
|
|
|
char __iomem *screen_base; /* Virtual address */
|
|
|
|
char *screen_buffer;
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long screen_size; /* Amount of ioremapped VRAM or 0 */
|
|
|
|
void *pseudo_palette; /* Fake palette of 16 colors */
|
|
|
|
#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-16 16:34:38 -06:00
|
|
|
void *par;
|
2011-03-30 19:57:33 -06:00
|
|
|
/* we need the PCI or similar aperture base/size not
|
2009-06-16 16:34:38 -06:00
|
|
|
smem_start/size as smem_start may just be an object
|
|
|
|
allocated inside the aperture so may not actually overlap */
|
2010-05-16 09:27:03 -06:00
|
|
|
struct apertures_struct {
|
|
|
|
unsigned int count;
|
|
|
|
struct aperture {
|
|
|
|
resource_size_t base;
|
|
|
|
resource_size_t size;
|
|
|
|
} ranges[0];
|
|
|
|
} *apertures;
|
2013-02-04 06:37:21 -07:00
|
|
|
|
|
|
|
bool skip_vt_switch; /* no VT switch on suspend/resume required */
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2010-05-16 09:27:03 -06:00
|
|
|
static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
|
|
|
|
struct apertures_struct *a = kzalloc(sizeof(struct apertures_struct)
|
|
|
|
+ max_num * sizeof(struct aperture), GFP_KERNEL);
|
2010-07-15 02:39:47 -06:00
|
|
|
if (!a)
|
|
|
|
return NULL;
|
2010-05-16 09:27:03 -06:00
|
|
|
a->count = max_num;
|
|
|
|
return a;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef MODULE
|
|
|
|
#define FBINFO_DEFAULT FBINFO_MODULE
|
|
|
|
#else
|
|
|
|
#define FBINFO_DEFAULT 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// This will go away
|
|
|
|
#define FBINFO_FLAG_MODULE FBINFO_MODULE
|
|
|
|
#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-27 16:33:28 -06:00
|
|
|
#define fb_memcpy_fromfb sbus_memcpy_fromio
|
|
|
|
#define fb_memcpy_tofb sbus_memcpy_toio
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-16 02:16:04 -07:00
|
|
|
#elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) || defined(__hppa__) || defined(__sh__) || defined(__powerpc__) || defined(__avr32__) || defined(__bfin__) || defined(__arm__)
|
2005-04-16 16:20:36 -06: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-27 16:33:28 -06:00
|
|
|
#define fb_memcpy_fromfb memcpy_fromio
|
|
|
|
#define fb_memcpy_tofb memcpy_toio
|
2005-04-16 16:20:36 -06: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-27 16:33:28 -06:00
|
|
|
#define fb_memcpy_fromfb memcpy
|
|
|
|
#define fb_memcpy_tofb memcpy
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-12-12 23:17:21 -07:00
|
|
|
#endif
|
|
|
|
|
2008-04-28 03:14:49 -06: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-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* `Generic' versions of the frame buffer device operations
|
|
|
|
*/
|
|
|
|
|
|
|
|
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);
|
|
|
|
extern int fb_blank(struct fb_info *info, int blank);
|
|
|
|
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);
|
|
|
|
extern void cfb_imageblit(struct fb_info *info, const struct fb_image *image);
|
2007-05-08 01:38:57 -06: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 01:39:03 -06: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-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* drivers/video/fbmem.c */
|
|
|
|
extern int register_framebuffer(struct fb_info *fb_info);
|
|
|
|
extern int unregister_framebuffer(struct fb_info *fb_info);
|
2012-01-28 12:57:46 -07:00
|
|
|
extern int unlink_framebuffer(struct fb_info *fb_info);
|
2013-12-16 08:57:39 -07:00
|
|
|
extern int remove_conflicting_framebuffers(struct apertures_struct *a,
|
|
|
|
const char *name, bool primary);
|
2005-11-08 22:39:10 -07: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-16 16:20:36 -06:00
|
|
|
extern char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size);
|
2005-06-21 18:17:07 -06:00
|
|
|
extern void fb_pad_unaligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 idx,
|
2005-04-16 16:20:36 -06:00
|
|
|
u32 height, u32 shift_high, u32 shift_low, u32 mod);
|
2005-06-21 18:17:07 -06:00
|
|
|
extern void fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch, u32 height);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void fb_set_suspend(struct fb_info *info, int state);
|
2005-09-09 14:04:37 -06:00
|
|
|
extern int fb_get_color_depth(struct fb_var_screeninfo *var,
|
|
|
|
struct fb_fix_screeninfo *fix);
|
2013-06-18 08:23:05 -06:00
|
|
|
extern int fb_get_options(const char *name, char **option);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern int fb_new_modelist(struct fb_info *info);
|
|
|
|
|
|
|
|
extern struct fb_info *registered_fb[FB_MAX];
|
|
|
|
extern int num_registered_fb;
|
2007-06-01 01:46:46 -06:00
|
|
|
extern struct class *fb_class;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-03-31 16:25:19 -06:00
|
|
|
extern int lock_fb_info(struct fb_info *info);
|
2009-02-04 16:12:03 -07:00
|
|
|
|
|
|
|
static inline void unlock_fb_info(struct fb_info *info)
|
|
|
|
{
|
|
|
|
mutex_unlock(&info->lock);
|
|
|
|
}
|
|
|
|
|
2005-09-09 14:10:04 -06:00
|
|
|
static inline void __fb_pad_aligned_buffer(u8 *dst, u32 d_pitch,
|
|
|
|
u8 *src, u32 s_pitch, u32 height)
|
|
|
|
{
|
2014-05-01 13:32:35 -06:00
|
|
|
u32 i, j;
|
2005-09-09 14:10:04 -06: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 01:37:37 -06:00
|
|
|
/* drivers/video/fb_defio.c */
|
2016-04-28 09:18:34 -06:00
|
|
|
int fb_deferred_io_mmap(struct fb_info *info, struct vm_area_struct *vma);
|
2007-05-08 01:37:37 -06:00
|
|
|
extern void fb_deferred_io_init(struct fb_info *info);
|
2008-08-20 15:09:23 -06:00
|
|
|
extern void fb_deferred_io_open(struct fb_info *info,
|
|
|
|
struct inode *inode,
|
|
|
|
struct file *file);
|
2007-05-08 01:37:37 -06:00
|
|
|
extern void fb_deferred_io_cleanup(struct fb_info *info);
|
2011-07-16 18:44:56 -06:00
|
|
|
extern int fb_deferred_io_fsync(struct file *file, loff_t start,
|
|
|
|
loff_t end, int datasync);
|
2007-05-08 01:37:37 -06:00
|
|
|
|
2008-04-28 03:14:49 -06: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-16 16:20:36 -06: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 08:30:59 -06:00
|
|
|
extern int fb_init_device(struct fb_info *fb_info);
|
|
|
|
extern void fb_cleanup_device(struct fb_info *head);
|
2006-06-25 06:47:08 -06:00
|
|
|
extern void fb_bl_default_curve(struct fb_info *fb_info, u8 off, u8 min, u8 max);
|
2005-04-16 16:20:36 -06: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-09 14:04:34 -06:00
|
|
|
extern const unsigned char *fb_firmware_edid(struct device *device);
|
|
|
|
extern void fb_edid_to_monspecs(unsigned char *edid,
|
|
|
|
struct fb_monspecs *specs);
|
2010-11-11 07:44:43 -07:00
|
|
|
extern void fb_edid_add_monspecs(unsigned char *edid,
|
|
|
|
struct fb_monspecs *specs);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void fb_destroy_modedb(struct fb_videomode *modedb);
|
2005-09-09 14:09:58 -06:00
|
|
|
extern int fb_find_mode_cvt(struct fb_videomode *mode, int margins, int rb);
|
2006-10-03 02:14:42 -06:00
|
|
|
extern unsigned char *fb_ddc_read(struct i2c_adapter *adapter);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-14 03:12:38 -07:00
|
|
|
extern int of_get_fb_videomode(struct device_node *np,
|
|
|
|
struct fb_videomode *fb,
|
|
|
|
int index);
|
2012-11-14 02:55:04 -07:00
|
|
|
extern int fb_videomode_from_videomode(const struct videomode *vm,
|
|
|
|
struct fb_videomode *fbmode);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* drivers/video/modedb.c */
|
2015-01-13 20:04:25 -07:00
|
|
|
#define VESA_MODEDB_SIZE 43
|
2015-01-13 20:04:26 -07:00
|
|
|
#define DMT_SIZE 0x50
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void fb_var_to_videomode(struct fb_videomode *mode,
|
2007-02-12 01:55:19 -07:00
|
|
|
const struct fb_var_screeninfo *var);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void fb_videomode_to_var(struct fb_var_screeninfo *var,
|
2007-02-12 01:55:19 -07: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-16 16:20:36 -06:00
|
|
|
struct list_head *head);
|
2007-02-12 01:55:19 -07: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-16 16:20:36 -06:00
|
|
|
extern void fb_destroy_modelist(struct list_head *head);
|
2007-02-12 01:55:19 -07:00
|
|
|
extern void fb_videomode_to_modelist(const struct fb_videomode *modedb, int num,
|
2005-04-16 16:20:36 -06:00
|
|
|
struct list_head *head);
|
2007-02-12 01:55:19 -07:00
|
|
|
extern const struct fb_videomode *fb_find_best_display(const struct fb_monspecs *specs,
|
|
|
|
struct list_head *head);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* drivers/video/fbcmap.c */
|
|
|
|
extern int fb_alloc_cmap(struct fb_cmap *cmap, int len, int transp);
|
2010-11-16 02:11:02 -07:00
|
|
|
extern int fb_alloc_cmap_gfp(struct fb_cmap *cmap, int len, int transp, gfp_t flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void fb_dealloc_cmap(struct fb_cmap *cmap);
|
2006-12-08 03:40:27 -07: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-16 16:20:36 -06: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 03:40:27 -07:00
|
|
|
extern const struct fb_cmap *fb_default_cmap(int len);
|
2005-04-16 16:20:36 -06: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-13 20:04:26 -07:00
|
|
|
struct dmt_videomode {
|
|
|
|
u32 dmt_id;
|
|
|
|
u32 std_2byte_code;
|
|
|
|
u32 cvt_3byte_code;
|
|
|
|
const struct fb_videomode *mode;
|
|
|
|
};
|
|
|
|
|
2007-10-16 02:29:51 -06:00
|
|
|
extern const char *fb_mode_option;
|
2005-04-16 16:20:36 -06:00
|
|
|
extern const struct fb_videomode vesa_modes[];
|
2015-01-15 04:47:19 -07:00
|
|
|
extern const struct fb_videomode cea_modes[65];
|
2015-01-13 20:04:26 -07:00
|
|
|
extern const struct dmt_videomode dmt_modes[];
|
2005-04-16 16:20:36 -06: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-19 19:35:54 -06: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-16 16:20:36 -06:00
|
|
|
#endif /* _LINUX_FB_H */
|