基于S3C2440的嵌入式Linux驱动——Framebuffer子系统解读

baqiao

本文将介绍Framebuffer子系统

目标平台：TQ2440 CPU：s3c2440

LCD设备：3.5英寸，分辨率320X240



1. 概述

: D7 i- _3 n3 p8 A# BFramebuffer，中文名字是帧缓冲，这个帧也就是一副图像所需要的数据。因此，帧缓冲其实就是LCD设备的驱动程序。Linux中，framebuffer子系统框架如下：
% D: ~' r3 t9 [; i- g8 S. u


核心层的代码以fbmem.c为主，核心层包括许多与具体硬件无关的代码，并且提供了API给用户空间。用户空间使用系统调用，系统调用会使用相应的API函数，最后会调用驱动层实现功能。对于不同的设备，驱动层的代码将有所不同。

接下来的内容中，首先给出framerbuffer使用的数据结构；随后简单描述framerbuffer核心层；最后，针对S3C2440，对驱动代码进行分析。

2 E' L8 v5 v; I- J" I6 h$ \9 O1 f2. 数据结构
2.1 fb_info 结构
  该结构是内核用于描述一个特定framebuffer设备。其中包含了几个重要的结构，将在下面介绍。
+ F" Y$ U6 z5 ^) ?" g( M
9 x" W; P+ y0 t! w  下列代码位于include/linux/fb.h

struct fb_info {
. r% E" P- R9 l9 Y) X$ Q! @: B        int node;
        int flags;
        struct mutex lock;                /* Lock for open/release/ioctl funcs */
        struct fb_var_screeninfo var;        /* Current var */
        struct fb_fix_screeninfo fix;        /* Current fix */
+ T8 D1 Z3 i  g$ o' X! E0 y        struct fb_monspecs monspecs;        /* Current Monitor specs */
% l7 O. I5 i% y, c9 N        struct work_struct queue;        /* Framebuffer event queue */
& W1 l& d) H  [        struct fb_pixmap pixmap;        /* Image hardware mapper */
        struct fb_pixmap sprite;        /* Cursor hardware mapper */
        struct fb_cmap cmap;                /* Current cmap */
& k3 f- y) I; q% C* I        struct list_head modelist;      /* mode list */
        struct fb_videomode *mode;        /* current mode */

#ifdef CONFIG_FB_BACKLIGHT
: H3 h) ~' s" Y" I+ T        /* assigned backlight device */
        /* set before framebuffer registration,
           remove after unregister */
        struct backlight_device *bl_dev;

1 K! `4 v5 K: F* h* s        /* Backlight level curve */
2 A0 ?6 G) h, V) l, M        struct mutex bl_curve_mutex;       
% U  B9 H/ o6 h0 f        u8 bl_curve[FB_BACKLIGHT_LEVELS];
#endif
#ifdef CONFIG_FB_DEFERRED_IO
6 a6 W' E6 o! q5 X+ z        struct delayed_work deferred_work;
        struct fb_deferred_io *fbdefio;
#endif
7 Q' C- ?6 D- o
& q6 h- e9 M$ W6 }, p: o4 M) J% q        struct fb_ops *fbops;
) d3 z+ \6 C2 J7 P        struct device *device;                /* This is the parent */
& o5 W" ~/ R% \9 y        struct device *dev;                /* This is this fb device */
        int class_flag;                    /* private sysfs flags */
#ifdef CONFIG_FB_TILEBLITTING
, R4 U/ {  A8 i/ I% X        struct fb_tile_ops *tileops;    /* Tile Blitting */
#endif
        char __iomem *screen_base;        /* Virtual address */
        unsigned long screen_size;        /* Amount of ioremapped VRAM or 0 */
        void *pseudo_palette;                /* Fake palette of 16 colors */
#define FBINFO_STATE_RUNNING        0
. Y3 O' h5 ]# Y! h- H' J#define FBINFO_STATE_SUSPENDED        1
        u32 state;                        /* Hardware state i.e suspend */
$ ?3 f1 b- F0 U; S2 V        void *fbcon_par;                /* fbcon use-only private area */
        /* From here on everything is device dependent */
9 X' t+ X) y) P* W  N, z        void *par;       
};
2.2 fb_fix_screeninfo结构
  该数据结构是不可改变的，也就是说用户空间不能改变该结构中的任何成员，在核心层我们将会看到这点。
; O. S1 D+ D1 j: P# v+ n
: a) o. \- n3 Z  下列代码位于include/linux/fb.h
2 f  M& }+ z1 i
struct fb_fix_screeninfo {
        char id[16];                        /* identification string eg "TT Builtin" */
0 e4 @. E" V3 }  ?. e( \        unsigned long smem_start;        /* Start of frame buffer mem */
                                        /* (physical address) */
& s  c( B3 V0 P; H8 G# y& p* O        __u32 smem_len;                        /* Length of frame buffer mem */
        __u32 type;                        /* see FB_TYPE_*                */
5 I# ^; {7 B3 v& k0 ?        __u32 type_aux;                        /* Interleave for interleaved Planes */
2 H; C* u  I1 N9 G7 x9 T        __u32 visual;                        /* see FB_VISUAL_*                */
        __u16 xpanstep;                        /* zero if no hardware panning  */
) a  V1 o5 Z. W! l        __u16 ypanstep;                        /* zero if no hardware panning  */
' [& Q9 h2 q6 `/ `& n+ l, k5 h0 d0 I        __u16 ywrapstep;                /* zero if no hardware ywrap    */
0 w/ `9 O# r( N2 z# V; `        __u32 line_length;                /* length of a line in bytes    */
( y4 {  R3 R0 F9 [        unsigned long mmio_start;        /* Start of Memory Mapped I/O   */
) ?4 W* w0 z: A                                        /* (physical address) */
        __u32 mmio_len;                        /* Length of Memory Mapped I/O  */
        __u32 accel;                        /* Indicate to driver which        */
                                        /*  specific chip/card we have        */
        __u16 reserved[3];                /* Reserved for future compatibility */
1 J: D  E" f2 F- K& N5 ^7 _( _};
& y) T$ I( P$ r4 z/ K/ X6 e
8 z! n  g1 E* b6 D' }* z* }2.3 fb_var_screeninfo结构
; w* }5 }3 q. S( ~' y  该数据结构是可以改变的，也就是说用户空间可以改变该结构中的成员。该数据结构中的很多成员就由板级信息复制而来，在驱动代码中我们将会看到这点。

# |; z; E2 E  M) H  下列代码位于include/linux/fb.h
, O, d) ?9 i& K9 _$ R% _6 ]8 W
struct fb_var_screeninfo {
        __u32 xres;                        /* visible resolution                */
        __u32 yres;
0 q9 ?. D8 M7 \9 V' [        __u32 xres_virtual;                /* virtual resolution                */
        __u32 yres_virtual;
8 @% R9 K7 N. b! \( n) T% {        __u32 xoffset;                        /* offset from virtual to visible */
        __u32 yoffset;                        /* resolution                        */

        __u32 bits_per_pixel;                /* guess what                        */
, n" I1 T. h  a; l6 g        __u32 grayscale;                /* != 0 Graylevels instead of colors */

5 S  H$ S1 T( |, Y- P3 B        struct fb_bitfield red;                /* bitfield in fb mem if true color, */
3 n, \' C2 f( o  P/ h- ~1 [7 k' A' f" ?        struct fb_bitfield green;        /* else only length is significant */
& H) p( N# H" u) W8 {, j  q        struct fb_bitfield blue;
        struct fb_bitfield transp;        /* transparency                        */       

        __u32 nonstd;                        /* != 0 Non standard pixel format */
. @, A( F2 [6 \5 ]
        __u32 activate;                        /* see FB_ACTIVATE_*                */

        __u32 height;                        /* height of picture in mm    */
! w$ d8 ]: f! ]3 k3 v& |5 m% H: G        __u32 width;                        /* width of picture in mm     */

        __u32 accel_flags;                /* (OBSOLETE) see fb_info.flags */

! x- U: V& }- L# R% n" [3 l        /* Timing: All values in pixclocks, except pixclock (of course) */
3 w- ~2 E. x) g" }* K6 @7 x- }        __u32 pixclock;                        /* pixel clock in ps (pico seconds) */
4 K4 ~3 E6 Z  j! A' K        __u32 left_margin;                /* time from sync to picture        */
2 @( S) W8 @3 M0 I5 @+ _        __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        */
: H0 |& L8 t$ U0 M* c8 k& I5 L        __u32 vsync_len;                /* length of vertical sync        */
        __u32 sync;                        /* see FB_SYNC_*                */
        __u32 vmode;                        /* see FB_VMODE_*                */
4 {% n* {7 h& C7 v* f        __u32 rotate;                        /* angle we rotate counter clockwise */
        __u32 reserved[5];                /* Reserved for future compatibility */
};
) O4 ^' S. b. u6 e8 c/ \/ j2 N( i8 a" U6 r
2.4 fb_ops结构
$ f; F' U1 S& a) O  该结构描述了用于fb_info的方法，这些方法中有些是要驱动程序提供的，而有些可以使用内核提供的方法。
0 y3 \$ Q: F! S5 Y
3 K7 G5 a; w) t 下列代码位于include/linux/fb.h
8 M& T9 Q0 G2 }2 V/ ?4 p- |
6 @! Q$ l. [/ [% L4 {; G! C6 E/*
* Frame buffer operations
*
; U2 i) ?+ j  M9 F  I' U0 z * LOCKING NOTE: those functions must _ALL_ be called with the console
* semaphore held, this is the only suitable locking mechanism we have
* in 2.6. Some may be called at interrupt time at this point though.
! [) F6 V% @# v" f+ N */
7 q4 F" u7 p; z9 m( Q, d
struct fb_ops {
+ H; w( L8 C3 W6 Y! W, a3 c9 y# w# t        /* open/release and usage marking */
/ {( u9 T4 X: x: [# C# p( O$ V; p        struct module *owner;
0 F# B, }% k; W5 P7 g2 s; i        int (*fb_open)(struct fb_info *info, int user);
        int (*fb_release)(struct fb_info *info, int user);
- P1 X" n# a2 N- D! c1 o1 N
2 _* O; u  M; {7 T        /* For framebuffers with strange non linear layouts or that do not
' C9 ]1 F3 g$ Q         * work with normal memory mapped access
# p5 S: A9 u2 L; i) D2 j         */
        ssize_t (*fb_read)(struct fb_info *info, char __user *buf,
/ J0 T; D  m. j" |- m7 E                           size_t count, loff_t *ppos);
        ssize_t (*fb_write)(struct fb_info *info, const char __user *buf,
6 @! j: W9 }6 U' f! P* F4 U. x                            size_t count, loff_t *ppos);

5 M6 E9 h' ?  P0 h! X& X        /* checks var and eventually tweaks it to something supported,
7 n' W( i% ?6 c( z3 Y         * DO NOT MODIFY PAR */
        int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);

# t, o+ w8 p" k$ k- r8 j* L6 T        /* set the video mode according to info->var */
        int (*fb_set_par)(struct fb_info *info);
$ s2 [& s0 g! |( X) S! ]5 ~
8 S0 E; n" J" C$ U2 v& s        /* set color register */
        int (*fb_setcolreg)(unsigned regno, unsigned red, unsigned green,
- @/ W' D4 l+ k                            unsigned blue, unsigned transp, struct fb_info *info);

        /* set color registers in batch */
        int (*fb_setcmap)(struct fb_cmap *cmap, struct fb_info *info);

2 n' t* d( M; {        /* 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);

4 A$ S; N' t3 M' b$ n        /* Draws a rectangle */
        void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect);
        /* Copy data from area to another */
; d  ^% [# [1 L        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);

' ?& X9 j0 i3 z; }        /* Draws cursor */
        int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor);
" w; }  u1 b. ]' T3 X
) |% i5 _1 S/ r4 R2 m+ G        /* Rotates the display */
) p$ Z7 r1 r7 r6 @( h        void (*fb_rotate)(struct fb_info *info, int angle);
) \% s" W" F  B0 z6 x
        /* wait for blit idle, optional */
        int (*fb_sync)(struct fb_info *info);

        /* peRForm fb specific ioctl (optional) */
        int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,
                        unsigned long arg);
6 n4 ]5 v! h+ b" H/ x
. j* Y# c0 c7 D) t" ?4 ~        /* Handle 32bit compat ioctl (optional) */
/ v' E; e7 B9 m' K        int (*fb_compat_ioctl)(struct fb_info *info, unsigned cmd,
! I( D9 G7 m. e3 y0 g                        unsigned long arg);
" z. J3 O# R9 g2 F
        /* perform fb specific mmap */
- K; B- W3 h0 A. A1 Q( B- [6 B        int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);
8 N" J/ O6 Y- V9 K# n; X
$ G9 i3 O9 a8 ~8 }2 G, P# V        /* save current hardware state */
        void (*fb_save_state)(struct fb_info *info);

# t# P, l' e; r7 z        /* restore saved state */
        void (*fb_restore_state)(struct fb_info *info);

        /* get capability given var */
        void (*fb_get_caps)(struct fb_info *info, struct fb_blit_caps *caps,
8 Z3 p5 W/ ]3 `$ [# O2 _$ F                            struct fb_var_screeninfo *var);
};

  R0 I2 i( N( P8 f$ R
3. frambuffer核心层
首先来看下frmaebuffer子系统的初始化函数。
2 q' L. l3 M4 m
3.1 fbmem_init和fbmem_exit
. K9 @& E3 q& p$ m. j* ?" ]7 z下列代码位于drivers/video/fbmem.c
7 c8 {4 O3 q; h/ U: y( r; w
8 ]3 q4 O; O1 B. V/**
*        fbmem_init - init frame buffer subsystem
*
*        Initialize the frame buffer subsystem.
*
*        NOTE: This function is _only_ to be called by drivers/char/mem.c.
! e6 {: i) y1 m *
' D+ q9 Q4 B% j% e6 R */
2 r2 p1 R% u6 e! f- E
  F' E% f$ v- ~1 R9 ~static int __init
fbmem_init(void)
0 O# J$ {  ^3 X3 d7 n+ J, m{
        proc_create("fb", 0, NULL, &fb_proc_fops);

        if (register_chrdev(FB_MAJOR,"fb",&fb_fops))                /*注册字符设备，major=29*/
7 Y+ x# l# l- b8 y4 W                printk("unable to get major %d for fb devs\n", FB_MAJOR);

+ D& R1 s3 Q6 a, M        fb_class = class_create(THIS_MODULE, "graphics");        /*创建类*/
        if (IS_ERR(fb_class)) {
2 ?2 |- S- d4 ], L9 y                printk(KERN_WARNING "Unable to create fb class; errno = %ld\n", PTR_ERR(fb_class));
                fb_class = NULL;
0 |! ?+ K$ H6 |+ @        }
        return 0;
}
! M9 t4 k( f; E. T7 s
. V& D2 U( K4 S6 Y6 I" q6 Y: E#ifdef MODULE
module_init(fbmem_init);
" z- c* v$ o1 s2 k8 v, d( ^6 Fstatic void __exit
5 d- h. ^6 e0 t: `  F3 ]4 |7 }! D; v3 Dfbmem_exit(void)
{
        remove_proc_entry("fb", NULL);
* c8 ^2 ?+ u* B* l        class_destroy(fb_class);
7 Q% R, U4 m0 `, `        unregister_chrdev(FB_MAJOR, "fb");
}

module_exit(fbmem_exit);
MODULE_LICENSE("GPL");
2 i5 E& y+ b1 H6 UMODULE_DESCRIPTION("Framebuffer base");
#else
7 [, p# p, y1 x( Rsubsys_initcall(fbmem_init);
" h9 H  I; B7 W0 S+ y#endif
  q1 }8 b5 N" l4 O
static const struct file_operations fb_fops = {
    .owner =    THIS_MODULE,
% y) V% ^" z- p" Z: v2 Q8 W& p    .read =        fb_read,
    .write =    fb_write,
    .unlocked_ioctl = fb_ioctl,
' \4 c2 ^: @7 g#ifdef CONFIG_COMPAT
    .compat_ioctl = fb_compat_ioctl,
. ^9 {# @# @: y, Q/ @#endif
    .mmap =        fb_mmap,
2 }( ^. T4 ]& R+ ?2 q    .open =        fb_open,
    .release =    fb_release,
. T" R4 ~6 G5 E: I: b/ M" ^#ifdef HAVE_ARCH_FB_UNMAPPED_AREA
    .get_unmapped_area = get_fb_unmapped_area,
8 ^" O% \1 z. N& i8 x7 v#endif
#ifdef CONFIG_FB_DEFERRED_IO
    .fsync =    fb_deferred_io_fsync,
#endif
+ F3 K7 s2 V. ~6 a: ~' f# ~5 l};

% K* [0 T: P  Z  _! u- M我们看到，如果不是作为模块，那么该初始化程序将在subsys_initcall阶段被调用。初始化时，仅仅注册了一个字符设备，并创建了一个类。通过字符设备，提供了API给用户空间，包open，release，write，read等。
; H8 o% e# n. q0 i2 |! ]随后我们看看如何分配一个fb_info结构。
' W" p9 E/ r9 P6 i
3.2 framebuffer_alloc
* X9 p0 c- R; {- \2 H+ }" K2 R下列代码位于drivers/video/fbmem.c
9 T5 Z: Z' @$ ^, z2 Y. |' X
/ Q3 C! m$ `4 r: r/**
$ e) @) A* I2 G! N! Q * framebuffer_alloc - creates a new frame buffer info structure
( F" K# G$ U+ B *
* @size: size of driver private data, can be zero
* @dev: pointer to the device for this fb, this can be NULL
, Q. Z6 Q, n' ?" w) H0 C2 E *
! t' k+ d6 Z/ N# d1 ~  F4 _ * Creates a new frame buffer info structure. Also reserves @size bytes
* for driver private data (info->par). info->par (if any) will be
0 K& w6 e6 H* S- [9 G1 r  K; [ * aligned to sizeof(long).
! k/ q6 `9 [6 b- Q/ k' V) _- C *
- n7 E. |4 V. }9 K  b * Returns the new structure, or NULL if an error occured.
5 a) G0 s! d2 D: n/ R *
*/
( \! y  R' N1 B1 K" \  [/ wstruct fb_info *framebuffer_alloc(size_t size, struct device *dev)
{
  l% S$ a$ n/ B5 t$ E3 G% Y2 W& y7 [#define BYTES_PER_LONG (BITS_PER_LONG/8)
0 L& H; D; Q; o7 W; C8 O#define PADDING (BYTES_PER_LONG - (sizeof(struct fb_info) % BYTES_PER_LONG))
        int fb_info_size = sizeof(struct fb_info);
; l! Q- |1 a0 ]( e8 E        struct fb_info *info;
% z$ d  `+ H' i" J9 X3 r        char *p;
% M0 g/ Y5 Q' Z
        if (size)
                fb_info_size += PADDING;
+ |& n- z3 Y9 o7 V3 @3 O3 d0 Y4 R; Q
/ ~; \  i% S# f3 X- o        p = kzalloc(fb_info_size + size, GFP_KERNEL);

% q! o4 u9 L3 v5 x        if (!p)
% Y3 S) Q7 h! [3 z                return NULL;
5 ^  _& R0 m5 u( V( N
0 u+ q0 \2 ]# K) H* Y) J% e        info = (struct fb_info *) p;

        if (size)
                info->par = p + fb_info_size;

, Y% y& W( Z5 F        info->device = dev;

+ e, B% o  Y8 ?9 E# @#ifdef CONFIG_FB_BACKLIGHT
        mutex_init(&info->bl_curve_mutex);
9 z8 L' S5 r1 v/ |0 N( }5 u0 }#endif
/ S& `5 Y5 ?0 S: Q# d  W
2 J3 d; U0 @% g; }% J$ E        return info;
#undef PADDING
% n( U/ K* W/ m& u#undef BYTES_PER_LONG
/ w$ x: ^7 }; f# Q}
EXPORT_SYMBOL(framebuffer_alloc);
在进行分配时，根据参数size的大小，分配了b_info_size + size的空间，然后让fb_info->par指向size的空间。因此par所指向的空间可视为设备特有的数据。
在分配了fb_info结构之后，需要将它注册到内核中。注册由register_framebuffer完成。我们来看下。

3.3 register_framebuffer
% z+ ?0 x/ }( v8 m6 }下列代码位于drivers/video/fbmem.c
! ^% M1 ^2 j2 E  M1 W
7 m. k1 \0 q- \  V# u/**
5 M& n" P/ x/ s6 A *        register_framebuffer - registers a frame buffer device
+ T$ E4 j. M) k1 T1 P: W* w *        @fb_info: frame buffer info structure
*
*        Registers a frame buffer device @fb_info.
" L4 R. v& Z7 L- W9 y, b; Q- w0 u *
*        Returns negative errno on error, or zero for success.
*
*/
% _0 l/ W+ P$ Y6 f/ W- r
int
register_framebuffer(struct fb_info *fb_info)
{
        int i;
+ `  A% ~" t0 Z* Z2 I% I5 q        struct fb_event event;
7 z. U. l3 D( A9 d; |4 `+ ?7 B$ G        struct fb_videomode mode;
+ Z& a1 `. m/ R
        if (num_registered_fb == FB_MAX) /*最多32个FB*/
                return -ENXIO;

+ ~. }- |7 b* W7 {, F- d        if (fb_check_foreignness(fb_info))
% O( P+ i1 g' u0 h1 k, ^                return -ENOSYS;
, A" Y! D  v( j7 n' C! l
9 A/ m( b+ G4 c2 a        num_registered_fb++;                /*对注册的FB计数*/
        /*寻找第一个空位*/
        for (i = 0 ; i < FB_MAX; i++)/*FB_MAX=32,也就是最多32个framebuffer*/
                if (!registered_fb)        /*struct fb_info *registered_fb[FB_MAX]*/
                        break;
        fb_info->node = i;
        mutex_init(&fb_info->lock);        /*初始化互斥体*/
' f( ^& B: ~# ]# R4 s0 L
        fb_info->dev = device_create(fb_class, fb_info->device,/*创建设备节点，节点名为fbx*/
/ I( \1 A$ [# T1 l$ j                                     MKDEV(FB_MAJOR, i), NULL, "fb%d", i);
* z8 V; c9 @- [; i3 d% s        if (IS_ERR(fb_info->dev)) {
                /* Not fatal */
                printk(KERN_WARNING "Unable to create device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->dev));
1 i# p0 J4 o/ U  ~& a                fb_info->dev = NULL;
        } else
. O8 ?) r2 e# i- o3 z  q                fb_init_device(fb_info);        /*初始化,在class/graphics/fbx/下创建设备属性*/
, ^3 F& b) t+ V4 U+ r
        if (fb_info->pixmap.addr == NULL) {
/ \( N- |( ~' p' h3 ?                fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL);/*分配内存，1024 * 8字节*/
1 F2 F7 k8 j9 F5 y+ ~' n- F- B                if (fb_info->pixmap.addr) {
9 c* |+ d. Q$ \' i) e# f                        fb_info->pixmap.size = FBPIXMAPSIZE;
& q+ f5 `* _9 t. x% t# p, o# {                        fb_info->pixmap.buf_align = 1;
                        fb_info->pixmap.scan_align = 1;
                        fb_info->pixmap.access_align = 32;
: \3 t5 m, y5 C- ~                        fb_info->pixmap.flags = FB_PIXMAP_DEFAULT;
                }
        }       
; F: w6 r( \5 ?4 T' v+ O- ^        fb_info->pixmap.offset = 0;
! H( n$ N% c. i2 V; u0 s
        if (!fb_info->pixmap.blit_x)
                fb_info->pixmap.blit_x = ~(u32)0;

: r: @! T+ `' w# f  @5 F  y6 ^+ O) c        if (!fb_info->pixmap.blit_y)
2 k* e' ?# p+ H! Y* e" @: u! |: \                fb_info->pixmap.blit_y = ~(u32)0;
2 D; I+ V" S6 _- G% m
        if (!fb_info->modelist.prev || !fb_info->modelist.next)        /*该链表没有指向其他节点*/
2 j, b0 M8 G8 J                INIT_LIST_HEAD(&fb_info->modelist);        /*初始化链表头*/
" p+ j& a9 a" O
. w' Q" S7 A3 C        fb_var_to_videomode(&mode, &fb_info->var);/*转换fb_var_screeninfo成fb_videomode*/
0 e  \* a% l5 d5 e        fb_add_videomode(&mode, &fb_info->modelist);/*添加mode至链表中*/
! q/ ~4 C& u' ?) W2 f) t) \8 x        registered_fb = fb_info;
0 l: B# s# P, j9 D/ `! m
        event.info = fb_info;
        if (!lock_fb_info(fb_info))
  k1 ~4 c% R" |' M% {/ N                return -ENODEV;
        fb_notifier_call_chain(FB_EVENT_FB_REGISTERED, &event);/*???*/
6 w$ j1 B7 ]& N        unlock_fb_info(fb_info);
5 G- y- W$ M8 [) z( p4 U        return 0;
2 |# B) f' ~0 F* ]4 I( U}

/ Y2 W9 w9 R/ Z9 _  u9 Q  K# |. U从这个函数我们可以看出，framebuffer子系统只支持32个设备。在创建了设备节点以后，建立设备属性节点，随后将fb_var_screeninfo转换成fb_videomode，最后添加fb_videomode至链表中。
我们看下其中调用的函数，首先是fb_init_device。
& O5 J: X$ c6 ^
0 T/ U* c; }: {- ?9 {下列代码位于drivers/video/fbsysfs.c
- i! A3 I" e7 i) M) J" O
int fb_init_device(struct fb_info *fb_info)
: U# u9 ]/ I$ A; o# d" F{
8 c! c, L6 ?4 I, P( J3 b1 }: P& V/ f        int i, error = 0;

& f: T4 E6 E0 C# S# O/ q$ J        dev_set_drvdata(fb_info->dev, fb_info);
8 A1 q. |9 e0 }( i* c2 T
6 k$ ?0 s; [' q. ]        fb_info->class_flag |= FB_SYSFS_FLAG_ATTR;

        /*建立设备属性*/
        for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
  }  o( Z* r: ~. I                error = device_create_file(fb_info->dev, &device_attrs);
4 n* k7 [- e+ L# m8 |2 \8 `8 T5 N
4 p; F. P: b7 S% v3 {6 P                if (error)
                        break;
6 w( |) W4 `& T$ J; \" H: i9 ?( g1 S        }

: ~* |. c" @! A  e  _2 A; l. z        if (error) {
                while (--i >= 0)
                        device_remove_file(fb_info->dev, &device_attrs);
                fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
        }
* x' z! d! V; E1 f" H) F" t
        return 0;
- \; U/ H2 Z, G}
/ v. p: b* R4 l$ A- S" [! ?
: D1 w4 u5 U, g; t5 x0 g* H, ]8 R3 Z/* When cmap is added back in it should be a binary attribute
* not a text one. Consideration should also be given to converting
* fbdev to use configfs instead of sysfs */
static struct device_attribute device_attrs[] = {
    __ATTR(bits_per_pixel, S_IRUGO|S_IWUSR, show_bpp, store_bpp),
    __ATTR(blank, S_IRUGO|S_IWUSR, show_blank, store_blank),
    __ATTR(console, S_IRUGO|S_IWUSR, show_console, store_console),
3 w/ |6 h6 W' Q6 y    __ATTR(cursor, S_IRUGO|S_IWUSR, show_cursor, store_cursor),
    __ATTR(mode, S_IRUGO|S_IWUSR, show_mode, store_mode),
    __ATTR(modes, S_IRUGO|S_IWUSR, show_modes, store_modes),
    __ATTR(pan, S_IRUGO|S_IWUSR, show_pan, store_pan),
" i, u( Z3 _! @8 A    __ATTR(virtual_size, S_IRUGO|S_IWUSR, show_virtual, store_virtual),
    __ATTR(name, S_IRUGO, show_name, NULL),
    __ATTR(stride, S_IRUGO, show_stride, NULL),
    __ATTR(rotate, S_IRUGO|S_IWUSR, show_rotate, store_rotate),
    __ATTR(state, S_IRUGO|S_IWUSR, show_fbstate, store_fbstate),
#ifdef CONFIG_FB_BACKLIGHT
    __ATTR(bl_curve, S_IRUGO|S_IWUSR, show_bl_curve, store_bl_curve),
: H* W( t* S6 `. w+ _! h+ I/ G#endif
' P- H3 B# @  l3 H};
0 Z; L9 n; Q8 B9 N4 B  N$ u8 ]; U4 g
我们可以在/sys/class/graphics/fb0下发现这些属性文件。
[root@yj423 fb0]#pwd
/sys/class/graphics/fb0
& I5 Z- w! M2 b" q[root@yj423 fb0]#ls
bits_per_pixel  cursor          mode            pan             state           uevent
: \; a, W! j$ Hblank           dev             modes           power           stride          virtual_size
console         device          name            rotate          subsystem
0 f$ I! z$ A/ f5 }% Q

接着看下fb_var_to_videomode和fb_add_videomode函数。
5 D3 z' P7 ^$ q+ f
$ }' V" Q) O) Y1 a下列代码位于drivers/video/modedb.c和drivers/video/fb.h
" s. H- K  c: t9 L2 f
struct fb_videomode {
7 P0 }" G& H. Y) _. w        const char *name;        /* optional */
        u32 refresh;                /* optional */
9 a- A9 \/ p, M        u32 xres;
" K4 w; ?" L1 i+ J2 g2 o4 Y& I8 {        u32 yres;
        u32 pixclock;
: m6 x+ n1 i' G7 i) Z- h0 D+ ]+ E        u32 left_margin;
        u32 right_margin;
6 E: n7 y, s: y1 K) V6 H' a8 `# M) u        u32 upper_margin;
        u32 lower_margin;
/ {2 z7 g4 r9 u4 H5 G- O        u32 hsync_len;
        u32 vsync_len;
        u32 sync;
        u32 vmode;
) p* V+ a1 g) @1 @6 ~        u32 flag;
};
% y2 z- n3 R; d  S
/**
+ J2 \! E# X" ~8 |, _; j0 O$ @3 r* {' e7 L * fb_var_to_videomode - convert fb_var_screeninfo to fb_videomode
* @mode: pointer to struct fb_videomode
* @var: pointer to struct fb_var_screeninfo
6 L/ H! z1 y/ n. O8 Q1 w$ R! J) h( v, d */
6 J+ B: y7 R$ k7 G* Uvoid fb_var_to_videomode(struct fb_videomode *mode,
/ r8 c0 M, U( [             const struct fb_var_screeninfo *var)
{
1 w$ U8 z9 j& W, O6 c    u32 pixclock, hfreq, htotal, vtotal;
; M( N0 v, F' l4 l) ?3 v$ f
; |  }5 V6 B) F5 N& x5 e    mode->name = NULL;
    mode->xres = var->xres;
    mode->yres = var->yres;
    mode->pixclock = var->pixclock;
* G1 P* b7 i- i, D1 U! w    mode->hsync_len = var->hsync_len;
    mode->vsync_len = var->vsync_len;
    mode->left_margin = var->left_margin;
    mode->right_margin = var->right_margin;
  b( A: S+ o- \9 {! x    mode->upper_margin = var->upper_margin;
    mode->lower_margin = var->lower_margin;
) C+ x! m  L* |' X5 x    mode->sync = var->sync;
2 H% M2 Q( i/ O9 Q) n" a    mode->vmode = var->vmode & FB_VMODE_MASK;
    mode->flag = FB_MODE_IS_FROM_VAR;
    mode->refresh = 0;

    if (!var->pixclock)
9 _, ]' @. Z; Y/ u        return;
' I+ b6 ~7 E6 F( u. A2 [0 S
    pixclock = PICOS2KHZ(var->pixclock) * 1000;

1 T) Y% H+ K* J/ m1 ?" }4 }; @    htotal = var->xres + var->right_margin + var->hsync_len +
' }' C4 Z( b% ]" q. `4 S& G        var->left_margin;
" K% I6 o; e' [0 q: o5 P. ]    vtotal = var->yres + var->lower_margin + var->vsync_len +
        var->upper_margin;

* ^/ [% x+ K$ K  \6 w, i" P    if (var->vmode & FB_VMODE_INTERLACED)
        vtotal /= 2;
* n. u& C9 S9 V- H8 g6 A3 S    if (var->vmode & FB_VMODE_DOUBLE)
$ c, ~4 i, ~0 m* }% m        vtotal *= 2;

    hfreq = pixclock/htotal;
    mode->refresh = hfreq/vtotal;
}

( ~  b/ l1 Z' w. Q+ J/**
* fb_add_videomode: adds videomode entry to modelist
* @mode: videomode to add
- o7 B- u7 N6 t5 z- I * @head: struct list_head of modelist
2 w- y0 f: f2 z *
, f1 ?! T6 P) P * NOTES:
* Will only add unmatched mode entries
0 A/ e' M1 Q; q( G% M' t */
int fb_add_videomode(const struct fb_videomode *mode, struct list_head *head)
{
    struct list_head *pos;
+ J* H/ Y" L2 s* W3 D; A1 Z    struct fb_modelist *modelist;d
    struct fb_videomode *m;
8 ]0 x  g9 a" E7 K) O" }; M4 }& l0 B    int found = 0;
4 b- {( k9 y3 c' _" P    /*遍历所有的fb_modelist，查找mode是否存在*/
    list_for_each(pos, head) {
3 |5 R# O% X$ r0 l# I        modelist = list_entry(pos, struct fb_modelist, list);
        m = &modelist->mode;
# n. u# p3 h( ]; @' A9 a" f        if (fb_mode_is_equal(m, mode)) {    /*比较两个fb_videomode*/
            found = 1;                        /*该fb_videomode已存在*/
5 Z2 p4 H2 i( L/ o8 C+ O# Y  m# l            break;
        }
( u7 H) ?6 k) ^: `& g' l+ m- i    }
    if (!found) {    /*不存在*/
        modelist = kmalloc(sizeof(struct fb_modelist),    /*分配fb_modelist*/
                          GFP_KERNEL);
: D$ A6 O" ~, c. ?2 v2 X6 S
  O, C8 c. x! w" V% C/ ^6 Q0 F        if (!modelist)
            return -ENOMEM;
        modelist->mode = *mode;            /*保存mode*/
5 Z. q9 v, h+ T1 e6 o        list_add(&modelist->list, head);/*添加mode至链表中*/
, {" G4 Z: E$ J! H    }
    return 0;
}

/**
* [- Z* ]+ S) [# q * fb_mode_is_equal - compare 2 videomodes
* @mode1: first videomode
) N" w2 @! o4 a * @mode2: second videomode
*
* RETURNS:
3 p" w9 _( R6 }1 G, I  I; |6 e7 F * 1 if equal, 0 if not
$ M+ ~* e% I1 M3 n */
int fb_mode_is_equal(const struct fb_videomode *mode1,
             const struct fb_videomode *mode2)
. D! q7 R1 U9 I# w/ }8 e. |{
    return (mode1->xres         == mode2->xres &&
        mode1->yres         == mode2->yres &&
        mode1->pixclock     == mode2->pixclock &&
6 @! s, C! b9 t2 S        mode1->hsync_len    == mode2->hsync_len &&
        mode1->vsync_len    == mode2->vsync_len &&
        mode1->left_margin  == mode2->left_margin &&
        mode1->right_margin == mode2->right_margin &&
        mode1->upper_margin == mode2->upper_margin &&
        mode1->lower_margin == mode2->lower_margin &&
- |2 V8 e& m; h, y, F- H        mode1->sync         == mode2->sync &&
        mode1->vmode        == mode2->vmode);
}

5 D7 a4 j& m: r( n6 V
fb_var_to_videomode函数只是将fb_var_screeninfo结构转换成fb_videomode结构。而fb_add_videomode函数查找是否该fb_videomode已经存在，如果不存在则添加到列表中。
3.4 字符设备方法
  在看过framebuffer子系统建立和注册过程后，我们看下framebuffer留给用户空间的API是怎样实现的。

4 X2 W% A  _! M: q  b! G/ l  Y本小结只分析5个常用的方法，即open，release，read，write和ioctl。
/ D5 o) U& @' a
  因为所有的方法和struct fb_ops定义的方法有紧密的联系，而该结构的定义由驱动程序给出，在这里我们提前看下在驱动中是如何定义的。
; Z/ ?  }- m4 R' I% _" d# R; }
* d  M# H% G" ?, L 下列代码位于drivers/video/s3c2410fb..c
# c7 V2 \: u& m4 A/ G4 x+ k$ b% F
* W5 N6 u" E! N5 \( n: ustatic struct fb_ops s3c2410fb_ops = {
+ o9 q* p$ W4 c3 d+ k5 \        .owner                = THIS_MODULE,
( R, X2 q4 T! L) \5 n        .fb_check_var        = s3c2410fb_check_var,                        /*检查变量的合法性*/
8 ~" d* ]' E3 t% P5 O9 V1 O        .fb_set_par        = s3c2410fb_set_par,                        /*将参数写入LCD控制器，该函数由帧缓冲核心调用*/
' J+ g8 T! v0 v9 J- w. l/ M( H        .fb_blank        = s3c2410fb_blank,                        /*该方法支持显示消隐和去消隐*/
        .fb_setcolreg        = s3c2410fb_setcolreg,                  /*设置颜色寄存器*/
+ ^( O; @# r8 l4 k4 m( S        .fb_fillrect        = cfb_fillrect,                                /*用像素行填充矩形框，通用库函数*/
0 _" X5 N. i6 k        .fb_copyarea        = cfb_copyarea,                                /*将屏幕的一个矩形区域复制到另一个区域，通用库函数*/
3 p. n/ z2 |$ S: V( t3 E/ q        .fb_imageblit        = cfb_imageblit,                        /*显示一副图像，通用库函数*/
};
( s9 n6 r( P5 e. t; F+ W: l- k最下面的三个方法使用的是内核提供的库函数，而上面4个则是由驱动提供。
3.4.1 open方法
下列代码位于drivers/video/fbmem.c

static int
% y: ]. k9 u# K! Kfb_open(struct inode *inode, struct file *file)
__acquires(&info->lock)
__releases(&info->lock)
{
        int fbidx = iminor(inode);
        struct fb_info *info;
: ^  @) h. M/ ?* a1 L        int res = 0;

        if (fbidx >= FB_MAX)
                return -ENODEV;
        info = registered_fb[fbidx];                /*在register_framebuffer函数中已经设置了元素*/
2 N" U1 ?* Y! |        if (!info)
" F$ m% K& a- N! P" I2 G; T                request_module("fb%d", fbidx);        /*加载模块，这里不加载*/
        info = registered_fb[fbidx];
        if (!info)
# d- C+ q8 F! I8 J" x                return -ENODEV;
' h7 k2 k( S' g3 X; c: A/ {, @3 Y        mutex_lock(&info->lock);                        /*加锁互斥体*/
        if (!try_module_get(info->fbops->owner)) {        /*增加模块引用计数*/
# o! }( [  x% \2 Z$ z( i7 R9 S/ M. J                res = -ENODEV;
5 b4 K7 X' G' W/ g  G- h8 \  R                goto out;
% f1 x* X; Y" ~  j  B        }
) J: z) y# k, m1 t        file->private_data = info;                /*保存info*/
/ ?0 f! L$ Z6 _        if (info->fbops->fb_open) {                /*这里fb_open方法为空*/
, G3 s, @" Y: p& i! q- X- a                res = info->fbops->fb_open(info,1);
# M2 Z6 Z4 P2 D# J; S+ n                if (res)
                        module_put(info->fbops->owner);
        }
. W2 W3 ~" l5 }7 k7 e3 \! ]0 o#ifdef CONFIG_FB_DEFERRED_IO
5 C5 `5 q4 g& g+ n& D0 o        if (info->fbdefio)
' }. |* k9 {! J& e* ~, L* g1 F# n# j                fb_deferred_io_open(info, inode, file);
) k, U* r8 Y8 ~2 {9 |! z#endif
out:
        mutex_unlock(&info->lock);                /*解锁互斥体*/
* P$ f2 {. `8 w0 R2 B4 b        return res;
" a/ b, j9 _7 `}
主要的一个工作就是增加模块引用计数。还有，程序会判断是否fb_open在驱动中给出，如果有则调用该方法。我们已经知道fb_open没有给出。
3.4.2 release方法
8 K( K3 O, F! ]5 T+ C+ ^下列代码位于drivers/video/fbmem.c

6 t( V# ]5 V% Gstatic int
fb_release(struct inode *inode, struct file *file)
9 Q+ ^  M& C1 [2 T__acquires(&info->lock)
__releases(&info->lock)
* k$ h: i# ]- i' Y1 |# O/ K{
. N5 Y5 Y$ w2 k7 Z8 a: Q* ?9 g        struct fb_info * const info = file->private_data;

% D, b3 ~' \. P        mutex_lock(&info->lock);
9 E: ?/ c: L9 z( c, }        if (info->fbops->fb_release)        /*这里fb_release为空*/
                info->fbops->fb_release(info,1);
        module_put(info->fbops->owner);        /*减少模块引用计数*/
2 @. z( {) {" m$ ]3 s        mutex_unlock(&info->lock);
& p0 H. Y1 n! T' x+ {5 N        return 0;
" t; Y# h% m* [" l' U# V/ t}
3 \/ p7 Q3 K6 \$ Q/ E6 A, N/ S和open相反，减少模块引用计数。
1 X6 s9 P7 w# }, K5 C$ k  t
3.4.3 write方法
  通过调用该方法，LCD将显示画面。
. ?6 c% ]: `5 y5 r5 O- t
7 t+ N7 T" _7 _  下列代码位于drivers/video/fbmem.c
9 R) ^0 a; K5 m* E9 }* W& y
static ssize_t
fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
6 @7 i" B- o* n; U* q{
    unsigned long p = *ppos;
1 W  ]  C$ L% Y/ p/ o/ g8 e    struct inode *inode = file->f_path.dentry->d_inode;
    int fbidx = iminor(inode);
    struct fb_info *info = registered_fb[fbidx];
    u32 *buffer, *src;
    u32 __iomem *dst;
9 h' @0 L& U$ ]6 Q    int c, i, cnt = 0, err = 0;
8 H: M; |/ O; H/ }    unsigned long total_size;

    if (!info || !info->screen_base)    /*screen_base在驱动中给出*/
* ^3 x' ?; s. u! D4 X        return -ENODEV;
8 u8 _5 q: z0 U6 f! h4 ?
    if (info->state != FBINFO_STATE_RUNNING)
        return -EPERM;
: F0 l# F& j  j! E6 r9 U. R2 T
    if (info->fbops->fb_write)    /*没有fb_write方法*/
# @5 q! R5 _# W        return info->fbops->fb_write(info, buf, count, ppos);

    total_size = info->screen_size;    /*screen_size没有给出*/
# D) W: a3 |( q4 ]
    if (total_size == 0)
  E! }" B& `2 q; I        total_size = info->fix.smem_len;/*153600字节，驱动probe方法中计算*/

) J5 \# R0 N# {) r7 y: M7 B    if (p > total_size)
9 L: Y) S  w4 u4 g  S  G        return -EFBIG;

5 D! n( Z6 m/ P9 u; i+ D    if (count > total_size) {    /*要写入的字节数大于153600*/
; Y7 P) y5 N* E1 W6 V* G+ |% M, R        err = -EFBIG;        /*file too big*/
        count = total_size;
8 o, k6 w& b2 X3 a    }
: C3 g5 R$ h) F
    if (count + p > total_size) {/*偏移量加上字节数超出了缓冲区*/
        if (!err)
            err = -ENOSPC;
( X; C( [( f6 s+ i6 x2 p
5 A; m; W, q# ?7 z+ ^; v        count = total_size - p;
    }

5 J9 F# b0 P8 L3 s. o    /*分配buffer，GFP_KERNEL*/
    buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
             GFP_KERNEL);                /
    if (!buffer)
        return -ENOMEM;

$ C8 P6 a; y% B- H( K7 j7 ?6 J+ V    dst = (u32 __iomem *) (info->screen_base + p);/*修改目的指针*/
; P) p3 k2 ?" I9 r
; w: j% r8 s- R6 o6 d" L6 m    if (info->fbops->fb_sync)    /*没有定义fb_sync*/
- U5 }0 A, G, J) X; t! F: ^        info->fbops->fb_sync(info);
, _' T* z0 P% |& B# G! V
. g& V7 b9 D9 R8 H    while (count) {
" s" t0 L/ X" P3 {        c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
        src = buffer;
1 z& x; c, T4 k& w
% s- c( f, j! h4 }* a. n        /*从buf(用户空间)拷贝数据到src中，一开始为1页，最后为count字节*/
        if (copy_from_user(src, buf, c)) {   
8 T  ?, b! D4 ^& c# g, X! j            err = -EFAULT;
# m4 U3 V  Q4 ]3 v3 h8 D, i( I$ c            break;
+ a3 A  \* b6 K' J3 N" ?$ r4 ?        }
8 `$ H2 x4 }4 m* U- P$ f        /*一次for循环，写入4个字节数据到dst处*/
/ f8 p1 \0 ^1 W  V: H) u& W) U6 _        for (i = c >> 2; i--; )
            fb_writel(*src++, dst++);
* P& |" }8 h: Z& A7 T: l0 w. l        /*最后还有3个，2个或者1个字节*/
* r5 e1 o; W) j        if (c & 3) {
            u8 *src8 = (u8 *) src;
            u8 __iomem *dst8 = (u8 __iomem *) dst;
, D) a% ?8 b4 l0 ]            /*一次写入一个字节*/
            for (i = c & 3; i--; )
* g! ?6 ^  k5 T! L7 W  g$ z( f" @                fb_writeb(*src8++, dst8++);

/ v+ L4 K7 ^! n1 a6 [            dst = (u32 __iomem *) dst8;
" F9 l/ V  F9 U- z" A        }

3 m+ V3 P$ b" h: [        *ppos += c;    /*用户空间偏移量增加*/
4 B3 I2 }" `0 w+ A' {9 M0 z        buf += c;    /*用户空间指针增加*/
        cnt += c;    /*修改已发送字节数*/
1 A, P- `5 b# f9 M0 ]        count -= c;    /*减去1页*/
# l2 |" p: E$ j; J5 W- {" @3 D# `    }

    kfree(buffer);    /*释放buffer*/

+ S8 T7 P/ G3 i+ l" I    return (cnt) ? cnt : err;
. M0 V& ^- F% Q+ E2 E7 p( ]}
# d8 y4 _/ `& l1 k$ P% [1 }% }4 `  O
这里，做了一系列的检查之后，开始拷贝数据。这里一个有三个buffer，一个是用户空间提供的buf，一个是在这里新开辟的buffer，还有就是驱动层提供的screen_base。
数据流如下：
- L7 c" U5 \- u2 |, G; P

8 O, }# G" }( y' `1 H
用户空间的数据首先被复制到buffer中，然后从buffer中复制到screen_base中，最后被映射到LCD上，LCD就显示响应的画面了。
+ P( q+ ~* [" _; h5 |; d8 `
3.4.4 read方法
该方法用于读取屏幕画面的数据。

read和write类似，只是数据流是反响的，就不多做介绍了。
' q- i" T) R2 F& m/ S; I
下列代码位于drivers/video/fbmem.c
1 {, f) a. M4 p" M6 j4 h3 D
4 P" S3 c# k8 O( \7 n: o0 f& D- _static ssize_t
fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
2 w4 L2 u! ]7 ]2 d( S        unsigned long p = *ppos;
        struct inode *inode = file->f_path.dentry->d_inode;
        int fbidx = iminor(inode);
" O  R% X  Z1 O6 G3 g        struct fb_info *info = registered_fb[fbidx];
        u32 *buffer, *dst;
        u32 __iomem *src;
        int c, i, cnt = 0, err = 0;
, |4 w6 K& f& a( v; @, O        unsigned long total_size;
8 f$ ~" @6 Q5 S& g! z0 n
- g. z, T# l; A# ?% _        if (!info || ! info->screen_base)
# m5 F  ^8 l5 }) Q5 n  ^/ E                return -ENODEV;

. J2 M, {0 j+ q' y, I        if (info->state != FBINFO_STATE_RUNNING)
' s) ^  P/ k9 z$ \; I9 u                return -EPERM;
0 [' g% M6 Z4 _; t( R# Y* O8 V8 K) }
; m& s  [8 s0 T; y- H        if (info->fbops->fb_read)        /*没有定义fb_read*/
) a+ J' e$ Y0 F                return info->fbops->fb_read(info, buf, count, ppos);
' ^+ [$ s- o; S+ k7 O: N/ m       
        total_size = info->screen_size;
4 Y* ^; a( q* S2 x2 `+ L& Y. R
        if (total_size == 0)
, y. N* |% q5 u* G) f% k                total_size = info->fix.smem_len;
" ]) m6 K# X, w$ f
2 M. q- Q* s0 ^* ?        if (p >= total_size)
& e/ [$ k9 {4 ^  Z  f9 _                return 0;

        if (count >= total_size)
                count = total_size;
6 A6 T  H# ]$ k- B6 X
2 b3 @5 A2 H1 j6 z6 Z        if (count + p > total_size)
/ H9 Q$ y( {' o0 A5 J- Z                count = total_size - p;
- R4 S. w" U9 I2 p: f+ W' M" P
4 I; X5 M# w( P& w9 ?& n6 m7 d1 i* s        buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
                         GFP_KERNEL);
        if (!buffer)
                return -ENOMEM;
/ r' ^1 c% N6 B9 v; i
        src = (u32 __iomem *) (info->screen_base + p);
2 t# K# G1 F0 z, _8 i( @8 U
" f9 a* p* u# k- r* K& ^        if (info->fbops->fb_sync)
                info->fbops->fb_sync(info);/*没有定义fb_sync*/
0 E; _+ O/ a) M5 m& E: h
        while (count) {
- x  a, [. p6 i" L0 O; S( }/ f8 n) K                c  = (count > PAGE_SIZE) ? PAGE_SIZE : count;
" g1 q' l' u: a! R                dst = buffer;
                for (i = c >> 2; i--; )
                        *dst++ = fb_readl(src++);
                if (c & 3) {
                        u8 *dst8 = (u8 *) dst;
                        u8 __iomem *src8 = (u8 __iomem *) src;
1 B4 x4 k8 R. C" {  i0 M# e! [/ B
/ L7 @* u; ?! F                        for (i = c & 3; i--;)
                                *dst8++ = fb_readb(src8++);
. r( T& g6 q  |+ G1 }' i
' C! h' \. F# ~8 C- {1 r9 }. I1 F# G9 m                        src = (u32 __iomem *) src8;
                }

2 A7 D' h: F7 B) L                if (copy_to_user(buf, buffer, c)) {
                        err = -EFAULT;
. ^8 P) ~1 ]) p  d, [4 P                        break;
6 O+ t# F5 E+ n1 b9 V                }
                *ppos += c;
$ a7 t1 k6 T  M/ U                buf += c;
4 C$ u; d3 p9 y' @8 p+ M                cnt += c;
                count -= c;
        }

8 W6 l, P0 N) `) q. Y        kfree(buffer);

        return (err) ? err : cnt;
}
7 j* T% J7 _) }5 E+ r3.4.5 ioctl方法
这里只是简单的看下ioctl方法，这个函数调用很多其他的函数，详细的请自己看吧。
: e! Y7 W: h. I; N. r  f2 c
下列代码位于drivers/video/fbmem.c

static long fb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
4 t" f( a6 n3 O; o+ Y' T; z- L; [{
        /*获取inode，再获取对应的fb_info*/
        struct inode *inode = file->f_path.dentry->d_inode;
* E, A0 }8 i+ h8 C        int fbidx = iminor(inode);       
" b6 m' b6 J- A1 Y' r/ P        struct fb_info *info = registered_fb[fbidx];

        return do_fb_ioctl(info, cmd, arg);
}

static long do_fb_ioctl(struct fb_info *info, unsigned int cmd,
            unsigned long arg)
3 F+ |  A. ]" E/ a* M1 D' R{
    struct fb_ops *fb;
' n0 h/ r, _7 g% d# w0 C; W% `    struct fb_var_screeninfo var;
' k- K! u- y3 T( U. F* C( k! f    struct fb_fix_screeninfo fix;
5 X* ^1 I/ y7 w8 N- o    struct fb_con2fbmap con2fb;
% m: m- ?6 W& ]' M3 `/ R3 F    struct fb_cmap cmap_from;
    struct fb_cmap_user cmap;
    struct fb_event event;
    void __user *argp = (void __user *)arg;
4 f6 [9 T* r: p( P( t$ v    long ret = 0;
2 i; }# m0 V# J# o# b5 x$ i
8 p0 l( y: D7 F5 I* t0 a    switch (cmd) {
    /*获取fb_var_screeninfo*/
    case FBIOGET_VSCREENINFO:   
  I5 w1 t6 _. z- }2 A3 }& \        if (!lock_fb_info(info))    /*加锁互斥体info->lock*/
            return -ENODEV;
) v, @& A9 y2 G5 K! i2 Y  r        var = info->var;            /*复制var*/
; z# t: \, Z) j$ U+ T        unlock_fb_info(info);

        ret = copy_to_user(argp, &var, sizeof(var)) ? -EFAULT : 0;    /*复制var到用户空间*/
        break;
    /*设置fb_var_screeninfo*/
    case FBIOPUT_VSCREENINFO:
        if (copy_from_user(&var, argp, sizeof(var)))    /*从用户空间获取var*/
  k0 |8 G& E. D            return -EFAULT;
" L& C# u) `# h        if (!lock_fb_info(info))
            return -ENODEV;
1 P' a; h$ M6 ?) n- ?" v; f, P        acquire_console_sem();
/ z1 @" _. v$ X4 K( B        info->flags |= FBINFO_MISC_USEREVENT;
# x$ m( k# l0 H- F  g4 ^$ Z        ret = fb_set_var(info, &var);            /*设置var*/
        info->flags &= ~FBINFO_MISC_USEREVENT;
        release_console_sem();
        unlock_fb_info(info);
1 |* {- S5 e* ?4 t        if (!ret && copy_to_user(argp, &var, sizeof(var)))
            ret = -EFAULT;
        break;
$ M% S/ h& B6 m9 D    /*获取fb_fix_screeninfo*/    /*fix为不可改变信息，只能获取，不能设置*/
2 E) m' V! m) j    case FBIOGET_FSCREENINFO:
& ]$ C5 z* G$ c& i% z* o2 B( z6 Y; U        if (!lock_fb_info(info))
2 p# s9 N( X6 x  q& a            return -ENODEV;
        fix = info->fix;
        unlock_fb_info(info);
$ ?6 ?2 d6 F+ |! p6 t9 e8 U6 N
1 n* ~1 c- ]: P  x2 [% ]        ret = copy_to_user(argp, &fix, sizeof(fix)) ? -EFAULT : 0;
; M9 W7 b& w( ?1 v( S        break;
; Y) v- s1 }1 _- \    /*设置fb_cmap*/   
    case FBIOPUTCMAP:
) G1 e* E5 `  X6 g        if (copy_from_user(&cmap, argp, sizeof(cmap)))
2 c2 ?6 b6 H5 Q5 R( D+ H" H            return -EFAULT;
. [8 Q6 f1 O2 Y5 U& R# S        ret = fb_set_user_cmap(&cmap, info);    /*设置fb_cmap*/
: L/ u5 G/ G; q        break;
    /*获取fb_cmap*/   
# D0 v2 V) d$ \7 ]) d0 u    case FBIOGETCMAP:
        if (copy_from_user(&cmap, argp, sizeof(cmap)))
( d* X' ^3 P3 e6 O# i            return -EFAULT;
# S7 ?8 [2 U4 j4 Y& }* O& O8 H! C        if (!lock_fb_info(info))
            return -ENODEV;
! a4 C( X7 e( F$ ^$ \        cmap_from = info->cmap;
: T  X4 ~7 {2 [7 v: U& [. q        unlock_fb_info(info);
/ K' w7 G8 r! E, ^, F; h% G        ret = fb_cmap_to_user(&cmap_from, &cmap);/*获取fb_cmp*/
        break;
; Z8 m5 E7 s7 F- Y    case FBIOPAN_DISPLAY:
        if (copy_from_user(&var, argp, sizeof(var)))
8 p3 ]5 A# e- h            return -EFAULT;
        if (!lock_fb_info(info))
            return -ENODEV;
& @+ P! z8 B# ?) R        acquire_console_sem();
7 |1 h  {$ n2 j9 [' z# g        ret = fb_pan_display(info, &var);
        release_console_sem();
        unlock_fb_info(info);
* A2 f1 u$ r- J! e% @9 n        if (ret == 0 && copy_to_user(argp, &var, sizeof(var)))
: p. x7 b8 l$ V- i2 B7 y            return -EFAULT;
        break;
    case FBIO_CURSOR:
        ret = -EINVAL;
, }* m6 W/ R% D! e* u7 G: ?0 a# V        break;
    case FBIOGET_CON2FBMAP:
  C. v  c6 M$ W. ?& }4 l# a        if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
            return -EFAULT;
: ]4 [' ~1 M9 Q3 l7 o( W        if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
: Z; J7 O$ z/ R& Q1 @9 G8 A            return -EINVAL;
$ v( E& ~. E, A6 F! c! y8 s        con2fb.framebuffer = -1;
6 Z& R" a1 v6 I0 N. _- T        event.data = &con2fb;
  s9 G/ u  t- |! v; p  e* L        if (!lock_fb_info(info))
            return -ENODEV;
0 s3 O7 @; t+ x$ D1 q        event.info = info;
; p+ V+ ]+ n, g, x& b        fb_notifier_call_chain(FB_EVENT_GET_CONSOLE_MAP, &event);
) `5 [9 v3 @. w) x9 M3 n        unlock_fb_info(info);
1 q4 y0 C7 c: _$ o. u$ [        ret = copy_to_user(argp, &con2fb, sizeof(con2fb)) ? -EFAULT : 0;
        break;
# ~5 n2 h% Y8 l* ]7 M    case FBIOPUT_CON2FBMAP:
        if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
  i; [: J' Z3 u0 ]6 G9 m! w. R            return -EFAULT;
5 T8 z/ z0 b9 g* ~; u8 C+ M        if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
            return -EINVAL;
2 l  S6 K. U4 e" K4 o        if (con2fb.framebuffer < 0 || con2fb.framebuffer >= FB_MAX)
+ g4 X0 V+ v# @% ~9 F. B            return -EINVAL;
        if (!registered_fb[con2fb.framebuffer])
7 w8 V0 c2 Y% m& |' f# Q  e            request_module("fb%d", con2fb.framebuffer);
8 n0 f% h" E) y4 C        if (!registered_fb[con2fb.framebuffer]) {
            ret = -EINVAL;
            break;
        }
2 a2 }8 D& L$ _0 I' ~0 L# f        event.data = &con2fb;
        if (!lock_fb_info(info))
! B8 Q. Y5 b8 I- N- ^            return -ENODEV;
        event.info = info;
1 g" F/ T# n' W2 Q        ret = fb_notifier_call_chain(FB_EVENT_SET_CONSOLE_MAP, &event);
' y8 t/ a8 k+ M4 D! M& M7 z8 @! X        unlock_fb_info(info);
        break;
* @( P1 W$ k% H% K* k: g5 ?& v    case FBIOBLANK:
  ?7 k3 Z0 E  ~1 L# [" J        if (!lock_fb_info(info))
/ p0 S) G) j7 T- q            return -ENODEV;
        acquire_console_sem();
5 e5 Y5 B0 N/ i. t! a3 @        info->flags |= FBINFO_MISC_USEREVENT;
& X# M& P/ U; n5 ?: D        ret = fb_blank(info, arg);        ?*最后调用驱动提供的s3c2410fb_blank*/
        info->flags &= ~FBINFO_MISC_USEREVENT;
        release_console_sem();
6 H3 v% S0 N7 t  _4 T        unlock_fb_info(info);
        break;
7 K9 D; W9 V6 {4 V    default:
        if (!lock_fb_info(info))
            return -ENODEV;
. W; W  X7 B, i/ ^$ f3 |! W        fb = info->fbops;
        if (fb->fb_ioctl)        /*fb_ioctl为空*/
! d; {9 _2 z  ~7 ?6 l9 j            ret = fb->fb_ioctl(info, cmd, arg);
        else
            ret = -ENOTTY;
- E: J2 P' S' I        unlock_fb_info(info);
+ v6 _0 P1 c4 ]3 c1 H" t    }
2 f. H) O) H6 `8 j% q: l: d    return ret;
! C! W4 ]( W! ~- w" G6 \}
正如2.2小结所说的，fb_fix_screeninfo只能获取不能设置，因此，ioctl只提供了获取fb_fix_screeninfo的方法，而没有提供设置fb_fix_screeninfo的方法。

3.5 小结
  本节对frambuffer的核心层进行了介绍。包括frambuffer子系统的创建，frambuffer的注册和提供给用户空间的5个API函数。下面开始介绍驱动层。

# X6 Q% }6 \0 x& ]) y6 C4. 驱动层
本节将开始介绍S3C2440的frambuffer驱动，该驱动源码位于drivers/video/s3c2410fb.c

首先来看下驱动模块的初始化和清除函数。
. ^3 V  X* `5 f) Y+ q
4.1 s3c2410fb_init和s3c2410fb_cleanup
static struct platform_driver s3c2410fb_driver = {
    .probe        = s3c2410fb_probe,
5 b9 m- C/ H7 p5 F1 F    .remove        = s3c2410fb_remove,
- ?9 y0 m8 P% N- _    .suspend    = s3c2410fb_suspend,
1 X# `8 D6 t. x# H: O1 L0 F    .resume        = s3c2410fb_resume,
# m' A! c: \2 S  `0 N) e    .driver        = {
        .name    = "s3c2410-lcd",
. J1 F1 J) C+ W! }& u        .owner    = THIS_MODULE,
    },
};
+ M4 v  Y8 W9 S, c( D9 S% v. I
1 c3 k% y4 J+ I8 m  D! [int __init s3c2410fb_init(void)
{
        int ret = platform_driver_register(&s3c2410fb_driver);

2 c% G! G' Q3 d        if (ret == 0)
                ret = platform_driver_register(&s3c2412fb_driver);;

        return ret;
}
+ k; z5 I% W* Y, A# w3 Q1 W) [+ u9 b5 {
static void __exit s3c2410fb_cleanup(void)
{
! S+ y! I; D0 \( w        platform_driver_unregister(&s3c2410fb_driver);
* [7 e. w8 q7 h1 p        platform_driver_unregister(&s3c2412fb_driver);
& X0 F$ j, U4 T, i( k3 Q}
' _5 h& Q' v; q1 z+ Y. ?/ p
0 Z/ d/ P% i( W) xmodule_init(s3c2410fb_init);
& B* O: Y* e" p2 Dmodule_exit(s3c2410fb_cleanup);
( I: A' J% I( J3 K8 H
, p: s0 v* A! c/ _3 A当platform_driver_register调用的最后会调用probe方法。接下来就来看看probe方法。
) ^9 }- s, U& H. V4.2 probe方法
( q; l6 i! x1 {1 m( ostruct s3c2410fb_info {
9 H5 A- h+ M$ U. a: w7 l    struct device        *dev;
    struct clk        *clk;
  u7 D1 f* m& K7 r+ \! p3 g
* M9 x# Q2 I. |/ L; S    struct resource        *mem;
    void __iomem        *io;        /*虚拟地址*/
$ l* u$ q* E1 N2 i    void __iomem        *irq_base;

    enum s3c_drv_type    drv_type;
    struct s3c2410fb_hw    regs;

    unsigned int        palette_ready;

6 U& N& \% U" \8 x; x    /* keep these registers in case we need to re-write palette */
    u32            palette_buffer[256];
% W+ q( Y  q9 ]5 I    u32            pseudo_pal[16];
$ j# N; I7 O- j6 B! ~2 i};

2 q5 J1 a" y: H- n1 C: dstruct s3c2410fb_mach_info {

        struct s3c2410fb_display *displays;        /* attached diplays info */
$ W$ Q+ G/ \# ~* e( o4 z" u# w        unsigned num_displays;                        /* number of defined displays */
/ }0 Q+ f8 T* y; S$ \9 W0 R5 q, H        unsigned default_display;
2 {4 Q; G! [$ P4 r
! A, _3 C4 P( U# j7 _0 P        /* GPIOs */
3 F% A  ]5 }8 l+ p
2 E  H( h2 c7 \2 }+ ?! {9 B        unsigned long        gpcup;
        unsigned long        gpcup_mask;
        unsigned long        gpccon;
' y" h% I7 o" e6 `7 h- `        unsigned long        gpccon_mask;
$ Y* u' ~# j+ Q2 p, O        unsigned long        gpdup;
# t5 r/ H) h4 Z" D        unsigned long        gpdup_mask;
        unsigned long        gpdcon;
! }" n* O8 h/ o( L# Y2 w" G        unsigned long        gpdcon_mask;
& u" m, v3 s' O
        /* lpc3600 control register */
        unsigned long        lpcsel;
};

/* LCD description */
7 E7 ]& |( D" S. f' R* w2 C' sstruct s3c2410fb_display {
# i0 x4 E0 ~9 u% g5 p/ ^7 \    /* LCD type */
7 J, W8 H2 G, C6 G/ D    unsigned type;
& {( l# }8 y3 q2 _1 o! i; I! V
3 t3 K  l* k9 D* L, P- W    /* Screen size */
    unsigned short width;
0 S$ n% L) F4 ?    unsigned short height;
# i( t& R: i0 P8 h, c9 J5 S5 V1 u
    /* Screen info */
: x/ F, ]4 G4 L    unsigned short xres;
( ~: i& w+ s. v4 }8 Y" W! q8 G    unsigned short yres;
    unsigned short bpp;

    unsigned pixclock;        /* pixclock in picoseconds */
    unsigned short left_margin;  /* value in pixels (TFT) or HCLKs (STN) */
    unsigned short right_margin; /* value in pixels (TFT) or HCLKs (STN) */
8 E* l) e7 h. J, W4 x( I8 \    unsigned short hsync_len;    /* value in pixels (TFT) or HCLKs (STN) */
    unsigned short upper_margin;    /* value in lines (TFT) or 0 (STN) */
    unsigned short lower_margin;    /* value in lines (TFT) or 0 (STN) */
    unsigned short vsync_len;    /* value in lines (TFT) or 0 (STN) */

    /* lcd configuration registers */
; X; ^* H7 V. R' Q. p    unsigned long    lcdcon5;
};

static int __init s3c24xxfb_probe(struct platform_device *pdev,
* D; Y. d2 `4 s& T                  enum s3c_drv_type drv_type)
{
3 J  V7 k7 ^* _    struct s3c2410fb_info *info;
    struct s3c2410fb_display *display;
: k$ r& |& O$ S" ~5 l- q0 t4 U$ R    struct fb_info *fbinfo;
    struct s3c2410fb_mach_info *mach_info;
0 z* r0 U) J1 z( y& ?4 S) W; Y    struct resource *res;
    int ret;
& i8 H7 U) `3 M. s# y. U  L    int irq;
    int i;
    int size;
    u32 lcdcon1;
    /*dev.platform_data由函数s3c24xx_fb_set_platdata(mach-smdk2410.c)设置，指向s3c2410fb_mach_info*/
    mach_info = pdev->dev.platform_data;   
% p7 M4 ]! [5 i6 ]/ O    if (mach_info == NULL) {
        dev_err(&pdev->dev,
            "no platform data for lcd, cannot attach\n");
        return -EINVAL;
    }
                                    /*在mach-smdk2440.c中，default_display=0, num_displays=1*/
# @" |- M  @( B1 w+ G& U    if (mach_info->default_display >= mach_info->num_displays) {     
7 U$ f6 n# f# y9 Y        dev_err(&pdev->dev, "default is %d but only %d displays\n",
, @! z% Y; |' R& y2 m            mach_info->default_display, mach_info->num_displays);
        return -EINVAL;
    }
6 [) ^4 @% Y& O! L% n0 L& Z/ k
    display = mach_info->displays + mach_info->default_display;
' Z. C( D; a' f, M8 |
    irq = platform_get_irq(pdev, 0);    /*获取IRQ号,16号中断*/
; k5 T# }  [2 U    if (irq < 0) {
        dev_err(&pdev->dev, "no irq for device\n");
        return -ENOENT;
' A4 T# B" W( V3 w" X( W    }
                                        /*分配struct fb_info 其中包括sizeof字节的私有数据区*/
: i6 R0 }2 F  ?7 f    fbinfo = framebuffer_alloc(sizeof(struct s3c2410fb_info), &pdev->dev);
    if (!fbinfo)
$ v) r/ h* {4 q- q2 Z' q        return -ENOMEM;

    platform_set_drvdata(pdev, fbinfo);    /*让platform_device->dev.driver_data指向struct fb_info*/

. [- q; T1 b$ \/ G' f0 P    info = fbinfo->par;                    /*par指向s3c2410fb_info*/
% V0 K% S* h  B$ `4 k2 i  Y    info->dev = &pdev->dev;
5 e2 A; M: t  n# ^! Q    info->drv_type = drv_type;

    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);/*获取平台资源*/
    if (res == NULL) {
  ~4 B, x1 [( U# H7 F        dev_err(&pdev->dev, "failed to get memory registers\n");
- f1 j% e5 Y2 e' l7 u6 j" J( [        ret = -ENXIO;
        goto dealloc_fb;
0 v7 m% \$ ^  [& ?' T% P. R( D    }

    size = (res->end - res->start) + 1;                /*IO内存申请*/
" H1 a. m  o% ]3 U$ r8 D4 P% b    info->mem = request_mem_region(res->start, size, pdev->name);   
    if (info->mem == NULL) {
/ S% A/ r- e) C9 F( }- e& [        dev_err(&pdev->dev, "failed to get memory region\n");
        ret = -ENOENT;
9 X8 S9 ~+ S' c        goto dealloc_fb;
" Q8 g1 g2 q  v) M2 p    }

    info->io = ioremap(res->start, size);            /*IO内存映射,获取lcd第一个寄存器的映射地址*/               
% {1 T; j7 x3 q7 i9 `) Q& t5 D    if (info->io == NULL) {
        dev_err(&pdev->dev, "ioremap() of registers failed\n");        
- I' U( {% x" r        ret = -ENXIO;   
1 K  c# A- b, H! U+ L( P6 u        goto release_mem;
% a/ k+ Y! T9 d, Q7 K    }
; T5 z8 R3 P, C3 x# `5 L                                            /*irq_base对应的物理地址是0X4D00 0054(寄存器LCDINTPND)*/
    info->irq_base = info->io + ((drv_type == DRV_S3C2412) ? S3C2412_LCDINTBASE : S3C2410_LCDINTBASE);
4 O, p. x# H% a* a  W9 G" K
) N( d; B. t$ ~- N" d8 F    dprintk("devinit\n");
4 C% b  R0 Z: h" \
* h3 E# n3 l$ d: i2 E    strcpy(fbinfo->fix.id, driver_name);    /*复制名字*/

    /* Stop the video */
    lcdcon1 = readl(info->io + S3C2410_LCDCON1);
    writel(lcdcon1 & ~S3C2410_LCDCON1_ENVID, info->io + S3C2410_LCDCON1); /*禁止LCD*/

" N, P2 E# ?" y% D    fbinfo->fix.type        = FB_TYPE_PACKED_PIXELS;
( L& y* [# F" B* c4 m    fbinfo->fix.type_aux        = 0;
2 F0 x5 R6 G0 j. K" M8 }    fbinfo->fix.xpanstep        = 0;
: @# F! i; C6 ?1 K% }3 n# D( s    fbinfo->fix.ypanstep        = 0;
! R3 R- H( M. Z5 [8 |. Q" j( Y    fbinfo->fix.ywrapstep        = 0;
    fbinfo->fix.accel        = FB_ACCEL_NONE;    /* no hardware accelerator    */

    fbinfo->var.nonstd        = 0;
    fbinfo->var.activate        = FB_ACTIVATE_NOW;
    fbinfo->var.accel_flags     = 0;
    fbinfo->var.vmode        = FB_VMODE_NONINTERLACED;

* i( O, T/ @& R4 e! t& J" N    fbinfo->fbops            = &s3c2410fb_ops;
: [: s7 V# U; v) H8 ^. Q+ z- E    fbinfo->flags            = FBINFO_FLAG_DEFAULT;
0 K; V* h$ R9 V1 q8 H! v. A. @    fbinfo->pseudo_palette      = &info->pseudo_pal;
! L: F3 V' I0 E" q8 `5 J! e0 W+ r
' J/ y+ V5 r+ W3 c3 s' Q    for (i = 0; i < 256; i++)
        info->palette_buffer = PALETTE_BUFF_CLEAR;
: P+ N. D+ Y) G9 _- Q3 |# j
    ret = request_irq(irq, s3c2410fb_irq, IRQF_DISABLED, pdev->name, info);    /*申请IRQ，快速中断*/
5 t3 p# u; f+ [0 ?    if (ret) {
        dev_err(&pdev->dev, "cannot get irq %d - err %d\n", irq, ret);
2 [$ _. d6 _/ R        ret = -EBUSY;
        goto release_regs;
    }

    info->clk = clk_get(NULL, "lcd");        /*获取时钟信息*/
    if (!info->clk || IS_ERR(info->clk)) {
+ q: t4 }) n5 x) ?! m; `) g        printk(KERN_ERR "failed to get lcd clock source\n");
        ret = -ENOENT;
        goto release_irq;
% ]! e0 P/ T2 p5 B2 m    }
, s3 V4 x' b' @; Z/ P; r8 b
    clk_enable(info->clk);                    /*使能时钟*/
% N" k8 e' L5 Y& R6 ]    dprintk("got and enabled clock\n");

    msleep(1);
# T7 R9 O5 T; f& o" [
    /* find maximum required memory size for display */
+ h5 S$ }7 [' ~% W( j% G. @    /*在多个屏幕中，找出需要的最大memory*/
    for (i = 0; i < mach_info->num_displays; i++) {
; n* O' U# T  @        unsigned long smem_len = mach_info->displays.xres;
        /*所需的memory空间 = xres * yres * bpp / 8*/
        smem_len *= mach_info->displays.yres;
        smem_len *= mach_info->displays.bpp;
        smem_len >>= 3;
        if (fbinfo->fix.smem_len < smem_len)
2 u9 J( H) G9 h+ a4 p; \0 O# f! G            fbinfo->fix.smem_len = smem_len;
$ x( z3 H0 \: c5 U5 X& v( m5 y    }

    /* Initialize video memory */    /*根据上面fix.smem_len的大小，获取DMA映射内存，一致性映射方式*/
# D' Z4 a: u- q5 {4 R    ret = s3c2410fb_map_video_memory(fbinfo);
    if (ret) {
  I* k3 o' H& J2 n7 P# R4 O- ^        printk(KERN_ERR "Failed to allocate video RAM: %d\n", ret);
( J# J1 Z! V5 n- G. Y        ret = -ENOMEM;
7 [3 I8 y; h0 m5 h        goto release_clock;
    }

    dprintk("got video memory\n");
  d1 g9 m9 r, f9 k
+ w9 N# `% z3 b- h! ?    fbinfo->var.xres = display->xres;            /*320*/
    fbinfo->var.yres = display->yres;            /*240*/   
3 O2 S2 N9 \/ u$ I6 i: u0 A    fbinfo->var.bits_per_pixel = display->bpp;    /*16*/
1 |% S2 O/ l  Z5 r* _9 d
    s3c2410fb_init_registers(fbinfo);            /*LCD寄存器初始化*/        
3 Y) [/ @' z# U8 S9 G" X
    s3c2410fb_check_var(&fbinfo->var, fbinfo);
4 t. T. M4 ]  C) |: r1 V! D
    ret = register_framebuffer(fbinfo);            /*注册framebuffer*/
    if (ret < 0) {
        printk(KERN_ERR "Failed to register framebuffer device: %d\n",ret);
        goto free_video_memory;
    }

$ ]3 B# d/ ]0 j6 A0 }% Y    /* create device files */
    ret = device_create_file(&pdev->dev, &dev_attr_debug); /*添加设备属性*/
    if (ret) {
        printk(KERN_ERR "failed to add debug attribute\n");
  F8 p& {3 _8 \- P+ y1 }    }

    printk(KERN_INFO "fb%d: %s frame buffer device\n",
        fbinfo->node, fbinfo->fix.id);

    return 0;
5 ]7 U& m$ R7 C' t& y/*一旦某个步骤发生错误，以注册的相反顺序开始注销*/
free_video_memory:
    s3c2410fb_unmap_video_memory(fbinfo);
" ^8 o" P6 y, {. Jrelease_clock:
! @' p1 q# y8 k& W    clk_disable(info->clk);
    clk_put(info->clk);
& I' J' p+ e1 \4 Y1 P2 ^release_irq:
! G5 A7 [) {9 O+ K    free_irq(irq, info);
- T9 v% Q. |3 s+ N+ Brelease_regs:
    iounmap(info->io);
& f3 H" J* }; Zrelease_mem:
0 V5 {# {7 j$ y' |! i    release_resource(info->mem);
    kfree(info->mem);
dealloc_fb:
    platform_set_drvdata(pdev, NULL);
/ [; p) B. ^6 b: Y# C$ T$ x    framebuffer_release(fbinfo);   
    return ret;
}

这里使用了三个新的数据结构。s3c2410fb_info是驱动程序使用的，里面将保存所有驱动程序所要使用的资源等。而s3c2410fb_display和s3c2410fb_mach_info，是由板级信息，通过platform总线添加到内核中。
$ F- y7 [1 o4 l/ u; i2 D  ^" b7 m
s3c2410fb_display中的成员将被复制到fb_var_screeninfo结构中。

该板级信息的定义在arch/ARM/mach-s3c2440/mach-smdk2440.c中,来看下
1 A& u  R5 Y, S8 C
static struct s3c2410fb_display smdk2440_lcd_cfg __initdata = {

        .lcdcon5        = S3C2410_LCDCON5_FRM565 |
8 D" u6 H  A; m                          S3C2410_LCDCON5_INVVLINE |
                          S3C2410_LCDCON5_INVVFRAME |
                          S3C2410_LCDCON5_PWREN |
% L! H: S: R) C8 j" m+ _" b                          S3C2410_LCDCON5_HWSWP,
' D, d* h# S& V3 |
        .type                = S3C2410_LCDCON1_TFT,
, h9 ?: L3 _+ \8 u) n# k
        .width                = 320,//240,
        .height                = 240,//320,
' z0 O' t1 d* j9 Y; u& d& J
        .pixclock        = 149000,//166667, /* HCLK 60 MHz, divisor 10 */
        .xres                = 320,//240,
) G) d/ Z+ s2 U: J8 j4 x        .yres                = 240,//320,
        .bpp                = 16,
        .left_margin        = 20,
% _5 E: ^$ a# i: c- W        .right_margin        = 38,//8,
' z2 h7 e: b/ p6 D! T        .hsync_len        = 30,//4,
        .upper_margin        = 15,//8,
/ R; a( r# `8 ]6 W% E% Z+ u        .lower_margin        = 12,//7,
# _. u* n  ]4 h9 e& ]        .vsync_len        = 3,//4,
};
5 n- G; [$ w& Z. P6 [/ w
2 m* }8 j( K9 v4 S9 @/ p/ Ystatic struct s3c2410fb_mach_info smdk2440_fb_info __initdata = {
        .displays        = &smdk2440_lcd_cfg,
        .num_displays        = 1,
        .default_display = 0,

# X* W4 Z0 m) ?% I#if 0
4 q9 r  ?) s4 W) u% s        /* currently setup by downloader */
        .gpccon                = 0xaa940659,
" y) e: O# k5 N9 z+ ]; B* s/ }$ M        .gpccon_mask        = 0xffffffff,
0 x! p! z2 ^* ]  d5 O5 }        .gpcup                = 0x0000ffff,
! J  X( B" U) b/ j        .gpcup_mask        = 0xffffffff,
        .gpdcon                = 0xaa84aaa0,
7 S3 {( h3 J$ _8 ?9 n. G, k  p; v        .gpdcon_mask        = 0xffffffff,
        .gpdup                = 0x0000faff,
        .gpdup_mask        = 0xffffffff,
#endif
0 R8 E; h# b; i8 n//no
" o, g5 E3 \8 u- j4 d  H3 i//        .lpcsel                = ((0xCE6) & ~7) | 1<<4,
8 W6 A* b- k# R6 C& I; T! ~};
$ \/ ?; G; q) i
这里NOTE：每个LCD屏幕的参数不一样，因此上面的参数会有所不同，这是需要移植的地方。
* W- n3 _" p; V' v
; {# F' s  a* A随后，我们看下在probe方法中调用的几个函数。首先是s3c2410fb_map_video_memory。
% @- k8 Q6 \$ _! n) u
5 ?- b8 I# ^$ H0 E4 ?/*
% L) L! z5 M  M+ ~ * s3c2410fb_map_video_memory():
*        Allocates the DRAM memory for the frame buffer.  This buffer is
*        remapped into a non-cached, non-buffered, memory region to
  d" z# F3 {" c *        allow palette and pixel writes to occur without flushing the
*        cache.  Once this area is remapped, all virtual memory
5 R' w" v5 X  E+ y* ?. ~ *        access to the video memory should occur at the new region.
8 S" d' I3 m% z: v/ A9 x */
; h% ~* K/ g/ {. E% Z* Nstatic int __init s3c2410fb_map_video_memory(struct fb_info *info)
{
        struct s3c2410fb_info *fbi = info->par;
        dma_addr_t map_dma;
8 f3 r! i0 M7 b4 s        unsigned map_size = PAGE_ALIGN(info->fix.smem_len);

        dprintk("map_video_memory(fbi=%p) map_size %u\n", fbi, map_size);
5 w4 B. m. P7 \* t8 ~5 y; {                /*分配DMA缓冲区，并保存DMA缓冲区虚拟地址*/
        info->screen_base = dma_alloc_writecombine(fbi->dev, map_size,
2 ?- O1 P! E* l4 I3 k                                                   &map_dma, GFP_KERNEL);
" ^5 C, T, W# z
        if (info->screen_base) {
, U: \- T2 `; m. j8 ?& O                /* prevent initial garbage on screen */
                dprintk("map_video_memory: clear %p:%08x\n",
                        info->screen_base, map_size);
+ I1 J' b6 `7 O7 ^- U* y9 R                memset(info->screen_base, 0x00, map_size);        /*DMA缓冲区清0*/

                info->fix.smem_start = map_dma;        /*保存DMA缓冲区物理地址*/
" P; e  ?6 n' w  F7 J2 @) |
                dprintk("map_video_memory: dma=%08lx cpu=%p size=%08x\n",
4 c2 p5 G% Z+ m, }; C; c1 j1 Q                        info->fix.smem_start, info->screen_base, map_size);
        }
& B( H. X$ Z( B3 e% y) Q
        return info->screen_base ? 0 : -ENOMEM;
}

; H( Z/ @  }. p  K
该函数根据fix.smem_len的大小，分配了一个DMA缓冲区，保存了该缓冲区的物理地址和虚拟地址。

7 z" f* `, t0 C; h" f接着是s3c2410fb_init_registers：
9 {; I* N3 a& A, z4 i
# {+ R0 _" E6 N- I# ?4 O
3 @! o* G2 g* J9 h6 d/*
" i: K" X) a  i+ t * s3c2410fb_init_registers - Initialise all LCD-related registers
) a1 |& e: t# x6 i0 @: [0 W/ h */
+ c. w' w. l% s6 L3 G; K% \) Fstatic int s3c2410fb_init_registers(struct fb_info *info)
{
    struct s3c2410fb_info *fbi = info->par;        /*par指向s3c2410fb_info*/
    struct s3c2410fb_mach_info *mach_info = fbi->dev->platform_data;
    unsigned long flags;
    void __iomem *regs = fbi->io;
8 w5 K4 R( t- ?3 h- L6 N    void __iomem *tpal;
1 |. a2 Y+ @+ Y  m7 O; E    void __iomem *lpcsel;

    if (is_s3c2412(fbi)) {
        tpal = regs + S3C2412_TPAL;
        lpcsel = regs + S3C2412_TCONSEL;
    } else {
        tpal = regs + S3C2410_TPAL;
        lpcsel = regs + S3C2410_LPCSEL;
7 N) Y' Q3 U; n" }& x$ o    }
( C4 P! F& ?4 m% Q( c3 ?
    /* Initialise LCD with values from haret */

    local_irq_save(flags);                        /*禁止所有中断*/

& O0 C0 \7 r; A/ j# u6 `    /* modify the gpio(s) with interrupts set (bjd) */    /*初始化io管脚*/
# B+ T. J- c9 n4 O
    modify_gpio(S3C2410_GPCUP,  mach_info->gpcup,  mach_info->gpcup_mask);
    modify_gpio(S3C2410_GPCCON, mach_info->gpccon, mach_info->gpccon_mask);
    modify_gpio(S3C2410_GPDUP,  mach_info->gpdup,  mach_info->gpdup_mask);
    modify_gpio(S3C2410_GPDCON, mach_info->gpdcon, mach_info->gpdcon_mask);
' M( L3 @  N: @4 |/ _
    local_irq_restore(flags);                    /*恢复中断*/
8 J& j8 N8 Q( C" V. A
9 S1 m' n% Q; k* y: i% A- c4 i    dprintk("LPCSEL    = 0x%08lx\n", mach_info->lpcsel);    /*设置TCONSEL，禁止LPC3600*/
& \4 u' m# i  [. p+ |8 Y    writel(mach_info->lpcsel, lpcsel);

    dprintk("replacing TPAL %08x\n", readl(tpal));

    /* ensure temporary palette disabled */
    writel(0x00, tpal);    /*禁止调色板*/
* F) p1 Z3 s$ C. g* q
( i( V5 G3 s4 O% q+ @    return 0;
}

3 a5 V. c8 v$ A: X- ustatic inline void modify_gpio(void __iomem *reg,
                   unsigned long set, unsigned long mask)
{
: ~/ p5 P1 s6 Y1 [0 u9 P; r    unsigned long tmp;
0 |. V: F* e( D3 g9 A* s3 k- |  E
* c0 z0 G! |7 s    tmp = readl(reg) & ~mask;
$ ^1 t+ N1 a1 o9 G* }- Z/ q# H    writel(tmp | set, reg);
  @! x" z' ~# i- [; {) h, ]% f}
/ B- N( G; f5 C2 A( O最后是s3c2410fb_check_var：

% @/ n* `$ `: N5 g1 m) X! m" Q/*
*        s3c2410fb_check_var():
! w- N+ M1 P# t* {- g5 b) h *        Get the video params out of 'var'. If a value doesn't fit, round it up,
4 ?9 D  }+ j7 d$ r4 q7 V *        if it's too big, return -EINVAL.
8 h% u4 ?# g$ h$ | *        检查变量的合法性
*/
3 a! m6 W% @6 _9 Cstatic int s3c2410fb_check_var(struct fb_var_screeninfo *var,
4 R3 G, e) Z) ]; c# X( }                               struct fb_info *info)
{
        struct s3c2410fb_info *fbi = info->par;                        /*par指向s3c2410fb_info*/
9 q& {& R  ?5 P) [' x4 B        struct s3c2410fb_mach_info *mach_info = fbi->dev->platform_data;/*指向s3c2410fb_mach_info*/
        struct s3c2410fb_display *display = NULL;
9 l: z' b% D# G2 F( o7 w. _2 p0 q        struct s3c2410fb_display *default_display = mach_info->displays +
7 f3 g. {# |9 l! j                                                    mach_info->default_display;
        int type = default_display->type;         /*S3C2410_LCDCON1_TFT*/
        unsigned i;
: L3 j- Y8 H  S2 u+ X! L
/ g% ^9 n! E, [9 H3 E        dprintk("check_var(var=%p, info=%p)\n", var, info);

        /* validate x/y resolution */
        /* choose default mode if possible */                        /*var中的成员在probe中设置*/
6 k& o9 ~* L7 W, G8 D8 ^: g! `/ t        if (var->yres == default_display->yres &&
            var->xres == default_display->xres &&
            var->bits_per_pixel == default_display->bpp)
                display = default_display;
  ]6 }; [6 i. b$ v- z        else
                for (i = 0; i < mach_info->num_displays; i++)
$ Y) g/ {3 X# n; m9 j& ?                        if (type == mach_info->displays.type &&
                            var->yres == mach_info->displays.yres &&
                            var->xres == mach_info->displays.xres &&
7 h! f( G, H& n/ g/ W. v: F3 v3 O                            var->bits_per_pixel == mach_info->displays.bpp) {
                                display = mach_info->displays + i;
                                break;
% s! v' t$ Z" P) m                        }

        if (!display) {
                dprintk("wrong resolution or depth %dx%d at %d bpp\n",
                        var->xres, var->yres, var->bits_per_pixel);
                return -EINVAL;
: J/ B- W* f7 |9 z        }

, u1 O" \1 t% H+ H' C        /* it is always the size as the display */
        var->xres_virtual = display->xres;
+ A6 u! A5 z; m, d# x        var->yres_virtual = display->yres;
% Z, u5 `- P4 `& \+ ]1 ~) f        var->height = display->height;
        var->width = display->width;

        /* copy lcd settings */
9 @6 c: D1 P* K" j        var->pixclock = display->pixclock;
        var->left_margin = display->left_margin;
        var->right_margin = display->right_margin;
        var->upper_margin = display->upper_margin;
        var->lower_margin = display->lower_margin;
        var->vsync_len = display->vsync_len;
        var->hsync_len = display->hsync_len;

4 v; C5 Q4 e6 ]& @        fbi->regs.lcdcon5 = display->lcdcon5;
2 X! C/ x! h8 ?3 ^1 u4 P8 B        /* set display type */
: M- J; v5 a: }; ?4 R, C        fbi->regs.lcdcon1 = display->type;
4 S2 C  B, T( B. S; [& g
        var->transp.offset = 0;
        var->transp.length = 0;
2 l9 y  |% y: T) b9 F  {4 Q        /* set r/g/b positions */
& g  f: z$ _$ f& s0 V* m- A1 P        switch (var->bits_per_pixel) {
$ g% b$ y4 w9 G        case 1:
3 z$ b6 c; q/ ]  c% H" N        case 2:
        case 4:
, L+ d4 d5 _2 `/ ^2 e) x- f9 s                var->red.offset        = 0;
; E& s  [, ^3 o. |& E                var->red.length        = var->bits_per_pixel;
                var->green        = var->red;
                var->blue        = var->red;
                break;
0 ~+ J, q+ [. Z6 W, S0 n8 n        case 8:
+ A, O% I/ D; ^$ ?2 `                if (display->type != S3C2410_LCDCON1_TFT) {
                        /* 8 bpp 332 */
                        var->red.length                = 3;
                        var->red.offset                = 5;
4 v8 K% n* _! ~+ o" T- @+ v! @                        var->green.length        = 3;
: C+ ]% i4 u. a: n                        var->green.offset        = 2;
) i, j: a: O$ u                        var->blue.length        = 2;
                        var->blue.offset        = 0;
; |! D7 O  O2 ?" b                } else {
8 }% O" K" o4 r4 H( s" C                        var->red.offset                = 0;
# X0 L% Y( M: V" F                        var->red.length                = 8;
                        var->green                = var->red;
                        var->blue                = var->red;
2 O. C% y( d% J! z6 N                }
                break;
        case 12:
7 y) N" @# \: q                /* 12 bpp 444 */
; Q4 x# a8 S' r$ e6 M                var->red.length                = 4;
                var->red.offset                = 8;
# ]2 `3 E9 f8 _4 x$ ^                var->green.length        = 4;
                var->green.offset        = 4;
+ y$ b0 D# B% |3 Q/ c                var->blue.length        = 4;
  n5 b3 v" x9 i9 R8 G                var->blue.offset        = 0;
                break;
9 u$ N* {3 Z; G) R4 `
! Z) ^! A* q1 q' k        default:
        case 16:
                if (display->lcdcon5 & S3C2410_LCDCON5_FRM565) { /*使用565格式*/
, ^* g5 m/ o5 x. A$ _                        /* 16 bpp, 565 format */
                        var->red.offset                = 11;
- b2 C6 G6 A$ l; w# N2 t                        var->green.offset        = 5;
                        var->blue.offset        = 0;
                        var->red.length                = 5;
# k, o. D4 i( P: }# E  I- K/ \                        var->green.length        = 6;
  N) z' v$ ]$ ~6 R! W: ]                        var->blue.length        = 5;
                } else {
2 g  I9 Z# G* Z4 L/ o                        /* 16 bpp, 5551 format */
3 k# o8 d- i2 X) {                        var->red.offset                = 11;
. L* e3 J5 I0 e) u                        var->green.offset        = 6;
2 Y" o2 [0 u" Q6 ?0 _8 [3 u                        var->blue.offset        = 1;
                        var->red.length                = 5;
8 _$ r- y  D3 T+ c! T! {                        var->green.length        = 5;
                        var->blue.length        = 5;
3 J: d  z3 ?4 R3 M                }
                break;
        case 32:
) d; b" P; l! k9 }. A/ G5 x/ w+ _                /* 24 bpp 888 and 8 dummy */
4 I8 P' `( `7 k4 k  ?1 V. ~5 O                var->red.length                = 8;
" C8 a3 ^: h/ N% a                var->red.offset                = 16;
                var->green.length        = 8;
                var->green.offset        = 8;
* ]( D9 X3 ?7 \2 g                var->blue.length        = 8;
9 b9 k9 m1 b  v                var->blue.offset        = 0;
                break;
        }
        return 0;
}

/* Interpretation of offset for color fields: All offsets are from the right,
; G" F; t7 {( T' ~. ?: J * inside a "pixel" value, which is exactly 'bits_per_pixel' wide (means: you
8 B" P: r; \# \2 t% D/ ]4 e * can use the offset as right argument to <<). A pixel afterwards is a bit
8 I: b: ~; ?1 z4 D' S( W' I * stream and is written to video memory as that unmodified.
*
* For pseudocolor: offset and length should be the same for all color
* components. Offset specifies the position of the least significant bit
* of the pallette index in a pixel value. Length indicates the number
* of available palette entries (i.e. # of entries = 1 << length).
*/
struct fb_bitfield {
) f) @! h6 E! W  C    __u32 offset;            /* beginning of bitfield    */
    __u32 length;            /* length of bitfield        */
5 C& E3 q3 p8 E0 o3 F0 s    __u32 msb_right;        /* != 0 : Most significant bit is */
                    /* right */
};
# s  `+ F8 ]4 ?% j6 v2 E9 H9 o该函数主要将板级信息s3c2410fb_display复制到对应的地方，然后根据RGB的模式设置位域。
0 a6 d: ]9 Z* s. \& q4.3 fb_ops方法
在驱动程序中，定义了fb_ops，如下：
& w& @+ t: ]/ _" {
static struct fb_ops s3c2410fb_ops = {
9 s8 u. _+ n1 b' a' \' g        .owner                = THIS_MODULE,
# s% @% G1 m& I! V+ J* j0 g        .fb_check_var        = s3c2410fb_check_var,                /*检查变量的合法性*/
        .fb_set_par        = s3c2410fb_set_par,                        /*将参数写入LCD控制器，该函数由帧缓冲核心调用*/
% B" x$ C: ^0 F$ ]        .fb_blank        = s3c2410fb_blank,                                /*该方法支持显示消隐和去消隐*/
" h2 L4 ?5 W9 `* x" W        .fb_setcolreg        = s3c2410fb_setcolreg,                /*设置颜色寄存器*/
        .fb_fillrect        = cfb_fillrect,                                /*用像素行填充矩形框，通用库函数*/
        .fb_copyarea        = cfb_copyarea,                                /*将屏幕的一个矩形区域复制到另一个区域，通用库函数*/
        .fb_imageblit        = cfb_imageblit,                        /*显示一副图像，通用库函数*/
};
/ w( ^+ W2 ^) V
: D  g. Z) _# Z) O& p. U% a* n; `其中s3c2410fb_check_var在4.2节中已经分析过了，最后三个方法是通用库函数，在这里不作分析。
. I+ K/ d; J) c& d7 P0 L剩余三个也是驱动程序提供的，现在对这三个程序进行分析。
4.3. 1 s3c2410fb_set_par
3 e& q) K5 w, K! _; Z+ K9 e; l/*
- D) s/ k9 T( _% g: x *      s3c2410fb_set_par - Alters the hardware state.
% F7 V# E! y! t *      @info: frame buffer structure that represents a single frame buffer
*                根据var中的值设置LCD控制器的寄存器
1 ]; ?& e4 k8 H! J! k */
# T# ^$ M0 B/ R+ S; p$ wstatic int s3c2410fb_set_par(struct fb_info *info)
) q3 P3 E$ M# i7 b! |{
        struct fb_var_screeninfo *var = &info->var;

+ O% U8 Q$ K4 ?  g        switch (var->bits_per_pixel) {
        case 32:
        case 16:
8 c9 d- U' c8 _8 I) ]        case 12:
                info->fix.visual = FB_VISUAL_TRUECOLOR;
                break;
        case 1:
, \! H3 n. F0 v  @5 l9 b8 K! [                info->fix.visual = FB_VISUAL_MONO01;
% `. T7 [- m  l6 N, ]                break;
5 X& A  v! _$ R$ u        default:
& Y$ w2 ?1 S& \  B! N                info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
( Y$ ~  `% ?; v2 x' I- R2 E                break;
$ x( Y0 g5 C8 l8 z        }

        info->fix.line_length = (var->xres_virtual * var->bits_per_pixel) / 8; /* 320*16/8 = 640Bytes */
8 [  W2 l+ W2 @6 ?- }6 j0 J: y
( _! E" B  E% U; g  z/ g4 k- y6 c        /* activate this new configuration */

        s3c2410fb_activate_var(info);
        return 0;
}
! H- b8 d" r  ~6 z. T, e+ g该函数根据像素的位数设置了视觉模式，本例为16为，使用真彩色。然后计算了每行的数据元素大小。共240行。

9 n) L) @( v- v( D! B然后调用了s3c2410fb_activate_var来设置控制器并激活LCD。
; _" q( n( \7 D! `- B
s3c2410fb_activate_var函数如下：

2 x; q, s* {- t* A$ D% o/* s3c2410fb_activate_var
*
) P/ \1 `; q& K( ?3 U7 b3 R8 @ * activate (set) the controller from the given framebuffer
' j( M6 k) R% }, I6 x& S# ?$ X * information
*/
static void s3c2410fb_activate_var(struct fb_info *info)
{
# V; e+ f0 @" d) Z2 X( v4 P* f        struct s3c2410fb_info *fbi = info->par;
  W" ~% z1 v. t        void __iomem *regs = fbi->io;
: E- Z) G& |+ I; i1 T        int type = fbi->regs.lcdcon1 & S3C2410_LCDCON1_TFT; /*regs.lcdcon1在s3c2410fb_check_var设置*/
1 z# {; }3 P; j        struct fb_var_screeninfo *var = &info->var;
. }/ z/ ^( ?# K! e1 Z$ r        int clkdiv = s3c2410fb_calc_pixclk(fbi, var->pixclock) / 2;

        dprintk("%s: var->xres  = %d\n", __func__, var->xres);
        dprintk("%s: var->yres  = %d\n", __func__, var->yres);
4 _* @) `) z9 X2 |  ]        dprintk("%s: var->bpp   = %d\n", __func__, var->bits_per_pixel);
9 g; R  @1 _8 i' Z$ \* z* l( _2 k
, M0 H' D3 U+ ]0 B  Q        if (type == S3C2410_LCDCON1_TFT) {
                s3c2410fb_calculate_tft_lcd_regs(info, &fbi->regs);/*根据var，计算出控制寄存器需要设置的值*/
& u8 b& f; ]3 Q6 B                --clkdiv;
                if (clkdiv < 0)
% I2 z  W. |+ z0 n                        clkdiv = 0;
5 A' V' u  ^* m! p        } else {
                s3c2410fb_calculate_stn_lcd_regs(info, &fbi->regs);
3 [1 W- ]- W$ M+ m1 P# F3 Z" M                if (clkdiv < 2)
                        clkdiv = 2;
. s  j5 f% Z0 ~/ W$ a        }
9 O8 R% ]5 V4 S
        fbi->regs.lcdcon1 |=  S3C2410_LCDCON1_CLKVAL(clkdiv);/*设置CLKVAL*/
. y' S; {/ L* z8 q3 \: Q/ {2 d( i
        /* write new registers */
' l0 f7 E' R, O
        dprintk("new register set:\n");
( o! t, H3 C" r        dprintk("lcdcon[1] = 0x%08lx\n", fbi->regs.lcdcon1);
        dprintk("lcdcon[2] = 0x%08lx\n", fbi->regs.lcdcon2);
- g! u( D% T: s        dprintk("lcdcon[3] = 0x%08lx\n", fbi->regs.lcdcon3);
        dprintk("lcdcon[4] = 0x%08lx\n", fbi->regs.lcdcon4);
        dprintk("lcdcon[5] = 0x%08lx\n", fbi->regs.lcdcon5);
% T& f2 ?; N! k. \& a        /*把计算好的值填入LCD控制器中*/
        writel(fbi->regs.lcdcon1 & ~S3C2410_LCDCON1_ENVID,       
                regs + S3C2410_LCDCON1);                                                /*仍然禁止LCD*/
        writel(fbi->regs.lcdcon2, regs + S3C2410_LCDCON2);
& Y3 o* y  l, B$ z/ J        writel(fbi->regs.lcdcon3, regs + S3C2410_LCDCON3);
7 D2 ]% S$ ^7 m/ S0 w% i$ V        writel(fbi->regs.lcdcon4, regs + S3C2410_LCDCON4);
/ Z+ b3 O/ u  ~& M        writel(fbi->regs.lcdcon5, regs + S3C2410_LCDCON5);
! ~5 z- ]# H  o8 N5 D
        /* set lcd address pointers */
        s3c2410fb_set_lcdaddr(info);                                                /*设置LCD帧缓冲起始地址*/

0 ?2 t' v9 G& s( u8 x        fbi->regs.lcdcon1 |= S3C2410_LCDCON1_ENVID,
6 z( U5 A$ n3 N- Y) E- \0 @6 h        writel(fbi->regs.lcdcon1, regs + S3C2410_LCDCON1);        /*使能LCD*/
}
其中调用的三个函数如下：
static unsigned int s3c2410fb_calc_pixclk(struct s3c2410fb_info *fbi,
  o! s) b0 k6 c- G) X                      unsigned long pixclk)
{
# w; o9 x" W: W" a    unsigned long clk = clk_get_rate(fbi->clk);         /*获取当前时钟频率(Hz)*/
4 I# v' N$ q5 q* t1 @8 Y    unsigned long long div;
* ?' j2 a4 W# g8 `  I
    /* pixclk is in picoseconds, our clock is in Hz
  e- |, t1 W" N     *
, k% u2 x: g9 l, W     * Hz -> picoseconds is / 10^-12
     */
: b) r# C" D1 i
    div = (unsigned long long)clk * pixclk;
    div >>= 12;            /* div / 2^12 */
1 O9 B2 b4 a: e* o- e" ]5 U    do_div(div, 625 * 625UL * 625); /* div / 5^12 */
& t  x" h( u( J
* U( a# |6 ]! Z9 a4 X    dprintk("pixclk %ld, divisor is %ld\n", pixclk, (long)div);
% G  F+ ~$ T$ D3 \0 n5 ?    return div;
}

0 V7 }- W7 O" o* v: u/* s3c2410fb_calculate_tft_lcd_regs
5 R( P) C3 I* m2 I *
* calculate register values from var settings
/ U% ?8 }, {) K3 l; l */
- E% T0 N! S1 k9 Q, r" }static void s3c2410fb_calculate_tft_lcd_regs(const struct fb_info *info,
8 k) o" t* z, N  a5 B. {                         struct s3c2410fb_hw *regs)
9 S  `( G! u0 V- G{
# p0 Z& q+ M2 @    const struct s3c2410fb_info *fbi = info->par;
2 y3 h) Q! O) m    const struct fb_var_screeninfo *var = &info->var;

9 h0 c1 O( d0 ~# O! J8 Z% }    switch (var->bits_per_pixel) {
    case 1:
( ~, F* m/ }2 e+ H  z& Z2 X        regs->lcdcon1 |= S3C2410_LCDCON1_TFT1BPP;
        break;
6 f! G3 P* U. a7 a& x    case 2:
        regs->lcdcon1 |= S3C2410_LCDCON1_TFT2BPP;
        break;
1 }! N+ S& ?  G6 E    case 4:
- N- K7 w4 x6 O8 ]7 O        regs->lcdcon1 |= S3C2410_LCDCON1_TFT4BPP;
% [) _. ~/ G1 E: ]$ q+ l        break;
" `- I- z$ v- B4 ?4 q8 y7 z    case 8:
9 Z. x: ]- B! j' i& C' n        regs->lcdcon1 |= S3C2410_LCDCON1_TFT8BPP;
        regs->lcdcon5 |= S3C2410_LCDCON5_BSWP |
) h  O  F% I% `                 S3C2410_LCDCON5_FRM565;
  n0 ~' }' A* B7 ]) v2 F- m        regs->lcdcon5 &= ~S3C2410_LCDCON5_HWSWP;
        break;
: d0 _. o: x2 S    case 16:
; Y# S7 M0 i* z! A- \; w4 V        regs->lcdcon1 |= S3C2410_LCDCON1_TFT16BPP;
4 v! S2 P2 [- Z* ^8 E7 N5 B+ |  O. T; h        regs->lcdcon5 &= ~S3C2410_LCDCON5_BSWP;
        regs->lcdcon5 |= S3C2410_LCDCON5_HWSWP;
        break;
    case 32:
        regs->lcdcon1 |= S3C2410_LCDCON1_TFT24BPP;
5 F! \: s( B8 ?- \% T! e* W        regs->lcdcon5 &= ~(S3C2410_LCDCON5_BSWP |
! M" v2 [4 W2 n0 r. B                   S3C2410_LCDCON5_HWSWP |
7 J6 R- q# p4 s  o0 s$ ?                   S3C2410_LCDCON5_BPP24BL);
        break;
! {; @5 |% c8 X( |8 v    default:
) ^* b; q8 ?0 d  u% Q* F        /* invalid pixel depth */
        dev_err(fbi->dev, "invalid bpp %d\n",
            var->bits_per_pixel);
    }
    /* update X/Y info */
    dprintk("setting vert: up=%d, low=%d, sync=%d\n",
        var->upper_margin, var->lower_margin, var->vsync_len);
  A; C% `& _0 R9 W" n
3 l2 r4 K) v# C! A    dprintk("setting horz: lft=%d, rt=%d, sync=%d\n",
. r0 d. T" W7 s$ P6 {" w8 G6 {+ ^        var->left_margin, var->right_margin, var->hsync_len);
    /*
4 E# W7 W# E5 o        所有时序参数必须减1，因为在公式中:
" h/ h2 P# J& Z3 n2 ^$ S; s) r        Frame Rate = 1/ [ { (VSPW+1) + (VBPD+1) + (LIINEVAL + 1) + (VFPD+1) } x {(HSPW+1) + (HBPD +1)
        + (HFPD+1) + (HOZVAL + 1) } x { 2 x ( CLKVAL+1 ) / ( HCLK ) } ]
5 X! P2 b4 L9 v$ i5 H    */
8 K0 q/ S; J3 k4 ~: c4 v( x    regs->lcdcon2 = S3C2410_LCDCON2_LINEVAL(var->yres - 1) |
            S3C2410_LCDCON2_VBPD(var->upper_margin - 1) |
- p' Q) ?# Z1 A. s; q# Q' U            S3C2410_LCDCON2_VFPD(var->lower_margin - 1) |
" `" w; C) m- `- I0 f            S3C2410_LCDCON2_VSPW(var->vsync_len - 1);
  f# g8 s( Z; }$ F0 \( n2 z
    regs->lcdcon3 = S3C2410_LCDCON3_HBPD(var->right_margin - 1) |
            S3C2410_LCDCON3_HFPD(var->left_margin - 1) |
            S3C2410_LCDCON3_HOZVAL(var->xres - 1);
  v# v& J; g5 d. D3 t# v
9 r: Q# t0 b8 [1 ?    regs->lcdcon4 = S3C2410_LCDCON4_HSPW(var->hsync_len - 1);
}
. Y7 M. d+ n5 P9 Q! z
; s) T( `! B, [9 _* L# L( `/* s3c2410fb_set_lcdaddr
0 H$ `9 D) u6 z/ j" w *
$ q5 X. e* H  V4 B * initialise lcd controller address pointers
# a3 w! Y3 g/ ]$ e7 j1 v */
static void s3c2410fb_set_lcdaddr(struct fb_info *info)
{
        unsigned long saddr1, saddr2, saddr3;
        struct s3c2410fb_info *fbi = info->par;
        void __iomem *regs = fbi->io;
( |6 l4 ]# w7 L( H: P/ l( K
        saddr1  = info->fix.smem_start >> 1;          /*帧缓冲区起始地址*/
- j1 z3 u: C0 b        saddr2  = info->fix.smem_start;                       
        saddr2 += info->fix.line_length * info->var.yres;
. W  r8 ~7 O& I3 x$ j" H        saddr2 >>= 1;                                                        /*帧缓冲区结束地址*/

4 @$ ^9 t" Z( Q3 ]2 r+ O3 Q        saddr3 = S3C2410_OFFSIZE(0) |
% d0 n, k- Z8 A2 o+ u/ e                 S3C2410_PAGEWIDTH((info->fix.line_length / 2) & 0x3ff); /*offset = 0, pagewidth = 320*/

        dprintk("LCDSADDR1 = 0x%08lx\n", saddr1);
' B4 L8 s( i  l6 y5 e( G. t        dprintk("LCDSADDR2 = 0x%08lx\n", saddr2);
        dprintk("LCDSADDR3 = 0x%08lx\n", saddr3);

1 q& _) ?/ Q" k        writel(saddr1, regs + S3C2410_LCDSADDR1);
        writel(saddr2, regs + S3C2410_LCDSADDR2);
: j% J' N8 m/ }  x        writel(saddr3, regs + S3C2410_LCDSADDR3);
}
s3c2410fb_calc_pixclk用于计算时钟频率。
' W4 d9 ]4 y, B
s3c2410fb_calculate_tft_lcd_regs设置了LCD的控制寄存器。

s3c2410fb_set_lcdaddr设置了LCD的地址寄存器，该寄存器的设置请参考datasheet。

4.3. 2 s3c2410fb_blank
该方法完成消隐功能。

4 w, E8 X0 H9 V* T7 a+ I/*
*      s3c2410fb_blank
*        @blank_mode: the blank mode we want.
*        @info: frame buffer structure that represents a single frame buffer
1 W$ w8 j5 S' h+ M3 T+ @ *
. c, k( L4 K9 o) v+ S8 n. E *        Blank the screen if blank_mode != 0, else unblank. Return 0 if
; L2 Q, [7 ]: ?8 T5 _4 o( O; x *        blanking succeeded, != 0 if un-/blanking failed due to e.g. a
# }7 S4 G9 i2 V6 m *        video mode which doesn't support it. Implements VESA suspend
+ r" ~' D7 F6 q" k  D *        and powerdown modes on hardware that supports disabling hsync/vsync:
' y# w0 a; B7 I *
*        Returns negative errno on error, or zero on success.
1 N- H7 \1 J* f# ^$ y* R0 r5 X6 O *
*/
$ w, X7 _/ O+ u, Pstatic int s3c2410fb_blank(int blank_mode, struct fb_info *info)
. m# g% j* U$ y* p8 z+ Z2 r, x8 D{
: H% J9 _. F6 c. m/ B: P    struct s3c2410fb_info *fbi = info->par;
% y, o$ \) N9 p  x& `4 c    void __iomem *tpal_reg = fbi->io;

" f5 F! e! v5 P1 W    dprintk("blank(mode=%d, info=%p)\n", blank_mode, info);
& X: Z( u+ U0 {. c& S
* u& C. G' N3 r  A6 w/ h$ x    tpal_reg += is_s3c2412(fbi) ? S3C2412_TPAL : S3C2410_TPAL;
" o- ~; h) U; \% z: y2 v  R2 f
6 X+ z  `- K5 H- P4 m    if (blank_mode == FB_BLANK_POWERDOWN) {    /*消隐*/
        s3c2410fb_lcd_enable(fbi, 0);        /*禁止LCD*/
    } else {
        s3c2410fb_lcd_enable(fbi, 1);        /*启动LCD*/
( M' r6 K$ ~6 _# |+ u- `$ m  r- o! ?    }
/ ]1 ^$ q' s0 v# q4 r* l. R
    if (blank_mode == FB_BLANK_UNBLANK)        /*去消隐*/
1 P  _8 a' Q! }9 ?2 a        writel(0x0, tpal_reg);                /*禁止temporary palette*/
    else {                                    /*消隐*/
, R" k# x$ `& |4 j        dprintk("setting TPAL to output 0x000000\n");
        writel(S3C2410_TPAL_EN, tpal_reg);    /*使能temporary palette，颜色为黑色*/
    }
" D8 U+ A+ Z* h1 w' |" m, f
    return 0;
4 U! r0 A) g* j% r/ D6 l}
在消隐时，屏幕将全黑。
; o; t9 K9 e) C" _
4.3.3 s3c2410fb_setcolreg
% @* x4 d/ z+ W9 j; V- p( F0 d该函数的功能用于设置LCD的调色板。调色板的概念请看我的转帖：LCD调色板。

- R6 G9 v$ L  m1 wstatic int s3c2410fb_setcolreg(unsigned regno,
' J- s7 H( l8 B  e1 P                   unsigned red, unsigned green, unsigned blue,
                   unsigned transp, struct fb_info *info)
{
, a! ?6 {' G) C  L" ~- S    struct s3c2410fb_info *fbi = info->par;    /*par指向s3c2410fb_info*/
    void __iomem *regs = fbi->io;
+ Y0 l& C: Z  V- ~9 r    unsigned int val;

    /* dprintk("setcol: regno=%d, rgb=%d,%d,%d\n",
           regno, red, green, blue); */
' ?' P9 l. D' i4 M& w
# n2 K9 Y4 x* D$ _1 }    switch (info->fix.visual) {   
    case FB_VISUAL_TRUECOLOR:    /*使用真彩色*/
        /* true-colour, use pseudo-palette */
. j# p- D4 M" D* n' n
/ ~- q  B7 F$ q$ l        if (regno < 16) {    /*16种颜色，为什么只用16种颜色???????????*/
* H7 _/ Y+ E( E  C( ~1 d            u32 *pal = info->pseudo_palette;

            val  = chan_to_field(red,   &info->var.red);
0 ]" e/ g; d- ~: V% O2 U            val |= chan_to_field(green, &info->var.green);
7 [& {1 f2 v# J% r# g3 M% n, u3 P1 N3 D            val |= chan_to_field(blue,  &info->var.blue);
& M7 M4 O' }: q# j& a' F$ L
            pal[regno] = val;    /*保存颜色值*/
        }
        break;

, x( C5 L8 e8 Z8 `3 |    case FB_VISUAL_PSEUDOCOLOR:
. J) A! c; W. I; {        if (regno < 256) {
            /* currently assume RGB 5-6-5 mode */
7 y2 \! h; }8 y$ _7 n2 ]% E8 R
            val  = (red   >>  0) & 0xf800;
# g, y! o0 p5 e/ G            val |= (green >>  5) & 0x07e0;
            val |= (blue  >> 11) & 0x001f;

            writel(val, regs + S3C2410_TFTPAL(regno));
. b" H$ S. @% H& ]0 l) N3 z" V            schedule_palette_update(fbi, regno, val);
7 x0 s2 _! z! H6 ?9 P0 L+ u: n% [        }

! ]; d# a; L3 X        break;
4 f  |1 U& a+ r/ x* o
    default:
2 @% D4 y( U) V* A  @/ Z        return 1;    /* unknown type */
9 `8 c- z" N% W4 F) C    }

' T2 M. g/ u$ v3 Z    return 0;
}
7 r1 m# W2 i* H, }/* from pxafb.c */
' q$ }! H7 U. g2 v* ~: y6 kstatic inline unsigned int chan_to_field(unsigned int chan,
. d7 F5 a5 y* @7 d$ ], ~                     struct fb_bitfield *bf)
  B' j$ i; \$ R5 E& X+ N{   
    /*下面用到的length和offset在s3c2410fb_check_var函数中设置*/
6 ^. I4 F* ^; q* z, T    chan &= 0xffff;                /*取低16位*/
( e6 I" V% E" k* V" P$ Y! L    chan >>= 16 - bf->length;   /*取第length为到16位为有效位*/
    return chan << bf->offset;    /*移动到相应的位置。*/
: S" O& ^3 X% f! W}
我们使用的是真彩色，可以设置16种颜色，颜色的位域值通过调用chan_to_field获得，然后保存了颜色的值。但是比较奇怪的是，这里并没有将值保存到0x4d000400为起始的内存中，不知为何。 反而倒是在伪彩色模式下， 使用了writel(val, regs + S3C2410_TFTPAL(regno))写到内存中，然后调用schedule_palette_update函数来更新palette表。我们来看下。
" W3 Z$ @8 r7 {* U
static void schedule_palette_update(struct s3c2410fb_info *fbi,
                                    unsigned int regno, unsigned int val)
{
# s% @" e8 ?( D# c        unsigned long flags;
        unsigned long irqen;
        void __iomem *irq_base = fbi->irq_base;

/ `" k& _# r; I7 D        local_irq_save(flags);

        fbi->palette_buffer[regno] = val;

        if (!fbi->palette_ready) {
                fbi->palette_ready = 1;
# M( N' _  T0 w! h- V
5 q2 `% k* f. b% `+ h, ^5 ^* C                /* enable IRQ */
                irqen = readl(irq_base + S3C24XX_LCDINTMSK);
                irqen &= ~S3C2410_LCDINT_FRSYNC;
  E  Z" b% X9 q) Q) y                writel(irqen, irq_base + S3C24XX_LCDINTMSK);
7 n% s+ B. o4 V1 c8 K9 e8 Z        }

        local_irq_restore(flags);
( X0 O9 F0 P, ^/ a  N  v9 O( |3 D}
这个函数的作用就是开启了LCD的帧同步中断，这个中断在VSYNC信号从无效变成有效时产生。当中断产生时，会调用在probe方法中注册的ISR。ISR如下：
static irqreturn_t s3c2410fb_irq(int irq, void *dev_id)
{
/ o0 e5 T$ x2 h& O4 J0 M        struct s3c2410fb_info *fbi = dev_id;
        void __iomem *irq_base = fbi->irq_base;
        unsigned long lcdirq = readl(irq_base + S3C24XX_LCDINTPND);
5 H: O, \' B% X- ~" y& zb
        if (lcdirq & S3C2410_LCDINT_FRSYNC) {
                if (fbi->palette_ready)
; ]: f6 [5 O( h+ ~6 y5 Z                        s3c2410fb_write_palette(fbi);

                writel(S3C2410_LCDINT_FRSYNC, irq_base + S3C24XX_LCDINTPND);
                writel(S3C2410_LCDINT_FRSYNC, irq_base + S3C24XX_LCDSRCPND);
        }

        return IRQ_HANDLED;
}
1 L( H8 V1 H4 Y$ n
1 ]3 {: E8 ^# x; O5 h. D7 O: astatic void s3c2410fb_write_palette(struct s3c2410fb_info *fbi)
1 U* |; x8 z# P, ]5 G. l{
    unsigned int i;
+ I& Y) E4 s3 Z2 d: C8 _    void __iomem *regs = fbi->io;
7 }8 x- O  R; B% B
; u7 n; v* }6 B# u8 ]$ N. E2 u    fbi->palette_ready = 0;  /*清除ready标志*/

    for (i = 0; i < 256; i++) {
        unsigned long ent = fbi->palette_buffer;
        if (ent == PALETTE_BUFF_CLEAR)
            continue;
: c& V; x! r7 f/ E9 z5 r
3 d# J& \2 x$ g, q6 v) B# Z7 `1 ?  d1 k        writel(ent, regs + S3C2410_TFTPAL(i));

5 C/ N" K9 ?* S6 W        /* it seems the only way to know exactly
         * if the palette wrote ok, is to check
' Y1 E7 Q7 Q/ L) L         * to see if the value verifies ok
- ~! D7 g% o1 r, _$ Z8 Q2 \1 r& b         */
8 u" M: R3 d4 O- c1 D$ l
        if (readw(regs + S3C2410_TFTPAL(i)) == ent)
            fbi->palette_buffer = PALETTE_BUFF_CLEAR;
        else
            fbi->palette_ready = 1;   /* retry */
" D0 ]" g7 p/ b6 t5 m    }
* @/ |* g' g" K0 v}
在中断函数中调用了s3c2410fb_write_palette，该函数对写入内存的颜色值进行检查。如果确认其已经写入，则将palette_buffer中的清除，否则retry。

( P( ^5 V# h% M# i  }  H- j5. 总结
本文对frambuffer子系统做了简单的介绍。frambuffer子系统的函数相当之多，在这里是不可能一一介绍的。本文首先介绍了主要的数据结构，
0 B( a2 ~: B) s1 B
: r6 K# q+ V9 `+ Z- c2 [' v随后分析了frambuffer核心层，在核心层简单的分析了5个API函数，接着，对驱动层做了介绍，驱动层的大多数函数都给出了分析。

" ^+ I7 O6 a  r8 r1 y/ Y



  C* M! u  L8 K+ |' H2 g1 h
( N8 W1 }% k& Y2 ]( ^
6 E/ @) P" K- i4 a+ \7 S
8 K* h5 h- E+ C" ~. i& X

SsaaM7

基于S3C2440的嵌入式Linux驱动——Framebuffer子系统解读