S3C2440上LCD驅動 (FrameBuffer)執行個體開發講解

一、開發環境

• 主  機：VMWare--Fedora 9
• 開發闆：Mini2440--64MB Nand, Kernel:2.6.30.4
• 編譯器：arm-linux-gcc-4.3.2

二、背景知識

1. LCD工作的硬體需求：    要使一塊LCD正常的顯示文字或圖像，不僅需要LCD驅動器，而且還需要相應的LCD控制器。在通常情況下，生産廠商把LCD驅動器會以COF/COG的形式與LCD玻璃基闆制作在一起，而LCD控制器則是由外部的電路來實作，現在很多的MCU内部都內建了LCD控制器，如S3C2410/2440等。通過LCD控制器就可以産生LCD驅動器所需要的控制信号來控制STN/TFT屏了。   2. S3C2440内部LCD控制器結構圖：

我們根據資料手冊來描述一下這個內建在S3C2440内部的LCD控制器： a：LCD控制器由REGBANK、LCDCDMA、TIMEGEN、VIDPRCS寄存器組成； b：REGBANK由17個可程式設計的寄存器組和一塊256*16的調色闆記憶體組成，它們用來配置LCD控制器的； c：LCDCDMA是一個專用的DMA，它能自動地把在偵記憶體中的視訊資料傳送到LCD驅動器，通過使用這個DMA通道，視訊資料在不需要 CPU的幹預的情況下顯示在LCD屏上； d：VIDPRCS接收來自LCDCDMA的資料，将資料轉換為合适的資料格式，比如說4/8位單掃，4位雙掃顯示模式，然後通過資料端口 VD[23:0]傳送視訊資料到LCD驅動器； e：TIMEGEN由可程式設計的邏輯組成，他生成LCD驅動器需要的控制信号，比如VSYNC、HSYNC、VCLK和LEND等等，而這些控制信号又與REGBANK寄存器組中的LCDCON1/2/3/4/5的配置密切相關，通過不同的配置，TIMEGEN就能産生這些信号的不同形态，進而支援不同的LCD驅動器(即不同的STN/TFT屏)。   3. 常見TFT屏工作時序分析：

LCD提供的外部接口信号：

VSYNC/VFRAME /STV： 垂直同步信号(TFT)/幀同步信号(STN)/SEC TFT信号； HSYNC/VLINE/CPV： 水準同步信号(TFT)/行同步脈沖信号(STN)/SEC TFT信号； VCLK/LCD_HCLK： 象素時鐘信号(TFT/STN)/SEC TFT信号； VD[23:0]： LCD 像素資料輸出端口(TFT/STN/SEC TFT)； VDEN/VM/TP： 資料使能信号(TFT)/LCD驅動交流偏置信号(STN)/SEC TFT 信号； LEND/STH： 行結束信号(TFT)/SEC TFT信号； LCD_LPCOE： SEC TFT OE信号； LCD_LPCREV： SEC TFT REV信号； LCD_LPCREVB： SEC TFT REVB信号。

  所有顯示器顯示圖像的原理都是從上到下，從左到右的。這是什麼意思呢？這麼說吧，一副圖像可以看做是一個矩形，由很多排列整齊的點一行一行組成，這些點稱之為像素。那麼這幅圖在LCD上的顯示原理就是：

A： 顯示指針從矩形左上角的第一行第一個點開始，一個點一個點的在LCD上顯示，在上面的時序圖上用時間線表示就為VCLK，我們稱之為像素時鐘信号； B： 當顯示指針一直顯示到矩形的右邊就結束這一行，那麼這一行的動作在上面的時序圖中就稱之為1 Line； C： 接下來顯示指針又回到矩形的左邊從第二行開始顯示，注意，顯示指針在從第一行的右邊回到第二行的左邊是需要一定的時間的，我們稱之為行切換； D： 如此類推，顯示指針就這樣一行一行的顯示至矩形的右下角才把一副圖顯示完成。是以，這一行一行的顯示在時間線上看，就是時序圖上的HSYNC； E： 然而，LCD的顯示并不是對一副圖像快速的顯示一下，為了持續和穩定的在LCD上顯示，就需要切換到另一幅圖上(另一幅圖可以和上一副圖一樣或者不一樣，目的隻是為了将圖像持續的顯示在LCD上)。那麼這一副一副的圖像就稱之為幀，在時序圖上就表示為1 Frame，是以從時序圖上可以看出1 Line隻是1 Frame中的一行； F： 同樣的，在幀與幀切換之間也是需要一定的時間的，我們稱之為幀切換，那麼LCD整個顯示的過程在時間線上看，就可表示為時序圖上的VSYNC。

  上面時序圖上各時鐘延時參數的含義如下：(這些參數的值，LCD産生廠商會提供相應的資料手冊)

VBPD(vertical back porch)： 表示在一幀圖像開始時，垂直同步信号以後的無效的行數，對應驅動中的 upper_margin； VFBD(vertical front porch)： 表示在一幀圖像結束後，垂直同步信号以前的無效的行數，對應驅動中的lower_margin； VSPW(vertical sync pulse width)： 表示垂直同步脈沖的寬度，用行數計算，對應驅動中的vsync_len； HBPD(horizontal back porch)： 表示從水準同步信号開始到一行的有效資料開始之間的VCLK的個數，對應驅動中的 left_margin； HFPD(horizontal front porth)： 表示一行的有效資料結束到下一個水準同步信号開始之間的VCLK的個數，對應驅動中的 right_margin； HSPW(horizontal sync pulse width)： 表示水準同步信号的寬度，用VCLK計算，對應驅動中的hsync_len；

  對于以上這些參數的值将分别儲存到REGBANK寄存器組中的LCDCON1/2/3/4/5寄存器中：(對寄存器的操作請檢視S3c2440 資料手冊LCD部分)

LCDCON1：17 - 8位CLKVAL           6 - 5位掃描模式(對于STN屏:4位單/雙掃、8位單掃)           4 - 1位色位模式(1BPP、8BPP、16BPP等) LCDCON2：31 - 24位VBPD          23 - 14位LINEVAL          13 - 6位VFPD           5 - 0位VSPW LCDCON3：25 - 19位HBPD          18 - 8位HOZVAL           7 - 0位HFPD LCDCON4： 7 - 0位HSPW LCDCON5：

  4. 幀緩沖(FrameBuffer)：    幀緩沖是Linux為顯示裝置提供的一個接口，它把一些顯示裝置描述成一個緩沖區，允許應用程式通過 FrameBuffer定義好的接口通路這些圖形裝置，進而不用去關心具體的硬體細節。對于幀緩沖裝置而言，隻要在顯示緩沖區與顯示點對應的區域寫入顔色值，對應的顔色就會自動的在螢幕上顯示。下面來看一下在不同色位模式下緩沖區與顯示點的對應關系：

三 、幀緩沖(FrameBuffer)裝置驅動結構 ：        幀緩沖裝置為标準的字元型裝置，在Linux中主裝置号29，定義在/include/linux/major.h中的 FB_MAJOR，次裝置号定義幀緩沖的個數，最大允許有32個FrameBuffer，定義在/include/linux/fb.h中的 FB_MAX，對應于檔案系統下/dev/fb%d裝置檔案。

1. 幀緩沖裝置驅動在Linux子系統中的結構如下：

我們從上面這幅圖看，幀緩沖裝置在Linux中也可以看做是一個完整的子系統，大體由fbmem.c和 xxxfb.c組成。向上給應用程式提供完善的裝置檔案操作接口(即對FrameBuffer裝置進行read、write、ioctl等操作)，接口在 Linux提供的fbmem.c檔案中實作；向下提供了硬體操作的接口，隻是這些接口Linux并沒有提供實作，因為這要根據具體的LCD控制器硬體進行設定，是以這就是我們要做的事情了(即xxxfb.c部分的實作)。

2. 幀緩沖相關的重要資料結構：

   從幀緩沖裝置驅動程式結構看，該驅動主要跟fb_info結構體有關，該結構體記錄了幀緩沖裝置的全部資訊，包括裝置的設定參數、狀态以及對底層硬體操作的函數指針。在Linux 中，每一個幀緩沖裝置都必須對應一個fb_info，fb_info在/linux/fb.h中的定義如下：(隻列出重要的一些)

struct fb_info {     int node;     int flags;     struct fb_var_screeninfo var;     struct fb_fix_screeninfo fix;     struct fb_monspecs monspecs;       struct work_struct queue ;          struct fb_pixmap pixmap;          struct fb_cmap cmap;              struct fb_videomode * mode;     # ifdef CONFIG_FB_BACKLIGHT      struct backlight_device * bl_dev;     struct mutex bl_curve_mutex;     u8 bl_curve[ FB_BACKLIGHT_LEVELS] ; # endif # ifdef CONFIG_FB_DEFERRED_IO     struct delayed_work deferred_work;     struct fb_deferred_io * fbdefio; # endif     struct fb_ops * fbops;     struct device * device;     struct device * dev;         int class_flag;      # ifdef CONFIG_FB_TILEBLITTING     struct fb_tile_ops * tileops;     unsigned long screen_size;         void * pseudo_palette;          # define FBINFO_STATE_RUNNING    0 # define FBINFO_STATE_SUSPENDED  1     u32 state;        void * fbcon_par;     void * par;      } ;

其中，比較重要的成員有struct fb_var_screeninfo var、struct fb_fix_screeninfo fix和struct fb_ops * fbops，他們也都是結構體。下面我們一個一個的來看。

fb_var_screeninfo結構體主要記錄使用者可以修改的控制器的參數，比如螢幕的分辨率和每個像素的比特數等，該結構體定義如下：

struct fb_var_screeninfo {     __u32 xres;                      __u32 yres;                      __u32 xres_virtual;                       __u32 yres_virtual;              __u32 xoffset;                   __u32 yoffset;                   __u32 bits_per_pixel;            __u32 grayscale;                 struct fb_bitfield red;          struct fb_bitfield green;        struct fb_bitfield blue;         struct fb_bitfield transp;            __u32 nonstd;                    __u32 activate;                      __u32 height;                    __u32 width;                     __u32 accel_flags;               __u32 pixclock;                  __u32 left_margin;               __u32 right_margin;              __u32 upper_margin;              __u32 lower_margin;              __u32 hsync_len;                 __u32 vsync_len;                 __u32 sync;     __u32 vmode;     __u32 rotate ;     __u32 reserved[ 5] ;           } ;

而fb_fix_screeninfo結構體又主要記錄使用者不可以修改的控制器的參數，比如螢幕緩沖區的實體位址和長度等，該結構體的定義如下：

struct fb_fix_screeninfo {     char id[ 16] ;                      unsigned long smem_start;         __u32 smem_len;                   __u32 type;                       __u32 type_aux;                   __u32 visual;                     __u16 xpanstep;                   __u16 ypanstep;                   __u16 ywrapstep;                  __u32 line_length;                unsigned long mmio_start;         __u32 mmio_len;                   __u32 accel;     __u16 reserved[ 3] ;            } ;

fb_ops結構體是對底層硬體操作的函數指針，該結構體中定義了對硬體的操作有:(這裡隻列出了常用的操作)

struct fb_ops {     struct module * owner;      //檢查可變參數并進行設定     int ( * fb_check_var) ( struct fb_var_screeninfo * var, struct fb_info * info) ;      //根據設定的值進行更新，使之有效     int ( * fb_set_par) ( struct fb_info * info) ;      //設定顔色寄存器     int ( * fb_setcolreg) ( unsigned regno, unsigned red, unsigned green,              unsigned blue, unsigned transp, struct fb_info * info) ;      //顯示空白     int ( * fb_blank) ( int blank, struct fb_info * info) ;      //矩形填充     void ( * fb_fillrect) ( struct fb_info * info, const struct fb_fillrect * rect) ;      //複制資料     void ( * fb_copyarea) ( struct fb_info * info, const struct fb_copyarea * region) ;      //圖形填充     void ( * fb_imageblit) ( struct fb_info * info, const struct fb_image * image) ; } ;

3. 幀緩沖裝置作為平台裝置：

   在S3C2440中，LCD控制器被內建在晶片的内部作為一個相對獨立的單元，是以Linux把它看做是一個平台裝置，故在核心代碼/arch/arm/plat-s3c24xx /devs.c中定義有LCD相關的平台裝置及資源，代碼如下：

//LCD控制器的資源資訊 static struct resource s3c_lcd_resource[ ] = {     [ 0] = {         . start = S3C24XX_PA_LCD , //控制器IO端口開始位址         . end = S3C24XX_PA_LCD + S3C24XX_SZ_LCD - 1 , //控制器IO端口結束位址         . flags = IORESOURCE_MEM , //辨別為 LCD控制器IO端口，在驅動中引用這個就表示引用IO端口     } ,     [ 1] = {         . start = IRQ_LCD , //LCD中斷         . end = IRQ_LCD,         . flags = IORESOURCE_IRQ , //辨別為LCD中斷     } } ; static u64 s3c_device_lcd_dmamask = 0xffffffffUL; struct platform_device s3c_device_lcd = {     . name         = "s3c2410-lcd" , //作為平台裝置的LCD裝置名     . id         = - 1,     . num_resources = ARRAY_SIZE( s3c_lcd_resource) , //資源數量     . resource     = s3c_lcd_resource , //引用上面定義的資源     . dev = {         . dma_mask = & s3c_device_lcd_dmamask,         . coherent_dma_mask = 0xffffffffUL     } } ; EXPORT_SYMBOL( s3c_device_lcd) ; //導出定義的LCD平台裝置，好在mach-smdk2440.c的 smdk2440_devices[]中添加到平台裝置清單中

   除此之外，Linux還在/arch/arm/mach-s3c2410/include/mach/fb.h中為LCD平台裝置定義了一個 s3c2410fb_mach_info結構體，該結構體主要是記錄LCD的硬體參數資訊(比如該結構體的s3c2410fb_display成員結構中就用于記錄LCD的螢幕尺寸、螢幕資訊、可變的螢幕參數、LCD配置寄存器等)，這樣在寫驅動的時候就直接使用這個結構體。下面，我們來看一下核心是如果使用這個結構體的。在/arch/arm/mach-s3c2440/mach-smdk2440.c中定義有：

//LCD硬體的配置資訊，注意這裡我使用的LCD是NEC 3.5寸TFT屏，這些參數要根據具體的LCD屏進行設定 static struct s3c2410fb_display smdk2440_lcd_cfg __initdata = {     //這個地方的設定是配置LCD寄存器5，這些宏定義在regs-lcd.h中，計算後二進制為：111111111111，然後對照資料手冊上LCDCON5的各位來看，注意是從右邊開始     . lcdcon5 = S3C2410_LCDCON5_FRM565 |                S3C2410_LCDCON5_INVVLINE |                S3C2410_LCDCON5_INVVFRAME |                S3C2410_LCDCON5_PWREN |                S3C2410_LCDCON5_HWSWP,     . type    = S3C2410_LCDCON1_TFT , //TFT 類型          . width        = 240 , //螢幕寬度     . height       = 320 , //螢幕高度     //以下一些參數在上面的時序圖分析中講到過,各參數的值請跟據具體的LCD屏資料手冊結合上面時序分析來設定     . pixclock     = 100000 , //像素時鐘     . xres         = 240 , //水準可見的有效像素     . yres         = 320 , //垂直可見的有效像素     . bpp          = 16 , //色位模式     . left_margin  = 19 , //行切換，從同步到繪圖之間的延遲     . right_margin = 36 , //行切換，從繪圖到同步之間的延遲     . hsync_len    = 5 , //水準同步的長度     . upper_margin = 1 , //幀切換，從同步到繪圖之間的延遲     . lower_margin = 5 , //幀切換，從繪圖到同步之間的延遲     . vsync_len    = 1 , //垂直同步的長度 } ; static struct s3c2410fb_mach_info smdk2440_fb_info __initdata = {     . displays        = & smdk2440_lcd_cfg , //應用上面定義的配置資訊     . num_displays    = 1,     . default_display = 0,     . gpccon          = 0xaaaa555a,//将GPC0、GPC1配置成LEND和VCLK，将GPC8-15配置成VD0-7,其他配置成普通輸出IO口     . gpccon_mask     = 0xffffffff,     . gpcup           = 0x0000ffff,//禁止GPIOC的上拉功能     . gpcup_mask      = 0xffffffff,     . gpdcon          = 0xaaaaaaaa,//将GPD0-15配置成VD8-23     . gpdcon_mask     = 0xffffffff,     . gpdup           = 0x0000ffff,//禁止GPIOD的上拉功能     . gpdup_mask      = 0xffffffff,     . lpcsel          = 0x0,//這個是三星TFT屏的參數，這裡不用 } ;

注意：可能有很多朋友不知道上面紅色部分的參數是做什麼的，其值又是怎麼設定的？其實它是跟你的開發闆LCD控制器密切相關的，看了下面兩幅圖相信就大概知道他們是幹什麼用的：

上面第一幅圖是開發闆原理圖的LCD控制器部分，第二幅圖是S3c2440資料手冊中IO端口C和IO端口D控制器部分。原理圖中使用了 GPC8-15和GPD0-15來用做LCD控制器VD0-VD23的資料端口，又分别使用GPC0、GPC1端口用做LCD控制器的LEND和VCLK 信号，對于GPC2-7則是用做STN屏或者三星專業TFT屏的相關信号。然而，S3C2440的各個IO口并不是單一的功能，都是複用端口，要使用他們首先要對他們進行配置。是以上面紅色部分的參數就是把GPC和GPD的部分端口配置成LCD控制功能模式。

   從以上講述的内容來看，要使LCD控制器支援其他的LCD屏，重要的是根據LCD的資料手冊修改以上這些參數的值。下面，我們再看一下在驅動中是如果引用到s3c2410fb_mach_info結構體的(注意上面講的是在核心中如何使用的)。在mach-smdk2440.c中有：

//S3C2440初始化函數 static void __init smdk2440_machine_init( void ) {     //調用該函數将上面定義的LCD硬體資訊儲存到平台資料中     s3c24xx_fb_set_platdata( & smdk2440_fb_info) ;          s3c_i2c0_set_platdata( NULL ) ;     platform_add_devices( smdk2440_devices, ARRAY_SIZE( smdk2440_devices) ) ;     smdk_machine_init( ) ; }

s3c24xx_fb_set_platdata定義在 plat- s3c24xx/devs.c中：

void __init s3c24xx_fb_set_platdata( struct s3c2410fb_mach_info * pd) {     struct s3c2410fb_mach_info * npd;     npd = kmalloc( sizeof ( * npd) , GFP_KERNEL) ;     if ( npd) {         memcpy ( npd, pd, sizeof ( * npd) ) ;         //這裡就是将核心中定義的s3c2410fb_mach_info結構體資料儲存到LCD平台資料中，是以在寫驅動的時候就可以直接在平台資料中擷取 s3c2410fb_mach_info結構體的資料(即LCD各種參數資訊)進行操作         s3c_device_lcd. dev. platform_data = npd;     } else {         printk( KERN_ERR "no memory for LCD platform data/n" ) ;     } }

   這裡再講一個小知識：不知大家有沒有留意，在平台裝置驅動中，platform_data可以儲存各自平台裝置執行個體的資料，但這些資料的類型都是不同的，為什麼都可以儲存？這就要看看platform_data的定義，定義在/linux/device.h中，void *platform_data是一個void類型的指針，在Linux中void可儲存任何資料類型。

四、幀緩沖(FrameBuffer)裝置驅動執行個體代碼：

①、建立驅動檔案：my2440_lcd.c，依就是驅動程式的最基本結構：FrameBuffer 驅動的初始化和解除安裝部分及其他，如下：

# include < linux/ kernel. h> # include < linux/ module. h> # include < linux/ errno . h> # include < linux/ init. h> # include < linux/ platform_device. h> # include < linux/ dma- mapping. h> # include < linux/ fb. h> # include < linux/ clk. h> # include < linux/ interrupt. h> # include < linux/ mm. h> # include < linux/slab . h> # include < linux/ delay . h> # include < asm / irq. h> # include < asm / io. h> # include < asm / div64. h> # include < mach/ regs- lcd. h> # include < mach/ regs- gpio. h> # include < mach/ fb. h> # include < linux/ pm. h> static char  driver_name[] = " my2440_lcd " ; struct my2440fb_var {     int lcd_irq_no;                struct clk * lcd_clock;          struct resource * lcd_mem;       void __iomem * lcd_base;         struct device * dev;     struct s3c2410fb_hw regs;       u32    palette_buffer[ 256] ;       u32 pseudo_pal[16];        unsigned int palette_ready;   } ; # define PALETTE_BUFF_CLEAR ( 0x80000000)      static struct platform_driver lcd_fb_driver = {     . probe     = lcd_fb_probe,                    . remove     = __devexit_p( lcd_fb_remove) ,       . suspend   = lcd_fb_suspend,                  . resume    = lcd_fb_resume,                    . driver    =     {         . name = "s3c2410-lcd" ,         . owner = THIS_MODULE,     } , } ; static int __init lcd_init( void ) {     return platform_driver_register( & lcd_fb_driver) ; } static void __exit lcd_exit( void ) {     platform_driver_unregister( & lcd_fb_driver) ; } module_init( lcd_init) ; module_exit( lcd_exit) ; MODULE_LICENSE( "GPL" ) ; MODULE_AUTHOR( "Huang Gang" ) ; MODULE_DESCRIPTION( "My2440 LCD FrameBuffer Driver" ) ;

②、LCD平台裝置各接口函數的實作：

static int __devinit lcd_fb_probe( struct platform_device * pdev) {     int i;     int ret;     struct resource * res;        struct fb_info  * fbinfo;       struct s3c2410fb_mach_info * mach_info;       struct my2440fb_var * fbvar;       struct s3c2410fb_display * display;            mach_info = pdev- > dev. platform_data;     if ( mach_info = = NULL )     {                  dev_err( & pdev- > dev, "no platform data for lcd/n" ) ;         return - EINVAL;     }          display = mach_info- > displays + mach_info- > default_display;         fbinfo = framebuffer_alloc( sizeof ( struct my2440fb_var) , & pdev- > dev) ;     if ( ! fbinfo)     {         dev_err( & pdev- > dev, "framebuffer alloc of registers failed/n" ) ;         ret = - ENOMEM ;         goto err_noirq;     }     platform_set_drvdata( pdev, fbinfo) ;          fbvar = fbinfo- > par;     fbvar- > dev = & pdev- > dev;          fbvar- > lcd_irq_no = platform_get_irq( pdev, 0) ;     if ( fbvar- > lcd_irq_no < 0)     {                  dev_err( & pdev- > dev, "no lcd irq for platform/n" ) ;         return - ENOENT;     }          res = platform_get_resource( pdev, IORESOURCE_MEM, 0) ;     if ( res = = NULL )     {                  dev_err( & pdev- > dev, "failed to get memory region resource/n" ) ;         return - ENOENT;     }          fbvar- > lcd_mem = request_mem_region( res- > start, res- > end - res- > start + 1, pdev- > name) ;     if ( fbvar- > lcd_mem = = NULL )     {                  dev_err( & pdev- > dev, "failed to reserve memory region/n" ) ;         return - ENOENT;     }          fbvar- > lcd_base = ioremap( res- > start, res- > end - res- > start + 1) ;     if ( fbvar- > lcd_base = = NULL )     {                  dev_err( & pdev- > dev, "ioremap() of registers failed/n" ) ;         ret = - EINVAL;         goto err_nomem;     }          fbvar- > lcd_clock = clk_get( NULL , "lcd" ) ;     if ( ! fbvar- > lcd_clock)     {                  dev_err( & pdev- > dev, "failed to find lcd clock source/n" ) ;         ret = - ENOENT;         goto err_nomap;     }          clk_enable( fbvar- > lcd_clock) ;          ret = request_irq( fbvar- > lcd_irq_no, lcd_fb_irq, IRQF_DISABLED, pdev- > name, fbvar) ;     if ( ret)     {                  dev_err( & pdev- > dev, "IRQ%d error %d/n" , fbvar- > lcd_irq_no, ret) ;         ret = - EBUSY;         goto err_noclk;     }                    strcpy (fbinfo ->fix .id , driver _name ) ;     fbinfo- > fix. type = FB_TYPE_PACKED_PIXELS;     fbinfo- > fix. type_aux = 0;     fbinfo- > fix. xpanstep = 0;     fbinfo- > fix. ypanstep = 0;     fbinfo- > fix. ywrapstep = 0;     fbinfo- > fix. accel = FB_ACCEL_NONE;         fbinfo - > var . nonstd           = 0 ;     fbinfo - > var . activate         = FB_ACTIVATE_NOW ;     fbinfo - > var . accel_flags      = 0 ;     fbinfo - > var . vmode            = FB_VMODE_NONINTERLACED ;     fbinfo - > var . xres             = display - > xres ;     fbinfo - > var . yres             = display - > yres ;     fbinfo - > var . bits_per_pixel   = display - > bpp ;         fbinfo - > fbops                = & my2440fb_ops ;     fbinfo - > flags               = FBINFO_FLAG_DEFAULT ;     fbinfo->pseudo_palette      = &fbvar->pseudo_pal;          for ( i = 0 ; i < 256 ; i + + )      {         fbvar - > palette_buffer [ i ] = PALETTE_BUFF_CLEAR ;      }     for ( i = 0; i < mach_info- > num_displays; i+ + )     {         unsigned long smem_len = ( mach_info- > displays[ i] . xres * mach_info- > displays[ i] . yres * mach_info- > displays[ i] . bpp) > > 3;         if ( fbinfo- > fix. smem_len < smem_len)         {             fbinfo- > fix. smem_len = smem_len;         }     }     msleep( 1) ;     my2440fb_init_registers( fbinfo) ;     my2440fb_check_var( fbinfo) ;     ret = my2440fb_map_video_memory( fbinfo) ;     if ( ret)     {         dev_err( & pdev- > dev, "failed to allocate video RAM: %d/n" , ret) ;         ret = - ENOMEM;         goto err_nofb;     }     ret = register_framebuffer( fbinfo) ;     if ( ret < 0)     {         dev_err( & pdev- > dev, "failed to register framebuffer device: %d/n" , ret) ;         goto err_video_nomem;     }     ret = device_create_file( & pdev- > dev, & dev_attr_debug) ;     if ( ret)     {         dev_err( & pdev- > dev, "failed to add debug attribute/n" ) ;     }     return 0; err_nomem:     release_resource( fbvar- > lcd_mem) ;     kfree( fbvar- > lcd_mem) ; err_nomap:     iounmap( fbvar- > lcd_base) ; err_noclk:     clk_disable( fbvar- > lcd_clock) ;     clk_put( fbvar- > lcd_clock) ; err_noirq:     free_irq( fbvar- > lcd_irq_no, fbvar) ; err_nofb:     platform_set_drvdata( pdev, NULL ) ;     framebuffer_release( fbinfo) ; err_video_nomem:     my2440fb_unmap_video_memory( fbinfo) ;     return ret; } static irqreturn_t lcd_fb_irq( int irq, void * dev_id) {     struct my2440fb_var    * fbvar = dev_id;     void __iomem * lcd_irq_base;     unsigned long lcdirq;     lcd_irq_base = fbvar- > lcd_base + S3C2410_LCDINTBASE;     lcdirq = readl( lcd_irq_base + S3C24XX_LCDINTPND) ;     if ( lcdirq & S3C2410_LCDINT_FRSYNC)     {         if ( fbvar- > palette_ready)         {             my2440fb_write_palette( fbvar) ;         }         writel( S3C2410_LCDINT_FRSYNC, lcd_irq_base + S3C24XX_LCDINTPND) ;         writel( S3C2410_LCDINT_FRSYNC, lcd_irq_base + S3C24XX_LCDSRCPND) ;     }     return IRQ_HANDLED; } static void my2440fb_write_palette( struct my2440fb_var * fbvar) {     unsigned int i;     void __iomem * regs = fbvar- > lcd_base;     fbvar- > palette_ready = 0;     for ( i = 0; i < 256; i+ + )     {         unsigned long ent = fbvar- > palette_buffer[ i] ;         if ( ent = = PALETTE_BUFF_CLEAR)         {             continue ;         }         writel( ent, regs + S3C2410_TFTPAL( i) ) ;         if ( readw( regs + S3C2410_TFTPAL( i) ) = = ent)         {             fbvar- > palette_buffer[ i] = PALETTE_BUFF_CLEAR;         }         else         {             fbvar- > palette_ready = 1;         }     } } static int my2440fb_init_registers( struct fb_info * fbinfo) {     unsigned long flags;     void __iomem * tpal;     void __iomem * lpcsel;     struct my2440fb_var    * fbvar = fbinfo- > par;     struct s3c2410fb_mach_info * mach_info = fbvar- > dev- > platform_data;     tpal = fbvar- > lcd_base + S3C2410_TPAL;     lpcsel = fbvar- > lcd_base + S3C2410_LPCSEL;     local_irq_save( flags) ;     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) ;     writel( 0x00, tpal) ;     writel( mach_info- > lpcsel, lpcsel) ;     return 0; } 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) ; } static int my2440fb_check_var( struct fb_info * fbinfo) {     unsigned i;     struct fb_var_screeninfo * var = & fbinfo- > var;     struct my2440fb_var    * fbvar = fbinfo- > par;     struct s3c2410fb_mach_info * mach_info = fbvar- > dev- > platform_data;     struct s3c2410fb_display * display = NULL ;     struct s3c2410fb_display * default_display = mach_info- > displays + mach_info- > default_display;     int type = default_display- > type;     if ( var- > yres = = default_display- > yres & &         var- > xres = = default_display- > xres & &         var- > bits_per_pixel = = default_display- > bpp)     {         display = default_display;     }     else     {         for ( i = 0; i < mach_info- > num_displays; i+ + )         {             if ( type = = mach_info- > displays[ i] . type & &              var- > yres = = mach_info- > displays[ i] . yres & &              var- > xres = = mach_info- > displays[ i] . xres & &              var- > bits_per_pixel = = mach_info- > displays[ i] . bpp)             {                 display = mach_info- > displays + i;                 break ;             }         }     }     if ( ! display)     {         return - EINVAL;     }     fbvar- > regs. lcdcon1 = display- > type;     fbvar- > regs. lcdcon5 = display- > lcdcon5;     var- > xres_virtual = display- > xres;     var- > yres_virtual = display- > yres;     var- > height = display- > height;     var- > width = display- > width;     var- > pixclock = display- > pixclock;     var- > left_margin = display- > left_margin;     var- > right_margin = display- > right_margin;     var- > upper_margin = display- > upper_margin;     var- > lower_margin = display- > lower_margin;     var- > vsync_len = display- > vsync_len;     var- > hsync_len = display- > hsync_len;     var- > transp. offset = 0;     var- > transp. length = 0;     switch ( var- > bits_per_pixel)     {         case 1:         case 2:         case 4:             var- > red. offset  = 0;             var- > red. length  = var- > bits_per_pixel;             var- > green       = var- > red;             var- > blue        = var- > red;             break ;         case 8:             if ( display- > type ! = S3C2410_LCDCON1_TFT)             {                 var- > red. length     = 3;                 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;                 var- > red. length     = 8;                 var- > green          = var- > red;                 var- > blue           = var- > red;             }             break ;         case 12:             var- > red. length         = 4;             var- > red. offset         = 8;             var- > green. length       = 4;             var- > green. offset       = 4;             var- > blue. length        = 4;             var- > blue. offset        = 0;             break ;         case 16:             if ( display- > lcdcon5 & S3C2410_LCDCON5_FRM565)             {                 var- > red. offset      = 11;                 var- > green. offset    = 5;                 var- > blue. offset     = 0;                 var- > red. length      = 5;                 var- > green. length    = 6;                 var- > blue. length     = 5;             } else {                 var- > red. offset      = 11;                 var- > green. offset    = 6;                 var- > blue. offset     = 1;                 var- > red. length      = 5;                 var- > green. length    = 5;                 var- > blue. length     = 5;             }             break ;         case 32:             var- > red. length        = 8;             var- > red. offset        = 16;             var- > green. length      = 8;             var- > green. offset      = 8;             var- > blue. length       = 8;             var- > blue. offset       = 0;             break ;     }     return 0; } static int __init my2440fb_map_video_memory( struct fb_info * fbinfo) {     dma_addr_t map_dma;     struct my2440fb_var    * fbvar = fbinfo- > par;     unsigned map_size = PAGE_ALIGN( fbinfo- > fix. smem_len) ;     fbinfo- > screen_base = dma_alloc_writecombine( fbvar- > dev, map_size, & map_dma, GFP_KERNEL) ;     if ( fbinfo- > screen_base)     {         memset ( fbinfo- > screen_base, 0x00, map_size) ;         fbinfo- > fix. smem_start = map_dma;     }     return fbinfo- > screen_base ? 0 : - ENOMEM; } static inline void my2440fb_unmap_video_memory( struct fb_info * fbinfo) {     struct my2440fb_var    * fbvar = fbinfo- > par;     unsigned map_size = PAGE_ALIGN( fbinfo- > fix. smem_len) ;     dma_free_writecombine( fbvar- > dev, map_size, fbinfo- > screen_base, fbinfo- > fix. smem_start) ; } static int __devexit lcd_fb_remove( struct platform_device * pdev) {     struct fb_info * fbinfo = platform_get_drvdata( pdev) ;     struct my2440fb_var    * fbvar = fbinfo- > par;     unregister_framebuffer( fbinfo) ;     my2440fb_lcd_enable( fbvar, 0) ;     msleep( 1) ;     my2440fb_unmap_video_memory( fbinfo) ;     platform_set_drvdata( pdev, NULL ) ;     framebuffer_release( fbinfo) ;     free_irq( fbvar- > lcd_irq_no, fbvar) ;     if (fbvar - >lcd_clock )     {         clk_disable( fbvar- > lcd_clock) ;         clk_put( fbvar- > lcd_clock) ;         fbvar- > lcd_clock = NULL ;     }     iounmap( fbvar- > lcd_base) ;     release_resource( fbvar- > lcd_mem) ;     kfree( fbvar- > lcd_mem) ;     return 0; } static void my2440fb_lcd_enable( struct my2440fb_var * fbvar, int enable) {     unsigned long flags;     local_irq_save( flags) ;     if ( enable)     {         fbvar- > regs. lcdcon1 | = S3C2410_LCDCON1_ENVID;     }     else     {         fbvar- > regs. lcdcon1 & = ~ S3C2410_LCDCON1_ENVID;     }     writel( fbvar- > regs. lcdcon1, fbvar- > lcd_base + S3C2410_LCDCON1) ;     local_irq_restore( flags) ; } # ifdef CONFIG_PM static int lcd_fb_suspend( struct platform_device * pdev, pm_message_t state) {     struct fb_info * fbinfo = platform_get_drvdata(p dev) ;     struct my2440fb_var    * fbvar = fbinfo- > par;     my2440fb_lcd_enable( fbvar, 0) ;     msleep( 1) ;     clk_disable( fbvar- > lcd_clock) ;     return 0; } static  int lcd_fb_resume( struct platform_device * pdev) {     struct fb_info * fbinfo = platform_get_drvdata(p dev) ;     struct my2440fb_var    * fbvar = fbinfo- > par;     clk_enable( fbvar- > lcd_clock) ;     msleep( 1) ;     my2440fb_init_registers( fbinfo) ;     my2440fb_activate_var( fbinfo) ;     my2440fb_blank( FB_BLANK_UNBLANK, fbinfo) ;     return 0; } # else # define lcd_fb_suspend    NULL # define lcd_fb_resume    NULL # endif

③、幀緩沖裝置驅動對底層硬體操作的函數接口實作(即：my2440fb_ops的實作)：

static struct fb_ops my2440fb_ops = {     . owner          = THIS_MODULE,     . fb_check_var   = my2440fb_check_var,     . fb_set_par     = my2440fb_set_par,     . fb_blank       = my2440fb_blank,     . fb_setcolreg   = my2440fb_setcolreg,          . fb_fillrect    = cfb_fillrect,     . fb_copyarea    = cfb_copyarea,     . fb_imageblit   = cfb_imageblit, }; static int my2440fb_set_par( struct fb_info * fbinfo) {          struct fb_var_screeninfo * var = & fbinfo- > var;          switch ( var- > bits_per_pixel)     {         case 32:         case 16:         case 12:             fbinfo- > fix. visual = FB_VISUAL_TRUECOLOR;             break ;         case 1:             fbinfo- > fix. visual = FB_VISUAL_MONO01;             break ;         default :             fbinfo- > fix. visual = FB_VISUAL_PSEUDOCOLOR;             break ;     }          fbinfo- > fix. line_length = ( var- > xres_virtual * var- > bits_per_pixel) / 8;          my2440fb_activate_var( fbinfo) ;     return 0; } static void my2440fb_activate_var( struct fb_info * fbinfo) {          struct my2440fb_var * fbvar = fbinfo- > par;     void __iomem * regs = fbvar- > lcd_base;          struct fb_var_screeninfo * var = & fbinfo- > var;          int clkdiv = my2440fb_calc_pixclk( fbvar, var- > pixclock) / 2;          int type = fbvar- > regs. lcdcon1 & S3C2410_LCDCON1_TFT;     if ( type = = S3C2410_LCDCON1_TFT)     {                  my2440fb_config_tft_lcd_regs( fbinfo, & fbvar- > regs) ;         - - clkdiv;         if ( clkdiv < 0)         {             clkdiv = 0;         }     }     else     {                  my2440fb_config_stn_lcd_regs( fbinfo, & fbvar- > regs) ;         if ( clkdiv < 2)         {             clkdiv = 2;         }     }          fbvar- > regs. lcdcon1 | = S3C2410_LCDCON1_CLKVAL( clkdiv) ;          writel( fbvar- > regs. lcdcon1 & ~ S3C2410_LCDCON1_ENVID, regs + S3C2410_LCDCON1) ;     writel( fbvar- > regs. lcdcon2, regs + S3C2410_LCDCON2) ;     writel( fbvar- > regs. lcdcon3, regs + S3C2410_LCDCON3) ;     writel( fbvar- > regs. lcdcon4, regs + S3C2410_LCDCON4) ;     writel( fbvar- > regs. lcdcon5, regs + S3C2410_LCDCON5) ;          my2440fb_set_lcdaddr( fbinfo) ;     fbvar- > regs. lcdcon1 | = S3C2410_LCDCON1_ENVID,     writel( fbvar- > regs. lcdcon1, regs + S3C2410_LCDCON1) ; } static unsigned int my2440fb_calc_pixclk( struct my2440fb_var * fbvar, unsigned long pixclk) {          unsigned long clk = clk_get_rate( fbvar- > lcd_clock) ;          unsigned long long div = ( unsigned long long ) clk * pixclk;     div > > = 12;                  do_div( div , 625 * 625UL * 625) ;     return div ; } static void my2440fb_config_tft_lcd_regs( const struct fb_info * fbinfo, struct s3c2410fb_hw * regs) {     const struct my2440fb_var * fbvar = fbinfo- > par;     const struct fb_var_screeninfo * var = & fbinfo- > var;          switch ( var- > bits_per_pixel)     {         case 1:             regs- > lcdcon1 | = S3C2410_LCDCON1_TFT1BPP;             break ;         case 2:             regs- > lcdcon1 | = S3C2410_LCDCON1_TFT2BPP;             break ;         case 4:             regs- > lcdcon1 | = S3C2410_LCDCON1_TFT4BPP;             break ;         case 8:             regs- > lcdcon1 | = S3C2410_LCDCON1_TFT8BPP;             regs- > lcdcon5 | = S3C2410_LCDCON5_BSWP | S3C2410_LCDCON5_FRM565;             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:             regs- > lcdcon1 | = S3C2410_LCDCON1_TFT24BPP;             regs- > lcdcon5 & = ~ ( S3C2410_LCDCON5_BSWP | S3C2410_LCDCON5_HWSWP | S3C2410_LCDCON5_BPP24BL) ;             break ;         default :             dev_err( fbvar- > dev, "invalid bpp %d/n" , var- > bits_per_pixel) ;     }          regs- > lcdcon2 = S3C2410_LCDCON2_LINEVAL( var- > yres - 1) |             S3C2410_LCDCON2_VBPD( var- > upper_margin - 1) |             S3C2410_LCDCON2_VFPD( var- > lower_margin - 1) |             S3C2410_LCDCON2_VSPW( var- > vsync_len - 1) ;     regs- > lcdcon3 = S3C2410_LCDCON3_HBPD( var- > right_margin - 1) |             S3C2410_LCDCON3_HFPD( var- > left_margin - 1) |             S3C2410_LCDCON3_HOZVAL( var- > xres - 1) ;     regs- > lcdcon4 = S3C2410_LCDCON4_HSPW( var- > hsync_len - 1) ; } static void my2440fb_config_stn_lcd_regs( const struct fb_info * fbinfo, struct s3c2410fb_hw * regs) {     const struct my2440fb_var    * fbvar = fbinfo- > par;     const struct fb_var_screeninfo * var = & fbinfo- > var;     int type = regs- > lcdcon1 & ~ S3C2410_LCDCON1_TFT;     int hs = var- > xres > > 2;     unsigned wdly = ( var- > left_margin > > 4) - 1;     unsigned wlh = ( var- > hsync_len > > 4) - 1;     if ( type ! = S3C2410_LCDCON1_STN4)     {         hs > > = 1;     }          switch ( var- > bits_per_pixel)     {         case 1:             regs- > lcdcon1 | = S3C2410_LCDCON1_STN1BPP;             break ;         case 2:             regs- > lcdcon1 | = S3C2410_LCDCON1_STN2GREY;             break ;         case 4:             regs- > lcdcon1 | = S3C2410_LCDCON1_STN4GREY;             break ;         case 8:             regs- > lcdcon1 | = S3C2410_LCDCON1_STN8BPP;             hs * = 3;             break ;         case 12:             regs- > lcdcon1 | = S3C2410_LCDCON1_STN12BPP;             hs * = 3;             break ;         default :             dev_err( fbvar- > dev, "invalid bpp %d/n" , var- > bits_per_pixel) ;     }               if ( wdly > 3) wdly = 3;     if ( wlh > 3) wlh = 3;     regs- > lcdcon2 = S3C2410_LCDCON2_LINEVAL( var- > yres - 1) ;     regs- > lcdcon3 =  S3C2410_LCDCON3_WDLY( wdly) |             S3C2410_LCDCON3_LINEBLANK( var- > right_margin / 8) |             S3C2410_LCDCON3_HOZVAL( hs - 1) ;     regs- > lcdcon4 = S3C2410_LCDCON4_WLH( wlh) ; } static void my2440fb_set_lcdaddr( struct fb_info * fbinfo) {     unsigned long saddr1, saddr2, saddr3;     struct my2440fb_var * fbvar = fbinfo- > par;     void __iomem * regs = fbvar- > lcd_base;     saddr1 = fbinfo- > fix. smem_start > > 1;     saddr2 = fbinfo- > fix. smem_start;     saddr2 + = fbinfo- > fix. line_length * fbinfo- > var. yres;     saddr2 > > = 1;     saddr3 = S3C2410_OFFSIZE( 0) | S3C2410_PAGEWIDTH( ( fbinfo- > fix. line_length / 2) & 0x3ff) ;     writel( saddr1, regs + S3C2410_LCDSADDR1) ;     writel( saddr2, regs + S3C2410_LCDSADDR2) ;     writel( saddr3, regs + S3C2410_LCDSADDR3) ; } static int my2440fb_blank( int blank_mode, struct fb_info * fbinfo) {     struct my2440fb_var * fbvar = fbinfo- > par;     void __iomem * regs = fbvar- > lcd_base;          if ( blank_mode = = FB_BLANK_POWERDOWN)     {         my2440fb_lcd_enable( fbvar, 0) ;     }     else     {         my2440fb_lcd_enable( fbvar, 1) ;     }          if ( blank_mode = = FB_BLANK_UNBLANK)     {                  writel( 0x0, regs + S3C2410_TPAL) ;     }     else     {                  writel( S3C2410_TPAL_EN, regs + S3C2410_TPAL) ;     }     return 0; } static int my2440fb_setcolreg( unsigned regno, unsigned red, unsigned green, unsigned blue, unsigned transp, struct fb_info * fbinfo) {     unsigned int val;     struct my2440fb_var * fbvar = fbinfo- > par;     void __iomem * regs = fbvar- > lcd_base;     switch ( fbinfo- > fix. visual)     {         case FB_VISUAL_TRUECOLOR:                          if ( regno < 16)             {                 u32 * pal = fbinfo- > pseudo_palette;                 val = chan_to_field( red, & fbinfo- > var. red) ;                 val | = chan_to_field( green, & fbinfo- > var. green) ;                 val | = chan_to_field( blue, & fbinfo- > var. blue) ;                 pal[ regno] = val;             }             break ;         case FB_VISUAL_PSEUDOCOLOR:                          if ( regno < 256)             {                 val = ( red > > 0) & 0xf800;                 val | = ( green > > 5) & 0x07e0;                 val | = ( blue > > 11) & 0x001f;                 writel( val, regs + S3C2410_TFTPAL( regno) ) ;                                  schedule_palette_update( fbvar, regno, val) ;             }             break ;         default :             return 1;     }     return 0; } static inline unsigned int chan_to_field( unsigned int chan, struct fb_bitfield * bf) {     chan & = 0xffff;     chan > > = 16 - bf- > length;     return chan < < bf- > offset; } static void schedule_palette_update( struct my2440fb_var    * fbvar, unsigned int regno, unsigned int val) {     unsigned long flags;     unsigned long irqen;          void __iomem * lcd_irq_base = fbvar- > lcd_base + S3C2410_LCDINTBASE;          local_irq_save( flags) ;     fbvar- > palette_buffer[ regno] = val;          if ( ! fbvar- > palette_ready)     {         fbvar- > palette_ready = 1;                  irqen = readl( lcd_irq_base + S3C24XX_LCDINTMSK) ;         irqen & = ~ S3C2410_LCDINT_FRSYNC;         writel( irqen, lcd_irq_base + S3C24XX_LCDINTMSK) ;     }          local_irq_restore( flags) ; }

五、從整體上再描述一下FrameBuffer裝置驅動執行個體代碼的結構：   1、在第①部分代碼中主要做的事情有：    a.将LCD裝置注冊到系統平台裝置中；    b.定義LCD平台裝置結構體lcd_fb_driver。   2、在第②部分代碼中主要做的事情有：    a.擷取和設定LCD平台裝置的各種資源；    b.配置設定fb_info結構體空間；    c.初始化fb_info結構體中的各參數；    d.初始化LCD控制器；    e.檢查fb_info中可變參數；    f.申請幀緩沖裝置的顯示緩沖區空間；    g.注冊fb_info。   3、在第③ 部分代碼中主要做的事情有：    a.實作對fb_info相關參數進行檢查的硬體接口函數；    b.實作對LCD顯示模式進行設定的硬體接口函數；    c.實作對LCD顯示開關(空白)的硬體接口函數等。    

• c/c++(語言工具)(16)
• algorithm(算法)(7)
• android(30)
• Linux(36)
• wince6.0(31)
• hardware(硬體)(38)
• bootloader(引導程式)(1)
• device driver(裝置驅動)(1)
• file system(檔案系統)(1)
• OS(作業系統)(18)
• application(應用開發)(18)
• My life(生活感悟)(11)
• health(養生)(2)
• 單片機(3)