4412 lcd驱动及简单字符显示

驱动：

基于framebuffer，整体代码参考内核s3c-fb.c

代码初始化步骤：

1、申请fb_info

2、初始化fb_info

3、管脚设置

4、时钟设置

5、控制芯片设置

6、注册fb

代码：

/*head file*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/clk.h>
#include <linux/fb.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/dma-mapping.h>
#include "mylcd.h"

/*module info*/
MODULE_LICENSE("Dual BSD/GPL");

static struct fb_info *my_fbInfo = NULL;
static int myLcdBpp = 32;   /*位深*/
static short myPaletteSize = 256;  /*调色板大小*/
static unsigned int myXvSize = 1024;  /*缓冲列大小*/
static unsigned int myYvSize = 600;  /*缓冲行大小*/
static unsigned int pseudo_palette[16];

/*io管脚寄存器*/
static unsigned int * __iomem gpf0con;
static unsigned int * __iomem gpf1con;
static unsigned int * __iomem gpf2con;
static unsigned int * __iomem gpf3con;
static unsigned int * __iomem gpd0con;
/*pwm寄存器*/
static unsigned int * __iomem tcfg0;
static unsigned int * __iomem tcfg1;
static unsigned int * __iomem tcon;
static unsigned int * __iomem tcntb1;
static unsigned int * __iomem tcmpb1;
/*时钟相关寄存器*/
static unsigned int * __iomem clk_div_lcd;
static unsigned int * __iomem clk_src_lcd0;
static unsigned int * __iomem lcdblk_cfg;
static unsigned int * __iomem lcdblk_cfg2;
/*lcd寄存器*/
static unsigned int * __iomem vidcon0;
static unsigned int * __iomem vidcon1;
static unsigned int * __iomem vidcon2;
static unsigned int * __iomem vidtcon0;
static unsigned int * __iomem vidtcon1;
static unsigned int * __iomem vidtcon2;
static unsigned int * __iomem wincon0;
static unsigned int * __iomem vidoso0a;
static unsigned int * __iomem vidoso0b;
static unsigned int * __iomem vidoso0c;
static unsigned int * __iomem shaadowcon;
static unsigned int * __iomem winchmap2;
static unsigned int * __iomem vidw00add0b0;
static unsigned int * __iomem vidw00add1b0;
static unsigned int * __iomem win0map;
static unsigned int * __iomem vidw00add2;

//static T_LCD_REG * __iomem lcdBase;

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 my_fb_setcolreg(unsigned regno,
                unsigned red, unsigned green, unsigned blue,
                unsigned transp, struct fb_info *info)
{
    unsigned int val = 0;
    switch (info->fix.visual) {
    case FB_VISUAL_TRUECOLOR:
        /* true-colour, use pseudo-palette */
        if (regno < 16) {
            u32 *pal = info->pseudo_palette;

            val  = chan_to_field(red,   &info->var.red);
            val |= chan_to_field(green, &info->var.green);
            val |= chan_to_field(blue,  &info->var.blue);

            pal[regno] = val;
        }
        break;
    default:
        return 1;    /* unknown type */
    }

    return 0;
}

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

static int fb_fill_var(struct fb_info *myfb)
{
    myfb->var.activate    = FB_ACTIVATE_NOW;
    myfb->var.vmode    = FB_VMODE_NONINTERLACED;
    myfb->var.bits_per_pixel = myLcdBpp;
    myfb->var.xres_virtual = myXvSize;
    myfb->var.yres_virtual = myYvSize;
    myfb->var.xres = myXvSize;
    myfb->var.yres = myYvSize;
    myfb->var.xoffset = 0;
    myfb->var.yoffset = 0;
    /* always ensure these are zero, for drop through cases below */
    myfb->var.transp.offset = 0;
    myfb->var.transp.length = 0;
    
    switch (myfb->var.bits_per_pixel) {
    case 1:
    case 2:
    case 4:
    case 8:
        /* non palletised, A:1,R:2,G:3,B:2 mode */
        myfb->var.red.offset    = 5;
        myfb->var.green.offset    = 2;
        myfb->var.blue.offset    = 0;
        myfb->var.red.length   = 2;
        myfb->var.green.length    = 3;
        myfb->var.blue.length    = 2;
        myfb->var.transp.offset = 7;
        myfb->var.transp.length = 1;
        break;

    case 19:
        /* 666 with one bit alpha/transparency */
        myfb->var.transp.offset    = 18;
        myfb->var.transp.length    = 1;
        /* drop through */
    case 18:
        myfb->var.bits_per_pixel    = 32;

        /* 666 format */
        myfb->var.red.offset    = 12;
        myfb->var.green.offset    = 6;
        myfb->var.blue.offset    = 0;
        myfb->var.red.length    = 6;
        myfb->var.green.length    = 6;
        myfb->var.blue.length    = 6;
        break;

    case 16:
        /* 16 bpp, 565 format */
        myfb->var.red.offset    = 11;
        myfb->var.green.offset    = 5;
        myfb->var.blue.offset    = 0;
        myfb->var.red.length   = 5;
        myfb->var.green.length    = 6;
        myfb->var.blue.length    = 5;
        break;

    case 32:
    case 28:
    case 25:
        myfb->var.transp.length = myfb->var.bits_per_pixel - 24;
        myfb->var.transp.offset = 24;
        /* drop through */
    case 24:
        /* our 24bpp is unpacked, so 32bpp */
        myfb->var.bits_per_pixel    = 32;
        myfb->var.red.offset        = 16;
        myfb->var.red.length        = 8;
        myfb->var.green.offset    = 8;
        myfb->var.green.length    = 8;
        myfb->var.blue.offset    = 0;
        myfb->var.blue.length    = 8;
        break;

    default:
        printk("invalid bpp\n");
        return -EINVAL;
    }
    return 0;
}

static int fb_fill_fix(struct fb_info *myfb)
{
    unsigned int real_size, virt_size, size;
    dma_addr_t map_dma;
    
    strcpy(myfb->fix.id ,"mylcd");

    myfb->fix.type = FB_TYPE_PACKED_PIXELS; //在该方式下，像素值与内存直接对应
    myfb->fix.accel    = FB_ACCEL_NONE;
    myfb->fix.line_length =  (myfb->var.xres_virtual * myfb->var.bits_per_pixel) / 8; //一行的大小(字节数)
    myfb->fix.xpanstep = myfb->var.xres_virtual > myfb->var.xres ? 1 : 0;
    myfb->fix.ypanstep = myfb->var.yres_virtual > myfb->var.yres ? 1 : 0;
    
    switch (myfb->var.bits_per_pixel) {
        case 32:
        case 24:
        case 16:
        case 12:
            myfb->fix.visual = FB_VISUAL_TRUECOLOR;
            break;
        case 8:
            if (myPaletteSize >= 256)
                myfb->fix.visual = FB_VISUAL_PSEUDOCOLOR;
            else
                myfb->fix.visual = FB_VISUAL_TRUECOLOR;
            break;
        case 1:
            myfb->fix.visual = FB_VISUAL_MONO01;
            break;
        default:
            myfb->fix.visual = FB_VISUAL_TRUECOLOR;
            break;
    }    
  
    /*计算整体缓冲大小*/
    real_size = myfb->var.xres * myfb->var.yres;
    virt_size = myfb->var.xres_virtual * myfb->var.yres_virtual;
    size = (real_size > virt_size) ? real_size : virt_size;
    size *= (myfb->var.bits_per_pixel > 16) ? 32 : myLcdBpp;
    size /= 8;
    myfb->fix.smem_len = size;
    size = PAGE_ALIGN(size);
    myfb->screen_base = dma_alloc_writecombine(myfb->dev, size,
                          &map_dma, GFP_KERNEL);
    if (!myfb->screen_base)
    {
        return -ENOMEM;
    }
    memset(myfb->screen_base, 0x0, size);
    myfb->fix.smem_start = map_dma;

    return 0;
}

/*fun*/
static void myfb_Init(struct fb_info *myfb)
{
    /*var init*/
    fb_fill_var(myfb);
    /*fix init*/
    fb_fill_fix(myfb);
    /*ops init*/
    myfb->fbops        = &my_fb_ops;
    /*other init*/
    myfb->flags        = FBINFO_FLAG_DEFAULT;
    myfb->pseudo_palette  = pseudo_palette;
}

static void mygpio_Init(void)
{
    gpf0con = ioremap(LCD_F0,4);
    gpf1con = ioremap(LCD_F1,4);
    gpf2con = ioremap(LCD_F2,4);
    gpf3con = ioremap(LCD_F3,4);
    
    writel(LCD_F0_VAL, gpf0con);
    writel(LCD_F1_VAL, gpf1con);
    writel(LCD_F2_VAL, gpf2con);
    writel(LCD_F3_VAL, gpf3con);
    
    //背光
    if(1) //pwm方式
    {
        gpd0con = ioremap(LCP_PWMIO_BASE,4);
        writel((readl(gpd0con) & (~(0xf<<4))) | (0x2<<4) , gpd0con);
    }
    else //直接点亮方式
    {
        int val;

        unsigned int * __iomem gpd0con;
        unsigned int * __iomem gpd0dat;

        gpd0con = ioremap(0x114000A0,0x4);
        gpd0dat = ioremap(0x114000A4,0x4);

        val = readl(gpd0con);
        val &= ~(0xf << 4);
        val |= (0x1 << 4);
        writel(val, gpd0con);

        val = readl(gpd0dat);
        val |= (1 << 1);
        writel(val, gpd0dat);
    }
}

static void myclk_Init(void)
{  
    clk_div_lcd  = ioremap(CLK_DIV_LCD,0x4);
    clk_src_lcd0 = ioremap(CLK_SRC_LCD,0x4);
    lcdblk_cfg = ioremap(LCDBLK_CFG, 0x4);
    lcdblk_cfg2= ioremap(LCDBLK_CFG2, 0x4);
    
    /*时钟源选择MPLL，具体参考<Exyons 4412 datasheet pg453>
     *SCLK_FIMD0 = MOUTFIMD0/(FIMD0_RATIO + 1) = 800M/1 = 800M
     */
    writel(readl(clk_div_lcd)&~0xf,clk_div_lcd);
    writel((readl(clk_src_lcd0)&~0xf)|0x6,clk_src_lcd0);
    
    /*选择FIMD0 具体参考<Exyons 4412 datasheet pg1796模块图FIMD6.0 >
     *<Exyons 4412 datasheet pg1799>
     *Using the display controller data, you can select one of the above data paths by setting LCDBLK_CFG Register
     *(0x1001_0210). For more information, refer to the "System Others" manual.
     *<Exyons 4412 datasheet pg1874>
     *While using RGB interface, the VT_LBLKx bit fields in LCDBLKC_CFG (0x1001_0210) register should be set to
RGB Interface out (2'b00), even though you use DSI Video Mode.*/
    writel((readl(lcdblk_cfg)&(~(0x3<<10)))|(1<<1),lcdblk_cfg);
    //writel(readl(lcdblk_cfg2)|(1<<0),lcdblk_cfg2);
}

static void mypwm_Init(void)
{
    tcfg0 = ioremap(LCP_PWM_TCFG0,4);
    tcfg1 = ioremap(LCP_PWM_TCFG1,4);    
    tcon = ioremap(LCP_PWM_TCON,4); 
    tcntb1 = ioremap(LCP_PWM_TCNTB1,4);
    tcmpb1 = ioremap(LCP_PWM_TCMPB1,4);
    /*占空比控制背光亮度*/
    writel((readl(tcfg0) &(~0xff))|0xff,tcfg0);
    writel((readl(tcfg1) &(~(0xf<<4)))|0x4<<4,tcfg1);
    writel(300,tcntb1);
    writel(150,tcmpb1);
    writel((readl(tcon)&(~(0xf<<8)))|(0x1<<9),tcon);
    
    //使能
    writel((readl(tcon)&(~(0x1<<9)))|(0x1<<8),tcon);
}

static int lcd_Init(struct fb_info *myfb)
{
    unsigned int val;    
    //lcd设置,寄存器太多，懒得放头文件了
    vidcon0  = ioremap(0x11c00000,0x4);
    vidcon1  = ioremap(0x11c00004,0x4);
    vidcon2  = ioremap(0x11c00008,0x4);
    vidtcon0 = ioremap(0x11c00010,0x4);
    vidtcon1 = ioremap(0x11c00014,0x4);
    vidtcon2 = ioremap(0x11c00018,0x4);

    win0map = ioremap(0x11C00180, 0x4);
    wincon0 = ioremap(0x11c00020, 0x4);

    vidoso0a = ioremap(0x11c00040,0x4);
    vidoso0b = ioremap(0x11c00044,0x4);
    vidoso0c = ioremap(0x11c00048,0x4);
    shaadowcon = ioremap(0x11c00034,0x4);
    winchmap2  = ioremap(0x11c0003c,0x4);
    vidw00add0b0 = ioremap(0x11c000a0,0x4);
    vidw00add1b0 = ioremap(0x11c000d0,0x4);
    vidw00add2 = ioremap(0x11C00104, 0x4);

    /*HV mode  fclk :44.9~63 推荐51.2Mhz 参考<JT70DT5012-ZH.pdf pg11>
     *vidcon0  [13-6]  VCLK = FIMD*SCLK/(CLKVAL+1)
     *50M = 800M/(CLK_VAL+1)     CLK_VAL= 15   这里为了取整，取50M
     */
    writel(15 << 6, vidcon0);
    
    /*
     *<Exyons 4412 datasheet pg1848(时序)> :VSYNC，HSYNC高电平触发信号，VCLK上升沿开始传输数据
     *<JT70DT5012-ZH pg10(时序)>:VSD,HSD低电平触发信号，CLKV下降沿开始传输数据
     *
     *VIDCON1:
     *      [5]:IVSYNC  ===> 1 : Inverted(反转)
     *      [6]:IHSYNC  ===> 1 : Inverted(反转)
     *      [7]:IVCLK   ===> 1 : Fetches video data at VCLK rising edge (下降沿触发，反转？)
     *      [10:9]:FIXVCLK  ====> 01 : VCLK running
     * */
    writel((1<<9)|(1<<7)|(1 << 5)|(1 << 6),vidcon1);

    //Reserved: This bit should be set to 1.
    writel(1 << 14, vidcon2);
    
    /*参考<JT70DT5012-ZH.pdf pg11> HV mode
     * thbp: 160 (DCLK)
     * thfp: 160 (DCLK)
     * thpw: 1-140 (DCLK)
     * tvpw: 1-20 (Th)
     * tvbp: 23 (Th)
     * tvfp: 12 (Th)
     */
    
    #define  HSPW    10    //行同步
    #define  HBPD    160
    #define  HFPD    160
    #define  VSPW    1    //帧同步
    #define  VBPD    23
    #define  VFPD    12
    writel(((VBPD << 16)|(VFPD << 8)|(VSPW << 0)),vidtcon0);
    writel(((HBPD << 16)|(HFPD << 8)|(HSPW << 0)),vidtcon1);

    /*设置大小,参考<JT70DT5012-ZH.pdf pg4> Display Format  Graphic 1024RGB*600 Dot-matrix
     * HOZVAL = (Horizontal display size) – 1 and LINEVAL = (Vertical display size) – 1.
     */
    writel(((1023 << 0) | (599 << 11)), vidtcon2);

    /*绑定win，这里直接使用了win0 
     * TODO：0xd=32位，这里强行写的，具体需要参考实际情况写16或32
     */
    writel((1<<6)|(0xD<<2)|1,wincon0);
    
    /* LCD左上角坐标*/
    writel(0<<11|0, vidoso0a);
    /* LCD右下角坐标 参考 <exynos4412 pg1895>
     * 24 BPP mode should have X position by 1 pixel. (For example, X = 0, 1, 2, 3….)
     * 16 BPP mode should have X position by 2 pixel. (For example, X = 0, 2, 4, 6….)
     * 8 BPP mode should have X position by 4 pixel. (For example, X = 0, 4, 8, 12….)
     */
    if(myLcdBpp == 16)
    {
        val = (((1023*2) << 11) | ((599*2) << 0));
    }
    else if((myLcdBpp == 24) || (myLcdBpp == 32))
    {
        val = (((1023) << 11) | ((599) << 0));
    }
    writel(val, vidoso0b);
    
    /*总大小*/
    writel(1024*600, vidoso0c);
    
    /*帧缓冲起始地址*/
    writel(myfb->fix.smem_start, vidw00add0b0);
    /*帧缓冲结束地址*/
    writel(myfb->fix.smem_start+myfb->fix.smem_len, vidw00add1b0);
    /*设置偏移和宽度*/
    writel((0 << 13) | ((1024 * myLcdBpp / 8)<< 0), vidw00add2);

    /*绑定通道和窗口*/
    writel(1, shaadowcon);
    writel((readl(winchmap2)&(~(0x7<<16))&(~0x7))|(1<<16)|(1<<0), winchmap2);
    
    /*Enables the video output and video control signal*/
    writel(readl(vidcon0)|0x3, vidcon0);    
    return 0;
}

static int fs4412_lcd_init(void)
{
    int ret =0 ;
    /************************kernel相关*******************************/
    /**这部分参考s3c-fb.c**/
    /*申请fb_info*/
    my_fbInfo = framebuffer_alloc(0,NULL);   //这里没有私有数据，所以是0；dev没有,平台驱动需要添加。
    /*初始化fb_info*/
    myfb_Init(my_fbInfo);
    /************************硬件相关*******************************/
    /*管脚设置*/
    mygpio_Init();
    /*时钟设置*/
    myclk_Init();    
    /*控制芯片设置*/
    mypwm_Init();
    lcd_Init(my_fbInfo);
    
    /*注册*/
    ret = register_framebuffer(my_fbInfo);
    if(0 > ret){
        printk(KERN_ERR "failed to register framebuffer \n");
        //dma_free_coherent(fs_info->dev, fs_info->fix.smem_len,fs_info->screen_base, fs_info->fix.smem_start);
        return ret;
    }
    
    printk("Lcd init ok\n");
    return 0;
}

/*没考虑退出，这里暂时没写*/
static void fs4412_lcd_exit(void)
{
    printk("Lcd exit\n");
}

/**/
module_init(fs4412_lcd_init);
module_exit(fs4412_lcd_exit);

 

应用：

下载一个字符转换工具，转换字符，我用的是字模提取V2.2。

先取一个字符转换码：

1、先在右下角的文字输入区输入需要转码的字，按Ctrl+Enter 输入结束

2、在左边列里面 选择取模方式，C51 格式，点击后在右下的 点阵生成区显示转换的字节数组。

3、把字节数组放到测试程序中，我为了方便，直接在c里面用了一个数组来装载。

应用编码

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <linux/fb.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <arpa/inet.h>
#include <errno.h>

#define MY_W 320   //图像宽
#define MY_H 240   //图像高
#define MAX_SIZE 1024*600*4  //lcd屏幕大小，具体要看对应的lcd手册。我的是1024*600

/*字符矩阵 16*14*/
#define C_W 40
#define C_H 35

static char *fbp = 0;   //映射内存起始地址
static int fbfd = 0;    //帧缓冲fd

/*存放转换后的汉字字节*/
const unsigned char cbuf[1024]=
{
/*--  文字:  我  --*/
/*--  宋体26;  此字体下对应的点阵为：宽x高=35x35   --*/
/*--  宽度不是8的倍数，现调整为：宽度x高度=40x35  --*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x38,0x00,0x00,0x00,
0x0F,0xBE,0x00,0x00,0x00,0x7F,0xFD,0xE0,0x00,0x07,0xF8,0x3C,0x78,0x00,0x3E,0x78,
0x3C,0x7C,0x00,0x00,0x78,0x3C,0x3E,0x00,0x00,0x78,0x3C,0x1C,0x00,0x00,0x78,0x3C,
0x0C,0x00,0x00,0x78,0x3C,0x06,0x00,0x00,0x78,0x3C,0x0F,0x00,0x7F,0xFF,0xFF,0xFF,
0x80,0x00,0x78,0x3C,0x00,0x80,0x00,0x78,0x1C,0x10,0x00,0x00,0x78,0x1C,0x38,0x00,
0x00,0x78,0x1C,0x3C,0x00,0x00,0x78,0x5C,0x7E,0x00,0x00,0x7F,0xDC,0x70,0x00,0x00,
0x7E,0x1C,0xF0,0x00,0x01,0xF8,0x1F,0xE0,0x00,0x1F,0xF8,0x1F,0xC0,0x00,0x7F,0x78,
0x0F,0x80,0x00,0x3C,0x78,0x0F,0x00,0x00,0x30,0x78,0x0F,0x01,0x80,0x00,0x78,0x3F,
0x81,0x80,0x00,0x78,0x7B,0xC1,0x80,0x00,0x78,0xF1,0xE1,0x80,0x00,0x7B,0xC0,0xF3,
0x80,0x00,0x7F,0x00,0x7F,0x80,0x0F,0xFC,0x00,0x3F,0x80,0x01,0xF0,0x00,0x0F,0xC0,
0x00,0xE0,0x00,0x03,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};

/*转换，并显示*/
void pch(int *add,const unsigned char* buf)
{
    int row = 0;
    int col = 0;
    int i = 0;
    int color = 0x0;
    for(row=0;row<C_H;row++)
    {
        /*一行数据，按位转换*/      
        unsigned char tmp[C_W];
        int index = 0;
        int j = 0;
        int k = 0;
        for(k=0;k<(C_W/8);k++)
        {
            for(j=0;j<8;j++)
            {
                tmp[index] = (buf[i] & ((0x1<<7)>>j))>0?1:0 ;
                index++;
            }
            i++;
            j = 0;
        }
        
        /*一行数据，按位显示*/
        for(col=0;col<C_W;col++)
        {
            if(tmp[col]&1)
            {
                color = 0xffff0000; //显示成红色，这里需要什么颜色自己设置(可以自行百度RGB颜色)
                printf("1");
            }
            else
            {
                color = 0x0; //显示成黑色，背景色
                printf("0");
            }
            add[row*1024+col] = color;
        }
        printf("\n\n");
    }
}

/*清整屏幕，全部置为黑色*/
void clearfb(void)
{
    memset(fbp,0,MAX_SIZE);  //显示成黑色，背景色
}

int main()
{
    int i;
    fbfd = open("/dev/fb0", O_RDWR);
    fbp = (char *)mmap(0, MAX_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fbfd, 0);
    if (fbp == NULL)
    {
        printf("Error: failed to map framebuffer device to memory.\n");
        return -1;
    }
    
    int *add;
    while(1)
    {
        add = (int *)fbp+1024*3+100;   /*第三行，偏移100*/
        clearfb();
        pch(add,cbuf);
        sleep(2);
    }

    munmap((void *)add,1024*600*4);
    return 0;
}

显示效果：