Writing Linux LCD drivers—深入分析framebuffer设备驱动的结构

Writing Linux LCD drivers

——本文深入地分析了framebuffer设备驱动的结构

作者：JimSheng

Writing Linux LCD drivers

Abstract

1 LCD Module/Driver/Controller

2 Linux Frame Buffer Driver

2.1 Why Frame Buffer?

2.2 What is Frame Buffer Devices?

2.3 How to Write Frame Buffer Device Drivers?

3 Analysis of Linux Frame Buffer Driver Source Codes

3.1 fb.h

3.2 fbmem.c

4 Skeleton of LCD controller rivers

4.1 Allocate a system memory as video memory

4.2 Implement the fb_ops functions

Reference

Abstract

This material discusses how to write a Linux frame buffer LCD device driver.

1 LCD Module/Driver/Controller

Besides
the datasheet of LCD devices, there are two quite good books (.pdf
format) on LCD technology. Both of them are written in Chinese. One is
“液晶显示技术”, and the other is “液晶显示器件”. The two books give almost all
needed LCD knowledge, including introductions to hardware implementation
of LCD devices and low level software programming used to operate LCD
devices. This helps LCD circuits design and low level LCD programming.

2 Linux Frame Buffer Driver

2.1 Why Frame Buffer?

If
GUIs (Graphic User Interface) such as MiniGUI, MicroWindows are used,
LCD device drivers must be implemented as Linux frame buffer device
drivers in addition to those low level operations which only deal with
commands provided by LCD controllers.

2.2 What is Frame Buffer Devices?

The
frame buffer device provides an abstraction for the graphics hardware.
It represents the frame buffer of some video hardware and allows
application software to access the graphics hardware through a
well-defined interface, so the software doesn't need to know anything
about the low-level (hardware register) stuff.

The device is accessed through special device nodes, usually located in the /dev directory, i.e. /dev/fb*.

More
description about frame buffer device can be found in two txt files:
linux /Documentation /fb /framebuffer.txt and linux /Documentation /fb
/interal.txt

2.3 How to Write Frame Buffer Device Drivers?

There
are few instructive materials about writing frame buffer device
drivers. You may find “Linux Frame buffer Driver Writing HOWTO” at this
web page http: /linux-fbdev.sourceforge.net /HOWTO /index.html, but the
HOWTO is somewhat curt and not enough. So having a look into Linux
source codes is necessary. The next section is an analysis of the
related source codes.

3 Analysis of Linux Frame Buffer Driver Source Codes

Linux implements Frame Buffer Drivers mainly based on the groundwork of these two files:

1) linux/include/linux/fb.h

2) linux/drivers/video/fbmem.c

It’s time to have a close look at them.

3.1 fb.h

Almost
all important structures are defined in this file. First let me
describe what each means and how they are used one by one.

1) fb_var_screeninfo

It
is used to describe the features of a video card you normally can set.
With fb_var_screeninfo, you can define such things as depth and the
resolution you want.

struct fb_var_screeninfo {

__u32 xres; /* visible resolution */

__u32 yres;

__u32 xres_virtual; /* virtual resolution */

__u32 yres_virtual;

__u32 xoffset; /* offset from virtual to visible */

__u32 yoffset; /* resolution */

__u32 bits_per_pixel; /* guess what */

__u32 grayscale; /* != 0 Graylevels instead of colors */

struct fb_bitfield red; /* bitfield in fb mem if true color, */

struct fb_bitfield green; /* else only length is significant */

struct fb_bitfield blue;

struct fb_bitfield transp; /* transparency */

__u32 nonstd; /* != 0 Non standard pixel format */

__u32 activate; /* see FB_ACTIVATE_* */

__u32 height; /* height of picture in mm */

__u32 width; /* width of picture in mm */

__u32 accel_flags; /* acceleration flags (hints) */

/* Timing: All values in pixclocks, except pixclock (of course) */

__u32 pixclock; /* pixel clock in ps (pico seconds) */

__u32 left_margin; /* time from sync to picture */

__u32 right_margin; /* time from picture to sync */

__u32 upper_margin; /* time from sync to picture */

__u32 lower_margin;

__u32 hsync_len; /* length of horizontal sync */

__u32 vsync_len; /* length of vertical sync */

__u32 sync; /* see FB_SYNC_* */

__u32 vmode; /* see FB_VMODE_* */

__u32 reserved[6]; /* Reserved for future compatibility */

};

2) fb_fix_screeninfon

It
defines the properties of a card that are created when you set a mode
and can't be changed otherwise. A good example is the start address of
the framebuffer memory. This can depend on what mode is set. Now while
using that mode, you don't want to have the memory position change on
you. In this case, the video hardware tells you the memory location and
you have no say about it.

struct fb_fix_screeninfo {

char id[16]; /* identification string eg "TT Builtin" */

unsigned long smem_start; /* Start of frame buffer mem */

/* (physical address) */

__u32 smem_len; /* Length of frame buffer mem */

__u32 type; /* see FB_TYPE_* */

__u32 type_aux; /* Interleave for interleaved Planes */

__u32 visual; /* see FB_VISUAL_* */

__u16 xpanstep; /* zero if no hardware panning */

__u16 ypanstep; /* zero if no hardware panning */

__u16 ywrapstep; /* zero if no hardware ywrap */

__u32 line_length; /* length of a line in bytes */

unsigned long mmio_start; /* Start of Memory Mapped I/O */

/* (physical address) */

__u32 mmio_len; /* Length of Memory Mapped I/O */

__u32 accel; /* Type of acceleration available */

__u16 reserved[3]; /* Reserved for future compatibility */

};

3) fb_cmap

Device independent colormap information. You can get and set the colormap using the FBIOGETCMAP and FBIOPUTCMAP ioctls.

struct fb_cmap {

__u32 start; /* First entry */

__u32 len; /* Number of entries */

__u16 *red; /* Red values */

__u16 *green;

__u16 *blue;

__u16 *transp; /* transparency, can be NULL */

};

4) fb_info


It defines the current state of the
video card. fb_info is only visible from the kernel. Inside of fb_info,
there exist a fb_ops which is a collection of needed functions to make
driver work.

struct fb_info {

char modename[40]; /* default video mode */

kdev_t node;

int flags;

int open; /* Has this been open already ? */

#define FBINFO_FLAG_MODULE 1 /* Low-level driver is a module */

struct fb_var_screeninfo var; /* Current var */

struct fb_fix_screeninfo fix; /* Current fix */

struct fb_monspecs monspecs; /* Current Monitor specs */

struct fb_cmap cmap; /* Current cmap */

struct fb_ops *fbops;

char *screen_base; /* Virtual address */

struct display *disp; /* initial display variable */

struct vc_data *display_fg; /* Console visible on this display */

char fontname[40]; /* default font name */

devfs_handle_t devfs_handle; /* Devfs handle for new name */

devfs_handle_t devfs_lhandle; /* Devfs handle for compat. symlink */

int (*changevar)(int); /* tell console var has changed */

int (*switch_con)(int, struct fb_info*);

/* tell fb to switch consoles */

int (*updatevar)(int, struct fb_info*);

/* tell fb to update the vars */

void (*blank)(int, struct fb_info*); /* tell fb to (un)blank the screen */

/* arg = 0: unblank */

/* arg > 0: VESA level (arg-1) */

void *pseudo_palette; /* Fake palette of 16 colors and

the cursor's color for non

palette mode */

/* From here on everything is device dependent */

void *par;

};

5) struct fb_ops

User
application program can use ioctl() system call to operate low LCD
hardware. Methods defined in fb_ops structure are used to support these
operations.

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);

/* get non settable parameters */

int (*fb_get_fix)(struct fb_fix_screeninfo *fix, int con,

struct fb_info *info);

/* get settable parameters */

int (*fb_get_var)(struct fb_var_screeninfo *var, int con,

struct fb_info *info);

/* set settable parameters */

int (*fb_set_var)(struct fb_var_screeninfo *var, int con,

struct fb_info *info);

/* get colormap */

int (*fb_get_cmap)(struct fb_cmap *cmap, int kspc, int con,

struct fb_info *info);

/* set colormap */

int (*fb_set_cmap)(struct fb_cmap *cmap, int kspc, int con,

struct fb_info *info);

/* pan display (optional) */

int (*fb_pan_display)(struct fb_var_screeninfo *var, int con,

struct fb_info *info);

/* perform fb specific ioctl (optional) */

int (*fb_ioctl)(struct inode *inode, struct file *file, unsigned int cmd,

unsigned long arg, int con, struct fb_info *info);

/* perform fb specific mmap */

int (*fb_mmap)(struct fb_info *info, struct file *file, struct vm_area_struct *vma);

/* switch to/from raster image mode */

int (*fb_rasterimg)(struct fb_info *info, int start);

};

6) structure map

struct fb_info_gen | struct fb_info | fb_var_screeninfo

| | fb_fix_screeninfo

| | fb_cmap

| | modename[40]

| | fb_ops ---|--->ops on var

| | ... | fb_open

| | | fb_release

| | | fb_ioctl

| | | fb_mmap

| struct fbgen_hwswitch -|-> detect

| | encode_fix

| | encode_var

| | decode_fix

| | decode_var

| | get_var

| | set_var

| | getcolreg

| | setcolreg

| | pan_display

| | blank

| | set_disp

[编排有点困难，第一行的第一条竖线和下面的第一列竖线对齐，第一行的第二条竖线和下面的第二列竖线对齐就可以了]

struct fbgen_hwswitch is an abstraction of hardware operations. It is not necessary, but sometimes useful.

3.2 fbmem.c

fbmem.c
is at the middle place of frame buffer driver architecture. It provides
system calls to support upper user application programs. It also
provides an interface to low level drivers for specific hardware. Those
low level frame buffer drivers can register themselves into the kernel
by this interface. fbmem.c implements the common codes used by all
drivers, thus avoids repeated work.

1) Global Varibles

struct fb_info *registered_fb[FB_MAX];

int num_registered_fb;

The
two are used to record on-using instance of fb_info structure. fb_info
represents the current state of video card. All fb_info structures are
globally placed in an array. When a frame buffer registers itself to
kernel, a new fb_info is added to this array and num_registered_fb
increases 1.

static struct {

const char *name;

int (*init)(void);

int (*setup)(void);

} fb_drivers[] __initdata= { ....};

If
frame buffer driver is static linked into kernel, a new entry must be
added to this table. If use insmod/rmmod, don’t care this.

static struct file_operations fb_ops ={

owner: THIS_MODULE,

read: fb_read,

write: fb_write,

ioctl: fb_ioctl,

mmap: fb_mmap,

open: fb_open,

release: fb_release

};

This is the interface to user application programs. fbmem.c implements these functions here.

2) register_framebuffer(struct fb_info *fb_info)

unregister_framebuffer(struct fb_info *fb_info)

This
is the interface to low level frame buffer device driver. The drivers
use this pair of functions to register or unregister themselves.

Almost all the work those low level drivers needed to do is to fill in an fb_info structure and then to (un)register it.

4 Skeleton of LCD controller rivers

LCD
drivers operate LCD device hardwares, while fbmem.c records and
administrates these drivers. There is a skeleton frame buffer driver in
linux /drivers /fb /skeleton.c. It shows how to implement a frame buffer
driver with very few codes. Because it is too simple, it does nothing
but filling an fb_info and then (un)registering it.

In order to
implement a usable LCD controller driver, something else must be added
into it. But what should be added? As we all know, device drivers
abstract hardware and provide system call interface to user programs. So
we can implements the low level hardware operations according to the
need of the system call interface, namely the file_operations structure
which is discussed in section 3.2.

4.1 Allocate a system memory as video memory

After
a careful lookup in fbmem.c, we know that open() and release() method
of file_operations structure do not need low level support, while
read(), write() and mmap() need a common support function fb_get_fix().
So fb_get_fix() must be provided by driver writers.

Additionally the
writer should allocate a system memory as video memory, for most LCD
controllers have no their own video memory. The allocated memory start
address and length are later placed in smem_start and smem_len fields of
fb_fix_screeninfo structure. The allocated memory should be physically
consecutive.

4.2 Implement the fb_ops functions

The
only method of file_operations still not discussed is ioctl(). User
application programs use ioctl() system call to operate LCD hardware.
Methods defined in fb_ops structure(section 3.1) are used to support
these operations. NOTE: fb_ops structure is NOT file_operations
structure. fb_ops is for abstraction of low level operations, while
file_operations is for upper level system call interface

Again we’d
better first decide which methods should be implemented. ioctl() system
call is implemented in fbmem.c, so we turn to it and quickly we can find
out such relationship between ioctl() commands and fb_ops’s methods:

FBIOGET_VSCREENINFO fb_get_var

FBIOPUT_VSCREENINFO fb_set_var

FBIOGET_FSCREENINFO fb_get_fix

FBIOPUTCMAP fb_set_cmap

FBIOGETCMAP fb_get_cmap

FBIOPAN_DISPLAY fb_pan_display

Now
we know that if we implement these fb_XXX_XXX functions, then user
application writers can use FBIOXXXX micros to operate LCD hardwares.
But how can we implement them?

It is fine to have a reference to linux/drivers/video/fbgen.c or other drivers under the linux/drivers/video directory.

Among
these functions, fb_set_var() is the most important. It is used to set
video mode and more. The following is the common steps performed by a
fb_set_var() function:

1) Check if mode setting is necessary

2) Set the mode

3) Set colormap

4) Reconfigure the registers of LCD controller according former settings

The
fourth step shows where low level operations are placed. Curious men
may have such a question: how image data of user application are put
onto the screen. Driver writer allocates a system memory as video
memory, and later he sets the start address and length of the memory to
LCD controller’s registers(often in fb_set_var() function). The content
of the memory will be sent to screen automatically by LCD controller(for
details, see specific LCD controller). On the other hand, the allocated
system memory is mapped to user space by mmap(). Thereby, when a user
sends data to the mapped memory, the data will be shown on LCD screen.

Reference

1 液晶显示技术

2 液晶显示器件

3 linux/Documentation/fb/framebuffer.txt

4 linux/Documentation/fb/interal.txt

5 Linux Framebuffer Driver Writing HOWTO

http:/linux-fbdev.sourceforge.net/HOWTO

/index.html

6 linux/include/linux/fb.h

7 linux/drivers/video/fbmem.c

8 linux/drivers/video/skeletonfb.c

9 linux/drivers/video/fbgen.c

10 linux/drivers/video/tgafb.c

11 s3c2410 microprocessor user manual

s3c2410fb.h, s3c2410fb.c, s3c2410fb.c-pre, s3c2410fb.c-mono

A kind of arm-based widely used MCU, with integrated LCD controller.

12 sed1335 datasheet

A kind of widely used LCD controller

原文地址: http://www.hzlitai.com.cn/article/yejin-article/system/1161.html