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

baqiao

本文将介绍Framebuffer子系统
8 Y. [: f* S3 l5 C/ `
9 y7 Q+ L4 R! Q$ r" _3 P4 B目标平台：TQ2440 CPU：s3c2440

" o. Z( `3 H0 U' c; n% S( t$ OLCD设备：3.5英寸，分辨率320X240

  |4 E# H: z* _' t) X

5 Y' T! x3 B& u1. 概述

Framebuffer，中文名字是帧缓冲，这个帧也就是一副图像所需要的数据。因此，帧缓冲其实就是LCD设备的驱动程序。Linux中，framebuffer子系统框架如下：
  L2 q0 P9 F% X: j
3 n* `1 s* M9 C1 T8 j% V0 P% U

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

: D2 s6 e. f& \+ ^- i接下来的内容中，首先给出framerbuffer使用的数据结构；随后简单描述framerbuffer核心层；最后，针对S3C2440，对驱动代码进行分析。
; w$ H5 s! ^0 [8 T$ U0 ]0 [
* v# c" {0 l; ]' }, E  H( Y2. 数据结构
1 I" _# K* W: M. j+ J0 _! I3 c" r2.1 fb_info 结构
  该结构是内核用于描述一个特定framebuffer设备。其中包含了几个重要的结构，将在下面介绍。

  下列代码位于include/linux/fb.h
3 _5 D) P- o$ ~# ?
struct fb_info {
5 c5 m" X# x2 Y4 g9 R% l        int node;
        int flags;
; ^" a) Q" D& i. y4 [( G        struct mutex lock;                /* Lock for open/release/ioctl funcs */
        struct fb_var_screeninfo var;        /* Current var */
! g, D9 j1 x1 [( ~7 A% Q2 L7 [7 G& L        struct fb_fix_screeninfo fix;        /* Current fix */
        struct fb_monspecs monspecs;        /* Current Monitor specs */
        struct work_struct queue;        /* Framebuffer event queue */
& A2 F% j: y- v6 S! ^2 ]        struct fb_pixmap pixmap;        /* Image hardware mapper */
, E: E; X2 n1 I8 A2 m) c        struct fb_pixmap sprite;        /* Cursor hardware mapper */
        struct fb_cmap cmap;                /* Current cmap */
        struct list_head modelist;      /* mode list */
2 ^$ n* B- [% v/ s  P6 C* s        struct fb_videomode *mode;        /* current mode */
8 g) [/ C+ s' c' f2 @2 E  P0 A
* x: Q+ Q! y* n3 d7 \$ a: m#ifdef CONFIG_FB_BACKLIGHT
        /* assigned backlight device */
& X: i- T0 G. s# U3 U        /* set before framebuffer registration,
0 g2 h# ?7 V2 F2 ^' f' R           remove after unregister */
        struct backlight_device *bl_dev;
1 i3 F8 d; M# b: [* v
6 [% Y3 a2 Y& \; v* |: W        /* Backlight level curve */
6 C* y' k! u& Q" l, t: V$ N        struct mutex bl_curve_mutex;       
        u8 bl_curve[FB_BACKLIGHT_LEVELS];
, }% Q/ g# l( w' s#endif
  P# F; \" G; B9 W; ?8 D: y" W( u7 `#ifdef CONFIG_FB_DEFERRED_IO
        struct delayed_work deferred_work;
# j. s$ {! R: ]: O# Z        struct fb_deferred_io *fbdefio;
8 @+ F, Z5 J6 c* T5 }! Z#endif
2 ]' G4 Y. c4 j( E4 w
. l! B2 y4 {% f7 }6 p! Y        struct fb_ops *fbops;
        struct device *device;                /* This is the parent */
        struct device *dev;                /* This is this fb device */
) H2 f/ S, t- C: R3 ]6 ~8 ^& o9 l        int class_flag;                    /* private sysfs flags */
: a1 S+ ]: P$ t#ifdef CONFIG_FB_TILEBLITTING
+ B7 U* c. P* ^9 Y6 K2 G* \. B/ w        struct fb_tile_ops *tileops;    /* Tile Blitting */
#endif
        char __iomem *screen_base;        /* Virtual address */
) p3 ]% J! Y% t, Z        unsigned long screen_size;        /* Amount of ioremapped VRAM or 0 */
& r" `9 c8 x/ ]5 c' `6 j3 r        void *pseudo_palette;                /* Fake palette of 16 colors */
#define FBINFO_STATE_RUNNING        0
+ t+ l. i1 j' Y) V. h5 ]9 V#define FBINFO_STATE_SUSPENDED        1
        u32 state;                        /* Hardware state i.e suspend */
        void *fbcon_par;                /* fbcon use-only private area */
3 e$ S: E# s' |# y9 ~5 ]        /* From here on everything is device dependent */
        void *par;       
};
4 g1 H+ O# k: {4 o& x2.2 fb_fix_screeninfo结构
  该数据结构是不可改变的，也就是说用户空间不能改变该结构中的任何成员，在核心层我们将会看到这点。
3 {) w" d3 U  n6 h0 \
  下列代码位于include/linux/fb.h
0 j; w* y, B: i, @- K
) k" x& p$ Y+ B3 |  G* Wstruct fb_fix_screeninfo {
        char id[16];                        /* identification string eg "TT Builtin" */
        unsigned long smem_start;        /* Start of frame buffer mem */
                                        /* (physical address) */
) l" d" O) F& z' S3 w) t        __u32 smem_len;                        /* Length of frame buffer mem */
        __u32 type;                        /* see FB_TYPE_*                */
        __u32 type_aux;                        /* Interleave for interleaved Planes */
  a) o: F. S- P* ^8 I. M, L2 _0 _4 x        __u32 visual;                        /* see FB_VISUAL_*                */
" c# S4 N+ J7 \" l8 D: w2 V+ B        __u16 xpanstep;                        /* zero if no hardware panning  */
        __u16 ypanstep;                        /* zero if no hardware panning  */
4 N4 n9 J8 V3 u2 k        __u16 ywrapstep;                /* zero if no hardware ywrap    */
4 I; M9 n9 v7 S; J$ N' q        __u32 line_length;                /* length of a line in bytes    */
        unsigned long mmio_start;        /* Start of Memory Mapped I/O   */
/ w' s- N- _; ^  ?; x. ]3 x% p7 Q                                        /* (physical address) */
        __u32 mmio_len;                        /* Length of Memory Mapped I/O  */
) a$ X' f8 {5 e; H" C0 K" k        __u32 accel;                        /* Indicate to driver which        */
                                        /*  specific chip/card we have        */
        __u16 reserved[3];                /* Reserved for future compatibility */
+ M, q  j- z* s( M/ M: V, }};

2 _, P; f6 Y- a2.3 fb_var_screeninfo结构
! e$ i7 t5 F' M5 Y+ `# Z  该数据结构是可以改变的，也就是说用户空间可以改变该结构中的成员。该数据结构中的很多成员就由板级信息复制而来，在驱动代码中我们将会看到这点。
! Z$ {' D8 X7 `4 c
5 W+ J" x- `5 q6 I/ w1 b5 H/ ]  下列代码位于include/linux/fb.h

struct fb_var_screeninfo {
        __u32 xres;                        /* visible resolution                */
        __u32 yres;
, h3 H  w! J. j8 e' @2 N3 `        __u32 xres_virtual;                /* virtual resolution                */
        __u32 yres_virtual;
        __u32 xoffset;                        /* offset from virtual to visible */
        __u32 yoffset;                        /* resolution                        */
% T- Z" ^, C* k' ^; g) f8 {7 q: ]6 w) S
1 n1 m7 Q, E- Q! Q        __u32 bits_per_pixel;                /* guess what                        */
/ I/ r+ c2 w  j) X. O        __u32 grayscale;                /* != 0 Graylevels instead of colors */

        struct fb_bitfield red;                /* bitfield in fb mem if true color, */
+ r6 P$ ~7 k! q: U" R4 P        struct fb_bitfield green;        /* else only length is significant */
        struct fb_bitfield blue;
5 \" ^/ O. @$ d1 N" T        struct fb_bitfield transp;        /* transparency                        */       
% U2 z5 i# s. K2 q
        __u32 nonstd;                        /* != 0 Non standard pixel format */

        __u32 activate;                        /* see FB_ACTIVATE_*                */

; B0 l. F: r: |6 |. J        __u32 height;                        /* height of picture in mm    */
        __u32 width;                        /* width of picture in mm     */
) Q+ q) X+ ^2 {( y( `6 I! @
        __u32 accel_flags;                /* (OBSOLETE) see fb_info.flags */
; N8 p4 Y1 K' E2 h
        /* 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        */
6 L, n$ _3 ^1 A+ m0 y        __u32 right_margin;                /* time from picture to sync        */
8 T7 L8 z) b1 h3 R& f- P5 L        __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_*                */
3 W8 z5 s3 p  B, A" d& p1 w/ D        __u32 vmode;                        /* see FB_VMODE_*                */
        __u32 rotate;                        /* angle we rotate counter clockwise */
        __u32 reserved[5];                /* Reserved for future compatibility */
};
0 L8 p+ L4 }8 S, T8 n; h9 _
; c! Z3 W$ u  C5 y2.4 fb_ops结构
  该结构描述了用于fb_info的方法，这些方法中有些是要驱动程序提供的，而有些可以使用内核提供的方法。

! e' Z- m% Z6 K$ h* B- H  k 下列代码位于include/linux/fb.h

/*
* Frame buffer operations
*
* LOCKING NOTE: those functions must _ALL_ be called with the console
7 }  G4 c( |" n3 s: o * semaphore held, this is the only suitable locking mechanism we have
% {: Z& ]5 N1 {" E: ] * in 2.6. Some may be called at interrupt time at this point though.
- g# ^* e7 t% t6 q */

* Y5 H5 T5 k/ `7 Z; a; t7 h2 d1 Lstruct fb_ops {
% G5 `* J3 K5 i5 k9 |5 p        /* open/release and usage marking */
$ P  K6 M9 K* |5 s$ I$ G* [        struct module *owner;
        int (*fb_open)(struct fb_info *info, int user);
3 J* a9 x+ b9 t- Y        int (*fb_release)(struct fb_info *info, int user);

+ e9 `: r. W: @, y: ]9 i: r: b        /* For framebuffers with strange non linear layouts or that do not
         * work with normal memory mapped access
) R% d6 l: l  Q1 p3 D         */
5 \. T$ O$ @) r3 `# D        ssize_t (*fb_read)(struct fb_info *info, char __user *buf,
                           size_t count, loff_t *ppos);
$ h- y; I* P4 o* K* q        ssize_t (*fb_write)(struct fb_info *info, const char __user *buf,
# t5 x# i6 ~4 L8 b* s1 K( w                            size_t count, loff_t *ppos);
' j1 H, I$ N$ B4 M& ~' I
( M2 c7 s( a# B3 b        /* checks var and eventually tweaks it to something supported,
6 _  x. J+ V- P2 a3 |* {. |         * DO NOT MODIFY PAR */
9 d& ?! `2 f- F6 j4 h  h. C# d        int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);
' T) `! ~+ j4 ~8 C" B
# u  o$ p: {( [  t* U        /* set the video mode according to info->var */
        int (*fb_set_par)(struct fb_info *info);
& m1 c8 b4 b/ S- t* H1 p% j6 i
; w7 N& ^* H9 p+ h        /* set color register */
. ?! i: S7 ^+ {% W        int (*fb_setcolreg)(unsigned regno, unsigned red, unsigned green,
4 u( e' V  ~2 {' l                            unsigned blue, unsigned transp, struct fb_info *info);
9 w. l& A7 @) _+ W9 A6 C1 F" L. b
        /* set color registers in batch */
        int (*fb_setcmap)(struct fb_cmap *cmap, struct fb_info *info);

: V  h6 I! n  l$ Y% {+ {        /* blank display */
. J) d2 \+ Q; g1 K% M) p        int (*fb_blank)(int blank, struct fb_info *info);

        /* pan display */
        int (*fb_pan_display)(struct fb_var_screeninfo *var, struct fb_info *info);
% L5 \) o" {3 J  d2 k$ T# |
1 U$ F' G7 v2 J. i) q0 s        /* Draws a rectangle */
2 q; b. c% }' B* Z+ p& M        void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect);
1 r6 O. x( ]0 W' u9 n: X, w        /* Copy data from area to another */
        void (*fb_copyarea) (struct fb_info *info, const struct fb_copyarea *region);
: S9 X; h6 H$ W7 |        /* Draws a image to the display */
  q3 P: Q! k) V        void (*fb_imageblit) (struct fb_info *info, const struct fb_image *image);

        /* Draws cursor */
7 f& Z( w6 R4 [- h( C' j! E        int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor);
. |0 h  I6 g% ~- v8 e- _( }
        /* Rotates the display */
        void (*fb_rotate)(struct fb_info *info, int angle);

        /* wait for blit idle, optional */
% L; ^9 b( E0 F5 G$ e4 ~3 Q5 a        int (*fb_sync)(struct fb_info *info);

4 @- J. N4 ~% o0 S" a        /* peRForm fb specific ioctl (optional) */
        int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,
                        unsigned long arg);
/ ?. ]1 U; ?# G7 ]
8 j* Q1 i" o/ T        /* Handle 32bit compat ioctl (optional) */
+ z( \" n  r/ R3 }7 R9 M        int (*fb_compat_ioctl)(struct fb_info *info, unsigned cmd,
                        unsigned long arg);

        /* perform fb specific mmap */
0 ~5 u) f) X7 j9 p3 P        int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);

        /* save current hardware state */
        void (*fb_save_state)(struct fb_info *info);
& K" u2 U% V: Y+ A& A( d
7 U* x+ V4 p; }& J        /* restore saved state */
        void (*fb_restore_state)(struct fb_info *info);
/ Y9 f8 o% n  l+ @2 z' \
- K- j* c. u% U) q% Z        /* get capability given var */
# l9 K, x- F1 C! w# ~% \4 Y6 }0 ?        void (*fb_get_caps)(struct fb_info *info, struct fb_blit_caps *caps,
/ I% P" W# ]$ d, ~& q4 x                            struct fb_var_screeninfo *var);
) \3 e& ]( C( O" Y};
$ F/ c  Z0 y" [: O7 [
& T8 Q+ s8 _: @$ Y. s
4 l  r) }3 r, p3. frambuffer核心层
- \/ p1 j7 U/ ?. W  i9 i9 u首先来看下frmaebuffer子系统的初始化函数。
9 _; A- |& q- k1 w1 E
0 P% _6 L: P& `6 D' e3.1 fbmem_init和fbmem_exit
1 l# a' ]- R) m! @3 a下列代码位于drivers/video/fbmem.c

/**
*        fbmem_init - init frame buffer subsystem
*
% N/ B5 v1 G7 o- W8 j, S *        Initialize the frame buffer subsystem.
*
9 ~, B) \% g+ C! M" ~2 O; S9 \/ f *        NOTE: This function is _only_ to be called by drivers/char/mem.c.
) c+ T  A" j. C9 Z( Y7 w *
*/
9 O. e* q& C) O5 n. F
static int __init
fbmem_init(void)
8 d4 X0 @+ k/ }$ I6 e{
5 A8 B8 S; d+ W        proc_create("fb", 0, NULL, &fb_proc_fops);

5 H* g+ E- i1 j# j        if (register_chrdev(FB_MAJOR,"fb",&fb_fops))                /*注册字符设备，major=29*/
- m% }& J$ V, Y0 ^) R" ^( G7 H; M                printk("unable to get major %d for fb devs\n", FB_MAJOR);

- U' W9 z# h% C- S, ?        fb_class = class_create(THIS_MODULE, "graphics");        /*创建类*/
        if (IS_ERR(fb_class)) {
, y: |6 ~; A2 h8 ~/ V                printk(KERN_WARNING "Unable to create fb class; errno = %ld\n", PTR_ERR(fb_class));
                fb_class = NULL;
1 z$ m8 b2 ?  {* [( R* Z8 ]        }
& T  A$ J3 h4 v+ `' v# \        return 0;
}

#ifdef MODULE
module_init(fbmem_init);
1 J, [+ X! ^. astatic void __exit
8 Q! j' ^  w6 K" B* a8 K3 [8 Ufbmem_exit(void)
/ N  ^1 g3 L" h: B# ]! K( g6 y{
        remove_proc_entry("fb", NULL);
' y) O7 N. s# ]5 w+ f        class_destroy(fb_class);
$ r" P2 L& h0 ^  w1 {' t2 C% t7 D        unregister_chrdev(FB_MAJOR, "fb");
* v: k) F* x  J; w4 X}
6 \* j, [/ W; w$ O4 A1 c/ u
  D  N5 h0 w! T6 ~3 L% O$ k5 Gmodule_exit(fbmem_exit);
4 F. f- b* b4 i+ V' d/ fMODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Framebuffer base");
#else
subsys_initcall(fbmem_init);
#endif
* [3 R/ d# d8 `( M  D( y2 B$ h
static const struct file_operations fb_fops = {
8 T- G9 T- c3 h+ ^% t' S3 J4 ]    .owner =    THIS_MODULE,
2 x% s% f% R3 c# `: q4 l% q    .read =        fb_read,
    .write =    fb_write,
( u6 |' E" n" j1 Z& y  `    .unlocked_ioctl = fb_ioctl,
- u, P. ^) q; m$ h8 v5 S2 M- v) M#ifdef CONFIG_COMPAT
) N* {& F5 S6 y+ S; x$ ~6 ]% B    .compat_ioctl = fb_compat_ioctl,
#endif
: P! p3 C2 @6 I% z1 F    .mmap =        fb_mmap,
/ h. O/ C2 r0 }4 n) w    .open =        fb_open,
. S6 g( s' p7 M, m" v) i    .release =    fb_release,
#ifdef HAVE_ARCH_FB_UNMAPPED_AREA
    .get_unmapped_area = get_fb_unmapped_area,
/ X  _% d* J, A. m# t4 ^# S#endif
" A5 e% [3 b4 E* F) g#ifdef CONFIG_FB_DEFERRED_IO
    .fsync =    fb_deferred_io_fsync,
#endif
};

我们看到，如果不是作为模块，那么该初始化程序将在subsys_initcall阶段被调用。初始化时，仅仅注册了一个字符设备，并创建了一个类。通过字符设备，提供了API给用户空间，包open，release，write，read等。
随后我们看看如何分配一个fb_info结构。
2 @* g: S3 e1 U) e  E
3.2 framebuffer_alloc
下列代码位于drivers/video/fbmem.c
) t5 s  W1 J  d, G3 D
; r+ F2 g6 D+ s1 A; F/**
* framebuffer_alloc - creates a new frame buffer info structure
*
* @size: size of driver private data, can be zero
* @dev: pointer to the device for this fb, this can be NULL
" W" l: G% a3 u6 O *
$ S6 A' n7 Z. ~; p6 T1 ?- R5 [ * Creates a new frame buffer info structure. Also reserves @size bytes
, _- P6 S7 v) f* _ * for driver private data (info->par). info->par (if any) will be
* aligned to sizeof(long).
*
( ?# G4 Z. I: Y# s * Returns the new structure, or NULL if an error occured.
6 F$ v8 h0 s0 Y, v$ W( ?- S *
* W* h8 {' x, U3 ?+ i: ` */
- Z' ^# {( P6 n9 F' g, L: jstruct fb_info *framebuffer_alloc(size_t size, struct device *dev)
{
' D9 T) s/ C0 T: W4 i! P#define BYTES_PER_LONG (BITS_PER_LONG/8)
#define PADDING (BYTES_PER_LONG - (sizeof(struct fb_info) % BYTES_PER_LONG))
        int fb_info_size = sizeof(struct fb_info);
1 g* C+ ?9 r% H        struct fb_info *info;
        char *p;

        if (size)
" n$ {8 y2 X% N2 v; E                fb_info_size += PADDING;
; X" ^* K# R, j
        p = kzalloc(fb_info_size + size, GFP_KERNEL);
) p; Z0 Z- C% N, {/ }5 _9 ^" e3 Q5 A
' }- e3 m2 Y; N) R5 g        if (!p)
                return NULL;
  _( e' T& E* z
. P7 i0 }( |) u3 A5 q% S! t        info = (struct fb_info *) p;
% _% c; ~3 c) F. p. s
        if (size)
                info->par = p + fb_info_size;
* Z3 t$ H; j/ Q4 y* ^* b9 m" ~
! e: z" Z1 W$ J" l        info->device = dev;
  C2 a4 k% Y6 U
; \; ?/ {' [2 _. U( a4 l! O#ifdef CONFIG_FB_BACKLIGHT
        mutex_init(&info->bl_curve_mutex);
#endif
: o' \7 T& f4 X* Y% p4 U! n9 h
        return info;
, v4 d* G/ D) B" @1 d#undef PADDING
#undef BYTES_PER_LONG
$ l/ W2 M3 O0 k6 l: D* D}
; o1 `, q$ W7 rEXPORT_SYMBOL(framebuffer_alloc);
) {- G9 c8 w  \+ ?在进行分配时，根据参数size的大小，分配了b_info_size + size的空间，然后让fb_info->par指向size的空间。因此par所指向的空间可视为设备特有的数据。
6 n8 y5 N; V1 g. H$ c在分配了fb_info结构之后，需要将它注册到内核中。注册由register_framebuffer完成。我们来看下。

7 F. O7 B+ g- u5 `3.3 register_framebuffer
+ H/ i: `  M" ?0 D0 }下列代码位于drivers/video/fbmem.c

/**
( B6 V( @/ e2 O- ?' B *        register_framebuffer - registers a frame buffer device
4 z. Y, q& v7 I0 D* R" c( o *        @fb_info: frame buffer info structure
*
*        Registers a frame buffer device @fb_info.
; b- n# g- X' b. ?+ k  x& @4 u *
5 ~, c$ g, ?0 U* f *        Returns negative errno on error, or zero for success.
) y% d# B" k3 t0 p! {4 y  ^ *
*/
+ p  U2 K6 y1 A. v- S
$ G1 M) o+ ^- O* i+ Jint
' V; _. j2 u% K' h0 Jregister_framebuffer(struct fb_info *fb_info)
{
        int i;
        struct fb_event event;
2 q1 V5 P. C# s        struct fb_videomode mode;

" M% I* x0 \; T: {0 ]3 r4 n) @. |        if (num_registered_fb == FB_MAX) /*最多32个FB*/
% g+ y6 L. a, o4 u; G5 f4 @                return -ENXIO;
( w- o+ h9 A% o8 V
' l2 H9 y1 J1 Z& O        if (fb_check_foreignness(fb_info))
3 Z* @" z+ J$ Z( V9 [0 h                return -ENOSYS;
1 [. T0 ~9 e8 G- p
- E& D0 }  x- X  f2 g( l        num_registered_fb++;                /*对注册的FB计数*/
4 _  H. e! c9 H! n+ n        /*寻找第一个空位*/
$ A, j! D6 _+ N; T& h        for (i = 0 ; i < FB_MAX; i++)/*FB_MAX=32,也就是最多32个framebuffer*/
0 y* c& F' w$ d                if (!registered_fb)        /*struct fb_info *registered_fb[FB_MAX]*/
& I6 h0 e$ ~% K  r9 l& q                        break;
1 T/ E8 `$ b& @$ Q# v& L; W        fb_info->node = i;
        mutex_init(&fb_info->lock);        /*初始化互斥体*/
) t% C& l! b3 H2 J" O3 y4 z4 C% l
+ [( p6 {! O6 |) z5 P        fb_info->dev = device_create(fb_class, fb_info->device,/*创建设备节点，节点名为fbx*/
7 b+ w( e* K( k8 e, O# `  V                                     MKDEV(FB_MAJOR, i), NULL, "fb%d", i);
        if (IS_ERR(fb_info->dev)) {
, r7 B1 [# Q) \0 K# K+ r6 _                /* Not fatal */
8 L1 B2 ]6 |. S/ q4 D                printk(KERN_WARNING "Unable to create device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->dev));
' {" Q& E/ q( d" q) v                fb_info->dev = NULL;
        } else
                fb_init_device(fb_info);        /*初始化,在class/graphics/fbx/下创建设备属性*/

0 |" e" D0 Y2 q. |- W9 d        if (fb_info->pixmap.addr == NULL) {
3 P3 x; K; D' S  E1 ]4 W0 l                fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL);/*分配内存，1024 * 8字节*/
1 y" v& r+ |5 u. a9 o3 z                if (fb_info->pixmap.addr) {
. @; |2 G9 J' t/ ^2 q& S7 x6 R) r                        fb_info->pixmap.size = FBPIXMAPSIZE;
                        fb_info->pixmap.buf_align = 1;
                        fb_info->pixmap.scan_align = 1;
9 Z. B0 P( X0 q                        fb_info->pixmap.access_align = 32;
7 l, H2 H. V) f9 Z: P6 _* b                        fb_info->pixmap.flags = FB_PIXMAP_DEFAULT;
                }
: L1 x; F* v* R/ h        }       
        fb_info->pixmap.offset = 0;

        if (!fb_info->pixmap.blit_x)
' W6 V' A8 G( X9 T. _3 P                fb_info->pixmap.blit_x = ~(u32)0;
. k3 K- A9 S2 y2 Y  v2 }
        if (!fb_info->pixmap.blit_y)
                fb_info->pixmap.blit_y = ~(u32)0;
, A. ?% }9 z! `0 v5 j; N8 U* `$ H4 a
% [, r  p. I* d9 q" S9 B        if (!fb_info->modelist.prev || !fb_info->modelist.next)        /*该链表没有指向其他节点*/
0 o/ ^( p* _; m                INIT_LIST_HEAD(&fb_info->modelist);        /*初始化链表头*/
: h3 w) k; O* m1 a: H
        fb_var_to_videomode(&mode, &fb_info->var);/*转换fb_var_screeninfo成fb_videomode*/
7 A% t9 p5 ^  n: _9 A. e9 D        fb_add_videomode(&mode, &fb_info->modelist);/*添加mode至链表中*/
' Q3 |$ o9 Y8 t        registered_fb = fb_info;

        event.info = fb_info;
        if (!lock_fb_info(fb_info))
2 _4 x4 U) U4 t8 j; C# {                return -ENODEV;
: _! o' ~* m& t6 _        fb_notifier_call_chain(FB_EVENT_FB_REGISTERED, &event);/*???*/
" }% J/ x( d. s; F        unlock_fb_info(fb_info);
/ M6 X# F) x- |! f) i        return 0;
}

从这个函数我们可以看出，framebuffer子系统只支持32个设备。在创建了设备节点以后，建立设备属性节点，随后将fb_var_screeninfo转换成fb_videomode，最后添加fb_videomode至链表中。
我们看下其中调用的函数，首先是fb_init_device。

下列代码位于drivers/video/fbsysfs.c

int fb_init_device(struct fb_info *fb_info)
8 E: [2 W! ~' o* f8 n5 q1 ]3 U; S$ s{
" }2 L7 W% [- S7 |/ k1 `3 W; W        int i, error = 0;

! P& x( J) A- F; ^* `5 A# R9 b1 ]- N; t        dev_set_drvdata(fb_info->dev, fb_info);

        fb_info->class_flag |= FB_SYSFS_FLAG_ATTR;
# k2 h6 J$ a* J; n) N
$ Y7 u+ w& N. b$ V% W) ~( e        /*建立设备属性*/
% Z; W/ i7 I$ E8 V        for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
                error = device_create_file(fb_info->dev, &device_attrs);

3 _# H- Q7 i4 L3 b3 c3 H# g                if (error)
                        break;
        }
+ [& Y8 t' `1 i; P$ A4 w2 I6 m
        if (error) {
: b$ a5 h. u- N5 k: B0 |                while (--i >= 0)
+ {4 i$ G& n' F" U6 p0 N                        device_remove_file(fb_info->dev, &device_attrs);
7 N4 S% ^2 |3 Q( R7 n2 \1 _                fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
: E+ [/ p2 d1 N. e4 x- x        }
, o' C7 X, {5 {# m
) D9 w; g3 i% K; g        return 0;
1 e- I- F; @' C$ X) Y( ?: A}

* S5 O( ^* s7 \, S9 U% h/* When cmap is added back in it should be a binary attribute
+ A( `6 a5 D. S* M/ L6 B2 t% @# A * not a text one. Consideration should also be given to converting
* fbdev to use configfs instead of sysfs */
+ }( r6 P' D2 P2 _2 T, {1 ?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),
    __ATTR(cursor, S_IRUGO|S_IWUSR, show_cursor, store_cursor),
    __ATTR(mode, S_IRUGO|S_IWUSR, show_mode, store_mode),
8 a+ q: s/ C. v: K9 u% _- s    __ATTR(modes, S_IRUGO|S_IWUSR, show_modes, store_modes),
- |, V. y5 ~2 [9 t! {    __ATTR(pan, S_IRUGO|S_IWUSR, show_pan, store_pan),
    __ATTR(virtual_size, S_IRUGO|S_IWUSR, show_virtual, store_virtual),
  r& R' `' `: O+ v( Y    __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),
6 k/ d- A" j3 x$ m  r# [#ifdef CONFIG_FB_BACKLIGHT
0 _) P- Z+ O3 c& E4 a. @    __ATTR(bl_curve, S_IRUGO|S_IWUSR, show_bl_curve, store_bl_curve),
) `/ b$ W3 e8 E" ?( @#endif
% S$ y. K( n8 [+ U};
( l2 w3 M# U+ K+ X% K
- L' i5 b' P; i. }' v/ Q4 n. M我们可以在/sys/class/graphics/fb0下发现这些属性文件。
[root@yj423 fb0]#pwd
$ q2 A+ V6 K9 c8 ?/sys/class/graphics/fb0
[root@yj423 fb0]#ls
bits_per_pixel  cursor          mode            pan             state           uevent
0 @0 A3 w. A/ ~' H$ i! n1 f% G( Jblank           dev             modes           power           stride          virtual_size
# z/ \2 O  e) R* k3 h8 ?% Fconsole         device          name            rotate          subsystem


接着看下fb_var_to_videomode和fb_add_videomode函数。
4 ?3 ~9 P1 v( V2 R$ B6 g+ ^
+ j; d/ D! t& I0 O下列代码位于drivers/video/modedb.c和drivers/video/fb.h
1 V! u5 ]) t$ T" V
2 X  R5 K& }7 {& rstruct fb_videomode {
/ B/ u" m0 b2 a9 |        const char *name;        /* optional */
  W+ w9 u. R: X' z" \        u32 refresh;                /* optional */
2 J+ N1 r) ~8 ~0 r6 r        u32 xres;
- g; M7 j! ^$ o1 [. C        u32 yres;
- N5 {# c$ j( `7 Z4 z; A( B        u32 pixclock;
8 N  r2 m" ?* Z! J5 A        u32 left_margin;
& S) t) P5 `+ o: F6 w; O, }  [        u32 right_margin;
6 z* ~9 J/ l$ M        u32 upper_margin;
        u32 lower_margin;
  Q; z& Y, `* G# E0 K8 h; p& d3 |        u32 hsync_len;
+ }7 \) K+ J/ z4 U2 l        u32 vsync_len;
        u32 sync;
+ d( F& S2 q. U5 r. d* K% `        u32 vmode;
' v. P% ]3 D( S$ a9 u$ H8 |1 c. |: M        u32 flag;
};

/**
* fb_var_to_videomode - convert fb_var_screeninfo to fb_videomode
* @mode: pointer to struct fb_videomode
* @var: pointer to struct fb_var_screeninfo
*/
void fb_var_to_videomode(struct fb_videomode *mode,
) ]1 t5 l9 ~% G. M0 v             const struct fb_var_screeninfo *var)
{
    u32 pixclock, hfreq, htotal, vtotal;

4 C9 h8 _# {! [: L/ M- t) ^    mode->name = NULL;
1 k6 t; }+ r5 ?2 S( m    mode->xres = var->xres;
    mode->yres = var->yres;
$ W# O) h- ?* c: G9 ~    mode->pixclock = var->pixclock;
* @& C4 B& o$ [5 z) b( \% Z    mode->hsync_len = var->hsync_len;
    mode->vsync_len = var->vsync_len;
" G8 `5 d4 w5 d    mode->left_margin = var->left_margin;
    mode->right_margin = var->right_margin;
/ G; s6 w$ K/ H; g' ^    mode->upper_margin = var->upper_margin;
, ~: p# |2 c; R( {' f1 o    mode->lower_margin = var->lower_margin;
" X) Q( v7 _+ j    mode->sync = var->sync;
! X$ x9 [- p( l$ P    mode->vmode = var->vmode & FB_VMODE_MASK;
. c/ P2 Y7 a: y% o+ ?: @    mode->flag = FB_MODE_IS_FROM_VAR;
    mode->refresh = 0;
0 I" }; V+ N5 P' `/ _* X2 d. U! U
    if (!var->pixclock)
        return;
, T1 U# L) Y3 Q8 b' z9 ]
6 z" {: A$ ^3 [6 X$ Q    pixclock = PICOS2KHZ(var->pixclock) * 1000;
( k7 l" h' D  J; I* ~  v& a/ X) u
    htotal = var->xres + var->right_margin + var->hsync_len +
        var->left_margin;
( Q3 g5 q: a, |" M7 d8 a" ?( P/ p" k    vtotal = var->yres + var->lower_margin + var->vsync_len +
        var->upper_margin;

    if (var->vmode & FB_VMODE_INTERLACED)
9 x5 ^: Y6 Y2 G' V3 `        vtotal /= 2;
7 ~: i# A6 w5 p6 N    if (var->vmode & FB_VMODE_DOUBLE)
        vtotal *= 2;
' q: t! j7 Q: O, x3 |
    hfreq = pixclock/htotal;
; {, o) f, w( b# R/ G& K5 ~" u4 m( j2 E    mode->refresh = hfreq/vtotal;
8 y2 l6 P: F- ~, {" F}

/**
* fb_add_videomode: adds videomode entry to modelist
* @mode: videomode to add
* @head: struct list_head of modelist
*
* NOTES:
5 x9 L% [" c  H  t9 P& @0 @& u * Will only add unmatched mode entries
*/
int fb_add_videomode(const struct fb_videomode *mode, struct list_head *head)
{
    struct list_head *pos;
    struct fb_modelist *modelist;d
! O9 }1 E* Q3 a8 T8 `2 ~    struct fb_videomode *m;
    int found = 0;
    /*遍历所有的fb_modelist，查找mode是否存在*/
    list_for_each(pos, head) {
0 }' e- K' l  G6 r7 v* ^, ]! h        modelist = list_entry(pos, struct fb_modelist, list);
        m = &modelist->mode;
6 B( ~& z1 n+ T        if (fb_mode_is_equal(m, mode)) {    /*比较两个fb_videomode*/
& ]% x6 ?4 n, v: @- Y4 }            found = 1;                        /*该fb_videomode已存在*/
            break;
3 h& _) `) D% d& q        }
7 g  k$ ?7 h+ L" U    }
/ g7 {9 |9 J7 i# Y6 u- v  z! {- `    if (!found) {    /*不存在*/
! v. r) j) i& z7 A3 G        modelist = kmalloc(sizeof(struct fb_modelist),    /*分配fb_modelist*/
                          GFP_KERNEL);

' j# S7 \( {* H        if (!modelist)
            return -ENOMEM;
        modelist->mode = *mode;            /*保存mode*/
        list_add(&modelist->list, head);/*添加mode至链表中*/
" `. ^9 v1 c' o* N4 b    }
+ m) T4 q7 o0 I8 K" T( _+ N    return 0;
9 T( m* S: S7 K% s}
7 Q' g" Q+ @# V4 u& q3 N
/**
* fb_mode_is_equal - compare 2 videomodes
* @mode1: first videomode
6 l  v$ Y% s  u. M, |4 `0 b * @mode2: second videomode
, C  V4 _/ t0 i+ p$ v; T' c *
* RETURNS:
  S9 q& r1 [/ [! D * 1 if equal, 0 if not
*/
$ J' z' V; P7 a: Bint fb_mode_is_equal(const struct fb_videomode *mode1,
             const struct fb_videomode *mode2)
" V' q' D2 o0 Z1 I4 b& b{
3 }4 V( ]0 i& |0 w    return (mode1->xres         == mode2->xres &&
        mode1->yres         == mode2->yres &&
        mode1->pixclock     == mode2->pixclock &&
/ J( I  i) c8 Y3 Z  S; O* X3 H        mode1->hsync_len    == mode2->hsync_len &&
        mode1->vsync_len    == mode2->vsync_len &&
        mode1->left_margin  == mode2->left_margin &&
        mode1->right_margin == mode2->right_margin &&
. _$ w  J4 w4 Y: _0 m8 f* P, ?" y: ^        mode1->upper_margin == mode2->upper_margin &&
- O1 _5 [2 T' c( S        mode1->lower_margin == mode2->lower_margin &&
( u1 y8 V& W+ b: g' {& E        mode1->sync         == mode2->sync &&
        mode1->vmode        == mode2->vmode);
1 y9 X$ c6 Z9 D. @}
2 `8 X6 R& w$ ?' D2 l6 C  ?' Q

fb_var_to_videomode函数只是将fb_var_screeninfo结构转换成fb_videomode结构。而fb_add_videomode函数查找是否该fb_videomode已经存在，如果不存在则添加到列表中。
3.4 字符设备方法
1 [" Q: k! F' T, Z8 L  在看过framebuffer子系统建立和注册过程后，我们看下framebuffer留给用户空间的API是怎样实现的。
( s4 M+ S2 n* p: O, ]- w
0 s  n, e: y2 d% F8 i' y( [) b本小结只分析5个常用的方法，即open，release，read，write和ioctl。

  U" a: T1 v6 h2 f9 E  E3 I5 U  因为所有的方法和struct fb_ops定义的方法有紧密的联系，而该结构的定义由驱动程序给出，在这里我们提前看下在驱动中是如何定义的。

下列代码位于drivers/video/s3c2410fb..c

static struct fb_ops s3c2410fb_ops = {
        .owner                = THIS_MODULE,
        .fb_check_var        = s3c2410fb_check_var,                        /*检查变量的合法性*/
9 c5 p9 k: J% T' P6 Q3 R        .fb_set_par        = s3c2410fb_set_par,                        /*将参数写入LCD控制器，该函数由帧缓冲核心调用*/
        .fb_blank        = s3c2410fb_blank,                        /*该方法支持显示消隐和去消隐*/
) K, f( U7 u0 \9 V        .fb_setcolreg        = s3c2410fb_setcolreg,                  /*设置颜色寄存器*/
+ I8 @$ m& C7 g        .fb_fillrect        = cfb_fillrect,                                /*用像素行填充矩形框，通用库函数*/
/ H* F5 }( g+ C5 g* b2 F0 I        .fb_copyarea        = cfb_copyarea,                                /*将屏幕的一个矩形区域复制到另一个区域，通用库函数*/
        .fb_imageblit        = cfb_imageblit,                        /*显示一副图像，通用库函数*/
};
* d' {7 R, d* k最下面的三个方法使用的是内核提供的库函数，而上面4个则是由驱动提供。
, ~2 A7 v  i8 c* i- i& O3.4.1 open方法
. n7 Z, Z4 y9 d, h7 {2 u下列代码位于drivers/video/fbmem.c
0 \+ x; s* ]9 L
static int
fb_open(struct inode *inode, struct file *file)
0 P4 v0 S2 T; @. a__acquires(&info->lock)
__releases(&info->lock)
{
        int fbidx = iminor(inode);
2 w8 a9 N9 M1 v& f& r& O9 Q: |: v        struct fb_info *info;
! e9 q( I1 d) q( V% R8 A! |        int res = 0;
1 z+ M, U0 X6 P- T
        if (fbidx >= FB_MAX)
9 ?! X% x0 S; h9 u                return -ENODEV;
        info = registered_fb[fbidx];                /*在register_framebuffer函数中已经设置了元素*/
5 M* g! G' f, ]0 W2 x( V8 P. O1 L+ f        if (!info)
                request_module("fb%d", fbidx);        /*加载模块，这里不加载*/
        info = registered_fb[fbidx];
        if (!info)
                return -ENODEV;
        mutex_lock(&info->lock);                        /*加锁互斥体*/
" E2 d* N; x: q6 i        if (!try_module_get(info->fbops->owner)) {        /*增加模块引用计数*/
                res = -ENODEV;
$ H" K/ d- m* F' }6 j& z' I% ^) L                goto out;
        }
1 e7 _  h1 \' f' V        file->private_data = info;                /*保存info*/
        if (info->fbops->fb_open) {                /*这里fb_open方法为空*/
! h+ w9 a4 T+ Y                res = info->fbops->fb_open(info,1);
1 |* N6 w5 [9 `: w: ^5 J                if (res)
! |3 H' B7 x( ~' f5 |( E                        module_put(info->fbops->owner);
2 @+ K2 a; e; P4 a. J        }
#ifdef CONFIG_FB_DEFERRED_IO
; Y1 e# }8 m8 j  t. y8 w        if (info->fbdefio)
                fb_deferred_io_open(info, inode, file);
. [- K% L/ Z$ F3 Q#endif
out:
        mutex_unlock(&info->lock);                /*解锁互斥体*/
        return res;
}
主要的一个工作就是增加模块引用计数。还有，程序会判断是否fb_open在驱动中给出，如果有则调用该方法。我们已经知道fb_open没有给出。
3.4.2 release方法
5 y3 K! P% M5 m6 i! B下列代码位于drivers/video/fbmem.c

static int
% M2 u9 ^7 N2 }4 {0 G: Zfb_release(struct inode *inode, struct file *file)
  `2 T" |, U6 J, }+ I__acquires(&info->lock)
: N5 c; p" ~' s- X3 a. n5 p% `__releases(&info->lock)
{
        struct fb_info * const info = file->private_data;

        mutex_lock(&info->lock);
        if (info->fbops->fb_release)        /*这里fb_release为空*/
' T$ B  K: I; q# I) m( d1 F! i                info->fbops->fb_release(info,1);
6 ?, K  N  O4 S# ~        module_put(info->fbops->owner);        /*减少模块引用计数*/
        mutex_unlock(&info->lock);
3 P( n* t5 _# }2 H$ y0 B        return 0;
) V/ W' }3 D: {2 m! Q  u}
和open相反，减少模块引用计数。

3.4.3 write方法
( K) G' p, Y& H0 [/ g3 l+ Y& y  通过调用该方法，LCD将显示画面。

+ f) J- d+ b. p4 m. z6 Y) U( Z  下列代码位于drivers/video/fbmem.c

static ssize_t
/ ~- F5 M$ |7 F4 V' ?2 h  [fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
8 f2 U! r2 t" W: _# ?{
    unsigned long p = *ppos;
    struct inode *inode = file->f_path.dentry->d_inode;
    int fbidx = iminor(inode);
    struct fb_info *info = registered_fb[fbidx];
    u32 *buffer, *src;
8 M7 l- E8 r% i! Y) g% H; F- T    u32 __iomem *dst;
# n5 T2 f& z6 {/ A% ~5 e    int c, i, cnt = 0, err = 0;
    unsigned long total_size;
( b' q5 B! G; F1 }  b
    if (!info || !info->screen_base)    /*screen_base在驱动中给出*/
        return -ENODEV;

    if (info->state != FBINFO_STATE_RUNNING)
1 e! Y. U  |  Z( }        return -EPERM;

/ U# w, p: ?4 V1 u3 K7 \: _+ i% |& K! X    if (info->fbops->fb_write)    /*没有fb_write方法*/
        return info->fbops->fb_write(info, buf, count, ppos);

    total_size = info->screen_size;    /*screen_size没有给出*/
! W! u" s$ `! _  j
9 [+ O: Q4 n+ v  h3 b8 |    if (total_size == 0)
        total_size = info->fix.smem_len;/*153600字节，驱动probe方法中计算*/

    if (p > total_size)
        return -EFBIG;
# e, Q  V9 Q0 n3 h5 `  {9 `+ l
    if (count > total_size) {    /*要写入的字节数大于153600*/
; m: z, X! C6 q& X        err = -EFBIG;        /*file too big*/
8 p3 h0 E5 j$ l        count = total_size;
    }

    if (count + p > total_size) {/*偏移量加上字节数超出了缓冲区*/
        if (!err)
            err = -ENOSPC;

        count = total_size - p;
    }

    /*分配buffer，GFP_KERNEL*/
5 H  z, T1 u. s1 S9 w# D    buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
6 s$ C2 i/ c! q: W; X             GFP_KERNEL);                /
    if (!buffer)
; o" t4 s$ f$ C: y- B        return -ENOMEM;

    dst = (u32 __iomem *) (info->screen_base + p);/*修改目的指针*/
; R. M( }+ Z( j( Z5 J7 z8 X$ v
& W" `1 m. ]. }* c* h! q    if (info->fbops->fb_sync)    /*没有定义fb_sync*/
& [, b3 F5 ]* O$ y7 B. j        info->fbops->fb_sync(info);

    while (count) {
        c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
        src = buffer;

        /*从buf(用户空间)拷贝数据到src中，一开始为1页，最后为count字节*/
( w& j8 L+ M! W5 W( s9 u        if (copy_from_user(src, buf, c)) {   
            err = -EFAULT;
            break;
9 K8 }! D$ d2 |; s: k/ {        }
        /*一次for循环，写入4个字节数据到dst处*/
1 @- ~6 a, D" J, J        for (i = c >> 2; i--; )
            fb_writel(*src++, dst++);
) I# v3 w: p: I6 f        /*最后还有3个，2个或者1个字节*/
        if (c & 3) {
            u8 *src8 = (u8 *) src;
0 k/ [- s$ Q$ h& R            u8 __iomem *dst8 = (u8 __iomem *) dst;
* L( h$ g8 G* L1 X( L            /*一次写入一个字节*/
            for (i = c & 3; i--; )
                fb_writeb(*src8++, dst8++);
8 N7 l2 k; L+ O/ n+ s
  s$ K. `. C6 \            dst = (u32 __iomem *) dst8;
8 H% `* ?# j. {) k  _7 u/ @        }
8 p% W4 F; E$ }- t3 @" N
        *ppos += c;    /*用户空间偏移量增加*/
' ?/ Z, j9 k; ~2 c2 p4 m. F# w        buf += c;    /*用户空间指针增加*/
" k+ i' K. }: s% h' k" z/ r7 M+ H        cnt += c;    /*修改已发送字节数*/
        count -= c;    /*减去1页*/
    }
6 {; q2 i( Z" G4 R, R' R
% j! V( K' G! C/ Z& q& T    kfree(buffer);    /*释放buffer*/

    return (cnt) ? cnt : err;
}

这里，做了一系列的检查之后，开始拷贝数据。这里一个有三个buffer，一个是用户空间提供的buf，一个是在这里新开辟的buffer，还有就是驱动层提供的screen_base。
( q) g) K) ?: D" x+ f3 G9 v数据流如下：
0 E$ S& n8 a0 W+ V( k1 O

, e" {1 x" z/ J4 A8 p' X2 @# ?
% Y, c$ ~& T! b' m. p. q4 ^用户空间的数据首先被复制到buffer中，然后从buffer中复制到screen_base中，最后被映射到LCD上，LCD就显示响应的画面了。
* h" Y! C6 p" L0 O5 C% H' Z8 G
0 i5 ?. j$ a  G, V$ i$ L) l" \' z7 P3.4.4 read方法
该方法用于读取屏幕画面的数据。
$ Y9 P# f0 t! n$ a! G
" C  b" {3 X+ ]* m7 ]read和write类似，只是数据流是反响的，就不多做介绍了。
$ q' f7 `3 U2 w# s7 V
5 G4 D3 i3 R& I% h/ i* x' i下列代码位于drivers/video/fbmem.c
" h! l, c' u& D9 u$ F4 p
' `) k& {7 a& B0 d+ I0 Fstatic ssize_t
fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
        unsigned long p = *ppos;
7 I# q# |/ K4 P- r$ L        struct inode *inode = file->f_path.dentry->d_inode;
        int fbidx = iminor(inode);
( V) D) t  u/ l1 ~4 [6 g        struct fb_info *info = registered_fb[fbidx];
, m) V( C, R8 f' [, P" i$ r& s        u32 *buffer, *dst;
  F: P) g& o! B5 C  E7 C        u32 __iomem *src;
7 ]3 U5 I, y0 ^# X+ s! E        int c, i, cnt = 0, err = 0;
        unsigned long total_size;

        if (!info || ! info->screen_base)
                return -ENODEV;
; ?) K, s3 R2 F! m
/ f4 }0 J0 W4 t        if (info->state != FBINFO_STATE_RUNNING)
                return -EPERM;
; E! i, _5 x* k7 J5 ]  v) {- h1 t
        if (info->fbops->fb_read)        /*没有定义fb_read*/
                return info->fbops->fb_read(info, buf, count, ppos);
0 Z/ d# F; R0 h       
        total_size = info->screen_size;

8 R9 M, N5 g' Q! l% z        if (total_size == 0)
                total_size = info->fix.smem_len;
& M3 [  X9 a7 n
        if (p >= total_size)
                return 0;
" h1 ]4 w9 N# t" ]5 A
6 x: k4 r, F' e( a9 X3 [        if (count >= total_size)
                count = total_size;

3 R# _: A( G1 G+ j3 e4 c% I  O, l        if (count + p > total_size)
% m( ~7 b8 a" \                count = total_size - p;
6 s9 ]; k% h+ ]% c: @: x( P2 e: R
        buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
( }! O: U6 b6 i2 R9 D, y- m                         GFP_KERNEL);
        if (!buffer)
                return -ENOMEM;

        src = (u32 __iomem *) (info->screen_base + p);
2 L, B3 @# g( C$ M! V
        if (info->fbops->fb_sync)
7 L, a) d# [/ \) Q                info->fbops->fb_sync(info);/*没有定义fb_sync*/
* X! n+ k" S4 I) B6 J% g
        while (count) {
6 `4 s6 |3 C: j& k                c  = (count > PAGE_SIZE) ? PAGE_SIZE : count;
                dst = buffer;
                for (i = c >> 2; i--; )
1 @5 v- [7 C: \7 |. j                        *dst++ = fb_readl(src++);
8 L3 r+ }7 W2 w3 M0 H) a                if (c & 3) {
                        u8 *dst8 = (u8 *) dst;
% I" ^- {1 x# j* V" E                        u8 __iomem *src8 = (u8 __iomem *) src;
) D  C  r5 j. w- |
9 z1 f5 H% T& {  B& e                        for (i = c & 3; i--;)
                                *dst8++ = fb_readb(src8++);
$ l! o& k* B$ J
4 y2 V: T4 B% f% ]4 q3 ?; R                        src = (u32 __iomem *) src8;
4 a0 l  n9 C( k. ?, n                }

                if (copy_to_user(buf, buffer, c)) {
                        err = -EFAULT;
) e- [5 D; m5 O1 F                        break;
- c/ b* Q3 h4 }' W2 v" t                }
& E' W+ E1 j0 {2 R+ D                *ppos += c;
, k' e7 V) j( a* m$ D% N                buf += c;
+ i) M' [8 ^# w: w                cnt += c;
2 ]) w  _* P( o/ r; B  V: H                count -= c;
  s+ _( Y2 |# n8 {" h        }
4 f+ {! o; J! U+ ]  ~
) k" y3 Y( Q/ Y- _/ q* s6 k: p! t        kfree(buffer);

        return (err) ? err : cnt;
}
  ?( U* K) z: j3.4.5 ioctl方法
这里只是简单的看下ioctl方法，这个函数调用很多其他的函数，详细的请自己看吧。
, z9 g+ [% I, I3 L
下列代码位于drivers/video/fbmem.c

static long fb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
' x$ W; p" T  k" u2 r{
        /*获取inode，再获取对应的fb_info*/
9 H% p5 p3 z3 j: f3 `        struct inode *inode = file->f_path.dentry->d_inode;
+ L  F2 N! R! K' j8 ^! h. l        int fbidx = iminor(inode);       
        struct fb_info *info = registered_fb[fbidx];
8 N% D  M# e+ Z- }. Y
! y5 Q: x6 @; O, x& t8 i, {1 ^        return do_fb_ioctl(info, cmd, arg);
}

static long do_fb_ioctl(struct fb_info *info, unsigned int cmd,
' B) e4 e1 q. o            unsigned long arg)
{
( \5 L. Q8 ]; S) U" l9 ]$ b    struct fb_ops *fb;
    struct fb_var_screeninfo var;
" O5 E1 Y- B5 `% y. A0 j    struct fb_fix_screeninfo fix;
    struct fb_con2fbmap con2fb;
    struct fb_cmap cmap_from;
5 z: k2 Q$ D: ]/ W5 I    struct fb_cmap_user cmap;
/ |) d, [- N% ?) O    struct fb_event event;
    void __user *argp = (void __user *)arg;
$ x5 W) ~& K1 \    long ret = 0;

& P& r+ Q) |0 p2 P    switch (cmd) {
    /*获取fb_var_screeninfo*/
% K+ q& e% U  W0 y. A0 R' b  y: l    case FBIOGET_VSCREENINFO:   
; U  d. f- t+ t* k% u: {, L( e        if (!lock_fb_info(info))    /*加锁互斥体info->lock*/
2 p5 P7 ]1 b# A. Z2 v; k% y            return -ENODEV;
        var = info->var;            /*复制var*/
6 I; q1 L$ k, Q9 {  M5 F        unlock_fb_info(info);

- F  `- p+ v1 s, G        ret = copy_to_user(argp, &var, sizeof(var)) ? -EFAULT : 0;    /*复制var到用户空间*/
6 D" N8 F0 f/ U4 s- A& |$ I        break;
1 ]; }7 Q. l- q, N' \7 R    /*设置fb_var_screeninfo*/
% O6 Q7 d5 q9 t: M0 }: S: E' y    case FBIOPUT_VSCREENINFO:
        if (copy_from_user(&var, argp, sizeof(var)))    /*从用户空间获取var*/
            return -EFAULT;
& Q$ a! ]$ K. S  C% P8 X        if (!lock_fb_info(info))
% K: L& ]$ R8 h4 h            return -ENODEV;
        acquire_console_sem();
. W! F4 j' ~) [' S/ h        info->flags |= FBINFO_MISC_USEREVENT;
, T) {$ P1 A% G" \: \* E        ret = fb_set_var(info, &var);            /*设置var*/
* {4 D' R' D9 _2 W        info->flags &= ~FBINFO_MISC_USEREVENT;
        release_console_sem();
        unlock_fb_info(info);
        if (!ret && copy_to_user(argp, &var, sizeof(var)))
& X- M0 ]& h6 v8 q% L4 |            ret = -EFAULT;
        break;
    /*获取fb_fix_screeninfo*/    /*fix为不可改变信息，只能获取，不能设置*/
    case FBIOGET_FSCREENINFO:
% L- V: h# G- B2 M+ {        if (!lock_fb_info(info))
            return -ENODEV;
        fix = info->fix;
- D4 K$ D* w8 z: ^  R! m0 }        unlock_fb_info(info);
- I$ i/ Y; y  c! L: s# T. O4 I0 ]
5 I4 x& A5 ^0 k8 O9 K        ret = copy_to_user(argp, &fix, sizeof(fix)) ? -EFAULT : 0;
0 P  T7 W/ b; X6 X3 Z' H" s' [! j0 f        break;
    /*设置fb_cmap*/   
* W* v1 `& h* |2 [5 \7 T    case FBIOPUTCMAP:
        if (copy_from_user(&cmap, argp, sizeof(cmap)))
            return -EFAULT;
* R4 @5 w5 m1 q! J) p# A. d9 ~        ret = fb_set_user_cmap(&cmap, info);    /*设置fb_cmap*/
        break;
% R, W" U8 g8 n2 N3 e( ?9 {    /*获取fb_cmap*/   
4 u# k* H5 O" Z: F5 k2 i    case FBIOGETCMAP:
1 [/ G7 Q7 Z( F        if (copy_from_user(&cmap, argp, sizeof(cmap)))
            return -EFAULT;
        if (!lock_fb_info(info))
            return -ENODEV;
0 G- p% G3 m2 r. n% I        cmap_from = info->cmap;
  z6 S% l' b4 d- j$ g        unlock_fb_info(info);
3 M  J5 N* S. R! M        ret = fb_cmap_to_user(&cmap_from, &cmap);/*获取fb_cmp*/
: ?: p% a3 B4 O6 W        break;
    case FBIOPAN_DISPLAY:
7 m9 R$ p9 B( \& x( I        if (copy_from_user(&var, argp, sizeof(var)))
' D) k, Q& K: N7 Q$ x2 Z/ q            return -EFAULT;
5 U2 D$ P# _7 U  A9 I, f        if (!lock_fb_info(info))
4 R" y: ]0 ^0 N& C: n# `, T            return -ENODEV;
5 y& N% N. Z2 [9 ^        acquire_console_sem();
        ret = fb_pan_display(info, &var);
* f* e3 P# p, L  _        release_console_sem();
        unlock_fb_info(info);
. ~" d4 n9 i/ |7 B. v9 f        if (ret == 0 && copy_to_user(argp, &var, sizeof(var)))
            return -EFAULT;
3 o2 j9 X# [, z# P. W        break;
# g4 U) p$ r- L- E    case FBIO_CURSOR:
        ret = -EINVAL;
        break;
    case FBIOGET_CON2FBMAP:
5 |& b; g/ h1 W        if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
            return -EFAULT;
3 A5 }* y  O& j% H: g6 k        if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
            return -EINVAL;
- Y. S/ T- T, ^9 ^        con2fb.framebuffer = -1;
        event.data = &con2fb;
        if (!lock_fb_info(info))
& K1 t2 M* ?" M" l; R: S            return -ENODEV;
+ b! k" V3 S5 O5 T# ]3 h) C2 C; a        event.info = info;
        fb_notifier_call_chain(FB_EVENT_GET_CONSOLE_MAP, &event);
        unlock_fb_info(info);
        ret = copy_to_user(argp, &con2fb, sizeof(con2fb)) ? -EFAULT : 0;
        break;
    case FBIOPUT_CON2FBMAP:
/ {) b6 K5 Z3 b& d- ?        if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
1 i& U  E0 ]5 r4 h+ V& N3 r            return -EFAULT;
        if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
            return -EINVAL;
( V5 v2 r/ m' P* b9 |        if (con2fb.framebuffer < 0 || con2fb.framebuffer >= FB_MAX)
            return -EINVAL;
        if (!registered_fb[con2fb.framebuffer])
# S( n. N( B. g6 n% w! G! w            request_module("fb%d", con2fb.framebuffer);
: m2 Z% P0 K! a. H9 ], d        if (!registered_fb[con2fb.framebuffer]) {
) t/ ~" U+ N! F  A( _" Y* j            ret = -EINVAL;
            break;
        }
/ s6 z8 U) r% r$ S6 ~1 K        event.data = &con2fb;
0 Z9 X8 t1 P8 j: M/ L* N! q        if (!lock_fb_info(info))
            return -ENODEV;
        event.info = info;
6 G+ H; p* Y, T' j$ E        ret = fb_notifier_call_chain(FB_EVENT_SET_CONSOLE_MAP, &event);
        unlock_fb_info(info);
/ f7 z4 \  }  h2 y        break;
7 S: s( y- @2 a    case FBIOBLANK:
, G, Q! n: @! f  q) h2 D        if (!lock_fb_info(info))
            return -ENODEV;
        acquire_console_sem();
; K' Z- m+ E0 l7 S6 \4 i        info->flags |= FBINFO_MISC_USEREVENT;
        ret = fb_blank(info, arg);        ?*最后调用驱动提供的s3c2410fb_blank*/
        info->flags &= ~FBINFO_MISC_USEREVENT;
/ F" w) M( V8 o  t* N        release_console_sem();
        unlock_fb_info(info);
        break;
    default:
        if (!lock_fb_info(info))
6 t" X& w* i7 p4 ]- j+ V            return -ENODEV;
4 l: I8 T4 r8 R% Z0 ]( ?/ o        fb = info->fbops;
        if (fb->fb_ioctl)        /*fb_ioctl为空*/
            ret = fb->fb_ioctl(info, cmd, arg);
        else
8 ~5 q' t' t; m/ ~6 G  }! N            ret = -ENOTTY;
        unlock_fb_info(info);
0 M2 ^* n% B. e4 R    }
; A7 k: m9 n" t: _5 A5 Z    return ret;
}
# A" ^9 h5 q8 b2 A' F+ |' U, C, e正如2.2小结所说的，fb_fix_screeninfo只能获取不能设置，因此，ioctl只提供了获取fb_fix_screeninfo的方法，而没有提供设置fb_fix_screeninfo的方法。

3.5 小结
/ M3 J( P8 A; V' n0 |" `# I  本节对frambuffer的核心层进行了介绍。包括frambuffer子系统的创建，frambuffer的注册和提供给用户空间的5个API函数。下面开始介绍驱动层。
3 z& e  A; P6 H! N1 H, W3 G9 g- G
0 ?: v9 Z9 b+ \4. 驱动层
本节将开始介绍S3C2440的frambuffer驱动，该驱动源码位于drivers/video/s3c2410fb.c
/ J  c- |, h( j) x5 G
: O! D% h' H0 T/ M$ K; r首先来看下驱动模块的初始化和清除函数。
  R4 W1 ]' a3 F$ t% R& V
4.1 s3c2410fb_init和s3c2410fb_cleanup
static struct platform_driver s3c2410fb_driver = {
    .probe        = s3c2410fb_probe,
    .remove        = s3c2410fb_remove,
    .suspend    = s3c2410fb_suspend,
+ y& Q0 \: j: X6 b1 O2 w( k1 T    .resume        = s3c2410fb_resume,
    .driver        = {
        .name    = "s3c2410-lcd",
        .owner    = THIS_MODULE,
    },
) c$ p( x6 g/ V+ y# h" G};

( A4 u# S0 p9 ~4 @* @8 {. tint __init s3c2410fb_init(void)
{
        int ret = platform_driver_register(&s3c2410fb_driver);
' C" g' f- a3 T4 y1 _& x; |
3 }4 r9 Y% D5 H        if (ret == 0)
) J  Y: x" }! v. E' C                ret = platform_driver_register(&s3c2412fb_driver);;

        return ret;
6 H1 W; T" z5 Q}

static void __exit s3c2410fb_cleanup(void)
{
        platform_driver_unregister(&s3c2410fb_driver);
8 b/ k  d; [5 m) t        platform_driver_unregister(&s3c2412fb_driver);
}
% o! x4 p1 O6 _
module_init(s3c2410fb_init);
module_exit(s3c2410fb_cleanup);
7 S6 d; O* I2 p5 Z9 R: T
7 z/ I# S, Z/ Q9 I3 G当platform_driver_register调用的最后会调用probe方法。接下来就来看看probe方法。
" R9 l0 l9 I4 O4 Z! c; P: D4.2 probe方法
struct s3c2410fb_info {
    struct device        *dev;
    struct clk        *clk;
' G  A! N4 H# B& a. ^3 M1 \; ~, t
    struct resource        *mem;
% v3 P  a! d+ V1 D( v    void __iomem        *io;        /*虚拟地址*/
# D, I$ P6 P( H  j    void __iomem        *irq_base;
1 y$ d! A" M$ ]
    enum s3c_drv_type    drv_type;
    struct s3c2410fb_hw    regs;

% ?2 w6 F1 o! V" F' _4 w1 |3 D    unsigned int        palette_ready;

+ g7 ]* U) i: R) D" f    /* keep these registers in case we need to re-write palette */
1 J& l; u( ^, h4 E+ f    u32            palette_buffer[256];
    u32            pseudo_pal[16];
5 q  f0 }2 q9 g# s};

struct s3c2410fb_mach_info {
1 y" V" ]( x' b# w: V
4 C6 `- Q8 i  N8 H9 j& T  y' B        struct s3c2410fb_display *displays;        /* attached diplays info */
        unsigned num_displays;                        /* number of defined displays */
$ Y3 \! w5 \" q! o        unsigned default_display;
! m5 Q  N; y  ~5 |
: z8 [* |. p# l/ u. h8 V        /* GPIOs */

        unsigned long        gpcup;
" [+ q/ n% d: X0 E) ^# D( N4 V& d; m/ b        unsigned long        gpcup_mask;
. z: V6 X$ i: F4 f5 ~' R        unsigned long        gpccon;
        unsigned long        gpccon_mask;
* w+ p) {6 S  w9 u/ n/ N' J        unsigned long        gpdup;
        unsigned long        gpdup_mask;
        unsigned long        gpdcon;
! b, O- R, k6 O9 |$ w* i; M* \        unsigned long        gpdcon_mask;

        /* lpc3600 control register */
3 b5 y1 |# f6 ?; g. y        unsigned long        lpcsel;
  ~+ h* D8 r' ?};

" a1 s# {5 E- g7 D# W$ O/* LCD description */
- y" K9 i: R6 n" }struct s3c2410fb_display {
0 K! I5 o; m; F% ?5 o" t    /* LCD type */
    unsigned type;

! C) n- N+ f8 K: D6 ?* S0 X/ N0 ?    /* Screen size */
, i* j! ~" X7 q- i9 d    unsigned short width;
8 c. d3 l( z. |. q0 }+ m; k    unsigned short height;
4 a5 v1 ?; \6 F! m
    /* Screen info */
9 j+ Y! y4 `, P7 f+ w$ a; s    unsigned short xres;
- u; H/ R, d  u5 i& C    unsigned short yres;
9 @' G: t2 J8 l: {7 N    unsigned short bpp;

# L5 j' S1 b9 Y  {: \1 h' t: X1 g1 s3 U    unsigned pixclock;        /* pixclock in picoseconds */
& E$ o/ Z/ F- h$ b8 g7 j6 ^9 w" A    unsigned short left_margin;  /* value in pixels (TFT) or HCLKs (STN) */
    unsigned short right_margin; /* value in pixels (TFT) or HCLKs (STN) */
1 I# ~0 g$ z& E0 M    unsigned short hsync_len;    /* value in pixels (TFT) or HCLKs (STN) */
) F& d7 u* F2 e- J6 \* R$ F- u    unsigned short upper_margin;    /* value in lines (TFT) or 0 (STN) */
    unsigned short lower_margin;    /* value in lines (TFT) or 0 (STN) */
3 z, s2 z) s1 l! R  ~% G    unsigned short vsync_len;    /* value in lines (TFT) or 0 (STN) */

$ U: P6 a1 w% {* P5 [7 D    /* lcd configuration registers */
    unsigned long    lcdcon5;
};

static int __init s3c24xxfb_probe(struct platform_device *pdev,
% N, i  v( z+ D5 Z  y9 t+ K- ~                  enum s3c_drv_type drv_type)
{
! {. m# ^% ^& A: D- M    struct s3c2410fb_info *info;
    struct s3c2410fb_display *display;
    struct fb_info *fbinfo;
    struct s3c2410fb_mach_info *mach_info;
    struct resource *res;
; P" Y9 n' s& B# [    int ret;
    int irq;
    int i;
    int size;
    u32 lcdcon1;
* F) J7 W/ _8 F, O3 g    /*dev.platform_data由函数s3c24xx_fb_set_platdata(mach-smdk2410.c)设置，指向s3c2410fb_mach_info*/
/ [8 e$ g# x( s+ ^6 c, K% O' a1 M$ R3 S    mach_info = pdev->dev.platform_data;   
    if (mach_info == NULL) {
        dev_err(&pdev->dev,
) v5 D, _# m0 b8 C/ e            "no platform data for lcd, cannot attach\n");
        return -EINVAL;
    }
& S4 D: D, o, J  c: G                                    /*在mach-smdk2440.c中，default_display=0, num_displays=1*/
    if (mach_info->default_display >= mach_info->num_displays) {     
        dev_err(&pdev->dev, "default is %d but only %d displays\n",
            mach_info->default_display, mach_info->num_displays);
        return -EINVAL;
; I, \/ q5 N& ~' {0 p    }

+ T9 @. s$ f! @; v. V    display = mach_info->displays + mach_info->default_display;
- r$ W+ Y( g* g7 V6 w
3 g6 P) t: M9 ?6 q1 g2 ^5 O0 P5 Z    irq = platform_get_irq(pdev, 0);    /*获取IRQ号,16号中断*/
    if (irq < 0) {
        dev_err(&pdev->dev, "no irq for device\n");
        return -ENOENT;
: ?! i# x9 ^' \/ ?, y    }
2 j! K9 Y) G$ x                                        /*分配struct fb_info 其中包括sizeof字节的私有数据区*/
    fbinfo = framebuffer_alloc(sizeof(struct s3c2410fb_info), &pdev->dev);
2 _9 }- t( |6 g( x    if (!fbinfo)
. K" \% Q) ^) W+ }        return -ENOMEM;

* p4 p/ K, O- D9 r7 o0 ~    platform_set_drvdata(pdev, fbinfo);    /*让platform_device->dev.driver_data指向struct fb_info*/

    info = fbinfo->par;                    /*par指向s3c2410fb_info*/
    info->dev = &pdev->dev;
    info->drv_type = drv_type;
( \5 z7 M# D3 P4 B( Q3 C
4 h' g( \# y+ Q# L8 Y0 w  b! f& D& [* t    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);/*获取平台资源*/
    if (res == NULL) {
: m) ?0 c* Z" d1 K        dev_err(&pdev->dev, "failed to get memory registers\n");
        ret = -ENXIO;
% X& Y' }  ~$ F3 i6 M' z        goto dealloc_fb;
: ?9 v: c+ E) v$ ~3 N! J. g    }
- c' M1 b2 n+ I, n$ o1 }0 B( |2 i  _
9 V& C5 r. E5 E2 B( ?    size = (res->end - res->start) + 1;                /*IO内存申请*/
/ k5 b4 W9 O7 A% D$ b0 m5 w    info->mem = request_mem_region(res->start, size, pdev->name);   
    if (info->mem == NULL) {
6 @( o1 I' w# ~        dev_err(&pdev->dev, "failed to get memory region\n");
        ret = -ENOENT;
" h; A9 a3 `. g/ ^6 r* L        goto dealloc_fb;
    }
8 t! M/ m! \4 P
5 [+ U. ^3 Y: _9 |# d    info->io = ioremap(res->start, size);            /*IO内存映射,获取lcd第一个寄存器的映射地址*/               
    if (info->io == NULL) {
        dev_err(&pdev->dev, "ioremap() of registers failed\n");        
        ret = -ENXIO;   
) M0 I1 ^, i1 A1 ~# K2 i        goto release_mem;
    }
' ]5 Q/ D% ~$ L$ ~' K                                            /*irq_base对应的物理地址是0X4D00 0054(寄存器LCDINTPND)*/
    info->irq_base = info->io + ((drv_type == DRV_S3C2412) ? S3C2412_LCDINTBASE : S3C2410_LCDINTBASE);
# O* O+ l5 a( j9 s: r( k9 M+ H6 O
    dprintk("devinit\n");

' ^3 Y* P) C+ \4 R# M$ A    strcpy(fbinfo->fix.id, driver_name);    /*复制名字*/

6 ?9 N# l4 j2 X" q/ E1 y    /* Stop the video */
! w5 R6 r7 N4 \% Y* V4 T9 J( d    lcdcon1 = readl(info->io + S3C2410_LCDCON1);
    writel(lcdcon1 & ~S3C2410_LCDCON1_ENVID, info->io + S3C2410_LCDCON1); /*禁止LCD*/

    fbinfo->fix.type        = FB_TYPE_PACKED_PIXELS;
7 ]4 n  G( N1 _; c! y    fbinfo->fix.type_aux        = 0;
    fbinfo->fix.xpanstep        = 0;
( M' G4 r# z: r+ f1 ^. g& m5 X    fbinfo->fix.ypanstep        = 0;
' _2 _8 e$ ^2 Z5 ^0 W  l9 m    fbinfo->fix.ywrapstep        = 0;
) Y4 o( R( w9 T: Y/ x2 _; F' I1 l- |    fbinfo->fix.accel        = FB_ACCEL_NONE;    /* no hardware accelerator    */
( @+ C2 n( r- J3 z/ n7 H+ r
% ]( s, V# Z7 E    fbinfo->var.nonstd        = 0;
    fbinfo->var.activate        = FB_ACTIVATE_NOW;
    fbinfo->var.accel_flags     = 0;
    fbinfo->var.vmode        = FB_VMODE_NONINTERLACED;
! I: A* R& M' k6 O1 F
    fbinfo->fbops            = &s3c2410fb_ops;
    fbinfo->flags            = FBINFO_FLAG_DEFAULT;
- Z) U' |, A8 a3 ]% `! A! _    fbinfo->pseudo_palette      = &info->pseudo_pal;
+ H) E# v" L8 |" E5 e/ M
    for (i = 0; i < 256; i++)
        info->palette_buffer = PALETTE_BUFF_CLEAR;
- |, O3 h* g3 J& x  ^
& s2 W& H; o% k3 I9 U    ret = request_irq(irq, s3c2410fb_irq, IRQF_DISABLED, pdev->name, info);    /*申请IRQ，快速中断*/
6 ]4 J4 e, V0 y3 N4 F2 Q9 U    if (ret) {
+ }+ G$ N5 z1 j9 X        dev_err(&pdev->dev, "cannot get irq %d - err %d\n", irq, ret);
        ret = -EBUSY;
* R. X9 a( d3 X) A! o! k1 s, T        goto release_regs;
    }
; a% m% P" t6 U- K2 w2 \0 b
8 L& G: u2 w! i2 k* J0 z    info->clk = clk_get(NULL, "lcd");        /*获取时钟信息*/
    if (!info->clk || IS_ERR(info->clk)) {
& h8 O5 W* [+ Y        printk(KERN_ERR "failed to get lcd clock source\n");
% n; @& }, s8 l4 w+ _        ret = -ENOENT;
& D* z8 R$ K8 N2 b5 j2 \        goto release_irq;
1 C& `% V$ l6 j3 n& @) E, Y; q9 c    }
. O" G+ ]. E# ^3 Q% z
    clk_enable(info->clk);                    /*使能时钟*/
; L) h6 j' l# V: n+ P1 D    dprintk("got and enabled clock\n");

7 Y& o, ?, b% m0 ]. k+ N9 ]6 d7 _' _    msleep(1);

8 F% m" R& z5 i( @  A( X, p6 l6 P. V    /* find maximum required memory size for display */
  `* _4 |$ W% O: h    /*在多个屏幕中，找出需要的最大memory*/
6 D* n$ W/ n/ W  f9 C    for (i = 0; i < mach_info->num_displays; i++) {
        unsigned long smem_len = mach_info->displays.xres;
5 p6 i* j; k$ G' Q        /*所需的memory空间 = xres * yres * bpp / 8*/
& c: G5 b8 a9 y; I        smem_len *= mach_info->displays.yres;
        smem_len *= mach_info->displays.bpp;
  l6 E! E# B! s$ g        smem_len >>= 3;
* O# k6 \. |* ?. `: e) x        if (fbinfo->fix.smem_len < smem_len)
            fbinfo->fix.smem_len = smem_len;
/ \  k. S0 Y2 {    }

  o' U/ ^; m4 J: u% V; w6 O, T    /* Initialize video memory */    /*根据上面fix.smem_len的大小，获取DMA映射内存，一致性映射方式*/
    ret = s3c2410fb_map_video_memory(fbinfo);
    if (ret) {
        printk(KERN_ERR "Failed to allocate video RAM: %d\n", ret);
        ret = -ENOMEM;
        goto release_clock;
    }

9 F) o3 I; i- a# A, c7 w    dprintk("got video memory\n");

9 M! P7 E0 K# u) c$ g. W" p    fbinfo->var.xres = display->xres;            /*320*/
: X, [6 X9 v7 B  C    fbinfo->var.yres = display->yres;            /*240*/   
0 C* \. L8 l; }4 i3 U+ C    fbinfo->var.bits_per_pixel = display->bpp;    /*16*/

    s3c2410fb_init_registers(fbinfo);            /*LCD寄存器初始化*/        

, B6 f' r; b7 O/ ]; o0 b* L    s3c2410fb_check_var(&fbinfo->var, fbinfo);
: `' S; k- K4 I' v! S4 s
+ b; l% B, D/ d# A& g! n    ret = register_framebuffer(fbinfo);            /*注册framebuffer*/
6 [5 v1 u2 \, ~1 Z8 q. z    if (ret < 0) {
9 H, {: b, X9 ]* j        printk(KERN_ERR "Failed to register framebuffer device: %d\n",ret);
        goto free_video_memory;
    }

& X+ D% U  Y5 b7 d    /* create device files */
    ret = device_create_file(&pdev->dev, &dev_attr_debug); /*添加设备属性*/
" ~8 g: f/ Z0 \  b$ D. \    if (ret) {
( E4 H) w$ v( F- P- R        printk(KERN_ERR "failed to add debug attribute\n");
    }

9 V0 ~4 F; s; f. M  i+ N    printk(KERN_INFO "fb%d: %s frame buffer device\n",
        fbinfo->node, fbinfo->fix.id);

    return 0;
/*一旦某个步骤发生错误，以注册的相反顺序开始注销*/
1 \9 E6 w. _' a! Z4 @free_video_memory:
/ U7 o% E' Z) i, Q0 n    s3c2410fb_unmap_video_memory(fbinfo);
0 P0 `4 M; Y, _release_clock:
    clk_disable(info->clk);
6 a# f- Q) F+ g& `' J9 V( S  Y2 P    clk_put(info->clk);
6 U7 m* Z0 U3 Arelease_irq:
    free_irq(irq, info);
release_regs:
    iounmap(info->io);
3 w: t; ^& N4 O+ t3 i3 p& @2 vrelease_mem:
    release_resource(info->mem);
    kfree(info->mem);
dealloc_fb:
. i# H/ \. x3 E6 A9 K: d    platform_set_drvdata(pdev, NULL);
( k% s/ d, u, M. L  `3 m    framebuffer_release(fbinfo);   
$ D' @( j6 l6 Q3 \. v0 {" A    return ret;
. y/ t% z8 o9 i5 p% a}
1 ]; x  z" f# ?- L2 ]; F
这里使用了三个新的数据结构。s3c2410fb_info是驱动程序使用的，里面将保存所有驱动程序所要使用的资源等。而s3c2410fb_display和s3c2410fb_mach_info，是由板级信息，通过platform总线添加到内核中。
4 z3 p# Z' O( A4 t9 ]$ Y; `
s3c2410fb_display中的成员将被复制到fb_var_screeninfo结构中。

' _& {" I- z3 W5 S: @该板级信息的定义在arch/ARM/mach-s3c2440/mach-smdk2440.c中,来看下
3 A0 `  O% J4 ?0 `# {8 k
static struct s3c2410fb_display smdk2440_lcd_cfg __initdata = {

        .lcdcon5        = S3C2410_LCDCON5_FRM565 |
                          S3C2410_LCDCON5_INVVLINE |
                          S3C2410_LCDCON5_INVVFRAME |
' F+ A  Q. D' f3 `& |                          S3C2410_LCDCON5_PWREN |
                          S3C2410_LCDCON5_HWSWP,
  R9 Y7 s0 c4 H4 }* F+ y
5 M+ i( {: ^. {        .type                = S3C2410_LCDCON1_TFT,
2 p/ k& ]7 D- r* u9 `
& `9 Z/ P3 K% X/ W9 P0 M9 T$ w        .width                = 320,//240,
0 ?0 n& z0 @, Y8 n* X* F! G        .height                = 240,//320,

        .pixclock        = 149000,//166667, /* HCLK 60 MHz, divisor 10 */
2 e2 p: S" l& H5 R/ {! W8 O        .xres                = 320,//240,
& L' g+ l" j4 U: p' ]        .yres                = 240,//320,
        .bpp                = 16,
0 [0 d9 k, G3 a6 {$ o        .left_margin        = 20,
        .right_margin        = 38,//8,
. \3 }& y" ]2 t        .hsync_len        = 30,//4,
        .upper_margin        = 15,//8,
        .lower_margin        = 12,//7,
        .vsync_len        = 3,//4,
};

; J2 E2 {5 x8 k  q7 Zstatic struct s3c2410fb_mach_info smdk2440_fb_info __initdata = {
) X2 ?( N5 B3 S        .displays        = &smdk2440_lcd_cfg,
        .num_displays        = 1,
+ f+ R7 i+ @2 E1 Z5 C0 _4 k! f        .default_display = 0,
9 Q- t+ O4 o5 f6 R
# |( b5 b+ r& q. A( W- n6 }#if 0
8 q! d$ j9 |* A. d        /* currently setup by downloader */
        .gpccon                = 0xaa940659,
5 n& Z2 Y* w: s0 q0 g# @' d        .gpccon_mask        = 0xffffffff,
2 z4 X9 v* f8 \' ?- D% H6 d4 ]        .gpcup                = 0x0000ffff,
        .gpcup_mask        = 0xffffffff,
2 p8 n1 D2 h4 R        .gpdcon                = 0xaa84aaa0,
" `" }  y' N3 J" H; E        .gpdcon_mask        = 0xffffffff,
        .gpdup                = 0x0000faff,
        .gpdup_mask        = 0xffffffff,
5 u" Z5 W7 A. K  `: J& N' P#endif
//no
8 d; o& D# O* E/ q//        .lpcsel                = ((0xCE6) & ~7) | 1<<4,
};
6 \; Y9 x0 W8 k, q! Y) ?
, I) {& Z% H# |1 m这里NOTE：每个LCD屏幕的参数不一样，因此上面的参数会有所不同，这是需要移植的地方。
- X' q6 Q4 c2 Y/ d& `! U( @
. @# w6 U% @% Q6 ?+ E随后，我们看下在probe方法中调用的几个函数。首先是s3c2410fb_map_video_memory。

+ O2 v4 {- R: v) B- {1 z/*
1 a0 D5 I7 H5 E7 S( A4 J3 V * s3c2410fb_map_video_memory():
5 k# D3 A; o- B *        Allocates the DRAM memory for the frame buffer.  This buffer is
' f( }; F4 ^/ o *        remapped into a non-cached, non-buffered, memory region to
! W2 H# ^" z% ^1 N8 C8 ` *        allow palette and pixel writes to occur without flushing the
*        cache.  Once this area is remapped, all virtual memory
*        access to the video memory should occur at the new region.
8 A  T* ^- b9 Y: D8 X */
static int __init s3c2410fb_map_video_memory(struct fb_info *info)
1 ^- O  {2 G7 ^( F7 k. C) j1 @{
        struct s3c2410fb_info *fbi = info->par;
        dma_addr_t map_dma;
        unsigned map_size = PAGE_ALIGN(info->fix.smem_len);
; U; l: q) X4 T" _$ R
        dprintk("map_video_memory(fbi=%p) map_size %u\n", fbi, map_size);
6 M) P5 J( c/ }' I2 o                /*分配DMA缓冲区，并保存DMA缓冲区虚拟地址*/
6 D! i, M- ]9 q. \! e7 u6 N" C, H        info->screen_base = dma_alloc_writecombine(fbi->dev, map_size,
                                                   &map_dma, GFP_KERNEL);
; N) o  H' p& |6 q+ r2 v2 n
        if (info->screen_base) {
+ a$ R9 p. g% H5 h7 y                /* prevent initial garbage on screen */
                dprintk("map_video_memory: clear %p:%08x\n",
( ?3 |: G. ^6 ~7 g7 V7 j                        info->screen_base, map_size);
7 N4 a" S& S( ]! J5 |2 s                memset(info->screen_base, 0x00, map_size);        /*DMA缓冲区清0*/
; z. Q5 y3 V) Q% a1 I( l# f
+ O, v; _2 a. Y/ j% o                info->fix.smem_start = map_dma;        /*保存DMA缓冲区物理地址*/
' w: Y8 }+ j' N
$ F& P* v2 ?- Y( y5 W$ }4 ~$ p+ D5 v, L                dprintk("map_video_memory: dma=%08lx cpu=%p size=%08x\n",
                        info->fix.smem_start, info->screen_base, map_size);
5 w3 V: B* a8 x9 p; X' c& g' W        }

        return info->screen_base ? 0 : -ENOMEM;
$ C5 G* {7 O% s. G7 {}
' A; |! I, A) m- N& k, m2 q! _

0 f9 `$ r, p9 c该函数根据fix.smem_len的大小，分配了一个DMA缓冲区，保存了该缓冲区的物理地址和虚拟地址。

接着是s3c2410fb_init_registers：

! }6 j% f) l7 L4 \7 A
/*
* s3c2410fb_init_registers - Initialise all LCD-related registers
- c+ F, p2 Q+ A9 w4 @ */
9 b+ d  u0 g2 Tstatic int s3c2410fb_init_registers(struct fb_info *info)
( A' _  u( I- D" }{
: Q8 l2 y2 N% Q1 P: L    struct s3c2410fb_info *fbi = info->par;        /*par指向s3c2410fb_info*/
    struct s3c2410fb_mach_info *mach_info = fbi->dev->platform_data;
$ W7 y1 O3 c! p    unsigned long flags;
    void __iomem *regs = fbi->io;
    void __iomem *tpal;
+ _9 l4 {, \0 i' [& a/ x    void __iomem *lpcsel;

    if (is_s3c2412(fbi)) {
# V1 n  v# P0 C        tpal = regs + S3C2412_TPAL;
4 C# ~( Z/ M8 C% X" y        lpcsel = regs + S3C2412_TCONSEL;
    } else {
$ M9 B$ ~6 R3 l7 H1 Y        tpal = regs + S3C2410_TPAL;
        lpcsel = regs + S3C2410_LPCSEL;
    }
, o7 [4 \2 M; ~( C, r! n
+ v3 l' k1 |8 I5 X4 h    /* Initialise LCD with values from haret */

" _: i! h* ^+ e* M* }    local_irq_save(flags);                        /*禁止所有中断*/

2 ?4 z4 ?- @% Z. @4 |, _7 d    /* modify the gpio(s) with interrupts set (bjd) */    /*初始化io管脚*/

    modify_gpio(S3C2410_GPCUP,  mach_info->gpcup,  mach_info->gpcup_mask);
    modify_gpio(S3C2410_GPCCON, mach_info->gpccon, mach_info->gpccon_mask);
# x7 F+ R4 a) k( f! M    modify_gpio(S3C2410_GPDUP,  mach_info->gpdup,  mach_info->gpdup_mask);
8 d3 j; \, p3 ~( u: Z1 P    modify_gpio(S3C2410_GPDCON, mach_info->gpdcon, mach_info->gpdcon_mask);

    local_irq_restore(flags);                    /*恢复中断*/

. I( `/ @/ o1 ^$ [* C- o) X" B& p8 h  w    dprintk("LPCSEL    = 0x%08lx\n", mach_info->lpcsel);    /*设置TCONSEL，禁止LPC3600*/
    writel(mach_info->lpcsel, lpcsel);
# f% S# f( N) P/ B3 }+ G
    dprintk("replacing TPAL %08x\n", readl(tpal));

, ~7 N. Q6 N* P5 d4 S0 n    /* ensure temporary palette disabled */
    writel(0x00, tpal);    /*禁止调色板*/
4 ]  _4 ]  u( S3 E# a. H/ B( D; _
4 ^7 e$ a% c  S    return 0;
$ T( N! y& C* @& [4 _' K2 t/ c}
  V( X! R5 b2 L$ q" I- `. G5 M
static inline void modify_gpio(void __iomem *reg,
                   unsigned long set, unsigned long mask)
{
    unsigned long tmp;

    tmp = readl(reg) & ~mask;
    writel(tmp | set, reg);
1 g. |& M! |9 w3 u2 g}
& {' k" j; S' I: T最后是s3c2410fb_check_var：

/*
*        s3c2410fb_check_var():
; B, M, q! f1 w: A0 y *        Get the video params out of 'var'. If a value doesn't fit, round it up,
+ [$ r& S5 q1 p1 X; s; J *        if it's too big, return -EINVAL.
*        检查变量的合法性
4 ?; ]; Q  b% D. E$ J */
8 ~- j4 H$ g% o( V1 h( U. Nstatic int s3c2410fb_check_var(struct fb_var_screeninfo *var,
" r; W6 a& F, K5 f( d$ c# R" ^                               struct fb_info *info)
{
; K0 m. v+ v8 ?/ H. \4 B! h        struct s3c2410fb_info *fbi = info->par;                        /*par指向s3c2410fb_info*/
8 R! {$ K( k+ v9 a0 g        struct s3c2410fb_mach_info *mach_info = fbi->dev->platform_data;/*指向s3c2410fb_mach_info*/
0 ^$ C  Z2 M) A        struct s3c2410fb_display *display = NULL;
        struct s3c2410fb_display *default_display = mach_info->displays +
                                                    mach_info->default_display;
        int type = default_display->type;         /*S3C2410_LCDCON1_TFT*/
! N  }7 L% l9 Z        unsigned i;

4 u0 G( `! ~9 h  h0 h        dprintk("check_var(var=%p, info=%p)\n", var, info);

# T' u& X8 d5 M3 z: c. y5 P        /* validate x/y resolution */
        /* choose default mode if possible */                        /*var中的成员在probe中设置*/
2 U8 a6 Q; q" x! z4 r        if (var->yres == default_display->yres &&
  _5 k/ P7 d1 o; g2 d) g            var->xres == default_display->xres &&
            var->bits_per_pixel == default_display->bpp)
                display = default_display;
) y. k1 d: v$ g: q8 `        else
1 Y% K+ v- o5 f, l5 c4 v                for (i = 0; i < mach_info->num_displays; i++)
                        if (type == mach_info->displays.type &&
                            var->yres == mach_info->displays.yres &&
                            var->xres == mach_info->displays.xres &&
$ X6 S5 f) c  L7 ?0 S2 ?. x                            var->bits_per_pixel == mach_info->displays.bpp) {
( z4 ~& A* K7 d- e                                display = mach_info->displays + i;
                                break;
                        }

        if (!display) {
; `# q' H) h6 Y7 Q. N0 Y" {                dprintk("wrong resolution or depth %dx%d at %d bpp\n",
                        var->xres, var->yres, var->bits_per_pixel);
( z) w: j+ H" i; y6 f# ^                return -EINVAL;
        }

        /* it is always the size as the display */
        var->xres_virtual = display->xres;
+ }! s: @% f3 L+ k7 z1 ~        var->yres_virtual = display->yres;
        var->height = display->height;
  c) o3 O1 U, T: _/ C% q) H        var->width = display->width;

, ?) {2 b* |' t- {8 Y' ]. p        /* copy lcd settings */
        var->pixclock = display->pixclock;
0 u3 {% J4 L- L, ?; G% ^        var->left_margin = display->left_margin;
        var->right_margin = display->right_margin;
  P/ e# o; k1 `2 M" R        var->upper_margin = display->upper_margin;
$ g3 }5 c+ G4 E1 |        var->lower_margin = display->lower_margin;
: z4 S4 a* M8 \, x+ t        var->vsync_len = display->vsync_len;
* ]( ], W' R) D8 b! f# m        var->hsync_len = display->hsync_len;

        fbi->regs.lcdcon5 = display->lcdcon5;
        /* set display type */
: \4 z5 ~/ w. u! O  q        fbi->regs.lcdcon1 = display->type;

        var->transp.offset = 0;
7 y3 e/ A; E; |2 c        var->transp.length = 0;
- p( {" P; i, B) Z4 `        /* set r/g/b positions */
        switch (var->bits_per_pixel) {
7 ?% i- ~5 t+ q6 ^2 @& V; @  Y        case 1:
5 _1 b" `; Z: C$ F0 \        case 2:
; G, b3 r, Q5 z# e' l        case 4:
/ U5 O' y- v( U! t5 s1 K                var->red.offset        = 0;
                var->red.length        = var->bits_per_pixel;
                var->green        = var->red;
                var->blue        = var->red;
                break;
. {( ?) `9 G3 {        case 8:
                if (display->type != S3C2410_LCDCON1_TFT) {
  Q, P, T" ~2 a                        /* 8 bpp 332 */
                        var->red.length                = 3;
" Z* [* j4 |) p2 ~) O; b7 K                        var->red.offset                = 5;
                        var->green.length        = 3;
                        var->green.offset        = 2;
                        var->blue.length        = 2;
                        var->blue.offset        = 0;
                } else {
                        var->red.offset                = 0;
  s+ L5 K5 Y: y3 [: e- V! n                        var->red.length                = 8;
" H7 i  A% S5 K. U1 q4 J9 Y" r                        var->green                = var->red;
                        var->blue                = var->red;
                }
                break;
        case 12:
" i6 H+ u' e: b* q4 d                /* 12 bpp 444 */
; `, }4 j. {, D; d% O0 Z1 h, B                var->red.length                = 4;
                var->red.offset                = 8;
2 H, R& E8 d$ |- C                var->green.length        = 4;
$ s9 q, L: s& l9 E4 f                var->green.offset        = 4;
! F- U8 {6 B7 s8 |' \% T                var->blue.length        = 4;
% b  R3 V0 p3 b: ?0 G" n                var->blue.offset        = 0;
# ?0 x/ a7 I- |3 g" F6 B# ?                break;
+ E% \" q7 o( g; ~; B) P( k
# Z8 D2 k  l  Y! x        default:
        case 16:
6 w' N$ y2 D7 T, x' J                if (display->lcdcon5 & S3C2410_LCDCON5_FRM565) { /*使用565格式*/
                        /* 16 bpp, 565 format */
7 t7 E$ C) {: G9 l9 a( x0 o+ K                        var->red.offset                = 11;
  `7 `+ Y. k, b( R                        var->green.offset        = 5;
- A. s9 d* J7 S9 y: h1 z' U                        var->blue.offset        = 0;
                        var->red.length                = 5;
4 f) F4 j+ \$ V                        var->green.length        = 6;
                        var->blue.length        = 5;
                } else {
6 [) u0 I4 b% ?1 B( W. Q$ u                        /* 16 bpp, 5551 format */
                        var->red.offset                = 11;
1 }5 y. d1 l( o+ X& I2 m                        var->green.offset        = 6;
' [+ o$ X" P7 A% P                        var->blue.offset        = 1;
                        var->red.length                = 5;
4 R/ e% _8 E' p) p; C- @9 V                        var->green.length        = 5;
                        var->blue.length        = 5;
9 |6 y. d8 I( E$ i- [; i                }
                break;
        case 32:
                /* 24 bpp 888 and 8 dummy */
                var->red.length                = 8;
                var->red.offset                = 16;
' k. r5 G5 }* y! j! _" F                var->green.length        = 8;
4 Q$ k& @3 ]* L                var->green.offset        = 8;
                var->blue.length        = 8;
                var->blue.offset        = 0;
0 N  L- m2 H0 A" T3 I) B- w/ v, N                break;
        }
6 `4 l% D; H, \7 c- F  z. P+ J        return 0;
}

, W1 U$ f- `, c2 U' a/* Interpretation of offset for color fields: All offsets are from the right,
* inside a "pixel" value, which is exactly 'bits_per_pixel' wide (means: you
* can use the offset as right argument to <<). A pixel afterwards is a bit
* stream and is written to video memory as that unmodified.
*
2 |6 S6 u8 {8 B% c) w/ [3 e8 g * For pseudocolor: offset and length should be the same for all color
* components. Offset specifies the position of the least significant bit
1 b3 k- |) r4 ^3 t% t. _% Q * of the pallette index in a pixel value. Length indicates the number
2 K( V. b& N( c6 k5 k * of available palette entries (i.e. # of entries = 1 << length).
, V2 j1 {+ S- e */
struct fb_bitfield {
    __u32 offset;            /* beginning of bitfield    */
4 J$ v: S6 `5 `" _5 ~4 y    __u32 length;            /* length of bitfield        */
7 C' I# z' \& j4 L$ l. g    __u32 msb_right;        /* != 0 : Most significant bit is */
                    /* right */
};
该函数主要将板级信息s3c2410fb_display复制到对应的地方，然后根据RGB的模式设置位域。
% R0 t9 B0 n4 }5 S+ l! ?5 k  T0 [4.3 fb_ops方法
在驱动程序中，定义了fb_ops，如下：

static struct fb_ops s3c2410fb_ops = {
        .owner                = THIS_MODULE,
        .fb_check_var        = s3c2410fb_check_var,                /*检查变量的合法性*/
        .fb_set_par        = s3c2410fb_set_par,                        /*将参数写入LCD控制器，该函数由帧缓冲核心调用*/
        .fb_blank        = s3c2410fb_blank,                                /*该方法支持显示消隐和去消隐*/
, l& c9 @" n6 h3 E; y; A        .fb_setcolreg        = s3c2410fb_setcolreg,                /*设置颜色寄存器*/
5 |& |9 _1 X* J! e2 G/ z2 M        .fb_fillrect        = cfb_fillrect,                                /*用像素行填充矩形框，通用库函数*/
        .fb_copyarea        = cfb_copyarea,                                /*将屏幕的一个矩形区域复制到另一个区域，通用库函数*/
' a8 [; `4 z. {  D/ _        .fb_imageblit        = cfb_imageblit,                        /*显示一副图像，通用库函数*/
};
+ {5 x, e; _# b0 @5 N: x
2 k6 j& I5 _7 J其中s3c2410fb_check_var在4.2节中已经分析过了，最后三个方法是通用库函数，在这里不作分析。
/ }" [! a. c* V4 y剩余三个也是驱动程序提供的，现在对这三个程序进行分析。
4.3. 1 s3c2410fb_set_par
/ u) b& H& `2 T6 h+ P, u/*
*      s3c2410fb_set_par - Alters the hardware state.
# N- h# ?8 k6 H( S* G3 h *      @info: frame buffer structure that represents a single frame buffer
*                根据var中的值设置LCD控制器的寄存器
*/
- f/ P" [6 l, Y) T4 p# k  ustatic int s3c2410fb_set_par(struct fb_info *info)
{
3 |+ x% t( @# S- U* z0 G        struct fb_var_screeninfo *var = &info->var;
8 L) F) f, C$ P3 [, n
' R) m- Z6 A' S6 X- [        switch (var->bits_per_pixel) {
        case 32:
2 P. }1 @0 T3 |/ s        case 16:
        case 12:
6 |, _- p8 P- i                info->fix.visual = FB_VISUAL_TRUECOLOR;
                break;
        case 1:
                info->fix.visual = FB_VISUAL_MONO01;
, I$ `& L; o1 p$ q                break;
        default:
" b3 o3 y4 `% ]4 }" Z. k: h: G3 n                info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
                break;
) b8 T3 c; Z. W; K1 V  x1 X        }

        info->fix.line_length = (var->xres_virtual * var->bits_per_pixel) / 8; /* 320*16/8 = 640Bytes */

2 U, j+ @+ d. I2 V8 _  U8 n        /* activate this new configuration */

; k- o3 ~. O( b& L( N        s3c2410fb_activate_var(info);
        return 0;
6 j% a1 C: `0 x  e" G: `}
该函数根据像素的位数设置了视觉模式，本例为16为，使用真彩色。然后计算了每行的数据元素大小。共240行。
5 u) C0 b  U: ]/ |
然后调用了s3c2410fb_activate_var来设置控制器并激活LCD。
' Z* j2 L6 F- Q( T& ~# M; X& K- ^
) F; G; u6 W1 w5 F& Q# ^s3c2410fb_activate_var函数如下：

/* s3c2410fb_activate_var
6 X) G/ h8 Z, `% B. v- H *
* activate (set) the controller from the given framebuffer
2 T" q6 T, U3 |' x& W& j, h * information
*/
- d" f7 R4 _0 H3 ^static void s3c2410fb_activate_var(struct fb_info *info)
9 H" J2 ?( q  L) ^- F{
  Y+ n. ?, p% W        struct s3c2410fb_info *fbi = info->par;
        void __iomem *regs = fbi->io;
        int type = fbi->regs.lcdcon1 & S3C2410_LCDCON1_TFT; /*regs.lcdcon1在s3c2410fb_check_var设置*/
        struct fb_var_screeninfo *var = &info->var;
        int clkdiv = s3c2410fb_calc_pixclk(fbi, var->pixclock) / 2;
& F+ E8 |1 C8 S: g$ A
        dprintk("%s: var->xres  = %d\n", __func__, var->xres);
1 \0 U0 e* T& u- Z' k9 T3 C        dprintk("%s: var->yres  = %d\n", __func__, var->yres);
        dprintk("%s: var->bpp   = %d\n", __func__, var->bits_per_pixel);
0 G5 V: Z% W* L& y1 g: V( v
1 P0 {) ?# T) X- w& u1 ]/ X        if (type == S3C2410_LCDCON1_TFT) {
                s3c2410fb_calculate_tft_lcd_regs(info, &fbi->regs);/*根据var，计算出控制寄存器需要设置的值*/
3 {  |' R3 m6 a                --clkdiv;
                if (clkdiv < 0)
- q% ^! g# s/ R                        clkdiv = 0;
' G# K4 R4 y$ a+ p+ m. O        } else {
                s3c2410fb_calculate_stn_lcd_regs(info, &fbi->regs);
/ c. s7 p4 \3 D  u                if (clkdiv < 2)
                        clkdiv = 2;
2 n% X" y) w& v3 T        }
" h8 f1 v/ V8 w9 J, d
        fbi->regs.lcdcon1 |=  S3C2410_LCDCON1_CLKVAL(clkdiv);/*设置CLKVAL*/
. w: u6 G8 `) G& K
0 O6 \* J: _" [. P6 T        /* write new registers */

' e# |: q6 V0 H; J8 y9 ?) D        dprintk("new register set:\n");
        dprintk("lcdcon[1] = 0x%08lx\n", fbi->regs.lcdcon1);
        dprintk("lcdcon[2] = 0x%08lx\n", fbi->regs.lcdcon2);
! f+ }1 G( @/ g: Y1 i0 e! c        dprintk("lcdcon[3] = 0x%08lx\n", fbi->regs.lcdcon3);
        dprintk("lcdcon[4] = 0x%08lx\n", fbi->regs.lcdcon4);
' l$ E, B4 p6 H, C. \6 m) _        dprintk("lcdcon[5] = 0x%08lx\n", fbi->regs.lcdcon5);
, A: ]. e3 z+ U- b, O5 r6 k        /*把计算好的值填入LCD控制器中*/
        writel(fbi->regs.lcdcon1 & ~S3C2410_LCDCON1_ENVID,       
                regs + S3C2410_LCDCON1);                                                /*仍然禁止LCD*/
& g8 W" @# A9 f- j* Y        writel(fbi->regs.lcdcon2, regs + S3C2410_LCDCON2);
        writel(fbi->regs.lcdcon3, regs + S3C2410_LCDCON3);
0 b" b- X8 N9 k7 g: u+ @& z        writel(fbi->regs.lcdcon4, regs + S3C2410_LCDCON4);
        writel(fbi->regs.lcdcon5, regs + S3C2410_LCDCON5);

9 C0 Y/ Z" u+ H- ~# l. o        /* set lcd address pointers */
; ^7 t' w6 G- n6 Z. C( r9 P1 P        s3c2410fb_set_lcdaddr(info);                                                /*设置LCD帧缓冲起始地址*/

        fbi->regs.lcdcon1 |= S3C2410_LCDCON1_ENVID,
        writel(fbi->regs.lcdcon1, regs + S3C2410_LCDCON1);        /*使能LCD*/
}
. _$ n, F  r+ p1 x其中调用的三个函数如下：
static unsigned int s3c2410fb_calc_pixclk(struct s3c2410fb_info *fbi,
                      unsigned long pixclk)
{
    unsigned long clk = clk_get_rate(fbi->clk);         /*获取当前时钟频率(Hz)*/
    unsigned long long div;

    /* pixclk is in picoseconds, our clock is in Hz
     *
     * Hz -> picoseconds is / 10^-12
     */
2 w; m, `1 g  w+ ?( q
( U# o$ M, x4 T% P% _( [' i' B    div = (unsigned long long)clk * pixclk;
    div >>= 12;            /* div / 2^12 */
    do_div(div, 625 * 625UL * 625); /* div / 5^12 */

    dprintk("pixclk %ld, divisor is %ld\n", pixclk, (long)div);
$ Y7 h  B5 @; E2 m- ~    return div;
% F  k6 g$ `1 E7 K" h9 y}
0 c: P  R! }8 ^& i
, g0 U2 y8 O& ^6 v2 K3 O. b/* s3c2410fb_calculate_tft_lcd_regs
6 |' s6 a/ P  B3 T( ~ *
* calculate register values from var settings
4 g) F0 B3 w3 b2 z1 w- c( n8 V/ n */
  T' J% W# I- S$ [& ]static void s3c2410fb_calculate_tft_lcd_regs(const struct fb_info *info,
! H, k9 @' s, R, M# N& x; B# P                         struct s3c2410fb_hw *regs)
( J9 \! l. `+ a1 u& l' t+ h{
+ w8 v; V3 l0 ~. Z- Y1 c    const struct s3c2410fb_info *fbi = info->par;
9 }+ r- f. L2 @- J    const struct fb_var_screeninfo *var = &info->var;
! \0 }: Q1 [) }' G/ S
: g, x9 F. l( n% n5 ]5 A% I    switch (var->bits_per_pixel) {
4 B6 e9 F  Q# a* P  E, m# a# V5 K0 c+ c    case 1:
        regs->lcdcon1 |= S3C2410_LCDCON1_TFT1BPP;
! Y7 K/ [8 a9 a3 i* x! p        break;
1 e* _# D# T% Y% C! l7 I    case 2:
( w7 e/ E) J+ Z7 A1 j; Q  U8 D: o- B3 h        regs->lcdcon1 |= S3C2410_LCDCON1_TFT2BPP;
1 W4 z5 p6 `: A        break;
    case 4:
        regs->lcdcon1 |= S3C2410_LCDCON1_TFT4BPP;
        break;
    case 8:
3 C( e" V9 v- ~; i4 V8 m+ f& |! n        regs->lcdcon1 |= S3C2410_LCDCON1_TFT8BPP;
- n4 w) C8 z6 b7 K        regs->lcdcon5 |= S3C2410_LCDCON5_BSWP |
                 S3C2410_LCDCON5_FRM565;
. R8 ~; N2 m' y# a3 a: i+ Z        regs->lcdcon5 &= ~S3C2410_LCDCON5_HWSWP;
        break;
; a6 l# e& A/ s7 ~6 N7 Z    case 16:
5 q9 m6 w/ o. b) M" u# y* b        regs->lcdcon1 |= S3C2410_LCDCON1_TFT16BPP;
        regs->lcdcon5 &= ~S3C2410_LCDCON5_BSWP;
        regs->lcdcon5 |= S3C2410_LCDCON5_HWSWP;
        break;
' Q/ D9 T  |( H! w, n/ K    case 32:
        regs->lcdcon1 |= S3C2410_LCDCON1_TFT24BPP;
        regs->lcdcon5 &= ~(S3C2410_LCDCON5_BSWP |
                   S3C2410_LCDCON5_HWSWP |
+ M+ h5 b/ L9 Y# P4 S. H                   S3C2410_LCDCON5_BPP24BL);
- [' d, j; ?/ z8 s1 C% ?        break;
    default:
( H# [6 d9 O+ o9 c% Q% X        /* invalid pixel depth */
        dev_err(fbi->dev, "invalid bpp %d\n",
            var->bits_per_pixel);
    }
    /* update X/Y info */
+ l/ ~1 {: M9 `1 J/ J    dprintk("setting vert: up=%d, low=%d, sync=%d\n",
        var->upper_margin, var->lower_margin, var->vsync_len);
, S3 u3 O  z; F$ m
    dprintk("setting horz: lft=%d, rt=%d, sync=%d\n",
        var->left_margin, var->right_margin, var->hsync_len);
    /*
        所有时序参数必须减1，因为在公式中:
        Frame Rate = 1/ [ { (VSPW+1) + (VBPD+1) + (LIINEVAL + 1) + (VFPD+1) } x {(HSPW+1) + (HBPD +1)
) Q2 U3 f( Z+ }2 [        + (HFPD+1) + (HOZVAL + 1) } x { 2 x ( CLKVAL+1 ) / ( HCLK ) } ]
    */
! S' z5 R8 f  J5 B  `    regs->lcdcon2 = S3C2410_LCDCON2_LINEVAL(var->yres - 1) |
  P1 d' m( w" v" Q* A/ T- g            S3C2410_LCDCON2_VBPD(var->upper_margin - 1) |
            S3C2410_LCDCON2_VFPD(var->lower_margin - 1) |
            S3C2410_LCDCON2_VSPW(var->vsync_len - 1);
9 A6 r& p9 g: N$ y) a7 B3 `* h
3 G4 G$ L' d$ l, Y$ Y0 i    regs->lcdcon3 = S3C2410_LCDCON3_HBPD(var->right_margin - 1) |
2 J( ]; z) D6 ?! L5 A            S3C2410_LCDCON3_HFPD(var->left_margin - 1) |
; a) B  z. u, i7 S- V- Z            S3C2410_LCDCON3_HOZVAL(var->xres - 1);

- H. h# N# ?' l: L: Q" P    regs->lcdcon4 = S3C2410_LCDCON4_HSPW(var->hsync_len - 1);
}

" ?, [4 @* N! [/* s3c2410fb_set_lcdaddr
1 {7 c" s2 U- A6 e3 h *
/ R9 Q' v2 F1 x1 d  z/ b * initialise lcd controller address pointers
' \0 Q9 j4 e; K1 x0 O; L */
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;

        saddr1  = info->fix.smem_start >> 1;          /*帧缓冲区起始地址*/
3 I- i1 A5 ], k- v2 o( h# X8 k        saddr2  = info->fix.smem_start;                       
        saddr2 += info->fix.line_length * info->var.yres;
        saddr2 >>= 1;                                                        /*帧缓冲区结束地址*/

        saddr3 = S3C2410_OFFSIZE(0) |
                 S3C2410_PAGEWIDTH((info->fix.line_length / 2) & 0x3ff); /*offset = 0, pagewidth = 320*/

        dprintk("LCDSADDR1 = 0x%08lx\n", saddr1);
6 ~0 r8 D& I) e( e2 z% }' i        dprintk("LCDSADDR2 = 0x%08lx\n", saddr2);
        dprintk("LCDSADDR3 = 0x%08lx\n", saddr3);
1 k; }7 q# g5 T2 D
: D/ h" D; z7 f! p- ~5 V        writel(saddr1, regs + S3C2410_LCDSADDR1);
        writel(saddr2, regs + S3C2410_LCDSADDR2);
" V( X: I9 ]! d( Q        writel(saddr3, regs + S3C2410_LCDSADDR3);
}
  k# X! l0 t+ m; s4 q) ?6 G) _, f9 Zs3c2410fb_calc_pixclk用于计算时钟频率。

s3c2410fb_calculate_tft_lcd_regs设置了LCD的控制寄存器。

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

( R* z' f' b5 f" M" {4.3. 2 s3c2410fb_blank
该方法完成消隐功能。
& q3 d1 U' Q4 [- ]. n
8 i- f7 n* F( m% P3 H/*
*      s3c2410fb_blank
1 J2 Y" U) L, @ *        @blank_mode: the blank mode we want.
*        @info: frame buffer structure that represents a single frame buffer
8 a- O3 P& q, g: M* E- {9 v0 ]0 b *
*        Blank the screen if blank_mode != 0, else unblank. Return 0 if
0 [) h9 r* H7 ]7 R *        blanking succeeded, != 0 if un-/blanking failed due to e.g. a
*        video mode which doesn't support it. Implements VESA suspend
*        and powerdown modes on hardware that supports disabling hsync/vsync:
, d& i$ E8 }2 R) ?" `  p *
*        Returns negative errno on error, or zero on success.
! t+ a) j; V: X5 Y  k0 ]- l *
*/
& u$ m/ }' q9 f5 i8 x; v5 X# u3 Dstatic int s3c2410fb_blank(int blank_mode, struct fb_info *info)
1 ^. h* o: v  h+ z- i% Q  u: Q" {{
/ U; s9 y  ?; y: s# r. ]% E    struct s3c2410fb_info *fbi = info->par;
    void __iomem *tpal_reg = fbi->io;
  e/ \; u( U! T5 H& G
    dprintk("blank(mode=%d, info=%p)\n", blank_mode, info);
" |3 G! U' M3 v3 ?# m
    tpal_reg += is_s3c2412(fbi) ? S3C2412_TPAL : S3C2410_TPAL;

: P( a% e' d: `! D) h    if (blank_mode == FB_BLANK_POWERDOWN) {    /*消隐*/
        s3c2410fb_lcd_enable(fbi, 0);        /*禁止LCD*/
$ L3 T$ U4 f- z4 E$ _8 z& q    } else {
        s3c2410fb_lcd_enable(fbi, 1);        /*启动LCD*/
    }
5 L9 R# i; r! v
    if (blank_mode == FB_BLANK_UNBLANK)        /*去消隐*/
; C# j1 ?( B/ x9 M0 |( t# v5 g* x, g6 l        writel(0x0, tpal_reg);                /*禁止temporary palette*/
    else {                                    /*消隐*/
. b! n) J2 r$ ^, D3 {9 \3 H' X% W        dprintk("setting TPAL to output 0x000000\n");
        writel(S3C2410_TPAL_EN, tpal_reg);    /*使能temporary palette，颜色为黑色*/
) M1 J9 L( n5 t7 A% e+ g    }

7 X. n+ i; V4 x/ h    return 0;
}
) z4 ?: z5 l& i, a5 {" c2 e3 R在消隐时，屏幕将全黑。

4.3.3 s3c2410fb_setcolreg
该函数的功能用于设置LCD的调色板。调色板的概念请看我的转帖：LCD调色板。

. E  A) v) [- k9 D# ?static int s3c2410fb_setcolreg(unsigned regno,
                   unsigned red, unsigned green, unsigned blue,
! X' a" |7 S; h                   unsigned transp, struct fb_info *info)
{
    struct s3c2410fb_info *fbi = info->par;    /*par指向s3c2410fb_info*/
* m& F5 w9 B! |0 p. T' U2 d1 i9 S    void __iomem *regs = fbi->io;
    unsigned int val;
" m5 |2 H% t2 Z! ~) Z
% y7 h; }, }% h. n0 h0 ^: M: @    /* dprintk("setcol: regno=%d, rgb=%d,%d,%d\n",
. D) ^0 ?- o% b2 m8 G9 u+ Z           regno, red, green, blue); */

; z$ P" ^7 V4 M    switch (info->fix.visual) {   
    case FB_VISUAL_TRUECOLOR:    /*使用真彩色*/
        /* true-colour, use pseudo-palette */
  J3 B$ f5 ^3 L* }" D7 g% H% W
        if (regno < 16) {    /*16种颜色，为什么只用16种颜色???????????*/
            u32 *pal = info->pseudo_palette;
, E1 z* V& C: f, ^0 _/ A, E" p( M
, B7 P7 J5 D0 K6 ^( w7 |1 y            val  = chan_to_field(red,   &info->var.red);
            val |= chan_to_field(green, &info->var.green);
            val |= chan_to_field(blue,  &info->var.blue);

            pal[regno] = val;    /*保存颜色值*/
        }
: X7 N! M9 Q" [& A        break;

    case FB_VISUAL_PSEUDOCOLOR:
        if (regno < 256) {
            /* currently assume RGB 5-6-5 mode */

4 ]! [' r4 Q9 E' Q8 j  |            val  = (red   >>  0) & 0xf800;
4 d6 w' ^; T( m% r# {: x            val |= (green >>  5) & 0x07e0;
            val |= (blue  >> 11) & 0x001f;

9 F! |4 v5 x: n0 D            writel(val, regs + S3C2410_TFTPAL(regno));
, A% I! Z6 S  U: a! }# G0 }0 H; \            schedule_palette_update(fbi, regno, val);
/ O, t; B9 n/ v% ]        }

6 `4 l  @5 S3 |9 {, l        break;
. L$ T9 q! w. N5 R' r% a: `
  M$ g: @3 j& ]9 {/ I/ q    default:
' ~, f$ _2 e6 Y7 ]# |4 _$ D! g        return 1;    /* unknown type */
    }
. r, b$ U8 o5 D# f
: B- u5 y# ?& M$ j' u    return 0;
3 C) }, L# u$ x}
- p: Z1 g4 h: ~2 x6 }/* from pxafb.c */
static inline unsigned int chan_to_field(unsigned int chan,
" j: @- N- q" [) Y) e# E                     struct fb_bitfield *bf)
{   
3 Q4 h& z! {4 z. n# z    /*下面用到的length和offset在s3c2410fb_check_var函数中设置*/
$ `4 V5 ^' Y, d+ B: p    chan &= 0xffff;                /*取低16位*/
    chan >>= 16 - bf->length;   /*取第length为到16位为有效位*/
    return chan << bf->offset;    /*移动到相应的位置。*/
& j. R2 W% h8 @2 @: u}
我们使用的是真彩色，可以设置16种颜色，颜色的位域值通过调用chan_to_field获得，然后保存了颜色的值。但是比较奇怪的是，这里并没有将值保存到0x4d000400为起始的内存中，不知为何。 反而倒是在伪彩色模式下， 使用了writel(val, regs + S3C2410_TFTPAL(regno))写到内存中，然后调用schedule_palette_update函数来更新palette表。我们来看下。
8 \# k  \2 z1 X4 c
static void schedule_palette_update(struct s3c2410fb_info *fbi,
4 \1 j- p3 u: P. n. G( b                                    unsigned int regno, unsigned int val)
{
        unsigned long flags;
        unsigned long irqen;
        void __iomem *irq_base = fbi->irq_base;

        local_irq_save(flags);
2 n0 L& Q5 i$ c# d" ?( T) |4 p
! P4 t( Z8 B6 k. u3 Q7 l, W* a        fbi->palette_buffer[regno] = val;

) N5 z1 N" i8 T4 c        if (!fbi->palette_ready) {
                fbi->palette_ready = 1;

7 l' Y7 H- m7 Z; v) X) H8 H8 B# N                /* enable IRQ */
+ V! j! z$ B. v) I7 J( f                irqen = readl(irq_base + S3C24XX_LCDINTMSK);
                irqen &= ~S3C2410_LCDINT_FRSYNC;
! x; [3 ]; e/ x3 z7 e1 a* @                writel(irqen, irq_base + S3C24XX_LCDINTMSK);
2 S* ~3 k. t/ K        }
7 H9 W* z1 |$ {2 L" k1 j' g
        local_irq_restore(flags);
}
这个函数的作用就是开启了LCD的帧同步中断，这个中断在VSYNC信号从无效变成有效时产生。当中断产生时，会调用在probe方法中注册的ISR。ISR如下：
6 U. ~/ f; `5 \6 j* o$ k* Dstatic irqreturn_t s3c2410fb_irq(int irq, void *dev_id)
/ _" ?8 g/ @& A" H{
4 x/ W7 f- x% {  L        struct s3c2410fb_info *fbi = dev_id;
: D/ j7 Q" Z6 W; h  E- h' f        void __iomem *irq_base = fbi->irq_base;
& e/ n1 ^! [# I# j        unsigned long lcdirq = readl(irq_base + S3C24XX_LCDINTPND);
/ P- T+ L7 t4 p* Tb
        if (lcdirq & S3C2410_LCDINT_FRSYNC) {
6 ^/ r4 V" A) s                if (fbi->palette_ready)
; x) J! a/ m1 {, z6 M' I+ I                        s3c2410fb_write_palette(fbi);

                writel(S3C2410_LCDINT_FRSYNC, irq_base + S3C24XX_LCDINTPND);
                writel(S3C2410_LCDINT_FRSYNC, irq_base + S3C24XX_LCDSRCPND);
        }
' {9 ^; w0 A2 Q) G/ U( @7 h
. C; C2 W; `4 K2 E2 f* ?! u( ?        return IRQ_HANDLED;
}

5 P' Z% H0 v7 Z' m8 _+ Estatic void s3c2410fb_write_palette(struct s3c2410fb_info *fbi)
{
    unsigned int i;
    void __iomem *regs = fbi->io;

: `: |1 R8 A1 H- P3 T    fbi->palette_ready = 0;  /*清除ready标志*/

7 e) `, f* ^& f9 }; U    for (i = 0; i < 256; i++) {
        unsigned long ent = fbi->palette_buffer;
7 P) _7 p$ [+ E3 ~9 [8 ]. O        if (ent == PALETTE_BUFF_CLEAR)
            continue;
- T% X2 ^9 Q8 n. D" {4 O4 I
. }6 A7 z0 k2 C9 n        writel(ent, regs + S3C2410_TFTPAL(i));
. x9 |4 J. m+ |3 L6 j, s4 j
        /* it seems the only way to know exactly
" |! k, s$ t& `# d8 c: m: }' `: [3 s         * if the palette wrote ok, is to check
7 u$ U5 j% E7 S         * to see if the value verifies ok
8 V! O" g+ s7 }5 h9 h         */

8 V# d% H2 q% k* a: e* e' a* A3 J$ I        if (readw(regs + S3C2410_TFTPAL(i)) == ent)
            fbi->palette_buffer = PALETTE_BUFF_CLEAR;
) n% c# s% l% O5 d        else
& D) s% q5 J9 o            fbi->palette_ready = 1;   /* retry */
    }
}
% k0 t/ G; u# P' v1 y) C在中断函数中调用了s3c2410fb_write_palette，该函数对写入内存的颜色值进行检查。如果确认其已经写入，则将palette_buffer中的清除，否则retry。

5. 总结
本文对frambuffer子系统做了简单的介绍。frambuffer子系统的函数相当之多，在这里是不可能一一介绍的。本文首先介绍了主要的数据结构，
( L6 X' d) G, |' C' t( Y
随后分析了frambuffer核心层，在核心层简单的分析了5个API函数，接着，对驱动层做了介绍，驱动层的大多数函数都给出了分析。

0 X1 `0 r% a; g




+ \- m) ~0 E! b: [( M2 x
) M) i+ ?( h6 j" G
( `5 i- _: E" d3 X- w7 l3 m

SsaaM7

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