S3C2440 LCD驱动(FrameBuffer)实例开发<二>

开发板自带的LCD驱动是基于platform总线写的，所以如果要使其它的LCD能够在自己的开发板上跑起来，那么就先了解platform驱动的架构，下面简单记录下自己看platform驱动时体会，简单的说platform是一种虚拟总线，那么它也是一条总线，所以它分为3个部分，platform_bus，platform_device，platform_driver。在platform_device向platform_bus注册设备，platform_driver向platform_bus注册驱动，注册后在platform_bus中会有一条device链表和driver链表，platform_bus中match函数将匹配两者的名字，如果相同那就把驱动和设备进行绑定。Linux platform driver机制和传统的device driver机制（通过driver_register进行注册）相比，一个明显的优势在于platform机制将设备本身的资源注册进内核，由内核统一管理，在驱动中使用这些资源时通过platform device提供的标准结构进行申请并使用。这样提高了驱动和资源的独立性，并且具有较好的可移植性和安全性（这些标准接口是安全的）。下面举一个简单platform驱动的例子来分析platform_device和platform_driver是怎么联系，platform_driver是怎么使用platform_device提供硬件信息的。

led_dev.c

 

#include <linux/module.h>
#include <linux/version.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/timer.h>
#include <linux/init.h>
#include <linux/serial_core.h>
#include <linux/platform_device.h>


/* 分配/设置/注册一个platform_device */

static  struct  resource led_resource[] = {
    [0] = {
        .start = 0x56000010,             /* TQ2440的LED是GPB5,6,7,8, GPBCON地址是0x56000010 */
        .end   = 0x56000010 + 8 - 1,
        .flags = IORESOURCE_MEM,         /* 标识led控制器io端口*/
    },
    [1] = {
        .start = 5,                      /* LED1 */
        .end   = 5,
        .flags = IORESOURCE_IRQ,         /* 标识LED中断 */
    }

};
/* 必须提供realease函数，可以不实现 */
static  void  led_release( struct  device * dev)
{
}


static  struct  platform_device led_dev = {
    .name         = "myled" ,   /* 设备名 */
    .id       = -1,            /* 一般设为-1，表示同样名字的设备只有一个 */
    .num_resources    = ARRAY_SIZE(led_resource), /*  资源数量*/
    .resource     = led_resource,
    .dev = {
        .release = led_release, /* 引用上面定义的资源 */
    },
};

static  int  led_dev_init( void )
{
    platform_device_register(&led_dev); /* 注册平台设备 */
    return  0;
}

static  void  led_dev_exit( void )
{
    platform_device_unregister(&led_dev); /*  注销平台设备*/
}

module_init(led_dev_init);
module_exit(led_dev_exit);

MODULE_LICENSE( "GPL" );

 

Led_drv.c

 

#include <linux/fs.h>
#include <linux/interrupt.h
#include <linux/irq.h>
#include <linux/sched.h>
#include <linux/pm.h>
#include <linux/sysctl.h>
#include <linux/proc_fs.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/io.h>

static  int  major;
static  struct  class  *cls;
static  volatile  unsigned long  *gpio_con;
static  volatile  unsigned long  *gpio_dat;
static  int  pin;

static  int  led_open( struct  inode *inode, struct  file *file)
{
    //printk("first_drv_open\n");
    /* 配置为输出 */
    *gpio_con &= ~(0x3<<(pin*2));
    *gpio_con |= (0x1<<(pin*2));
    return  0;
}

static  ssize_t led_write( struct  file *file, const  char  __user *buf, size_t count, loff_t * ppos)
{
    int  val;

    //printk("first_drv_write\n");

    copy_from_user(&val, buf, count); //    copy_to_user();

    if  (val == 1)
    {
        // 点灯
        *gpio_dat &= ~(1<<pin);
    }
    else
    {
        // 灭灯
        *gpio_dat |= (1<<pin);
    }

    return  0;
}
static  struct  file_operations led_fops = {
    .owner  =   THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open   =   led_open,
    .write  =   led_write,
};
static  int  led_probe( struct  platform_device *pdev)
{
    struct  resource     *res;
    /* 分配/设置/注册一个platform_driver */
    /* 根据platform_device的资源进行ioremap */
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    gpio_con = ioremap(res->start, res->end - res->start + 1);
    gpio_dat = gpio_con + 1;

    res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
    pin = res->start;

    /* 注册字符设备驱动程序 */
    printk( "led_probe, found led\n" );

    /* 注册设备，生成设备文件*/
    major = register_chrdev(0, "myled" , &led_fops);
    cls = class_create(THIS_MODULE, "myled" );
    class_device_create(cls, NULL, MKDEV(major, 0), NULL, "led" ); /* /dev/led */
    return  0;
}
static  int  led_remove( struct  platform_device *pdev)
{
    /* 卸载字符设备驱动程序 */
    /* iounmap */
    printk( "led_remove, remove led\n" );
    class_device_destroy(cls, MKDEV(major, 0));
    class_destroy(cls);
    unregister_chrdev(major, "myled" );
    iounmap(gpio_con);
    return  0;
}
struct  platform_driver led_drv = {
    .probe      = led_probe,
    .remove     = led_remove,
    .driver     = {
        .name   = "myled" ,
    }
};
static  int  led_drv_init( void )
{
    platform_driver_register(&led_drv);  /* 注册平台驱动 */
    return  0;
}
static  void  led_drv_exit( void )
{
    platform_driver_unregister(&led_drv); /* 注销平台驱动 */
}
module_init(led_drv_init);
module_exit(led_drv_exit);
MODULE_LICENSE( "GPL" );

 

这就是一个简单的platform驱动，这两个文件我们完全可以写道一个文件中去实现，现在看下由一个文件如何实现这个驱动：

 

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>

static  struct  class  *seconddrv_class;
static  struct  class_device  *seconddrv_class_dev;

volatile  unsigned long  *gpfcon;
volatile  unsigned long  *gpfdat;
static  int  second_drv_open( struct  inode *inode, struct  file *file)
{
    /*
     * K1,K2,K3,K4对应GPF1、GPF4、GPF2、GPF0
     */

    /* 配置GPF1、GPF4、GPF2、GPF0为输入引脚 */
    *gpfcon &= ~((0x3<<(1*2)) | (0x3<<(4*2)) | (0x3<<(2*2)) | (0x3<<(0*2)));
    return  0;
}
ssize_t second_drv_read( struct  file *file, char  __user *buf, size_t size, loff_t *ppos)
{
    /* 返回4个引脚的电平 */
    unsigned char  key_vals[4];
    int  regval;
    if  (size != sizeof (key_vals))
        return  -EINVAL;

    regval = *gpfdat;
    key_vals[0] = (regval & (1<<1)) ? 1 : 0;
    key_vals[1] = (regval & (1<<4)) ? 1 : 0;
    key_vals[2] = (regval & (1<<2)) ? 1 : 0;
    key_vals[3] = (regval & (1<<0)) ? 1 : 0;

    copy_to_user(buf, key_vals, sizeof (key_vals));

    return  sizeof (key_vals);
}
static  struct  file_operations sencod_drv_fops = {
    .owner  =   THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open   =   second_drv_open,
    .read   =   second_drv_read,
};
int  major;
static  int  second_drv_init( void )
{
    major = register_chrdev(0, "second_drv" , &sencod_drv_fops);

    seconddrv_class = class_create(THIS_MODULE, "second_drv" );

    seconddrv_class_dev = class_device_create(seconddrv_class, NULL, MKDEV(major, 0), NULL, "buttons" ); /* /dev/buttons */

    gpfcon = ( volatile  unsigned long  *)ioremap(0x56000050, 16);
    gpfdat = gpfcon + 1;

    return  0;
}
static  void  second_drv_exit( void )
{
    unregister_chrdev(major, "second_drv" );
    class_device_unregister(seconddrv_class_dev);
    class_destroy(seconddrv_class);
    iounmap(gpfcon);
    return  0;
}
module_init(second_drv_init);
module_exit(second_drv_exit);
MODULE_LICENSE( "GPL" );

 

     由此可见，如果由platform驱动去实现led驱动将会多出很多东西，而这些多出来的就是我们如何把一个驱动程序融合到platform里面，那既然用platform驱动要多写那么多东西那问什么还要写基于platform的驱动呢？我的理解是基于以下几个原因：如果一个设备挂在总线上，其结果是配套的sysfs结点，设备电源管理都成为可能；隔离了BSP和驱动，在BSP中定义platform设备和设备使用的资源，设备的具体配置信息，而在驱动中，只要通过API去获取资源和数据，做到了板相关代码与驱动代码的分离，使得驱动具有更好的可移植性和更好的扩展性和跨平台性；假如我们要实现一个LCD驱动，那么我们只需修改BSP相关的代码，platform基本上不需修改，避免重复着轮子的可能性；基于platformplatform机制将设备本身的资源注册进内核，由内核统一管理。

    上面platform的例子还没有完全按照linux platform的标准去写，因为阅读代码可知linux platform驱动把platform_device相关的代码放在一块，然后统一进行注册！

下面记录下如何把device添加到板级文件中（最开始还是建议写成两个文件，分别编译成模块加载，因为如果是放到板级文件中那么需要重新编译内核，这个将在编译上浪费很多时间）

步骤：

1. 在/arch/arm/plat-s3c24xx/devs.c中定义led 相关的设备及资源，代码如下：

 

static  struct  resource led_resource[] = {
    [0] = {
        .start = 0x56000010,             /* TQ2440的LED是GPB5,6,7,8, GPBCON地址是0x56000010 */
        .end   = 0x56000010 + 8 - 1,
        .flags = IORESOURCE_MEM,         /* 标识led控制器io端口*/
    },
    [1] = {
        .start = 5,                      /* LED1 */
        .end   = 5,
        .flags = IORESOURCE_IRQ,         /* 标识LED中断 */
    }

};
EXPORT_SYMBOL(s3c_device_lcd);

 

请注意最后一行是导出led平台设备，会在mach-smdk2440.c中添加到平台设备列表中。

2. 如果还需定义led的其它信息，那么在/arch/arm/plat-s3c2410/include/mach/fb.h 为led平台设备定义一个s3c2410fb_mach_info结果体。led很简单所以没有必要再去定义，但是后面讲的LCD的平台设备需要定义！因为仅仅通过resource，驱动还无法操作LCD。

3. 不要实现，只是记录下系统还会做什么事！ 在mach-smdk2440.c中将会调用platform_add_devices()，注册平台设备。

好了对platform有了一定了解后，那么看看如果将LCD驱动写成linux设备模型的platform驱动，同样给出不使用platform架构是一个完整的字符设备驱动的lcd驱动，在给出一个符合platform模型的lcd驱动，通过这两个文件的对比，就可以知道在符合platform模型的lcd驱动中可以找到LCD驱动的全部信息，也会发现基本上所有plat_form驱动出了驱动本身的东西外，框架性的东西基本上一样的，所以如果理解了一两个platform驱动，那么以后写platform驱动或看platform代码跟不以flatform写出的代码是没有什么区别的！代码如下：

 

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/fb.h>
#include <linux/init.h>
#include <linux/dma-mapping.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/wait.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/div64.h>
#include <asm/mach/map.h>
#include <asm/arch/regs-lcd.h>
#include <asm/arch/regs-gpio.h>
#include <asm/arch/fb.h>
static  int  s3c_lcdfb_setcolreg(unsigned int  regno, unsigned int  red,
                 unsigned int  green, unsigned int  blue,
                 unsigned int  transp, struct  fb_info *info);
struct  lcd_regs {
    unsigned long    lcdcon1;
    unsigned long    lcdcon2;
    unsigned long    lcdcon3;
    unsigned long    lcdcon4;
    unsigned long    lcdcon5;
    unsigned long    lcdsaddr1;
    unsigned long    lcdsaddr2;
    unsigned long    lcdsaddr3;
    unsigned long    redlut;
    unsigned long    greenlut;
    unsigned long    bluelut;
    unsigned long    reserved[9];
    unsigned long    dithmode;
    unsigned long    tpal;
    unsigned long    lcdintpnd;
    unsigned long    lcdsrcpnd;
    unsigned long    lcdintmsk;
    unsigned long    lpcsel;
};

static  struct  fb_ops s3c_lcdfb_ops = {
    .owner      = THIS_MODULE,
    .fb_setcolreg   = s3c_lcdfb_setcolreg,
    .fb_fillrect    = cfb_fillrect,
    .fb_copyarea    = cfb_copyarea,
    .fb_imageblit   = cfb_imageblit,
};


static  struct  fb_info *s3c_lcd;
static  volatile  unsigned long  *gpbcon;
static  volatile  unsigned long  *gpbdat;
static  volatile  unsigned long  *gpccon;
static  volatile  unsigned long  *gpdcon;
static  volatile  unsigned long  *gpgcon;
static  volatile  struct  lcd_regs* lcd_regs;
static  u32 pseudo_palette[16];


/* from pxafb.c */
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  int  s3c_lcdfb_setcolreg(unsigned int  regno, unsigned int  red,
                 unsigned int  green, unsigned int  blue,
                 unsigned int  transp, struct  fb_info *info)
{
    unsigned int  val;

    if  (regno > 16)
        return  1;

    /* 用red,green,blue三原色构造出val */
    val  = chan_to_field(red,   &info-> var .red);
    val |= chan_to_field(green, &info-> var .green);
    val |= chan_to_field(blue,  &info-> var .blue);

    //((u32 *)(info->pseudo_palette))[regno] = val;
    pseudo_palette[regno] = val;
    return  0;
}

static  int  lcd_init( void )
{
    /* 1. 分配一个fb_info */
    s3c_lcd = framebuffer_alloc(0, NULL);

    /* 2. 设置 */
    /* 2.1 设置固定的参数 */
    strcpy(s3c_lcd->fix.id, "mylcd" );
    s3c_lcd->fix.smem_len = 480*272*32/8;        /* TQ2440的LCD位宽是24,但是2440里会分配4字节即32位(浪费1字节) */
    s3c_lcd->fix.type     = FB_TYPE_PACKED_PIXELS;
    s3c_lcd->fix.visual   = FB_VISUAL_TRUECOLOR; /* TFT */
    s3c_lcd->fix.line_length = 480*4;

    /* 2.2 设置可变的参数 */
    s3c_lcd-> var .xres           = 480;
    s3c_lcd-> var .yres           = 272;
    s3c_lcd-> var .xres_virtual   = 480;
    s3c_lcd-> var .yres_virtual   = 272;
    s3c_lcd-> var .bits_per_pixel = 32;

    /* RGB:565 */
    s3c_lcd-> var .red.offset     = 16;
    s3c_lcd-> var .red.length     = 8;
    s3c_lcd-> var .green.offset   = 8;
    s3c_lcd-> var .green.length   = 8;
    s3c_lcd-> var .blue.offset    = 0;
    s3c_lcd-> var .blue.length    = 8;
    s3c_lcd-> var .activate       = FB_ACTIVATE_NOW;
    /* 2.3 设置操作函数 */
    s3c_lcd->fbops              = &s3c_lcdfb_ops;

    /* 2.4 其他的设置 */
    s3c_lcd->pseudo_palette = pseudo_palette;
    //s3c_lcd->screen_base  = ;  /* 显存的虚拟地址 */
    s3c_lcd->screen_size   = 480*272*32/8;
    /* 3. 硬件相关的操作 */
    /* 3.1 配置GPIO用于LCD */
    gpbcon = ioremap(0x56000010, 8);
    gpbdat = gpbcon+1;
    gpccon = ioremap(0x56000020, 4);
    gpdcon = ioremap(0x56000030, 4);
    gpgcon = ioremap(0x56000060, 4);
    *gpccon  = 0xaaaaaaaa;   /* GPIO管脚用于VD[7:0],LCDVF[2:0],VM,VFRAME,VLINE,VCLK,LEND */
    *gpdcon  = 0xaaaaaaaa;   /* GPIO管脚用于VD[23:8] */
    *gpgcon |= (3<<8); /* GPG4用作LCD_PWREN */

    /* 3.2 根据LCD手册设置LCD控制器, 比如VCLK的频率等 */
    lcd_regs = ioremap(0x4D000000, sizeof ( struct  lcd_regs));
    /*
     * TQ2440 4.3英寸LCD手册为WXCAT43-TG6#001_V1.0.pdf第22、23页
     *
     * LCD手册和2440手册"Figure 15-6. TFT LCD Timing Example"一对比就知道参数含义了
     */

    /* bit[17:8]: VCLK = HCLK / [(CLKVAL+1) x 2], LCD手册P22 (Dclk=9MHz~15MHz)
     *            10MHz(100ns) = 100MHz / [(CLKVAL+1) x 2]
     *            CLKVAL = 4
     * bit[6:5]: 0b11, TFT LCD
     * bit[4:1]: 0b1101, 24 bpp for TFT
     * bit[0]  : 0 = Disable the video output and the LCD control signal.
     */
    lcd_regs->lcdcon1  = (4<<8) | (3<<5) | (0x0d<<1);
    /* 垂直方向的时间参数
     * bit[31:24]: VBPD, VSYNC之后再过多长时间才能发出第1行数据
     *             LCD手册 tvb=2
     *             VBPD=1
     * bit[23:14]: 多少行, 272, 所以LINEVAL=272-1=271
     * bit[13:6] : VFPD, 发出最后一行数据之后，再过多长时间才发出VSYNC
     *             LCD手册tvf=2, 所以VFPD=2-1=1
     * bit[5:0]  : VSPW, VSYNC信号的脉冲宽度, LCD手册tvp=10, 所以VSPW=10-1=9
     */
    lcd_regs->lcdcon2  = (1<<24) | (271<<14) | (1<<6) | (9<<0);
    /* 水平方向的时间参数
     * bit[25:19]: HBPD, VSYNC之后再过多长时间才能发出第1行数据
     *             LCD手册 thb=2
     *             HBPD=1
     * bit[18:8]: 多少列, 480, 所以HOZVAL=480-1=479
     * bit[7:0] : HFPD, 发出最后一行里最后一个象素数据之后，再过多长时间才发出HSYNC
     *             LCD手册thf=2, 所以HFPD=2-1=1
     */
    lcd_regs->lcdcon3 = (1<<19) | (479<<8) | (1<<0);
    /* 水平方向的同步信号
     * bit[7:0] : HSPW, HSYNC信号的脉冲宽度, LCD手册Thp=41, 所以HSPW=41-1=40
     */
    lcd_regs->lcdcon4 = 40;

    /* 信号的极性
     * bit[11]: 1=565 format, 对于24bpp这个不用设
     * bit[10]: 0 = The video data is fetched at VCLK falling edge
     * bit[9] : 1 = HSYNC信号要反转,即低电平有效
     * bit[8] : 1 = VSYNC信号要反转,即低电平有效
     * bit[6] : 0 = VDEN不用反转
     * bit[3] : 0 = PWREN输出0
     *
     * BSWP = 0, HWSWP = 0, BPP24BL = 0 : 当bpp=24时,2440会给每一个象素分配32位即4字节,哪一个字节是不使用的? 看2440手册P412
         * bit[12]: 0, LSB valid, 即最高字节不使用
     * bit[1] : 0 = BSWP
     * bit[0] : 0 = HWSWP
     */
    lcd_regs->lcdcon5 = (0<<10) | (1<<9) | (1<<8) | (0<<12) | (0<<1) | (0<<0);
    /* 3.3 分配显存(framebuffer), 并把地址告诉LCD控制器 */
    s3c_lcd->screen_base = dma_alloc_writecombine(NULL, s3c_lcd->fix.smem_len, &s3c_lcd->fix.smem_start, GFP_KERNEL);
    lcd_regs->lcdsaddr1  = (s3c_lcd->fix.smem_start >> 1) & ~(3<<30);
    lcd_regs->lcdsaddr2  = ((s3c_lcd->fix.smem_start + s3c_lcd->fix.smem_len) >> 1) & 0x1fffff;
    lcd_regs->lcdsaddr3  = (480*32/16);  /* 一行的长度(单位: 2字节) */
    //s3c_lcd->fix.smem_start = xxx;  /* 显存的物理地址 */
    /* 启动LCD */
    lcd_regs->lcdcon1 |= (1<<0); /* 使能LCD控制器 */
    lcd_regs->lcdcon5 |= (1<<3); /* 使能LCD本身: LCD_PWREN */
//  *gpbdat |= 1;     /* 输出高电平, 使能背光, TQ2440的背光电路也是通过LCD_PWREN来控制的 */
    /* 4. 注册 */
    register_framebuffer(s3c_lcd);
    return  0;
}

static  void  lcd_exit( void )
{
    unregister_framebuffer(s3c_lcd);
    lcd_regs->lcdcon1 &= ~(1<<0); /* 关闭LCD控制器 */
    lcd_regs->lcdcon1 &= ~(1<<3); /* 关闭LCD本身 */
//  *gpbdat &= ~1;     /* 关闭背光 */
    dma_free_writecombine(NULL, s3c_lcd->fix.smem_len, s3c_lcd->screen_base, s3c_lcd->fix.smem_start);
    iounmap(lcd_regs);
    iounmap(gpbcon);
    iounmap(gpccon);
    iounmap(gpdcon);
    iounmap(gpgcon);
    framebuffer_release(s3c_lcd);
}
module_init(lcd_init);
module_exit(lcd_exit);
MODULE_LICENSE( "GPL" );

 

基于platform的代码在这就不贴出来了，太多了，可以参考/driver/videv/s3c2410fb.c