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

baqiao

本文将介绍Framebuffer子系统

, a& E3 ]' m" R- p9 ~. @& Q9 o目标平台：TQ2440 CPU：s3c2440
; F( K  Q+ a5 G4 U' a  f) K
- }$ \. |( b. `" o6 rLCD设备：3.5英寸，分辨率320X240



1. 概述

Framebuffer，中文名字是帧缓冲，这个帧也就是一副图像所需要的数据。因此，帧缓冲其实就是LCD设备的驱动程序。Linux中，framebuffer子系统框架如下：
* N' t  y% n6 O# @) k2 `


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

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

2. 数据结构
' k- p% t( ]+ f  e2.1 fb_info 结构
  该结构是内核用于描述一个特定framebuffer设备。其中包含了几个重要的结构，将在下面介绍。

  下列代码位于include/linux/fb.h

struct fb_info {
# u% H( H2 j8 v- y6 Z( }" ]        int node;
+ {% X. m  a6 U" P- W3 Y+ _        int flags;
        struct mutex lock;                /* Lock for open/release/ioctl funcs */
' }& F- [* s( ?% n( |& B! [8 n        struct fb_var_screeninfo var;        /* Current var */
        struct fb_fix_screeninfo fix;        /* Current fix */
# i2 @, m# t3 S        struct fb_monspecs monspecs;        /* Current Monitor specs */
        struct work_struct queue;        /* Framebuffer event queue */
- o4 H# e/ h7 q* @# S; @        struct fb_pixmap pixmap;        /* Image hardware mapper */
' }/ t6 A' W4 _% r/ Q2 t        struct fb_pixmap sprite;        /* Cursor hardware mapper */
4 t# o; p5 p! n! k        struct fb_cmap cmap;                /* Current cmap */
        struct list_head modelist;      /* mode list */
: B+ {* M: }4 u. r3 F  F        struct fb_videomode *mode;        /* current mode */
) @4 r& h( d7 L0 d6 K
#ifdef CONFIG_FB_BACKLIGHT
# j- v8 g/ l# H' a  j        /* assigned backlight device */
) F4 }2 m- Q6 |% `9 C        /* set before framebuffer registration,
- t7 R+ f* S+ G2 a           remove after unregister */
7 y7 X0 Q# j4 ~( K        struct backlight_device *bl_dev;
6 f  @( W: y) ?) q, F" K
        /* Backlight level curve */
: C; `+ p) c, j' _        struct mutex bl_curve_mutex;       
        u8 bl_curve[FB_BACKLIGHT_LEVELS];
9 E. B+ d$ x; C! P7 R#endif
5 O: K" r+ }7 [( A+ h1 L#ifdef CONFIG_FB_DEFERRED_IO
# R* H/ F% \& W: }        struct delayed_work deferred_work;
6 [2 n/ m$ N4 }- X& x& ^; }        struct fb_deferred_io *fbdefio;
#endif
: _( e: g+ t; u, U4 x' \3 R
' U) O# Y' U1 A- b+ I; A: C* p        struct fb_ops *fbops;
, t1 g, e: q/ F$ E        struct device *device;                /* This is the parent */
        struct device *dev;                /* This is this fb device */
        int class_flag;                    /* private sysfs flags */
#ifdef CONFIG_FB_TILEBLITTING
% Q9 R- H4 ^' q- p! m5 |. h        struct fb_tile_ops *tileops;    /* Tile Blitting */
7 T' \& m+ v& m#endif
, N6 n& c, o  D/ U        char __iomem *screen_base;        /* Virtual address */
        unsigned long screen_size;        /* Amount of ioremapped VRAM or 0 */
: d/ W* {5 E5 c+ g- v        void *pseudo_palette;                /* Fake palette of 16 colors */
% Q9 Y! e6 f+ ]0 q& }#define FBINFO_STATE_RUNNING        0
#define FBINFO_STATE_SUSPENDED        1
        u32 state;                        /* Hardware state i.e suspend */
        void *fbcon_par;                /* fbcon use-only private area */
- q* C6 U: a5 S; A, O+ I# G8 C        /* From here on everything is device dependent */
        void *par;       
};
2.2 fb_fix_screeninfo结构
3 n2 S% M% i" M4 `; J  该数据结构是不可改变的，也就是说用户空间不能改变该结构中的任何成员，在核心层我们将会看到这点。

) [$ b+ C# ?+ r% |4 s9 B  下列代码位于include/linux/fb.h
: L3 s: u' n; r
, G* N9 Z- v* O! n6 j) M  F0 kstruct fb_fix_screeninfo {
        char id[16];                        /* identification string eg "TT Builtin" */
        unsigned long smem_start;        /* Start of frame buffer mem */
8 y7 P& K9 l: H( M$ E; l                                        /* (physical address) */
  U  i1 o8 d+ L5 W$ }& |: a        __u32 smem_len;                        /* Length of frame buffer mem */
        __u32 type;                        /* see FB_TYPE_*                */
        __u32 type_aux;                        /* Interleave for interleaved Planes */
        __u32 visual;                        /* see FB_VISUAL_*                */
        __u16 xpanstep;                        /* zero if no hardware panning  */
0 ^5 P. w3 P2 m& j        __u16 ypanstep;                        /* zero if no hardware panning  */
        __u16 ywrapstep;                /* zero if no hardware ywrap    */
        __u32 line_length;                /* length of a line in bytes    */
        unsigned long mmio_start;        /* Start of Memory Mapped I/O   */
                                        /* (physical address) */
9 H6 N, }" a% z/ m0 a7 m+ T' M        __u32 mmio_len;                        /* Length of Memory Mapped I/O  */
0 U; v$ g/ F* c        __u32 accel;                        /* Indicate to driver which        */
                                        /*  specific chip/card we have        */
        __u16 reserved[3];                /* Reserved for future compatibility */
};
) U4 ^6 ^# w0 H) s$ g, i
1 s2 r/ N4 O8 E; [2.3 fb_var_screeninfo结构
  该数据结构是可以改变的，也就是说用户空间可以改变该结构中的成员。该数据结构中的很多成员就由板级信息复制而来，在驱动代码中我们将会看到这点。

1 K) T/ X0 O: l2 u  下列代码位于include/linux/fb.h

struct fb_var_screeninfo {
( ]" u, k: E6 u5 }: Q2 g        __u32 xres;                        /* visible resolution                */
        __u32 yres;
" T  ^% y% ?6 j4 _$ l- N        __u32 xres_virtual;                /* virtual resolution                */
! e/ S0 R2 q2 W* h        __u32 yres_virtual;
( g3 u- o5 |' C0 s% V" r        __u32 xoffset;                        /* offset from virtual to visible */
3 U2 B  x( q& K9 s( l# ]% V7 A: ~        __u32 yoffset;                        /* resolution                        */

        __u32 bits_per_pixel;                /* guess what                        */
% C- s5 d$ J! w/ I- a: E        __u32 grayscale;                /* != 0 Graylevels instead of colors */

6 H$ `* u2 E3 f: G5 h* A# J        struct fb_bitfield red;                /* bitfield in fb mem if true color, */
2 z/ l- m! i9 L7 `- J0 M        struct fb_bitfield green;        /* else only length is significant */
        struct fb_bitfield blue;
        struct fb_bitfield transp;        /* transparency                        */       

2 v) i4 y4 b* d5 p2 t" U        __u32 nonstd;                        /* != 0 Non standard pixel format */

        __u32 activate;                        /* see FB_ACTIVATE_*                */

        __u32 height;                        /* height of picture in mm    */
+ q0 A* O1 ~) R. a  b' h        __u32 width;                        /* width of picture in mm     */
8 |7 p2 o/ J, Q! P! \
        __u32 accel_flags;                /* (OBSOLETE) see fb_info.flags */
6 R5 D' n5 s+ n. V% C( m
        /* Timing: All values in pixclocks, except pixclock (of course) */
( j. Y+ X3 g/ M. z        __u32 pixclock;                        /* pixel clock in ps (pico seconds) */
        __u32 left_margin;                /* time from sync to picture        */
        __u32 right_margin;                /* time from picture to sync        */
        __u32 upper_margin;                /* time from sync to picture        */
        __u32 lower_margin;
        __u32 hsync_len;                /* length of horizontal sync        */
- e7 k9 u2 t' s2 h' p7 Y5 J        __u32 vsync_len;                /* length of vertical sync        */
! M/ ?, X+ r& x        __u32 sync;                        /* see FB_SYNC_*                */
        __u32 vmode;                        /* see FB_VMODE_*                */
        __u32 rotate;                        /* angle we rotate counter clockwise */
$ ?2 ?" g0 p, v* h1 h- O        __u32 reserved[5];                /* Reserved for future compatibility */
};
! A1 Q" f. {+ z' I9 `/ ]" u
, ?4 M; t9 z( U( E5 K3 q; `  k" [2.4 fb_ops结构
  该结构描述了用于fb_info的方法，这些方法中有些是要驱动程序提供的，而有些可以使用内核提供的方法。

6 g3 S: ?8 F5 b$ v 下列代码位于include/linux/fb.h
6 e1 q- a6 K1 F& m8 t' f
/*
* Frame buffer operations
*
* LOCKING NOTE: those functions must _ALL_ be called with the console
" A' ?3 M0 S8 F3 U' K# t$ Z * 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.
  d" {2 j3 Q0 Q$ O- | */
& W- A, h0 C8 x9 @+ n
struct fb_ops {
        /* open/release and usage marking */
        struct module *owner;
        int (*fb_open)(struct fb_info *info, int user);
2 {0 G  {  B/ i1 `        int (*fb_release)(struct fb_info *info, int user);
% [/ R0 z* C; h
" H  N: s9 l& [        /* For framebuffers with strange non linear layouts or that do not
+ W# X8 R& O, v4 a& D         * work with normal memory mapped access
/ P: w5 F7 \9 T9 {9 @         */
1 W: |% J5 i; C9 m: P: `        ssize_t (*fb_read)(struct fb_info *info, char __user *buf,
                           size_t count, loff_t *ppos);
3 s0 R. i. Y0 [/ @5 d& X        ssize_t (*fb_write)(struct fb_info *info, const char __user *buf,
  u, h- k8 {$ ]. q8 l2 ]                            size_t count, loff_t *ppos);

4 U, b! Z2 ~0 F2 D) A* _        /* checks var and eventually tweaks it to something supported,
         * DO NOT MODIFY PAR */
        int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);

        /* set the video mode according to info->var */
0 ^* U0 ?+ f/ o9 o/ r( o5 v        int (*fb_set_par)(struct fb_info *info);
, i$ y6 C/ G9 P! y! I
- R- M% S* g1 Z, d) H7 t1 p        /* set color register */
        int (*fb_setcolreg)(unsigned regno, unsigned red, unsigned green,
                            unsigned blue, unsigned transp, struct fb_info *info);

        /* set color registers in batch */
        int (*fb_setcmap)(struct fb_cmap *cmap, struct fb_info *info);
; p2 ?- [- m- ^, e% v
9 P! t4 ?' \$ W  j$ T/ G' A7 H3 Z        /* blank display */
% Q/ D6 ~: f) e  g( Y0 N( C; {        int (*fb_blank)(int blank, struct fb_info *info);

; n7 q. C/ P# v- j$ _' I        /* pan display */
0 ]2 S; H" ^0 O/ ^4 o        int (*fb_pan_display)(struct fb_var_screeninfo *var, struct fb_info *info);

" l/ }% {4 y2 y        /* Draws a rectangle */
+ s: }- ^1 S: T" g5 X+ c; `        void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect);
        /* Copy data from area to another */
: l+ x% i( i, q& ~        void (*fb_copyarea) (struct fb_info *info, const struct fb_copyarea *region);
        /* Draws a image to the display */
, q+ E, ?9 _! e        void (*fb_imageblit) (struct fb_info *info, const struct fb_image *image);
. R, S  M. r* F* t1 W8 s
* E! v& L/ x, ]$ V1 M        /* Draws cursor */
        int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor);
+ s; J9 S( Q) {' ?' t8 P5 M- X
3 i/ {( y' E# V" W        /* Rotates the display */
        void (*fb_rotate)(struct fb_info *info, int angle);

, r- s, A* l5 f  z2 l3 B        /* wait for blit idle, optional */
; }+ e* Q' s7 g4 C( \$ z; h        int (*fb_sync)(struct fb_info *info);

        /* peRForm fb specific ioctl (optional) */
        int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,
( E1 u2 O' W) c- o+ n5 k                        unsigned long arg);
) |' H# r& a/ x0 A0 X5 S
        /* Handle 32bit compat ioctl (optional) */
        int (*fb_compat_ioctl)(struct fb_info *info, unsigned cmd,
                        unsigned long arg);

        /* perform fb specific mmap */
1 a9 o' s: M! O1 b        int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);

4 A. X, c7 z) h) ~( Z        /* save current hardware state */
7 X# J) X' ]0 H/ i1 B+ V% T2 J4 j6 M        void (*fb_save_state)(struct fb_info *info);

4 j! h' g$ A& T6 a8 A        /* restore saved state */
/ [% R$ J9 b$ A! u2 `* T! A* f        void (*fb_restore_state)(struct fb_info *info);

6 R3 L: W( |4 ?5 K        /* get capability given var */
# n5 S- B% A7 d4 p0 @  }$ p" K        void (*fb_get_caps)(struct fb_info *info, struct fb_blit_caps *caps,
5 r) ?; P2 L* ?5 y1 \                            struct fb_var_screeninfo *var);
' x: O' L2 g: L5 v; n: L' o};


" v2 n- ]& [/ p4 |+ _3. frambuffer核心层
2 c8 [: h4 ?/ w6 Z7 a  M; f" L首先来看下frmaebuffer子系统的初始化函数。
+ B# i$ R" F3 b# W2 d! E) R
: ?* l6 ?0 p+ r1 A* r# A3.1 fbmem_init和fbmem_exit
下列代码位于drivers/video/fbmem.c

/**
. w- b# F, }+ C6 {' q4 D *        fbmem_init - init frame buffer subsystem
*
*        Initialize the frame buffer subsystem.
2 q: x- r& v3 W2 b' l *
3 g5 h' ~/ n  w) b$ b *        NOTE: This function is _only_ to be called by drivers/char/mem.c.
*
*/

static int __init
fbmem_init(void)
0 F3 t7 y& t9 `. {& i4 h* t{
        proc_create("fb", 0, NULL, &fb_proc_fops);

+ h1 R9 n# w# a3 y+ M: G) O, h  ]+ q        if (register_chrdev(FB_MAJOR,"fb",&fb_fops))                /*注册字符设备，major=29*/
                printk("unable to get major %d for fb devs\n", FB_MAJOR);

        fb_class = class_create(THIS_MODULE, "graphics");        /*创建类*/
        if (IS_ERR(fb_class)) {
# Y7 `" Y& B- [. e0 w/ ?( _                printk(KERN_WARNING "Unable to create fb class; errno = %ld\n", PTR_ERR(fb_class));
                fb_class = NULL;
        }
        return 0;
9 _" V# ^+ j$ ?2 |}
- R; G; q- B% `. U3 o8 X9 [1 g& D
# y: j2 a# e6 ^8 E#ifdef MODULE
, n9 {. V7 J) s9 T/ e% w% `  vmodule_init(fbmem_init);
static void __exit
fbmem_exit(void)
{
        remove_proc_entry("fb", NULL);
3 g4 o( r* A, d7 R+ s, ?+ O        class_destroy(fb_class);
        unregister_chrdev(FB_MAJOR, "fb");
$ @; a- ~0 S: j+ o8 q+ u}
, b4 J# X; Z5 b& I4 A
, I2 R( E7 H. F* R/ ymodule_exit(fbmem_exit);
MODULE_LICENSE("GPL");
+ u& ~# n" K& ?, R) XMODULE_DESCRIPTION("Framebuffer base");
4 u0 C" W( n9 C$ @" {#else
& M4 F" u( m0 csubsys_initcall(fbmem_init);
( F! i4 c- D4 ~9 I5 g. w#endif

; O2 H, U$ H+ w# B/ {static const struct file_operations fb_fops = {
  n, O, F2 _) g2 c& R8 T    .owner =    THIS_MODULE,
    .read =        fb_read,
: _. A( V2 |( N# q' e, X    .write =    fb_write,
    .unlocked_ioctl = fb_ioctl,
#ifdef CONFIG_COMPAT
    .compat_ioctl = fb_compat_ioctl,
3 C6 b7 W! r5 S. z#endif
    .mmap =        fb_mmap,
    .open =        fb_open,
    .release =    fb_release,
#ifdef HAVE_ARCH_FB_UNMAPPED_AREA
    .get_unmapped_area = get_fb_unmapped_area,
! }" T0 q9 N. C% P0 e#endif
#ifdef CONFIG_FB_DEFERRED_IO
    .fsync =    fb_deferred_io_fsync,
5 `: x+ B' D% u1 g#endif
% L& |: Y8 e. R  U};
( ?6 O4 b2 d3 j/ R
我们看到，如果不是作为模块，那么该初始化程序将在subsys_initcall阶段被调用。初始化时，仅仅注册了一个字符设备，并创建了一个类。通过字符设备，提供了API给用户空间，包open，release，write，read等。
随后我们看看如何分配一个fb_info结构。
+ M  v# s: F5 r9 ]. A+ [  d
7 w* K- ^& V; r# Q+ q( W3.2 framebuffer_alloc
! Y* ^$ s  ]% _- p) x下列代码位于drivers/video/fbmem.c
, s, ?7 M7 j& y& E. }+ V
/**
& i1 l2 u$ o  u3 {4 Y1 C * framebuffer_alloc - creates a new frame buffer info structure
; V' b0 n* H, U# Z2 s5 h' ] *
* @size: size of driver private data, can be zero
9 s1 [- |' l+ c' M) c( \8 w( {$ Y, ]6 G * @dev: pointer to the device for this fb, this can be NULL
& B# Z1 i, T6 d *
* Creates a new frame buffer info structure. Also reserves @size bytes
9 k, ?/ \: Q# V# G4 \ * for driver private data (info->par). info->par (if any) will be
* aligned to sizeof(long).
*
* Returns the new structure, or NULL if an error occured.
- X) L- p( w$ E* W: q *
" Q% p6 l, G5 p1 T) A4 B$ \ */
struct fb_info *framebuffer_alloc(size_t size, struct device *dev)
{
#define BYTES_PER_LONG (BITS_PER_LONG/8)
8 I  n0 m. X3 z/ y' d+ z1 s5 L#define PADDING (BYTES_PER_LONG - (sizeof(struct fb_info) % BYTES_PER_LONG))
        int fb_info_size = sizeof(struct fb_info);
6 c: p4 z( {2 C7 T2 m# |8 q        struct fb_info *info;
        char *p;
$ ^# L* _7 u- ?) t5 C9 e
" y- A9 w: W3 [/ C( l        if (size)
                fb_info_size += PADDING;
; Y9 E8 m( n& Q
) ~$ [, y7 Q2 w% p1 C: M" u6 Q5 h        p = kzalloc(fb_info_size + size, GFP_KERNEL);
6 [, K$ {  A- C9 `. ~
        if (!p)
: v- H1 t2 Y" y) X* C7 Y: H5 U                return NULL;
. d0 }$ L/ A3 g, G7 J1 ^2 X* O
        info = (struct fb_info *) p;
5 ^6 Q. s7 y- k* F
        if (size)
; B4 t* f0 P4 U/ B9 ]; W' C                info->par = p + fb_info_size;
; C( }$ t" O- }( G' @9 S$ B5 f' I. Z
        info->device = dev;
5 o: ^& o) _3 N* A- y7 F
#ifdef CONFIG_FB_BACKLIGHT
        mutex_init(&info->bl_curve_mutex);
#endif
# P: v$ H9 O9 K' D4 W" P  f
        return info;
#undef PADDING
6 ]# f' b7 T9 e6 t- R, B' e#undef BYTES_PER_LONG
% m, a$ ]" A; u% C, z3 j}
0 y3 U% x3 E7 b. d# W# {) s4 ?EXPORT_SYMBOL(framebuffer_alloc);
在进行分配时，根据参数size的大小，分配了b_info_size + size的空间，然后让fb_info->par指向size的空间。因此par所指向的空间可视为设备特有的数据。
; E/ p3 T0 C6 i1 Z  `& Y在分配了fb_info结构之后，需要将它注册到内核中。注册由register_framebuffer完成。我们来看下。

3.3 register_framebuffer
下列代码位于drivers/video/fbmem.c
1 ?& Q. ^5 _0 H, y
/**
*        register_framebuffer - registers a frame buffer device
# G$ g% }& B) J8 A# O *        @fb_info: frame buffer info structure
% c9 m% a. X$ @. {$ n *
# M1 |' e+ ^( E8 d4 f" q$ [2 C  c *        Registers a frame buffer device @fb_info.
*
*        Returns negative errno on error, or zero for success.
*
*/
$ v. L7 |  g9 E9 Z, N
int
register_framebuffer(struct fb_info *fb_info)
{
( _# i5 u- u3 d        int i;
" k3 V$ X; l* m0 O5 P# {        struct fb_event event;
8 A' A) n7 v/ t7 Q. |% {        struct fb_videomode mode;
& ~$ X4 \( j/ J
, Z- |* ]& O7 S* H        if (num_registered_fb == FB_MAX) /*最多32个FB*/
/ C2 [; q0 C* A  D3 r                return -ENXIO;
/ b- e. W+ Y3 C. z% O
        if (fb_check_foreignness(fb_info))
                return -ENOSYS;
2 E6 o6 k: _+ L
* c, G* ^8 i# [  F! E$ g+ x$ q: ^        num_registered_fb++;                /*对注册的FB计数*/
' G( E/ {$ V! |& J        /*寻找第一个空位*/
" s  P3 k) M8 L! a( G        for (i = 0 ; i < FB_MAX; i++)/*FB_MAX=32,也就是最多32个framebuffer*/
$ b/ j6 z( v* w: n) s$ z                if (!registered_fb)        /*struct fb_info *registered_fb[FB_MAX]*/
                        break;
4 z6 {; G, }* T        fb_info->node = i;
        mutex_init(&fb_info->lock);        /*初始化互斥体*/

        fb_info->dev = device_create(fb_class, fb_info->device,/*创建设备节点，节点名为fbx*/
: Q* m7 p1 o: O' o$ a  {0 `                                     MKDEV(FB_MAJOR, i), NULL, "fb%d", i);
& r8 B( H2 H9 n/ }3 G        if (IS_ERR(fb_info->dev)) {
, ], J. V% x5 T' d& D6 q                /* Not fatal */
                printk(KERN_WARNING "Unable to create device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->dev));
1 J& M" B" Z& M) c                fb_info->dev = NULL;
        } else
2 K; \1 b  X2 o) E! h* f0 k! e                fb_init_device(fb_info);        /*初始化,在class/graphics/fbx/下创建设备属性*/

        if (fb_info->pixmap.addr == NULL) {
                fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL);/*分配内存，1024 * 8字节*/
                if (fb_info->pixmap.addr) {
6 H; Q! s1 a/ Q7 O                        fb_info->pixmap.size = FBPIXMAPSIZE;
* h* s6 G' O' b, X, u% E1 ~, e. m                        fb_info->pixmap.buf_align = 1;
                        fb_info->pixmap.scan_align = 1;
2 I$ [  |0 ?8 D; w/ e9 X                        fb_info->pixmap.access_align = 32;
0 ~6 [0 h5 H, b: [                        fb_info->pixmap.flags = FB_PIXMAP_DEFAULT;
3 h( n  I% X7 ^2 b- m- L                }
        }       
  ]$ Q! ^9 u4 A" k8 v3 l: n        fb_info->pixmap.offset = 0;
' h3 E! F( y- t1 m
; L4 s- z: [( ?, }; W        if (!fb_info->pixmap.blit_x)
                fb_info->pixmap.blit_x = ~(u32)0;
, s: `2 |- H: q0 L
7 M: g2 W1 D, U/ ?+ {        if (!fb_info->pixmap.blit_y)
$ H( `" }5 V6 }7 R                fb_info->pixmap.blit_y = ~(u32)0;

        if (!fb_info->modelist.prev || !fb_info->modelist.next)        /*该链表没有指向其他节点*/
5 E2 D9 a# W" R1 K                INIT_LIST_HEAD(&fb_info->modelist);        /*初始化链表头*/
2 f# G3 F# l- ^/ V2 c
0 M6 S8 Z) ~, S3 t( f        fb_var_to_videomode(&mode, &fb_info->var);/*转换fb_var_screeninfo成fb_videomode*/
        fb_add_videomode(&mode, &fb_info->modelist);/*添加mode至链表中*/
! r9 [0 _  W1 a; s, `        registered_fb = fb_info;

        event.info = fb_info;
        if (!lock_fb_info(fb_info))
                return -ENODEV;
        fb_notifier_call_chain(FB_EVENT_FB_REGISTERED, &event);/*???*/
        unlock_fb_info(fb_info);
        return 0;
}
; F$ j! P' v; Q" z; N2 M$ M
从这个函数我们可以看出，framebuffer子系统只支持32个设备。在创建了设备节点以后，建立设备属性节点，随后将fb_var_screeninfo转换成fb_videomode，最后添加fb_videomode至链表中。
% `: A% ]1 t8 x; c; H( B" d我们看下其中调用的函数，首先是fb_init_device。
  y) Y# s/ s& v/ D. H) [
下列代码位于drivers/video/fbsysfs.c

int fb_init_device(struct fb_info *fb_info)
/ r: b& Y3 `( a1 @1 \{
        int i, error = 0;

        dev_set_drvdata(fb_info->dev, fb_info);
) u2 C+ R0 b9 I+ N7 h, G" [
        fb_info->class_flag |= FB_SYSFS_FLAG_ATTR;

        /*建立设备属性*/
4 u0 q$ O& m2 S. I, M* Y        for (i = 0; i < ARRAY_SIZE(device_attrs); i++) {
2 |# q6 v! u1 k+ X; Q0 N9 s                error = device_create_file(fb_info->dev, &device_attrs);
7 s$ T6 u9 ]7 l/ W; M
                if (error)
% W  d) {4 j1 a4 }                        break;
        }
) b/ D. Q" C0 Q7 t
        if (error) {
                while (--i >= 0)
                        device_remove_file(fb_info->dev, &device_attrs);
6 r6 C/ ?7 O) x" [' c3 h5 u                fb_info->class_flag &= ~FB_SYSFS_FLAG_ATTR;
        }

% r% e( l( x- v/ \7 I( {        return 0;
. N/ p7 P1 Z0 A- q! c! W6 R}

! C- D* l0 {- }! Y6 z* L/* When cmap is added back in it should be a binary attribute
1 `' a1 G/ c( W, _* h1 p * not a text one. Consideration should also be given to converting
- S$ e, `" ~, t1 G8 C& y; I * fbdev to use configfs instead of sysfs */
static struct device_attribute device_attrs[] = {
% U) b$ N  J& ^( a! y- E; ?( v    __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),
    __ATTR(modes, S_IRUGO|S_IWUSR, show_modes, store_modes),
    __ATTR(pan, S_IRUGO|S_IWUSR, show_pan, store_pan),
    __ATTR(virtual_size, S_IRUGO|S_IWUSR, show_virtual, store_virtual),
    __ATTR(name, S_IRUGO, show_name, NULL),
0 n: z! N- c; L3 r4 d  i! S    __ATTR(stride, S_IRUGO, show_stride, NULL),
6 I. F) t2 h9 `* y    __ATTR(rotate, S_IRUGO|S_IWUSR, show_rotate, store_rotate),
    __ATTR(state, S_IRUGO|S_IWUSR, show_fbstate, store_fbstate),
/ v$ F8 c# n( u9 @8 M0 ^. V+ N2 `#ifdef CONFIG_FB_BACKLIGHT
    __ATTR(bl_curve, S_IRUGO|S_IWUSR, show_bl_curve, store_bl_curve),
#endif
6 a) O; P, W7 H};

我们可以在/sys/class/graphics/fb0下发现这些属性文件。
[root@yj423 fb0]#pwd
/sys/class/graphics/fb0
[root@yj423 fb0]#ls
bits_per_pixel  cursor          mode            pan             state           uevent
blank           dev             modes           power           stride          virtual_size
console         device          name            rotate          subsystem


接着看下fb_var_to_videomode和fb_add_videomode函数。

7 J3 c5 V  O# M0 |下列代码位于drivers/video/modedb.c和drivers/video/fb.h

struct fb_videomode {
        const char *name;        /* optional */
  `1 h8 O' f. q" @8 F        u32 refresh;                /* optional */
        u32 xres;
        u32 yres;
4 o$ Q1 }5 h- n8 [        u32 pixclock;
        u32 left_margin;
        u32 right_margin;
        u32 upper_margin;
        u32 lower_margin;
        u32 hsync_len;
0 ^2 u/ C2 `7 s) {3 y8 ?        u32 vsync_len;
3 f8 h1 J7 U' c5 l' h/ V" ]5 m7 s        u32 sync;
/ U1 f, q$ I# u# S' g  Z        u32 vmode;
        u32 flag;
2 y' F  }  [9 R+ u, Y};
" p, f3 m. W5 v$ X
8 _% B9 i3 M: D# L8 W  W/**
$ [0 ^  p' \/ Z" E3 c. } * fb_var_to_videomode - convert fb_var_screeninfo to fb_videomode
: @' y0 t% N- P6 Z4 q * @mode: pointer to struct fb_videomode
* @var: pointer to struct fb_var_screeninfo
* b- B8 K3 w  ^, N' P& z5 } */
5 M0 }) K) G3 i4 ]! Y9 Tvoid fb_var_to_videomode(struct fb_videomode *mode,
/ K+ i& O/ P$ ^             const struct fb_var_screeninfo *var)
{
    u32 pixclock, hfreq, htotal, vtotal;
. d" t: k+ k" S, o# ?, o
2 Z% F, e) O$ F' I. X    mode->name = NULL;
; j& }: z0 Z+ B( @3 e. s0 Y    mode->xres = var->xres;
* P% j  z$ f5 f1 S9 J    mode->yres = var->yres;
    mode->pixclock = var->pixclock;
    mode->hsync_len = var->hsync_len;
' [1 J6 _4 M/ H5 H  N    mode->vsync_len = var->vsync_len;
    mode->left_margin = var->left_margin;
    mode->right_margin = var->right_margin;
    mode->upper_margin = var->upper_margin;
& t/ h# Y7 ~4 ~* w! `) `    mode->lower_margin = var->lower_margin;
2 z4 [' L: w# r' ?' Z$ }' e    mode->sync = var->sync;
; s, v6 s0 d% W    mode->vmode = var->vmode & FB_VMODE_MASK;
% O( N5 C+ a- l) \* E0 h; y    mode->flag = FB_MODE_IS_FROM_VAR;
, g" W: `1 T8 G; c- F! @3 w/ B    mode->refresh = 0;

    if (!var->pixclock)
9 E$ m! ]- M9 R, R" `3 @, b        return;
4 L( M6 e* ]+ n, W( Q7 J
0 ?; C0 _" b" @  X    pixclock = PICOS2KHZ(var->pixclock) * 1000;

    htotal = var->xres + var->right_margin + var->hsync_len +
        var->left_margin;
0 j+ q0 @, ]' g6 s. g; p    vtotal = var->yres + var->lower_margin + var->vsync_len +
        var->upper_margin;
  g% E- r* V& }: e
. W* i, e9 ~2 G) ~% D" C. G    if (var->vmode & FB_VMODE_INTERLACED)
        vtotal /= 2;
0 u* k  w8 K2 R7 [    if (var->vmode & FB_VMODE_DOUBLE)
        vtotal *= 2;

  }' L- w  Q7 N+ m# W' O. P    hfreq = pixclock/htotal;
    mode->refresh = hfreq/vtotal;
}
) d$ b' b* V0 G  n! d
3 x( }/ E. |( A  w0 U3 U/**
6 N+ x; D' J4 n! Z, B' d * fb_add_videomode: adds videomode entry to modelist
6 K7 W* G. b! f * @mode: videomode to add
# A) s- o- B5 c7 n8 ?1 I( s * @head: struct list_head of modelist
*
& A% w) a6 `% V) ~ * NOTES:
* Will only add unmatched mode entries
8 V# E3 p& c7 H+ L; D */
int fb_add_videomode(const struct fb_videomode *mode, struct list_head *head)
{
    struct list_head *pos;
# g0 U3 ]3 m4 Z# K( e    struct fb_modelist *modelist;d
2 a5 c7 |+ O) p+ ?/ ]    struct fb_videomode *m;
* e: @& _% D6 B+ R$ o. H" q; ]    int found = 0;
, p+ E4 G1 h3 o' d( P% a2 S1 p    /*遍历所有的fb_modelist，查找mode是否存在*/
+ Z4 J/ r6 g& e/ ~, S0 W    list_for_each(pos, head) {
        modelist = list_entry(pos, struct fb_modelist, list);
        m = &modelist->mode;
" H  Y8 H% A) t1 ]$ H3 x% |        if (fb_mode_is_equal(m, mode)) {    /*比较两个fb_videomode*/
. j  Q: O( F' u; k& }            found = 1;                        /*该fb_videomode已存在*/
            break;
/ Y0 L6 M4 w- c, Z        }
    }
    if (!found) {    /*不存在*/
        modelist = kmalloc(sizeof(struct fb_modelist),    /*分配fb_modelist*/
                          GFP_KERNEL);
5 O9 B$ x! o' a1 {% k
        if (!modelist)
            return -ENOMEM;
        modelist->mode = *mode;            /*保存mode*/
8 y: E. ~$ |/ A: J) r9 {4 M/ K# J        list_add(&modelist->list, head);/*添加mode至链表中*/
    }
+ H5 S% ]% C0 u) t5 @7 q$ }    return 0;
# i# [* P! [! c- e: r* r}

4 P  R: Q3 ?2 w- b/**
* fb_mode_is_equal - compare 2 videomodes
4 j5 Z0 b9 g/ F4 R * @mode1: first videomode
* @mode2: second videomode
/ w% L  F" T* n0 b& l) P) P" S *
& y, h5 j, ~' C; N7 Y) K * RETURNS:
' [5 N8 C0 |5 L * 1 if equal, 0 if not
*/
; Q9 s4 R+ L5 Q0 }# m% F4 q% [int fb_mode_is_equal(const struct fb_videomode *mode1,
             const struct fb_videomode *mode2)
& G$ N  P( t' p  r{
# d' ?4 M! e" K* \" Y: ^/ e    return (mode1->xres         == mode2->xres &&
- H0 {& I) o& ?        mode1->yres         == mode2->yres &&
! j; y! B2 ?- K8 t5 o9 e6 z4 Q        mode1->pixclock     == mode2->pixclock &&
. N$ F2 x1 z) ^* K3 v- C4 A. I8 {        mode1->hsync_len    == mode2->hsync_len &&
        mode1->vsync_len    == mode2->vsync_len &&
        mode1->left_margin  == mode2->left_margin &&
0 l0 H, r5 `$ c3 M! |( [$ [% M; H) x        mode1->right_margin == mode2->right_margin &&
) F' P- N8 X& v$ u& h6 L9 U# H        mode1->upper_margin == mode2->upper_margin &&
0 ]9 A0 Y" e3 T# Q3 I        mode1->lower_margin == mode2->lower_margin &&
. m7 Y- {; p# J2 [        mode1->sync         == mode2->sync &&
        mode1->vmode        == mode2->vmode);
}

$ O: G( K3 \# P
7 n$ d) Y, {; o/ |2 Tfb_var_to_videomode函数只是将fb_var_screeninfo结构转换成fb_videomode结构。而fb_add_videomode函数查找是否该fb_videomode已经存在，如果不存在则添加到列表中。
7 O; f  s+ O# H# S7 H. N3.4 字符设备方法
/ Z6 u$ L3 c8 u' M7 o$ Y  在看过framebuffer子系统建立和注册过程后，我们看下framebuffer留给用户空间的API是怎样实现的。

本小结只分析5个常用的方法，即open，release，read，write和ioctl。

' V2 O& P) _4 W  因为所有的方法和struct fb_ops定义的方法有紧密的联系，而该结构的定义由驱动程序给出，在这里我们提前看下在驱动中是如何定义的。
! _  q1 Q6 d- |; L! c6 y
下列代码位于drivers/video/s3c2410fb..c
9 o) f" Q$ Q1 n- M) H3 Q. G5 x
static struct fb_ops s3c2410fb_ops = {
        .owner                = THIS_MODULE,
, p/ v# }* p/ i' j        .fb_check_var        = s3c2410fb_check_var,                        /*检查变量的合法性*/
        .fb_set_par        = s3c2410fb_set_par,                        /*将参数写入LCD控制器，该函数由帧缓冲核心调用*/
        .fb_blank        = s3c2410fb_blank,                        /*该方法支持显示消隐和去消隐*/
$ J$ v0 u, U% d7 w( E4 b        .fb_setcolreg        = s3c2410fb_setcolreg,                  /*设置颜色寄存器*/
5 ~- i. T2 k2 @: h        .fb_fillrect        = cfb_fillrect,                                /*用像素行填充矩形框，通用库函数*/
        .fb_copyarea        = cfb_copyarea,                                /*将屏幕的一个矩形区域复制到另一个区域，通用库函数*/
        .fb_imageblit        = cfb_imageblit,                        /*显示一副图像，通用库函数*/
};
最下面的三个方法使用的是内核提供的库函数，而上面4个则是由驱动提供。
3.4.1 open方法
' T: t  Q( M5 G% m) [: N1 B0 o2 Q7 S下列代码位于drivers/video/fbmem.c

static int
+ b- _6 h3 z1 `3 R7 S. Ofb_open(struct inode *inode, struct file *file)
) q. J* V. \% T. i__acquires(&info->lock)
) u: v! D" [4 R# H__releases(&info->lock)
{
        int fbidx = iminor(inode);
        struct fb_info *info;
" [. w/ C5 z! A" r        int res = 0;
5 N0 h2 |# H: R8 Q. {$ b
        if (fbidx >= FB_MAX)
                return -ENODEV;
        info = registered_fb[fbidx];                /*在register_framebuffer函数中已经设置了元素*/
        if (!info)
; g0 k9 c( l* [$ V) @; u                request_module("fb%d", fbidx);        /*加载模块，这里不加载*/
        info = registered_fb[fbidx];
        if (!info)
                return -ENODEV;
        mutex_lock(&info->lock);                        /*加锁互斥体*/
) P8 _7 R1 A$ }        if (!try_module_get(info->fbops->owner)) {        /*增加模块引用计数*/
" K  s2 t! J& c' c! v! B/ N                res = -ENODEV;
                goto out;
        }
        file->private_data = info;                /*保存info*/
( ]; N% L- O; J        if (info->fbops->fb_open) {                /*这里fb_open方法为空*/
                res = info->fbops->fb_open(info,1);
                if (res)
  {$ ]1 V$ J( I9 i8 M                        module_put(info->fbops->owner);
; d' {: g0 k" \; P        }
#ifdef CONFIG_FB_DEFERRED_IO
* q5 f% [) W. l7 d8 o9 ]+ l        if (info->fbdefio)
$ K/ C% Z- }- U: |                fb_deferred_io_open(info, inode, file);
  W9 D/ @# m% W. ~#endif
, b* Q+ \6 h: p. `! }# Wout:
        mutex_unlock(&info->lock);                /*解锁互斥体*/
        return res;
}
主要的一个工作就是增加模块引用计数。还有，程序会判断是否fb_open在驱动中给出，如果有则调用该方法。我们已经知道fb_open没有给出。
6 c& C: U' v2 v% J3.4.2 release方法
, a# e" A2 X" F0 l; ?% m下列代码位于drivers/video/fbmem.c

' r1 X  W  S( G, K% astatic int
fb_release(struct inode *inode, struct file *file)
__acquires(&info->lock)
) R, y% b9 j& Q, V: Y9 e9 h__releases(&info->lock)
! m0 _0 D, r3 Q8 A' b0 V{
        struct fb_info * const info = file->private_data;
7 ]# U9 L1 W; x/ h4 a8 I3 ]
! q  Q2 Q& M  Q+ T        mutex_lock(&info->lock);
        if (info->fbops->fb_release)        /*这里fb_release为空*/
                info->fbops->fb_release(info,1);
4 O3 w9 b8 _6 B        module_put(info->fbops->owner);        /*减少模块引用计数*/
% Y/ b6 P) f5 x* F8 W( E        mutex_unlock(&info->lock);
        return 0;
( O) c& R/ b# T9 N9 b! p}
和open相反，减少模块引用计数。
0 W3 E( D7 w1 B& x5 c: m- O8 E: G
3.4.3 write方法
. e) D1 ]8 ^0 x) c) Y* O  通过调用该方法，LCD将显示画面。

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

2 Y7 ?1 }2 c# \) ^static ssize_t
fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    unsigned long p = *ppos;
    struct inode *inode = file->f_path.dentry->d_inode;
    int fbidx = iminor(inode);
    struct fb_info *info = registered_fb[fbidx];
+ f0 l9 b, B0 j" F3 q) k    u32 *buffer, *src;
. u# C4 y) b8 [. \1 I    u32 __iomem *dst;
    int c, i, cnt = 0, err = 0;
& y) G; f9 u- S- ^3 o' P    unsigned long total_size;

    if (!info || !info->screen_base)    /*screen_base在驱动中给出*/
        return -ENODEV;
9 ~  R" E! \; W' F
    if (info->state != FBINFO_STATE_RUNNING)
- ?, P5 ?+ ?' m( ?$ U4 i, O        return -EPERM;

( X! w: q4 I& u' t' {5 y    if (info->fbops->fb_write)    /*没有fb_write方法*/
        return info->fbops->fb_write(info, buf, count, ppos);

( s, L1 p' Q3 O$ Y8 E0 C" [: V    total_size = info->screen_size;    /*screen_size没有给出*/

: e( j. a; Y. ~# F9 U* J8 Z    if (total_size == 0)
8 @3 v5 F( ^5 a' n, c8 n+ V% v        total_size = info->fix.smem_len;/*153600字节，驱动probe方法中计算*/
- ?( K2 p. l& K0 U, P7 b6 b
7 |& }* `5 P9 O    if (p > total_size)
9 s2 K9 F' b4 Q        return -EFBIG;
$ P" H7 l& m+ X4 f
    if (count > total_size) {    /*要写入的字节数大于153600*/
        err = -EFBIG;        /*file too big*/
        count = total_size;
: g6 W7 j$ M; `    }

+ G2 t4 }/ m* O! x% y: g5 H1 `    if (count + p > total_size) {/*偏移量加上字节数超出了缓冲区*/
+ f" W9 l- e9 F1 x$ E        if (!err)
$ \2 Y' ?- n" \, i            err = -ENOSPC;

6 t& w4 [1 o  {" K' Z        count = total_size - p;
2 i# @- L; e% \! e; m5 X& h    }
( Y9 Q$ {! ?6 j. b: r
% r- @3 k0 z( S4 [* i3 f0 E& h8 S    /*分配buffer，GFP_KERNEL*/
    buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
             GFP_KERNEL);                /
    if (!buffer)
6 N. |( \  X( a( T        return -ENOMEM;
' f: G  o  _9 B% A5 @3 [. ~
    dst = (u32 __iomem *) (info->screen_base + p);/*修改目的指针*/

5 w3 J8 }7 ?0 c& l) F    if (info->fbops->fb_sync)    /*没有定义fb_sync*/
        info->fbops->fb_sync(info);

    while (count) {
        c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
9 V7 F6 I0 j1 G6 d        src = buffer;

/ o+ \9 j" {  R! W        /*从buf(用户空间)拷贝数据到src中，一开始为1页，最后为count字节*/
. C  d9 H. L* A# ^7 L        if (copy_from_user(src, buf, c)) {   
            err = -EFAULT;
            break;
: W' [0 l( \9 p6 x, L  F        }
        /*一次for循环，写入4个字节数据到dst处*/
        for (i = c >> 2; i--; )
  x! c2 g$ L" `+ J* k9 T# Q            fb_writel(*src++, dst++);
        /*最后还有3个，2个或者1个字节*/
' W7 v; Y$ x7 y" l5 P        if (c & 3) {
            u8 *src8 = (u8 *) src;
' _6 T0 N: R% z            u8 __iomem *dst8 = (u8 __iomem *) dst;
" @8 t; t$ O* R  x            /*一次写入一个字节*/
            for (i = c & 3; i--; )
7 d# x# I4 V' X; X7 A8 E. B                fb_writeb(*src8++, dst8++);

0 r! u0 ^% u8 k! H' M            dst = (u32 __iomem *) dst8;
        }
0 _- f" _% X) ?8 T
        *ppos += c;    /*用户空间偏移量增加*/
        buf += c;    /*用户空间指针增加*/
2 H( r- \) |: R' W6 ~        cnt += c;    /*修改已发送字节数*/
  R6 h' i! O9 {. u: W/ i        count -= c;    /*减去1页*/
    }

# R8 \3 H6 Q# U6 _- c! {    kfree(buffer);    /*释放buffer*/

    return (cnt) ? cnt : err;
}

这里，做了一系列的检查之后，开始拷贝数据。这里一个有三个buffer，一个是用户空间提供的buf，一个是在这里新开辟的buffer，还有就是驱动层提供的screen_base。
2 C6 T  [, F2 a; A6 k& s- [) D8 M( I数据流如下：

: i1 U8 S, r: x- c

6 x. E) d! I7 L; ~# i4 _用户空间的数据首先被复制到buffer中，然后从buffer中复制到screen_base中，最后被映射到LCD上，LCD就显示响应的画面了。
9 `1 f) b5 z/ m. Y% x: X) d1 d
3.4.4 read方法
  a, Z; [+ Z) R) j- T该方法用于读取屏幕画面的数据。

read和write类似，只是数据流是反响的，就不多做介绍了。
2 H) v; g; n9 F$ J2 r; u
下列代码位于drivers/video/fbmem.c
1 L+ k  T& d( `
0 y. S; e1 L* A4 N( C3 v; t- M: P2 Fstatic ssize_t
fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
        unsigned long p = *ppos;
        struct inode *inode = file->f_path.dentry->d_inode;
0 f7 y3 V8 |2 l8 p( {* b        int fbidx = iminor(inode);
& w) V7 s6 g# r- }' A  Z8 R        struct fb_info *info = registered_fb[fbidx];
        u32 *buffer, *dst;
! `3 @3 S2 s! o        u32 __iomem *src;
        int c, i, cnt = 0, err = 0;
$ l, ^6 B$ S2 L) e- Y* ~$ g        unsigned long total_size;
; I  T; Q' @+ Q
' ]/ t9 s" x8 Z8 b8 m1 S        if (!info || ! info->screen_base)
                return -ENODEV;

* z' Q* T4 U( O: Z9 S6 H        if (info->state != FBINFO_STATE_RUNNING)
                return -EPERM;
5 ]- |4 V7 A* n# v0 k9 ~  X
. E$ R- [. b) k  [3 D* t1 B        if (info->fbops->fb_read)        /*没有定义fb_read*/
7 q  {8 q. I* P% V                return info->fbops->fb_read(info, buf, count, ppos);
       
        total_size = info->screen_size;
8 ^5 ]  ?0 m. t3 e# s$ j& B# D" s
& J0 B& `) {' Y        if (total_size == 0)
                total_size = info->fix.smem_len;
/ O6 k. d! ?$ R& _
: a+ H1 e! `- }        if (p >= total_size)
" P0 Q/ ]7 u  n( {2 Y, L. r                return 0;
0 y/ S$ B, _( d! |) O; o
        if (count >= total_size)
                count = total_size;

! h- e/ K( _- H  w9 B        if (count + p > total_size)
- A% S) {4 ]9 n- B' b; j                count = total_size - p;

* f4 s$ w: A6 R% v        buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
                         GFP_KERNEL);
% r/ {1 B! I/ @0 g. o% {! t$ t+ f; e        if (!buffer)
! I" M( V+ p) q7 {: O2 f                return -ENOMEM;
( d# |% d% u) _
0 W! o0 Z5 A( ]* B8 m1 e% l# K        src = (u32 __iomem *) (info->screen_base + p);
0 Y' h* d8 ]* Q) X. ~% {
7 o  [: p1 c( e+ D& C! D+ @, }        if (info->fbops->fb_sync)
' {8 T! x. z$ t. S. x+ B) H                info->fbops->fb_sync(info);/*没有定义fb_sync*/
# x6 m; g) ]8 [# [4 @
        while (count) {
% Y2 P8 f; n, L) r                c  = (count > PAGE_SIZE) ? PAGE_SIZE : count;
- f  s+ D) m  k* i! j  h  x                dst = buffer;
                for (i = c >> 2; i--; )
                        *dst++ = fb_readl(src++);
" g% m  `& Q: {% y2 v9 d                if (c & 3) {
, b( W. Z- R9 j9 T5 {) k& v# }, Q                        u8 *dst8 = (u8 *) dst;
                        u8 __iomem *src8 = (u8 __iomem *) src;

                        for (i = c & 3; i--;)
: G, N; i. B; {                                *dst8++ = fb_readb(src8++);
2 ?, C7 c/ _! ?* D) ]
                        src = (u32 __iomem *) src8;
. m8 D; V0 {) |5 i                }
+ d7 O6 f) K9 L6 W4 o
                if (copy_to_user(buf, buffer, c)) {
                        err = -EFAULT;
2 @& O. c+ o, M! u) u                        break;
. @. `1 K' G3 \2 s1 `, {                }
& o( r: n  I/ a& E7 X$ N                *ppos += c;
                buf += c;
                cnt += c;
! q/ A6 p+ R. U7 `& Y                count -= c;
: B& J- }" Q4 p$ h" ?$ k5 _        }

; D/ I* Z# N" j6 |7 e( P: g        kfree(buffer);
/ J( ]  @, ?/ m, M( N' R3 C7 ^) }$ K
" Q8 ]: [% `0 i! n        return (err) ? err : cnt;
% z2 j- Y9 v  \4 s$ |2 d5 q- d9 Y}
3.4.5 ioctl方法
这里只是简单的看下ioctl方法，这个函数调用很多其他的函数，详细的请自己看吧。
1 B9 f5 f# _; H, G3 U
7 U4 E+ c" r5 ]下列代码位于drivers/video/fbmem.c

2 K; Z6 [( f/ O+ r+ E( a& estatic long fb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
$ \$ S" Z  m5 e) R. U8 y        /*获取inode，再获取对应的fb_info*/
        struct inode *inode = file->f_path.dentry->d_inode;
3 Y- Y" E- d( U( J* _        int fbidx = iminor(inode);       
        struct fb_info *info = registered_fb[fbidx];
6 t/ t5 D, K2 d! |8 X/ I
# a) f  V. |& D$ w        return do_fb_ioctl(info, cmd, arg);
}

static long do_fb_ioctl(struct fb_info *info, unsigned int cmd,
            unsigned long arg)
{
- D" c1 s& |- ^# ]4 v' B& W    struct fb_ops *fb;
" r2 B3 p5 ~/ X    struct fb_var_screeninfo var;
    struct fb_fix_screeninfo fix;
    struct fb_con2fbmap con2fb;
3 a8 T8 @$ H# x$ Z- z* K) }    struct fb_cmap cmap_from;
/ x" N" m% P! q. ^) j1 h% q    struct fb_cmap_user cmap;
    struct fb_event event;
; n5 V3 m; H" s3 n) Z    void __user *argp = (void __user *)arg;
$ E2 v; O+ {8 k8 r$ v    long ret = 0;

' F! L0 v' J) n/ R( O; W  `. S    switch (cmd) {
( [( P4 g$ U7 z# B: P2 F    /*获取fb_var_screeninfo*/
% @* t$ E6 V- J- B# y    case FBIOGET_VSCREENINFO:   
        if (!lock_fb_info(info))    /*加锁互斥体info->lock*/
  n4 ?' _1 w3 R; N5 L            return -ENODEV;
5 \  }8 H# y1 k# A2 v        var = info->var;            /*复制var*/
: E" F! B& T) z/ ^  s4 z        unlock_fb_info(info);
5 L" ^6 c5 L5 {5 @3 r
        ret = copy_to_user(argp, &var, sizeof(var)) ? -EFAULT : 0;    /*复制var到用户空间*/
        break;
    /*设置fb_var_screeninfo*/
& z, m! f0 g+ W3 J    case FBIOPUT_VSCREENINFO:
: R/ X* L4 o2 H/ ^! w1 u0 p: `        if (copy_from_user(&var, argp, sizeof(var)))    /*从用户空间获取var*/
            return -EFAULT;
        if (!lock_fb_info(info))
            return -ENODEV;
        acquire_console_sem();
        info->flags |= FBINFO_MISC_USEREVENT;
        ret = fb_set_var(info, &var);            /*设置var*/
$ j2 ]+ ~- w' X) p1 @3 L        info->flags &= ~FBINFO_MISC_USEREVENT;
        release_console_sem();
        unlock_fb_info(info);
        if (!ret && copy_to_user(argp, &var, sizeof(var)))
            ret = -EFAULT;
        break;
    /*获取fb_fix_screeninfo*/    /*fix为不可改变信息，只能获取，不能设置*/
& ~+ c: ~- u8 }, X1 H1 j    case FBIOGET_FSCREENINFO:
$ E" s& r# w/ Y0 T* ]  L/ b5 l        if (!lock_fb_info(info))
            return -ENODEV;
% H3 y. R& g& c( h        fix = info->fix;
        unlock_fb_info(info);
- J) n9 v: f0 d9 ]# k9 S
; a) B$ ]& G. W( T' }        ret = copy_to_user(argp, &fix, sizeof(fix)) ? -EFAULT : 0;
% m% i5 Q& A( }0 P! y) V$ Z        break;
) S1 n! z' L- C+ Q+ u    /*设置fb_cmap*/   
    case FBIOPUTCMAP:
        if (copy_from_user(&cmap, argp, sizeof(cmap)))
            return -EFAULT;
; n% @2 G" F& S3 S        ret = fb_set_user_cmap(&cmap, info);    /*设置fb_cmap*/
        break;
    /*获取fb_cmap*/   
    case FBIOGETCMAP:
        if (copy_from_user(&cmap, argp, sizeof(cmap)))
% E5 I# u% D4 U0 q. d# c7 e8 o, ^            return -EFAULT;
        if (!lock_fb_info(info))
            return -ENODEV;
0 C% `6 e+ R$ I8 V+ s# f        cmap_from = info->cmap;
        unlock_fb_info(info);
        ret = fb_cmap_to_user(&cmap_from, &cmap);/*获取fb_cmp*/
1 ^; U3 G$ n7 C7 f9 F        break;
    case FBIOPAN_DISPLAY:
) Y! A9 \$ f! r& j" C% a" ?        if (copy_from_user(&var, argp, sizeof(var)))
            return -EFAULT;
4 }: U; L+ Q( O3 u. v. j4 |$ W1 @        if (!lock_fb_info(info))
# ^' Q" p1 n  p            return -ENODEV;
* F* Y- ]6 }- `6 Y$ j! {        acquire_console_sem();
        ret = fb_pan_display(info, &var);
        release_console_sem();
        unlock_fb_info(info);
        if (ret == 0 && copy_to_user(argp, &var, sizeof(var)))
            return -EFAULT;
        break;
    case FBIO_CURSOR:
        ret = -EINVAL;
        break;
    case FBIOGET_CON2FBMAP:
        if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
            return -EFAULT;
, L. y* t& U2 k, P0 U  E# R) O        if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
            return -EINVAL;
; `( m$ e7 Z1 U, B/ N. J0 l5 ]        con2fb.framebuffer = -1;
1 i4 Z  \6 K9 c& I# A- n        event.data = &con2fb;
        if (!lock_fb_info(info))
& z$ t- v, t) ?            return -ENODEV;
' K6 @4 t; P4 \9 P        event.info = info;
% W7 S, l- E5 f        fb_notifier_call_chain(FB_EVENT_GET_CONSOLE_MAP, &event);
) p, x# x5 g" x& G" |1 K        unlock_fb_info(info);
5 B0 F& x8 M' X2 U+ R% L  v        ret = copy_to_user(argp, &con2fb, sizeof(con2fb)) ? -EFAULT : 0;
  b* I( A9 r/ r! m. m1 k        break;
8 S& m$ y* u! p    case FBIOPUT_CON2FBMAP:
4 E2 x. Q1 c( ^& Z/ S" b# _* t& C        if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
% w  o. T2 B7 {# g8 G% j            return -EFAULT;
6 @' H) F' _  f% O# h* O& _        if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
            return -EINVAL;
' Y# C1 U6 {. O1 `6 p        if (con2fb.framebuffer < 0 || con2fb.framebuffer >= FB_MAX)
            return -EINVAL;
        if (!registered_fb[con2fb.framebuffer])
            request_module("fb%d", con2fb.framebuffer);
/ x& O/ u! `- C) y8 P; ?        if (!registered_fb[con2fb.framebuffer]) {
            ret = -EINVAL;
            break;
        }
( t+ t4 W3 ^* d+ u$ x        event.data = &con2fb;
/ D: w4 v7 B0 v% V; H1 F        if (!lock_fb_info(info))
) m0 r# E4 \; W6 c            return -ENODEV;
        event.info = info;
! m9 G! [* U4 _; X        ret = fb_notifier_call_chain(FB_EVENT_SET_CONSOLE_MAP, &event);
% S1 {; s. g: j) a$ b% k. U9 K" V        unlock_fb_info(info);
        break;
    case FBIOBLANK:
* F' K! M! P, V$ a        if (!lock_fb_info(info))
- J0 @: |. B/ k: A            return -ENODEV;
        acquire_console_sem();
/ v2 ]# k! m+ z8 O        info->flags |= FBINFO_MISC_USEREVENT;
5 C( g( _% R; _( S& r        ret = fb_blank(info, arg);        ?*最后调用驱动提供的s3c2410fb_blank*/
        info->flags &= ~FBINFO_MISC_USEREVENT;
        release_console_sem();
        unlock_fb_info(info);
        break;
, {# [, W" G0 r! E& A, V, @0 Y    default:
8 w. M* W2 ]% w6 V( a        if (!lock_fb_info(info))
$ R3 m5 _2 |) ^/ P2 A+ ~            return -ENODEV;
1 M$ y2 Q2 U0 o6 @. j        fb = info->fbops;
        if (fb->fb_ioctl)        /*fb_ioctl为空*/
$ y4 D3 ]$ J9 }! I6 J1 ]# l            ret = fb->fb_ioctl(info, cmd, arg);
        else
$ t1 F3 e, I$ O+ j* l7 N            ret = -ENOTTY;
% T* P8 k# ^+ _6 x, Z& E, M: S        unlock_fb_info(info);
    }
/ `) z% c. f; L* A, w    return ret;
) g; q( p/ n  t, f5 I}
* H( S8 L* @8 K  g& s5 |  b3 Q( \正如2.2小结所说的，fb_fix_screeninfo只能获取不能设置，因此，ioctl只提供了获取fb_fix_screeninfo的方法，而没有提供设置fb_fix_screeninfo的方法。

+ M* ^" G, `- R- X  }6 l  J3.5 小结
  本节对frambuffer的核心层进行了介绍。包括frambuffer子系统的创建，frambuffer的注册和提供给用户空间的5个API函数。下面开始介绍驱动层。

4 N1 w7 ^6 U  [/ Y4. 驱动层
本节将开始介绍S3C2440的frambuffer驱动，该驱动源码位于drivers/video/s3c2410fb.c
- D- v3 y# x! ~( G' {
首先来看下驱动模块的初始化和清除函数。
2 s3 l5 I6 q3 u: T; G9 V' K
! [# z. J9 M9 M8 c4 j; I, o+ ^* k/ L4.1 s3c2410fb_init和s3c2410fb_cleanup
* n/ T# z" C6 Q* j4 T' `static struct platform_driver s3c2410fb_driver = {
  ^0 |$ P; m' [    .probe        = s3c2410fb_probe,
    .remove        = s3c2410fb_remove,
    .suspend    = s3c2410fb_suspend,
    .resume        = s3c2410fb_resume,
    .driver        = {
4 E! ]- z) J1 _- X% v; c; I        .name    = "s3c2410-lcd",
' V$ N  B# z5 x0 o  W        .owner    = THIS_MODULE,
    },
};

int __init s3c2410fb_init(void)
: C! \) U% S8 _: e% S1 `- O! L7 w{
        int ret = platform_driver_register(&s3c2410fb_driver);

        if (ret == 0)
; `/ e! a) ~" ~                ret = platform_driver_register(&s3c2412fb_driver);;

        return ret;
}
2 W# _( S0 j9 F$ W! J4 J" u
' V7 k/ {: {+ c, O7 c0 _1 J  ]static void __exit s3c2410fb_cleanup(void)
{
        platform_driver_unregister(&s3c2410fb_driver);
7 V8 e, I! C' ]- K, g        platform_driver_unregister(&s3c2412fb_driver);
}

" M" J( j# @# V9 Jmodule_init(s3c2410fb_init);
module_exit(s3c2410fb_cleanup);
8 c" |- F% A, B" I: B! S$ E/ r: t
7 `! T1 |! E$ G' O% N" b) \/ ~当platform_driver_register调用的最后会调用probe方法。接下来就来看看probe方法。
6 Q3 x3 w9 @6 ^4 Z$ E6 Z5 g4.2 probe方法
4 k! C& |( W; s. C& j* \& j2 t' `struct s3c2410fb_info {
    struct device        *dev;
$ V6 K6 L3 q  \! e/ M: ]    struct clk        *clk;
  B, z9 u  z* U! S8 f* [/ O
& V( q# R% r* g  m/ m6 {& O    struct resource        *mem;
    void __iomem        *io;        /*虚拟地址*/
3 r! r! W  G3 Q# _! Q# W6 X    void __iomem        *irq_base;
# g8 R8 _# l/ p% w
    enum s3c_drv_type    drv_type;
' o4 X4 m) J# s$ }    struct s3c2410fb_hw    regs;

    unsigned int        palette_ready;
1 ?+ u( x; {$ p( Q0 u2 J
  d- ?) _  h( I4 u    /* keep these registers in case we need to re-write palette */
# L) M- i% t* E    u32            palette_buffer[256];
    u32            pseudo_pal[16];
};
; J! {3 p& @9 `: ^" n
struct s3c2410fb_mach_info {
& |9 e6 U* p" Y7 b4 v0 g6 |3 }+ d
; K  Q2 o7 p. y5 w        struct s3c2410fb_display *displays;        /* attached diplays info */
' v6 l& K# B7 Y5 k* i9 `        unsigned num_displays;                        /* number of defined displays */
        unsigned default_display;
! r2 i; W$ ?  \
$ n/ P( A. L, |# g- @! d. h" {8 u% V* P        /* GPIOs */
* i9 t& I* ?" P* ~
        unsigned long        gpcup;
: }' a" K8 U2 H        unsigned long        gpcup_mask;
; @: u& _9 r% d        unsigned long        gpccon;
        unsigned long        gpccon_mask;
        unsigned long        gpdup;
1 n' E; `, \( B6 m( @, }) e        unsigned long        gpdup_mask;
! j* I0 z( m2 R* c6 T  _: F0 [        unsigned long        gpdcon;
) l5 Y( d7 C  O/ r* [        unsigned long        gpdcon_mask;

! B! D$ W3 [- T0 x        /* lpc3600 control register */
  s  }2 A- m$ k0 c! [0 h        unsigned long        lpcsel;
};
# f- x2 r7 b# c# ^' Q* V0 N5 _
6 ?3 C! N( J: B% c( U/* LCD description */
* B6 _+ o# U2 v+ h" D8 `/ i& N0 ?struct s3c2410fb_display {
, j! [) l3 L4 w: g9 H5 q/ z& Q    /* LCD type */
9 S' B1 b/ |: R; Q% A+ u    unsigned type;

1 O$ o# t: _) Q( y2 ^- L% V    /* Screen size */
. L& P6 K' z* O/ w& w3 o    unsigned short width;
! {. M0 n9 Z. }7 {    unsigned short height;

    /* Screen info */
    unsigned short xres;
3 t' D+ Z! M9 e1 `: o    unsigned short yres;
    unsigned short bpp;
& u+ r' E  b- ^8 T
  Z- E; H7 w+ x    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) */
    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) */
2 x  ^( m" X" W    unsigned short vsync_len;    /* value in lines (TFT) or 0 (STN) */
: ~" D& `7 y! i" E5 T
    /* lcd configuration registers */
    unsigned long    lcdcon5;
};

static int __init s3c24xxfb_probe(struct platform_device *pdev,
3 l+ [" G: w# I                  enum s3c_drv_type drv_type)
4 `: U& k+ P3 _8 C7 J{
    struct s3c2410fb_info *info;
% h6 r9 ^; P9 N" A$ J! l    struct s3c2410fb_display *display;
  N- Z( ]& I% r$ g" n$ G7 E% A    struct fb_info *fbinfo;
    struct s3c2410fb_mach_info *mach_info;
/ }4 K8 P9 B, v; y& V  Q    struct resource *res;
    int ret;
9 \! i. p7 g( O- u  w% y- I1 c. p    int irq;
    int i;
& N6 v* c. }  D4 n    int size;
$ i+ f( R; h3 Z$ d9 `    u32 lcdcon1;
    /*dev.platform_data由函数s3c24xx_fb_set_platdata(mach-smdk2410.c)设置，指向s3c2410fb_mach_info*/
% I$ {1 q2 p# k    mach_info = pdev->dev.platform_data;   
1 \* \! u, `- G- \( C! Q0 G" R    if (mach_info == NULL) {
        dev_err(&pdev->dev,
8 V$ r/ G& X  ^! b2 T- ?% `+ s            "no platform data for lcd, cannot attach\n");
1 O  `( \% e6 x. _7 i* v        return -EINVAL;
    }
                                    /*在mach-smdk2440.c中，default_display=0, num_displays=1*/
- d9 p/ W. [2 D* S1 c/ l    if (mach_info->default_display >= mach_info->num_displays) {     
. ^* A6 w5 H6 i( v7 c( F, |( {        dev_err(&pdev->dev, "default is %d but only %d displays\n",
            mach_info->default_display, mach_info->num_displays);
        return -EINVAL;
    }

0 F# X% x& e4 x+ K    display = mach_info->displays + mach_info->default_display;

    irq = platform_get_irq(pdev, 0);    /*获取IRQ号,16号中断*/
0 |8 z8 |2 T  K6 r8 s    if (irq < 0) {
        dev_err(&pdev->dev, "no irq for device\n");
        return -ENOENT;
1 v6 }/ |9 W$ @& s5 U: m    }
$ W; H) q6 ~6 `( E4 F                                        /*分配struct fb_info 其中包括sizeof字节的私有数据区*/
! n! A2 F' t. p; }    fbinfo = framebuffer_alloc(sizeof(struct s3c2410fb_info), &pdev->dev);
    if (!fbinfo)
        return -ENOMEM;
, r# {; _/ |) f) J
* j. v* R! a; r6 e    platform_set_drvdata(pdev, fbinfo);    /*让platform_device->dev.driver_data指向struct fb_info*/

    info = fbinfo->par;                    /*par指向s3c2410fb_info*/
$ s5 Y1 `! y2 d- _. q. B3 v6 ^    info->dev = &pdev->dev;
. p# [: E5 _$ M0 m: F8 E    info->drv_type = drv_type;
* z) I- v/ ^% E2 P
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);/*获取平台资源*/
3 m& z& F7 I5 n) b    if (res == NULL) {
        dev_err(&pdev->dev, "failed to get memory registers\n");
        ret = -ENXIO;
        goto dealloc_fb;
    }
7 B$ d; O3 B5 y* J( j& q) w
    size = (res->end - res->start) + 1;                /*IO内存申请*/
5 a8 O, B7 e& o0 [! j5 v    info->mem = request_mem_region(res->start, size, pdev->name);   
    if (info->mem == NULL) {
' {" t, [/ }2 j( I( Z% o        dev_err(&pdev->dev, "failed to get memory region\n");
- Q3 u, [/ X" c        ret = -ENOENT;
        goto dealloc_fb;
    }
  X0 T3 R( A+ r$ i
    info->io = ioremap(res->start, size);            /*IO内存映射,获取lcd第一个寄存器的映射地址*/               
8 B% _1 D9 V) j5 [) r+ t4 i; f    if (info->io == NULL) {
        dev_err(&pdev->dev, "ioremap() of registers failed\n");        
$ j6 O; I; W- O/ a        ret = -ENXIO;   
        goto release_mem;
    }
                                            /*irq_base对应的物理地址是0X4D00 0054(寄存器LCDINTPND)*/
    info->irq_base = info->io + ((drv_type == DRV_S3C2412) ? S3C2412_LCDINTBASE : S3C2410_LCDINTBASE);

; @- `3 X" B  ^' ^% O, }( H    dprintk("devinit\n");

    strcpy(fbinfo->fix.id, driver_name);    /*复制名字*/

    /* Stop the video */
! I- d1 ]& F8 {2 @    lcdcon1 = readl(info->io + S3C2410_LCDCON1);
# [8 E5 x1 H% |4 ?, v1 {    writel(lcdcon1 & ~S3C2410_LCDCON1_ENVID, info->io + S3C2410_LCDCON1); /*禁止LCD*/
9 @: E) o& Q( d' U7 ?
    fbinfo->fix.type        = FB_TYPE_PACKED_PIXELS;
. d3 F8 @& d1 B' G, A7 k) _    fbinfo->fix.type_aux        = 0;
3 S- t$ E, U/ ?    fbinfo->fix.xpanstep        = 0;
' `! j! d  v5 q0 X. W2 f    fbinfo->fix.ypanstep        = 0;
    fbinfo->fix.ywrapstep        = 0;
& x, Y" X8 D: J1 g* s, D' s" j" r    fbinfo->fix.accel        = FB_ACCEL_NONE;    /* no hardware accelerator    */
$ s% H, T- h" `$ q
/ m+ _: z- W* D7 u+ z6 X    fbinfo->var.nonstd        = 0;
0 g- s8 i9 W5 f. d8 \0 n1 j5 B5 Y    fbinfo->var.activate        = FB_ACTIVATE_NOW;
    fbinfo->var.accel_flags     = 0;
5 Q) G( v7 P" F    fbinfo->var.vmode        = FB_VMODE_NONINTERLACED;

    fbinfo->fbops            = &s3c2410fb_ops;
    fbinfo->flags            = FBINFO_FLAG_DEFAULT;
    fbinfo->pseudo_palette      = &info->pseudo_pal;

; ~! s! u( Q5 b; I+ D9 D& H    for (i = 0; i < 256; i++)
& @( |' O, W7 C2 K        info->palette_buffer = PALETTE_BUFF_CLEAR;
8 a) y: K) e3 ~0 @0 n& u1 k
    ret = request_irq(irq, s3c2410fb_irq, IRQF_DISABLED, pdev->name, info);    /*申请IRQ，快速中断*/
  K6 v# i( w3 r+ {    if (ret) {
. n: c- V& v3 }2 p  @7 l9 {        dev_err(&pdev->dev, "cannot get irq %d - err %d\n", irq, ret);
8 ]" _4 F4 e9 g- U8 g& h        ret = -EBUSY;
        goto release_regs;
    }

    info->clk = clk_get(NULL, "lcd");        /*获取时钟信息*/
    if (!info->clk || IS_ERR(info->clk)) {
7 m0 c- N/ P: N0 M4 A) E0 ^        printk(KERN_ERR "failed to get lcd clock source\n");
3 K2 w4 ]  {5 T        ret = -ENOENT;
4 f& ~& V. `, V" z, Q  H        goto release_irq;
    }
4 n! X/ B$ ^! n1 C
    clk_enable(info->clk);                    /*使能时钟*/
    dprintk("got and enabled clock\n");
  J6 w. x" ^9 m; L3 T
$ X% b3 E! O3 u& G# x    msleep(1);

    /* find maximum required memory size for display */
- U  Y4 a# _) ]: F- t/ S    /*在多个屏幕中，找出需要的最大memory*/
' }$ z& d& r! n  a    for (i = 0; i < mach_info->num_displays; i++) {
! c) W, {* p. a6 X0 Q, E        unsigned long smem_len = mach_info->displays.xres;
! m8 q3 j; S1 {" M! z  q        /*所需的memory空间 = xres * yres * bpp / 8*/
* {( J+ a' {! X: t        smem_len *= mach_info->displays.yres;
4 W, Z$ P4 w& U5 {3 s: t        smem_len *= mach_info->displays.bpp;
        smem_len >>= 3;
        if (fbinfo->fix.smem_len < smem_len)
            fbinfo->fix.smem_len = smem_len;
/ H/ G( x  `! i+ ^% p$ V) I5 n- c    }

    /* Initialize video memory */    /*根据上面fix.smem_len的大小，获取DMA映射内存，一致性映射方式*/
% l  a6 a$ E& ~) B! v    ret = s3c2410fb_map_video_memory(fbinfo);
    if (ret) {
        printk(KERN_ERR "Failed to allocate video RAM: %d\n", ret);
        ret = -ENOMEM;
        goto release_clock;
    }
5 |( Z6 ?. x) g5 F% x
, R/ j( n! `7 {8 K- e$ r    dprintk("got video memory\n");

7 v; c- f0 `& f0 I3 a    fbinfo->var.xres = display->xres;            /*320*/
( A) D2 K/ Q7 s    fbinfo->var.yres = display->yres;            /*240*/   
! \' k: I! X- j5 l0 q* r    fbinfo->var.bits_per_pixel = display->bpp;    /*16*/

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

    s3c2410fb_check_var(&fbinfo->var, fbinfo);

    ret = register_framebuffer(fbinfo);            /*注册framebuffer*/
    if (ret < 0) {
8 q; p, a" i& }        printk(KERN_ERR "Failed to register framebuffer device: %d\n",ret);
        goto free_video_memory;
    }
' R$ W) z- a4 a5 L$ @2 N
    /* create device files */
    ret = device_create_file(&pdev->dev, &dev_attr_debug); /*添加设备属性*/
    if (ret) {
* c, ?/ i/ G  k+ b: C        printk(KERN_ERR "failed to add debug attribute\n");
+ V* Z* P0 q; R, e! r: L0 K  d$ G    }

% l: D. {  U3 \9 C: B    printk(KERN_INFO "fb%d: %s frame buffer device\n",
        fbinfo->node, fbinfo->fix.id);
5 H$ \4 b0 w/ u9 x6 I9 d$ R
$ [/ `( s) I, m$ V# i* R: E  V& P    return 0;
/*一旦某个步骤发生错误，以注册的相反顺序开始注销*/
free_video_memory:
) j1 P. x6 q$ J1 d, X2 `. Q: o    s3c2410fb_unmap_video_memory(fbinfo);
release_clock:
0 J+ k7 ^. B* u: Q% v7 z* S    clk_disable(info->clk);
1 e6 ~0 q9 p) A8 K    clk_put(info->clk);
release_irq:
    free_irq(irq, info);
release_regs:
# h; I% Q8 G8 }+ C) X" V    iounmap(info->io);
release_mem:
    release_resource(info->mem);
  p. `  c4 `+ K  a! ?1 L3 f    kfree(info->mem);
1 Q& k( q3 t9 Adealloc_fb:
    platform_set_drvdata(pdev, NULL);
    framebuffer_release(fbinfo);   
6 P0 y% R4 u3 u8 B( e    return ret;
& ?& R1 U" J% y4 O7 {8 E}
5 o( q  W# t8 R3 Q, Y. A/ Z0 W
这里使用了三个新的数据结构。s3c2410fb_info是驱动程序使用的，里面将保存所有驱动程序所要使用的资源等。而s3c2410fb_display和s3c2410fb_mach_info，是由板级信息，通过platform总线添加到内核中。
; c+ C8 ?6 x* |8 ?( q2 @  \5 x+ N
s3c2410fb_display中的成员将被复制到fb_var_screeninfo结构中。

/ Y" \* Q; L$ `+ g+ L该板级信息的定义在arch/ARM/mach-s3c2440/mach-smdk2440.c中,来看下

static struct s3c2410fb_display smdk2440_lcd_cfg __initdata = {

1 I' y- _/ w& y& {6 s        .lcdcon5        = S3C2410_LCDCON5_FRM565 |
                          S3C2410_LCDCON5_INVVLINE |
                          S3C2410_LCDCON5_INVVFRAME |
                          S3C2410_LCDCON5_PWREN |
                          S3C2410_LCDCON5_HWSWP,
. Y$ V  H$ C3 H& x
        .type                = S3C2410_LCDCON1_TFT,
+ z' z' g, y7 t% X
$ s$ z$ C, w% G8 T+ d) w. U        .width                = 320,//240,
        .height                = 240,//320,

        .pixclock        = 149000,//166667, /* HCLK 60 MHz, divisor 10 */
* u& y: D4 ^" E) h' I& U' ?: |( J) N        .xres                = 320,//240,
        .yres                = 240,//320,
4 r! G9 ?( b3 o) X' g3 `        .bpp                = 16,
        .left_margin        = 20,
# X" ^) o2 K' R) g        .right_margin        = 38,//8,
        .hsync_len        = 30,//4,
" R) _5 Z6 z$ F2 T% [9 I        .upper_margin        = 15,//8,
4 u( ~4 S% }- p* }; R' K: |        .lower_margin        = 12,//7,
        .vsync_len        = 3,//4,
0 B$ c! X0 R0 l+ v; k};
6 v6 ?: t- M( F$ x+ {  X4 J
2 B1 m- K' Y2 @( N4 Fstatic struct s3c2410fb_mach_info smdk2440_fb_info __initdata = {
' a9 N9 F9 S; [# c: l+ g  K        .displays        = &smdk2440_lcd_cfg,
        .num_displays        = 1,
4 R$ ^8 _8 e6 _- u/ ], |        .default_display = 0,

0 J1 I9 B' z/ t4 O, H+ W#if 0
        /* currently setup by downloader */
        .gpccon                = 0xaa940659,
        .gpccon_mask        = 0xffffffff,
        .gpcup                = 0x0000ffff,
        .gpcup_mask        = 0xffffffff,
        .gpdcon                = 0xaa84aaa0,
        .gpdcon_mask        = 0xffffffff,
, F! X( p. o4 A  R0 I- K        .gpdup                = 0x0000faff,
4 F! G" ]3 `. ?        .gpdup_mask        = 0xffffffff,
8 }1 I: ?; ~% r$ h, J#endif
//no
//        .lpcsel                = ((0xCE6) & ~7) | 1<<4,
. _* _5 j! ^' d- N5 a3 t};
$ G3 u( Y" J: S# P) M) v8 T& T, @/ Q
( z* U3 W9 |) H# C' Y4 _, d; b, K+ X这里NOTE：每个LCD屏幕的参数不一样，因此上面的参数会有所不同，这是需要移植的地方。
3 r2 k) q! X. M, ]0 @
随后，我们看下在probe方法中调用的几个函数。首先是s3c2410fb_map_video_memory。

/*
; w: p6 I) s0 `; t( P * s3c2410fb_map_video_memory():
*        Allocates the DRAM memory for the frame buffer.  This buffer is
0 j7 h4 W& D7 r" I *        remapped into a non-cached, non-buffered, memory region to
5 b, r: w) n6 N* n7 p *        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.
*/
3 T. H! W  k) P7 h1 ~" g- ustatic int __init s3c2410fb_map_video_memory(struct fb_info *info)
{
        struct s3c2410fb_info *fbi = info->par;
% p6 {1 H2 c; f# k        dma_addr_t map_dma;
' |& a) s3 N" g- c7 }% B        unsigned map_size = PAGE_ALIGN(info->fix.smem_len);
: x: P: F' q) C2 b& @% j  z9 o6 Y
$ X. _: f1 p6 p. ^        dprintk("map_video_memory(fbi=%p) map_size %u\n", fbi, map_size);
                /*分配DMA缓冲区，并保存DMA缓冲区虚拟地址*/
        info->screen_base = dma_alloc_writecombine(fbi->dev, map_size,
* j6 U# _$ [# N1 c                                                   &map_dma, GFP_KERNEL);
# i: y, X: D+ B; U) O
9 {" ?% a5 W0 f8 Q* ~1 A; a' `: f        if (info->screen_base) {
' n7 `8 V& e8 e6 [2 B( \                /* prevent initial garbage on screen */
5 N; h' U( g" k0 ]" R( c% }1 k                dprintk("map_video_memory: clear %p:%08x\n",
                        info->screen_base, map_size);
                memset(info->screen_base, 0x00, map_size);        /*DMA缓冲区清0*/
1 c, X3 i! D4 h# g. O  I0 K) Z
                info->fix.smem_start = map_dma;        /*保存DMA缓冲区物理地址*/

                dprintk("map_video_memory: dma=%08lx cpu=%p size=%08x\n",
                        info->fix.smem_start, info->screen_base, map_size);
        }
2 }( J3 U8 _& W3 c/ x- E
        return info->screen_base ? 0 : -ENOMEM;
5 O' f8 F$ Y% Z9 t}
; ]7 F5 [" T4 ]6 R) i

5 @+ R: j, B% P+ H该函数根据fix.smem_len的大小，分配了一个DMA缓冲区，保存了该缓冲区的物理地址和虚拟地址。
  O4 l: a4 z/ }8 o+ [: B  v7 [7 R  G
! `7 [$ c( \! P) M9 O接着是s3c2410fb_init_registers：
; _4 P! N; U! P6 V" r' d
" N; u8 w: w: h7 B- \: K7 B7 N
/*
# w3 C% g: Q; z% h * s3c2410fb_init_registers - Initialise all LCD-related registers
*/
static int s3c2410fb_init_registers(struct fb_info *info)
{
9 H7 s& K+ u0 z" n% Z    struct s3c2410fb_info *fbi = info->par;        /*par指向s3c2410fb_info*/
    struct s3c2410fb_mach_info *mach_info = fbi->dev->platform_data;
% J- I! N! k# K( T  z& D    unsigned long flags;
) L# j( Y9 q- T8 Q5 x. C: c" O    void __iomem *regs = fbi->io;
    void __iomem *tpal;
    void __iomem *lpcsel;

    if (is_s3c2412(fbi)) {
        tpal = regs + S3C2412_TPAL;
! ?" d- r9 |$ T7 c, z        lpcsel = regs + S3C2412_TCONSEL;
    } else {
        tpal = regs + S3C2410_TPAL;
        lpcsel = regs + S3C2410_LPCSEL;
* K  q% P3 O* c+ E/ L    }

2 D1 T( d# a: z0 s    /* Initialise LCD with values from haret */
8 F/ k1 x5 X  c& W( D
    local_irq_save(flags);                        /*禁止所有中断*/
# k& y, x3 F% h2 [  v
5 D& V  [- J4 ]9 k! y6 V    /* modify the gpio(s) with interrupts set (bjd) */    /*初始化io管脚*/

% V- v$ N' ]+ s; N' o% D; R( B    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);

    local_irq_restore(flags);                    /*恢复中断*/
( h( \: [9 T! A0 j+ D( e
    dprintk("LPCSEL    = 0x%08lx\n", mach_info->lpcsel);    /*设置TCONSEL，禁止LPC3600*/
    writel(mach_info->lpcsel, lpcsel);
" K! S! W6 @  l! g
4 v% V  g8 m$ I3 L    dprintk("replacing TPAL %08x\n", readl(tpal));
$ X$ B6 m  N0 g
    /* ensure temporary palette disabled */
    writel(0x00, tpal);    /*禁止调色板*/

! v' N' U8 Z; h1 |! M; S! `    return 0;
}
9 c; C4 t7 t! ~
+ |9 u/ M* v5 h  ustatic inline void modify_gpio(void __iomem *reg,
                   unsigned long set, unsigned long mask)
1 e" w. ?$ u9 i$ n5 t{
+ u" D0 K) P1 r3 S7 j2 ?6 R$ \    unsigned long tmp;
- \9 Y# o* q6 ?, I. r
    tmp = readl(reg) & ~mask;
    writel(tmp | set, reg);
}
最后是s3c2410fb_check_var：
& b1 w/ A6 U5 }! Z" h
, G# q, U, `* r* D/*
*        s3c2410fb_check_var():
*        Get the video params out of 'var'. If a value doesn't fit, round it up,
3 s; W4 y  e0 W! z% b0 g *        if it's too big, return -EINVAL.
+ F8 k& Z6 ~0 M. V4 C *        检查变量的合法性
1 k1 q$ K) ~2 s( U */
static int s3c2410fb_check_var(struct fb_var_screeninfo *var,
                               struct fb_info *info)
{
: p+ a1 n  i: E) v+ O        struct s3c2410fb_info *fbi = info->par;                        /*par指向s3c2410fb_info*/
/ o& t3 f* G3 m1 N9 g, v1 z6 U        struct s3c2410fb_mach_info *mach_info = fbi->dev->platform_data;/*指向s3c2410fb_mach_info*/
( o' p0 K6 s( Y5 @2 ?" H$ P        struct s3c2410fb_display *display = NULL;
( S+ D2 ?- Y. u5 X5 K. H: G! b        struct s3c2410fb_display *default_display = mach_info->displays +
' g+ K' |& L5 U8 q1 c$ E  F                                                    mach_info->default_display;
        int type = default_display->type;         /*S3C2410_LCDCON1_TFT*/
        unsigned i;

8 z* c" \  N6 H7 ]$ {" `        dprintk("check_var(var=%p, info=%p)\n", var, info);

        /* validate x/y resolution */
        /* choose default mode if possible */                        /*var中的成员在probe中设置*/
        if (var->yres == default_display->yres &&
            var->xres == default_display->xres &&
6 _/ Q0 g0 `0 ~4 v3 o            var->bits_per_pixel == default_display->bpp)
                display = default_display;
4 y( n/ @' C& M        else
5 ?7 ]- d9 N4 Z3 ?$ G6 m                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 &&
                            var->bits_per_pixel == mach_info->displays.bpp) {
                                display = mach_info->displays + i;
  R: D3 s% [4 m, W                                break;
                        }

        if (!display) {
3 G5 J9 p' k4 z0 v  h3 g/ h: ?                dprintk("wrong resolution or depth %dx%d at %d bpp\n",
                        var->xres, var->yres, var->bits_per_pixel);
                return -EINVAL;
1 v% ^1 A) }' X( M        }

- p% \! u( X" ^        /* it is always the size as the display */
        var->xres_virtual = display->xres;
- ]4 R% K# g& Y1 o9 G. P        var->yres_virtual = display->yres;
        var->height = display->height;
        var->width = display->width;
+ A  e: |9 v. `7 s1 o
        /* copy lcd settings */
        var->pixclock = display->pixclock;
, E$ U' a, {* k        var->left_margin = display->left_margin;
9 ~  T5 d" B% B+ b        var->right_margin = display->right_margin;
( ?% L* T7 j# Y        var->upper_margin = display->upper_margin;
$ @' I0 Y! k( e% _0 W6 C        var->lower_margin = display->lower_margin;
, J% a, M$ R' H: P2 }5 ?# D        var->vsync_len = display->vsync_len;
        var->hsync_len = display->hsync_len;
- v! m" L( b7 F! n' s( M3 v
* n3 M! c6 |( u4 m        fbi->regs.lcdcon5 = display->lcdcon5;
( j$ X3 y& t- b, |' Q9 P; Z8 }        /* set display type */
        fbi->regs.lcdcon1 = display->type;

1 @) H) _& ?; i+ x9 Y; R: Q        var->transp.offset = 0;
- W( N' c; i/ C        var->transp.length = 0;
        /* set r/g/b positions */
  p, R8 e  U6 a% ~: o% D+ K  [        switch (var->bits_per_pixel) {
& v* ]( K% T5 ^        case 1:
+ O7 [8 w# Y2 [5 R! ?        case 2:
: @1 v* r( g5 `4 {        case 4:
                var->red.offset        = 0;
9 Y' H: {# m; k$ ~9 O+ P                var->red.length        = var->bits_per_pixel;
7 f2 T7 Y$ B4 A' A                var->green        = var->red;
6 z$ U$ z- D" d1 K( t9 z; o5 j5 B                var->blue        = var->red;
) F, A( _( L5 d  _& A& o3 g! F; H                break;
6 i- {2 L7 g+ H- X        case 8:
                if (display->type != S3C2410_LCDCON1_TFT) {
5 A( y' G' {4 }1 a0 e+ n' F                        /* 8 bpp 332 */
                        var->red.length                = 3;
' ?5 L+ V( K8 z4 \                        var->red.offset                = 5;
                        var->green.length        = 3;
- F3 u+ {6 g3 @; ^                        var->green.offset        = 2;
                        var->blue.length        = 2;
" i( `9 @( M" n# e, B                        var->blue.offset        = 0;
; _$ J3 ^# g& m0 b( S% o                } else {
                        var->red.offset                = 0;
: k' x  S, H2 ~/ L! h                        var->red.length                = 8;
                        var->green                = var->red;
                        var->blue                = var->red;
                }
                break;
2 B( E) p7 g1 K        case 12:
( w2 m$ h# F) ?) ?- C5 B+ p                /* 12 bpp 444 */
                var->red.length                = 4;
                var->red.offset                = 8;
. Z4 q+ I( v8 e. K                var->green.length        = 4;
                var->green.offset        = 4;
, {3 r5 D! c% ]' R$ {* p                var->blue.length        = 4;
" F/ j/ K/ S/ f& E  |                var->blue.offset        = 0;
- m! p: p* \( u, I" o. s0 |. ]                break;
  ^9 P6 P5 `+ `
9 Z6 k* @  ?1 Z3 F  }! ?3 [        default:
        case 16:
) P) |. \+ q2 k9 _& c+ D% N* `                if (display->lcdcon5 & S3C2410_LCDCON5_FRM565) { /*使用565格式*/
                        /* 16 bpp, 565 format */
                        var->red.offset                = 11;
$ ?( r( ^# v  a6 K7 J                        var->green.offset        = 5;
' h7 S5 Q( I" z                        var->blue.offset        = 0;
                        var->red.length                = 5;
                        var->green.length        = 6;
4 F" z5 Z. ~1 t9 o) Y                        var->blue.length        = 5;
                } else {
                        /* 16 bpp, 5551 format */
                        var->red.offset                = 11;
2 d; O" D& q5 t) B8 O( k% h                        var->green.offset        = 6;
                        var->blue.offset        = 1;
, N# `1 Y* e) j# p1 `                        var->red.length                = 5;
6 D! q8 w2 A0 f) j4 Y3 y                        var->green.length        = 5;
                        var->blue.length        = 5;
8 {3 K; l: n5 k1 |0 B) g                }
                break;
        case 32:
                /* 24 bpp 888 and 8 dummy */
( u% ~1 [: Z8 k+ x- }! J5 L                var->red.length                = 8;
; x- h1 K3 ^; _7 T                var->red.offset                = 16;
                var->green.length        = 8;
                var->green.offset        = 8;
) ]  L4 U4 J) n7 A8 R) {                var->blue.length        = 8;
                var->blue.offset        = 0;
                break;
        }
        return 0;
3 w4 H  D7 p4 l$ y}

) a0 n8 o# Y2 H8 R/* 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
0 Y6 r. R# H9 d9 P& d& O * can use the offset as right argument to <<). A pixel afterwards is a bit
- ]( V; H  i+ K * stream and is written to video memory as that unmodified.
& c9 ?$ c! B& ~7 T- Y% ~0 _, j *
- u0 D2 |* _0 Y' k * 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
; o9 Z3 T: p: O  m * of available palette entries (i.e. # of entries = 1 << length).
2 L" a- p$ Y. m */
struct fb_bitfield {
    __u32 offset;            /* beginning of bitfield    */
) h3 e6 z- J. u" l+ `$ O    __u32 length;            /* length of bitfield        */
: o% E: J7 [" U- Y. j    __u32 msb_right;        /* != 0 : Most significant bit is */
/ G0 z5 v$ U1 Z" \( z& V0 d                    /* right */
- Q% Q7 B, n. z# ]! J1 R. a% {};
& {" K" r% b3 s2 i6 ?该函数主要将板级信息s3c2410fb_display复制到对应的地方，然后根据RGB的模式设置位域。
# A! H9 x0 E, ^: T4.3 fb_ops方法
7 ?: A" q6 t6 t9 c在驱动程序中，定义了fb_ops，如下：

static struct fb_ops s3c2410fb_ops = {
4 W) K# Q$ R) r) w; x1 c        .owner                = THIS_MODULE,
* r; o& ]2 k& ~        .fb_check_var        = s3c2410fb_check_var,                /*检查变量的合法性*/
        .fb_set_par        = s3c2410fb_set_par,                        /*将参数写入LCD控制器，该函数由帧缓冲核心调用*/
4 {, g3 o" H6 f' p( L        .fb_blank        = s3c2410fb_blank,                                /*该方法支持显示消隐和去消隐*/
$ ?; D" \! i  W7 f4 n+ p. w( R        .fb_setcolreg        = s3c2410fb_setcolreg,                /*设置颜色寄存器*/
6 k7 d# |8 @1 Q, R; A9 ~" W: J        .fb_fillrect        = cfb_fillrect,                                /*用像素行填充矩形框，通用库函数*/
        .fb_copyarea        = cfb_copyarea,                                /*将屏幕的一个矩形区域复制到另一个区域，通用库函数*/
        .fb_imageblit        = cfb_imageblit,                        /*显示一副图像，通用库函数*/
/ e. U( S6 X* ]" B0 f};

0 B, s- t; ]8 B& V; [其中s3c2410fb_check_var在4.2节中已经分析过了，最后三个方法是通用库函数，在这里不作分析。
# X. z. d. U% G/ C剩余三个也是驱动程序提供的，现在对这三个程序进行分析。
: ?1 T- b- q+ w4 M0 _4.3. 1 s3c2410fb_set_par
/*
*      s3c2410fb_set_par - Alters the hardware state.
*      @info: frame buffer structure that represents a single frame buffer
1 i: t( b- ]' |! g; v- f8 } *                根据var中的值设置LCD控制器的寄存器
, h% J7 L6 W+ [; N' v$ d  f */
static int s3c2410fb_set_par(struct fb_info *info)
{
        struct fb_var_screeninfo *var = &info->var;

        switch (var->bits_per_pixel) {
        case 32:
        case 16:
# e6 Q* a# a0 S! R        case 12:
/ Q; e" u) M% l( }, e  {                info->fix.visual = FB_VISUAL_TRUECOLOR;
$ u# A3 U  r8 w5 f$ H; v) p- [                break;
        case 1:
$ W0 \/ m3 Q' Q                info->fix.visual = FB_VISUAL_MONO01;
' ?" A5 l0 w* z                break;
        default:
# w9 W# ?" j$ }- `7 I8 ~% B                info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
                break;
        }

        info->fix.line_length = (var->xres_virtual * var->bits_per_pixel) / 8; /* 320*16/8 = 640Bytes */
( g" I  g$ M  s/ e: z/ l& X5 j
; z8 ?0 l! d- u8 v+ B! s        /* activate this new configuration */

        s3c2410fb_activate_var(info);
& q  z7 i2 b" a# K* |6 `        return 0;
}
" i* m' M6 C. v% j) R" f9 z8 u该函数根据像素的位数设置了视觉模式，本例为16为，使用真彩色。然后计算了每行的数据元素大小。共240行。

然后调用了s3c2410fb_activate_var来设置控制器并激活LCD。
; Z) |, s5 @( j+ B. ]
s3c2410fb_activate_var函数如下：

/* s3c2410fb_activate_var
! A( v" F. U  Y% d4 b/ M8 c *
* activate (set) the controller from the given framebuffer
* information
% S! V. C. J( H8 t */
static void s3c2410fb_activate_var(struct fb_info *info)
& W' \7 n  J/ @& X* X{
        struct s3c2410fb_info *fbi = info->par;
        void __iomem *regs = fbi->io;
# P! n6 o0 ]3 o1 K; Z! X" k/ i        int type = fbi->regs.lcdcon1 & S3C2410_LCDCON1_TFT; /*regs.lcdcon1在s3c2410fb_check_var设置*/
- y& A# c" u3 q        struct fb_var_screeninfo *var = &info->var;
9 [; o' P/ `& Z        int clkdiv = s3c2410fb_calc_pixclk(fbi, var->pixclock) / 2;
! G6 ^4 D$ ?2 Q- D3 K) f# F( n
3 ?* r$ r# e/ R0 y6 D- ~# ~        dprintk("%s: var->xres  = %d\n", __func__, var->xres);
        dprintk("%s: var->yres  = %d\n", __func__, var->yres);
8 e2 }& e/ ]4 v: ?5 k        dprintk("%s: var->bpp   = %d\n", __func__, var->bits_per_pixel);
- ]2 V+ v6 V! e0 j
; W" V# Y+ U" k9 i7 w. K% K        if (type == S3C2410_LCDCON1_TFT) {
9 [& W2 L' ^: V+ c  u6 N* {% c3 i                s3c2410fb_calculate_tft_lcd_regs(info, &fbi->regs);/*根据var，计算出控制寄存器需要设置的值*/
$ e5 j0 Z* X  m& g: `                --clkdiv;
( O" j. q0 }! F1 e                if (clkdiv < 0)
) @* W0 J8 l5 i0 {/ |% s                        clkdiv = 0;
        } else {
* b, x2 q1 t4 w$ ~6 p3 a                s3c2410fb_calculate_stn_lcd_regs(info, &fbi->regs);
                if (clkdiv < 2)
$ G1 ?! J* q/ l! i/ O! F% _                        clkdiv = 2;
        }
' J, I6 s& m2 M) }5 r/ ^
: f( p: e: g5 F7 @9 V1 ?        fbi->regs.lcdcon1 |=  S3C2410_LCDCON1_CLKVAL(clkdiv);/*设置CLKVAL*/

8 v# b6 M; m+ u, s$ Q! P        /* write new registers */
) f  w" F# Q8 W1 H# W" C5 N
3 \/ a9 l4 d: s( r* z6 [/ ?        dprintk("new register set:\n");
0 i9 s8 J) W0 E# S# b8 P% N3 m        dprintk("lcdcon[1] = 0x%08lx\n", fbi->regs.lcdcon1);
; Q# c3 o% Z2 G9 I        dprintk("lcdcon[2] = 0x%08lx\n", fbi->regs.lcdcon2);
        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);
        /*把计算好的值填入LCD控制器中*/
        writel(fbi->regs.lcdcon1 & ~S3C2410_LCDCON1_ENVID,       
9 o  z4 e% T1 e* U  t* R3 J1 y( Q; E8 p                regs + S3C2410_LCDCON1);                                                /*仍然禁止LCD*/
, q9 V5 o& @1 {) _/ \! K        writel(fbi->regs.lcdcon2, regs + S3C2410_LCDCON2);
9 U- w3 ?( U$ U1 c  X7 w% c: a        writel(fbi->regs.lcdcon3, regs + S3C2410_LCDCON3);
        writel(fbi->regs.lcdcon4, regs + S3C2410_LCDCON4);
0 W7 s/ B6 m) [) d, z" i3 t) M( o9 E        writel(fbi->regs.lcdcon5, regs + S3C2410_LCDCON5);

6 \( @1 v9 Y4 K$ c        /* set lcd address pointers */
        s3c2410fb_set_lcdaddr(info);                                                /*设置LCD帧缓冲起始地址*/

        fbi->regs.lcdcon1 |= S3C2410_LCDCON1_ENVID,
' z8 b- M! N4 ^/ _/ Q        writel(fbi->regs.lcdcon1, regs + S3C2410_LCDCON1);        /*使能LCD*/
}
- w: I! Z  Y; J2 X" a. E. ?其中调用的三个函数如下：
static unsigned int s3c2410fb_calc_pixclk(struct s3c2410fb_info *fbi,
! j! U9 _( n: \5 Y- v                      unsigned long pixclk)
7 ?  b0 [1 r, P/ s; O1 o{
    unsigned long clk = clk_get_rate(fbi->clk);         /*获取当前时钟频率(Hz)*/
2 |4 ]. |+ A* ^" F/ Q    unsigned long long div;
& I5 ~2 h( r# [$ v4 H- N# w! S8 P
    /* pixclk is in picoseconds, our clock is in Hz
# i9 \+ Y3 ]$ Y6 L     *
     * Hz -> picoseconds is / 10^-12
) i5 u  [% u6 d" Y) b# @& P     */

    div = (unsigned long long)clk * pixclk;
8 R  }, d+ X: {8 W' v$ z    div >>= 12;            /* div / 2^12 */
    do_div(div, 625 * 625UL * 625); /* div / 5^12 */
( x$ j9 r5 P$ v) \' g. e& t$ v
    dprintk("pixclk %ld, divisor is %ld\n", pixclk, (long)div);
    return div;
( S7 k, X6 O) O5 y. E}

2 |: f+ P) I" `5 U  C/* s3c2410fb_calculate_tft_lcd_regs
*
* W- r$ e7 k- T2 M * calculate register values from var settings
*/
) b( d# V6 r7 p4 g! Jstatic void s3c2410fb_calculate_tft_lcd_regs(const struct fb_info *info,
: w, f& N: J9 _                         struct s3c2410fb_hw *regs)
{
4 `7 [5 X( K& {  J    const struct s3c2410fb_info *fbi = info->par;
    const struct fb_var_screeninfo *var = &info->var;
8 v6 e7 K4 u" V- z
" L( `( V% r- f- E    switch (var->bits_per_pixel) {
    case 1:
        regs->lcdcon1 |= S3C2410_LCDCON1_TFT1BPP;
        break;
7 I6 S* k0 U) M) y+ k. T5 e8 ]    case 2:
        regs->lcdcon1 |= S3C2410_LCDCON1_TFT2BPP;
; b( r: ^/ k6 H; O% q        break;
1 r1 Z: A) w7 o6 V) x) X4 R    case 4:
6 J" B" g0 |, T9 U2 |" j  ~5 L        regs->lcdcon1 |= S3C2410_LCDCON1_TFT4BPP;
9 W. }- s, X2 W, C  Y4 {( d        break;
    case 8:
; R% p& \' t/ U9 {6 O  a# t        regs->lcdcon1 |= S3C2410_LCDCON1_TFT8BPP;
. i6 s) y5 Q  H        regs->lcdcon5 |= S3C2410_LCDCON5_BSWP |
# z9 E8 w' i  l6 K4 d6 p                 S3C2410_LCDCON5_FRM565;
7 S% E# u" F% }4 c        regs->lcdcon5 &= ~S3C2410_LCDCON5_HWSWP;
        break;
    case 16:
        regs->lcdcon1 |= S3C2410_LCDCON1_TFT16BPP;
        regs->lcdcon5 &= ~S3C2410_LCDCON5_BSWP;
        regs->lcdcon5 |= S3C2410_LCDCON5_HWSWP;
        break;
    case 32:
% q) s# e* [1 I; J        regs->lcdcon1 |= S3C2410_LCDCON1_TFT24BPP;
1 X3 k) `- i# h6 `7 S0 d% j        regs->lcdcon5 &= ~(S3C2410_LCDCON5_BSWP |
                   S3C2410_LCDCON5_HWSWP |
                   S3C2410_LCDCON5_BPP24BL);
4 {. i$ f* s9 b/ r& v8 g" I2 V, G8 S        break;
    default:
' f* A/ Q4 N0 o) ^! X        /* invalid pixel depth */
        dev_err(fbi->dev, "invalid bpp %d\n",
            var->bits_per_pixel);
0 n. d0 d* V) p+ ~2 x    }
    /* update X/Y info */
    dprintk("setting vert: up=%d, low=%d, sync=%d\n",
5 c* c4 L, A# e8 V        var->upper_margin, var->lower_margin, var->vsync_len);

    dprintk("setting horz: lft=%d, rt=%d, sync=%d\n",
6 D# y/ S3 ~; `        var->left_margin, var->right_margin, var->hsync_len);
    /*
        所有时序参数必须减1，因为在公式中:
( [5 Q. u1 p* P$ \( t        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 ) } ]
    */
    regs->lcdcon2 = S3C2410_LCDCON2_LINEVAL(var->yres - 1) |
( u+ ^$ Y; v  }( o            S3C2410_LCDCON2_VBPD(var->upper_margin - 1) |
            S3C2410_LCDCON2_VFPD(var->lower_margin - 1) |
$ ~- o1 y; u0 I& v. f            S3C2410_LCDCON2_VSPW(var->vsync_len - 1);

    regs->lcdcon3 = S3C2410_LCDCON3_HBPD(var->right_margin - 1) |
0 O6 V' G4 h* ^( |2 k            S3C2410_LCDCON3_HFPD(var->left_margin - 1) |
            S3C2410_LCDCON3_HOZVAL(var->xres - 1);

" ^1 t) e) K6 x6 Q    regs->lcdcon4 = S3C2410_LCDCON4_HSPW(var->hsync_len - 1);
# C, `& }2 F8 K- b) R0 h$ P/ R}

6 Z# |3 P& Z5 c% ^7 O1 p; \: t9 u/* s3c2410fb_set_lcdaddr
*
" `$ }! I$ W" a& d * initialise lcd controller address pointers
- f7 u7 {( z2 n. |1 K; l */
$ C" E  W! A) z) {static void s3c2410fb_set_lcdaddr(struct fb_info *info)
& v8 G( {  D1 }  y4 `# J{
        unsigned long saddr1, saddr2, saddr3;
' I9 Z* P; [; c, f, L        struct s3c2410fb_info *fbi = info->par;
# g% W) q) N6 ]+ G        void __iomem *regs = fbi->io;

        saddr1  = info->fix.smem_start >> 1;          /*帧缓冲区起始地址*/
        saddr2  = info->fix.smem_start;                       
$ B* S! u) j: ]1 r1 @) w' n        saddr2 += info->fix.line_length * info->var.yres;
) _; y; @8 N3 r8 a8 J* U        saddr2 >>= 1;                                                        /*帧缓冲区结束地址*/

$ n( G3 r$ N, d; ^% u        saddr3 = S3C2410_OFFSIZE(0) |
0 e' M& h3 @' _. Q( r, g                 S3C2410_PAGEWIDTH((info->fix.line_length / 2) & 0x3ff); /*offset = 0, pagewidth = 320*/

        dprintk("LCDSADDR1 = 0x%08lx\n", saddr1);
$ ~" y, ^9 p& k% T9 b. ^0 f        dprintk("LCDSADDR2 = 0x%08lx\n", saddr2);
        dprintk("LCDSADDR3 = 0x%08lx\n", saddr3);

        writel(saddr1, regs + S3C2410_LCDSADDR1);
        writel(saddr2, regs + S3C2410_LCDSADDR2);
        writel(saddr3, regs + S3C2410_LCDSADDR3);
1 h7 w1 `& H* _  j0 g}
s3c2410fb_calc_pixclk用于计算时钟频率。
# L9 h' t5 y# U
s3c2410fb_calculate_tft_lcd_regs设置了LCD的控制寄存器。

. S: e. F3 B5 M, O' @' T' _s3c2410fb_set_lcdaddr设置了LCD的地址寄存器，该寄存器的设置请参考datasheet。

7 Y& w  @( S. }& H. C0 g; L4.3. 2 s3c2410fb_blank
/ ]- z$ t! z" j该方法完成消隐功能。

2 g" v/ d( |( E/*
*      s3c2410fb_blank
*        @blank_mode: the blank mode we want.
% E* c$ y& ^' u- _6 o *        @info: frame buffer structure that represents a single frame buffer
8 m0 K& S& S* r% G, Q  s *
*        Blank the screen if blank_mode != 0, else unblank. Return 0 if
*        blanking succeeded, != 0 if un-/blanking failed due to e.g. a
2 z$ E* |, W% l4 l. y. f4 {+ v9 q *        video mode which doesn't support it. Implements VESA suspend
/ w& ]0 l# h  S) K- U* H *        and powerdown modes on hardware that supports disabling hsync/vsync:
*
2 z2 J0 ~) p, o' E0 }$ s0 [( B" g *        Returns negative errno on error, or zero on success.
' n& c1 n" S' d" p+ L *
*/
. m: x. R  ?) m- q+ zstatic int s3c2410fb_blank(int blank_mode, struct fb_info *info)
  ]  T0 T( Q/ g/ s0 f{
' J0 w1 B* ^2 n* O& N$ u  u! Z    struct s3c2410fb_info *fbi = info->par;
    void __iomem *tpal_reg = fbi->io;
* P9 S6 h5 v1 D& o4 s, n
    dprintk("blank(mode=%d, info=%p)\n", blank_mode, info);

    tpal_reg += is_s3c2412(fbi) ? S3C2412_TPAL : S3C2410_TPAL;
/ `7 }5 j8 ]) F
+ z0 D! [1 Q; \9 {4 s: b    if (blank_mode == FB_BLANK_POWERDOWN) {    /*消隐*/
        s3c2410fb_lcd_enable(fbi, 0);        /*禁止LCD*/
5 Y( a1 T% Y9 m9 w    } else {
* ?9 Y# A- Z$ y7 }$ R) Z        s3c2410fb_lcd_enable(fbi, 1);        /*启动LCD*/
    }

    if (blank_mode == FB_BLANK_UNBLANK)        /*去消隐*/
5 m0 z" h0 ^3 n+ s5 T& U; V) J/ Y        writel(0x0, tpal_reg);                /*禁止temporary palette*/
    else {                                    /*消隐*/
        dprintk("setting TPAL to output 0x000000\n");
        writel(S3C2410_TPAL_EN, tpal_reg);    /*使能temporary palette，颜色为黑色*/
& A% g2 A% R) H    }
' A. k$ ~$ }: I
# t8 _7 |: O9 v( C/ ^+ `: {    return 0;
6 U+ \9 c& J! u/ M6 V) _. d' t& T}
  w$ x' z% k/ T& y" Z# I3 i在消隐时，屏幕将全黑。

" L$ \, e- `4 r4.3.3 s3c2410fb_setcolreg
0 @9 M8 T; Q( Q1 L  e8 F该函数的功能用于设置LCD的调色板。调色板的概念请看我的转帖：LCD调色板。
. n- A$ X# b3 ?7 s7 Q; W1 ~
" }8 H4 G+ V" Y0 z5 U+ r" c9 T2 \static int s3c2410fb_setcolreg(unsigned regno,
2 u8 j2 G; {/ r& D                   unsigned red, unsigned green, unsigned blue,
9 Q3 J) I) P# _. U                   unsigned transp, struct fb_info *info)
{
    struct s3c2410fb_info *fbi = info->par;    /*par指向s3c2410fb_info*/
2 z7 j, e. d- W3 u( A    void __iomem *regs = fbi->io;
9 y0 h0 d8 h8 Z5 b+ u9 n    unsigned int val;

! o! ~! N$ c, w7 b) y    /* dprintk("setcol: regno=%d, rgb=%d,%d,%d\n",
           regno, red, green, blue); */

9 L; K( S9 d% D7 X) H9 \# w7 K" L: @8 t    switch (info->fix.visual) {   
% g- \. t& M# R/ j    case FB_VISUAL_TRUECOLOR:    /*使用真彩色*/
- l9 I" c% F; O! P- u2 G, f        /* true-colour, use pseudo-palette */

        if (regno < 16) {    /*16种颜色，为什么只用16种颜色???????????*/
8 r* h+ ^2 w; z! G2 {" j: N            u32 *pal = info->pseudo_palette;

            val  = chan_to_field(red,   &info->var.red);
            val |= chan_to_field(green, &info->var.green);
8 o/ @7 S, e" u% D" _8 H1 F            val |= chan_to_field(blue,  &info->var.blue);

# V0 c. R& L1 x" _! v4 w! M! R            pal[regno] = val;    /*保存颜色值*/
        }
        break;

    case FB_VISUAL_PSEUDOCOLOR:
        if (regno < 256) {
            /* currently assume RGB 5-6-5 mode */
# a% Z5 y' V) g- Y
            val  = (red   >>  0) & 0xf800;
            val |= (green >>  5) & 0x07e0;
. {* C, y" \+ E3 n- s            val |= (blue  >> 11) & 0x001f;
, i& j1 ]) t! |6 G4 q8 v: W6 W
* m0 \5 w! `: S            writel(val, regs + S3C2410_TFTPAL(regno));
# }+ D2 ?% t# N8 ?3 v" P8 T7 M            schedule_palette_update(fbi, regno, val);
        }

7 U. n: {; s/ `6 [        break;
  r$ y  X9 U8 U0 b* E
    default:
        return 1;    /* unknown type */
    }

    return 0;
" S# i; t4 e) a; {2 P}
/* from pxafb.c */
static inline unsigned int chan_to_field(unsigned int chan,
                     struct fb_bitfield *bf)
; b4 q4 d% I* Y1 F{   
7 S* H$ Q; r2 T7 P8 q    /*下面用到的length和offset在s3c2410fb_check_var函数中设置*/
$ X* N$ p7 {" W) p, q! y7 a    chan &= 0xffff;                /*取低16位*/
/ F. l6 ?+ g- Z    chan >>= 16 - bf->length;   /*取第length为到16位为有效位*/
    return chan << bf->offset;    /*移动到相应的位置。*/
. Y2 o: e/ a  U8 F0 _6 f}
我们使用的是真彩色，可以设置16种颜色，颜色的位域值通过调用chan_to_field获得，然后保存了颜色的值。但是比较奇怪的是，这里并没有将值保存到0x4d000400为起始的内存中，不知为何。 反而倒是在伪彩色模式下， 使用了writel(val, regs + S3C2410_TFTPAL(regno))写到内存中，然后调用schedule_palette_update函数来更新palette表。我们来看下。
! W2 S% v% s. o! c, ?- r6 _
% M% e( R* z, _! k# X7 Zstatic void schedule_palette_update(struct s3c2410fb_info *fbi,
                                    unsigned int regno, unsigned int val)
8 P9 R& Z7 r% d2 S: I" u{
$ M7 b$ k) L  s/ H8 {        unsigned long flags;
        unsigned long irqen;
: T5 P$ Y8 T' ^& M        void __iomem *irq_base = fbi->irq_base;

/ ^. O6 @8 |& A+ U" w: V% h        local_irq_save(flags);
* a: ^2 |0 i2 y/ C) G. m7 }3 N% Q2 t
4 s8 ~% W7 {/ C) F, V" n3 V- E        fbi->palette_buffer[regno] = val;
( Y8 }+ o& W' E+ p
6 }% f0 c, B* |( y        if (!fbi->palette_ready) {
; I9 A2 Y! O* C# [                fbi->palette_ready = 1;
/ h/ }! Q0 b( Q* W. G& n% d
) T1 y1 I, s  o) f) i2 A                /* enable IRQ */
9 `7 V7 P6 h" i1 Y8 t* B                irqen = readl(irq_base + S3C24XX_LCDINTMSK);
                irqen &= ~S3C2410_LCDINT_FRSYNC;
                writel(irqen, irq_base + S3C24XX_LCDINTMSK);
% T( T+ ^) L( l0 J8 A" V. k" ?. O        }
3 Q5 @2 Z# W# X8 H0 ~
        local_irq_restore(flags);
}
这个函数的作用就是开启了LCD的帧同步中断，这个中断在VSYNC信号从无效变成有效时产生。当中断产生时，会调用在probe方法中注册的ISR。ISR如下：
static irqreturn_t s3c2410fb_irq(int irq, void *dev_id)
{
% j3 M( T9 d5 U6 J        struct s3c2410fb_info *fbi = dev_id;
        void __iomem *irq_base = fbi->irq_base;
        unsigned long lcdirq = readl(irq_base + S3C24XX_LCDINTPND);
b
        if (lcdirq & S3C2410_LCDINT_FRSYNC) {
                if (fbi->palette_ready)
" r5 n, }5 Z/ f% [3 O1 T                        s3c2410fb_write_palette(fbi);

                writel(S3C2410_LCDINT_FRSYNC, irq_base + S3C24XX_LCDINTPND);
                writel(S3C2410_LCDINT_FRSYNC, irq_base + S3C24XX_LCDSRCPND);
: r7 d4 e. M/ F# x        }
; w, N' w) g! B8 A. ?; H! a% ?) ~
* S, L4 b' M- d+ i4 h        return IRQ_HANDLED;
}
$ M# }- ^7 f8 {8 Q7 M; a
static void s3c2410fb_write_palette(struct s3c2410fb_info *fbi)
) Z+ ^% \  o( r+ ]{
; f' _0 X& [+ w- A& h8 }    unsigned int i;
5 U* A5 O- {2 H* o    void __iomem *regs = fbi->io;

; n  x' w" ^+ e8 d) w. ^    fbi->palette_ready = 0;  /*清除ready标志*/
' E& i+ O0 X8 d* @/ O* ]' \, Q) u  a
    for (i = 0; i < 256; i++) {
" I; `; I" u. {! d$ X        unsigned long ent = fbi->palette_buffer;
        if (ent == PALETTE_BUFF_CLEAR)
$ N$ t+ [, g5 y3 [+ q; E            continue;

        writel(ent, regs + S3C2410_TFTPAL(i));
) k2 Y- D# R2 S  l3 l# X' G
, k, y% S" h; b1 p0 D5 v* u+ C& `        /* it seems the only way to know exactly
         * if the palette wrote ok, is to check
         * to see if the value verifies ok
% F; [) A1 D8 Y/ K/ ^         */
8 _4 |9 R8 y+ o. l
        if (readw(regs + S3C2410_TFTPAL(i)) == ent)
" \) D& x, E1 _- G8 |' ^            fbi->palette_buffer = PALETTE_BUFF_CLEAR;
/ J# p" A0 f/ h- J+ ?2 F/ f& d        else
# p7 M% k" n& n$ i) }1 g            fbi->palette_ready = 1;   /* retry */
    }
$ j( `* }, w7 a$ W}
在中断函数中调用了s3c2410fb_write_palette，该函数对写入内存的颜色值进行检查。如果确认其已经写入，则将palette_buffer中的清除，否则retry。
/ C( M0 l& W$ r1 k! a
$ O+ F" {6 g& _* n: x  ^3 b5. 总结
, D: m; G: x4 ^. _$ S3 x6 x# h* \/ H本文对frambuffer子系统做了简单的介绍。frambuffer子系统的函数相当之多，在这里是不可能一一介绍的。本文首先介绍了主要的数据结构，

随后分析了frambuffer核心层，在核心层简单的分析了5个API函数，接着，对驱动层做了介绍，驱动层的大多数函数都给出了分析。

* h1 |  B& v( X3 V& e




7 y$ r. L  b3 x$ q4 {' d

2 J2 z. F% y7 N9 J8 D6 K& @1 L

SsaaM7

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