学习笔记 --- LINUX LCD显示原理与驱动分析

 

在分析驱动之前,先来分析下显示原理,这里以S3C2440为例,看下这个芯片的LCD控制器时序图:

VSYNC :帧数据脉冲,脉冲换屏,表示一屏数据开始

HSYNC :行数据脉冲,脉冲换行,表示一行数据开始

LEND :行结束脉冲,脉冲表示一行结束

VDEN :数据使能,表示VD可以发数据

VCLK  :基准时钟,脉冲送往数据线送一次数据

VD :数据

这些都是硬件管脚信号线,从图中可以看出一行中有效数据是HOZVAL+1个像素,(HSPW+1)+(HBPD+1)是屏幕左边黑框的像素,HFPD+1是屏幕右边黑框的像素,一般设置为左边等于右边,上边等于下边,iphone手机有很明显的黑框。那么上边就是(VSPW+1)+(VBPD+1)行,下边就是VFPD+1行,中间有效数据是LINEVAL+1行。假设LCD为240X320那么时序对应的显示图像就是(截图自韦东山老师):

外面的大框表示LCD黑框,里面表示真正显示的有效数据240X320。接下来说下显示16bpp图像的原理:

16bpp图像意思就是一个像素要用16个位来表示,那么就有2的16次方种颜色,一个像素16位,占2个字节,一屏240X320像素,那么一屏数据占240X320X2个字节,所以显存至少要这么大的空间。一个像素由红绿蓝三原色构成,所以这两个字节包含了红绿蓝三种颜色的信息,他们的占用bit数的比率为5:6:5,也可以是5:5:5,先只说5:6:5格式的,5+6+5=16bit,高位到低位分别表示5位红色,6位绿色,5位蓝色组成了一个两字节数据放在显存区里面,然后LCD控制器将其搬到LCD上显示出来,他们在显存里面的存放有两种方式:

一般选择下面这种方式,先放低16位,再放高16位,S3C2440默认是小端存储,所以这样低位对应低地址,刚好可以对应起来;那么从显存传输到LCD时数据线[0-23]传输的格式如何?

 

______________________________________________________________________________________________________

分析了原理,下面看驱动,LCD的驱动核心在内核fbmem.c里面,分析驱动从入口开始:

 

 
  1. static int __init fbmem_init(void)

  2. {

  3. proc_create("fb", 0, NULL, &fb_proc_fops);

  4.  
  5. if (register_chrdev(FB_MAJOR,"fb",&fb_fops)) //注册为字符设备驱动,主设备号为FB_MAJOR

  6. printk("unable to get major %d for fb devs\n", FB_MAJOR);

  7.  
  8. fb_class = class_create(THIS_MODULE, "graphics"); //创建类

  9. if (IS_ERR(fb_class)) {

  10. printk(KERN_WARNING "Unable to create fb class; errno = %ld\n", PTR_ERR(fb_class));

  11. fb_class = NULL;

  12. }

  13. return 0;

  14. }

可以知道LCD驱动也就是一个字符设备驱动而已,这个框架已经熟悉了,再看下fops部分:

 

 

 
  1. static const struct file_operations fb_fops = {

  2. .owner = THIS_MODULE,

  3. .read = fb_read,

  4. .write = fb_write,

  5. .unlocked_ioctl = fb_ioctl,

  6. #ifdef CONFIG_COMPAT

  7. .compat_ioctl = fb_compat_ioctl,

  8. #endif

  9. .mmap = fb_mmap,

  10. .open = fb_open,

  11. .release = fb_release,

  12. #ifdef HAVE_ARCH_FB_UNMAPPED_AREA

  13. .get_unmapped_area = get_fb_unmapped_area,

  14. #endif

  15. #ifdef CONFIG_FB_DEFERRED_IO

  16. .fsync = fb_deferred_io_fsync,

  17. #endif

  18. };

这里有读写控制,打开等操作,我们首先肯定是打开,先看打开:

 
  1. static int

  2. fb_open(struct inode *inode, struct file *file)

  3. __acquires(&info->lock)

  4. __releases(&info->lock)

  5. {

  6. int fbidx = iminor(inode);

  7. struct fb_info *info;

  8. int res = 0;

  9.  
  10. if (fbidx >= FB_MAX)

  11. return -ENODEV;

  12. info = registered_fb[fbidx]; //这里从数组传入一个info

  13. if (!info)

  14. request_module("fb%d", fbidx);

  15. info = registered_fb[fbidx];

  16. if (!info)

  17. return -ENODEV;

  18. mutex_lock(&info->lock);

  19. if (!try_module_get(info->fbops->owner)) {

  20. res = -ENODEV;

  21. goto out;

  22. }

  23. file->private_data = info;

  24. if (info->fbops->fb_open) {

  25. res = info->fbops->fb_open(info,1); //调用info的打开函数

  26. if (res)

  27. module_put(info->fbops->owner);

  28. }

  29. #ifdef CONFIG_FB_DEFERRED_IO

  30. if (info->fbdefio)

  31. fb_deferred_io_open(info, inode, file);

  32. #endif

  33. out:

  34. mutex_unlock(&info->lock);

  35. return res;

  36. }

可以知道他首先从registered_fb获取一个info,再调用info的open,再看read:

 

 

 
  1. static ssize_t

  2. fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)

  3. {

  4. unsigned long p = *ppos;

  5. struct inode *inode = file->f_path.dentry->d_inode;

  6. int fbidx = iminor(inode);

  7. struct fb_info *info = registered_fb[fbidx];//熟悉吧,我们又看到这个数组了

  8. u32 *buffer, *dst;

  9. u32 __iomem *src;

  10. int c, i, cnt = 0, err = 0;

  11. unsigned long total_size;

  12.  
  13. if (!info || ! info->screen_base)//跟那个数组有关

  14. return -ENODEV;

  15.  
  16. if (info->state != FBINFO_STATE_RUNNING)//跟那个数组有关

  17. return -EPERM;

  18.  
  19. if (info->fbops->fb_read)//如果操作函数集里定义了read函数,就调用,否则就算了

  20. return info->fbops->fb_read(info, buf, count, ppos);

  21.  
  22. total_size = info->screen_size;//跟那个数组有关

  23.  
  24. if (total_size == 0)

  25. total_size = info->fix.smem_len;//跟那个数组有关

  26.  
  27. if (p >= total_size)

  28. return 0;

  29.  
  30. if (count >= total_size)

  31. count = total_size;

  32.  
  33. if (count + p > total_size)

  34. count = total_size - p;

  35.  
  36. buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,//开辟一个buffer

  37. GFP_KERNEL);

  38. if (!buffer)

  39. return -ENOMEM;

  40.  
  41. src = (u32 __iomem *) (info->screen_base + p);//显存基地址也在里面

  42.  
  43. if (info->fbops->fb_sync)

  44. info->fbops->fb_sync(info);

  45.  
  46. while (count) {

  47. c = (count > PAGE_SIZE) ? PAGE_SIZE : count;

  48. dst = buffer;//目的指针指向一个buffer(我们在上面开辟的)

  49. for (i = c >> 2; i--; )

  50. *dst++ = fb_readl(src++);//从基地址读取数据放进buffer中

  51. if (c & 3) {

  52. u8 *dst8 = (u8 *) dst;

  53. u8 __iomem *src8 = (u8 __iomem *) src;

  54.  
  55. for (i = c & 3; i--;)

  56. *dst8++ = fb_readb(src8++);

  57.  
  58. src = (u32 __iomem *) src8;

  59. }

  60.  
  61. if (copy_to_user(buf, buffer, c))//将buffer中的数据拷贝到用户空间,这样在用户空间调用read函数时就把显存内容读出来了

  62. {

  63. err = -EFAULT;

  64. break;

  65. }

  66. *ppos += c;

  67. buf += c;

  68. cnt += c;

  69. count -= c;

  70. }

  71.  
  72. kfree(buffer);

  73.  
  74. return (err) ? err : cnt;

  75. }

读函数就是读info里面显存存放的数据,可以知道这个info很重要,那么registered_fb里面放的info,怎么来的?

 

 

 
  1. int

  2. register_framebuffer(struct fb_info *fb_info)

  3. {

  4. int i;

  5. struct fb_event event;

  6. struct fb_videomode mode;

  7.  
  8. if (num_registered_fb == FB_MAX)

  9. return -ENXIO;

  10.  
  11. if (fb_check_foreignness(fb_info))

  12. return -ENOSYS;

  13.  
  14. /* check all firmware fbs and kick off if the base addr overlaps */

  15. for (i = 0 ; i < FB_MAX; i++) {

  16. if (!registered_fb[i])

  17. continue;

  18.  
  19. if (registered_fb[i]->flags & FBINFO_MISC_FIRMWARE) {

  20. if (fb_do_apertures_overlap(registered_fb[i], fb_info)) {

  21. printk(KERN_ERR "fb: conflicting fb hw usage "

  22. "%s vs %s - removing generic driver\n",

  23. fb_info->fix.id,

  24. registered_fb[i]->fix.id);

  25. unregister_framebuffer(registered_fb[i]);

  26. break;

  27. }

  28. }

  29. }

  30.  
  31. num_registered_fb++;

  32. for (i = 0 ; i < FB_MAX; i++)

  33. if (!registered_fb[i])

  34. break;

  35. fb_info->node = i;

  36. mutex_init(&fb_info->lock);

  37. mutex_init(&fb_info->mm_lock);

  38.  
  39. fb_info->dev = device_create(fb_class, fb_info->device,

  40. MKDEV(FB_MAJOR, i), NULL, "fb%d", i);

  41. if (IS_ERR(fb_info->dev)) {

  42. /* Not fatal */

  43. printk(KERN_WARNING "Unable to create device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->dev));

  44. fb_info->dev = NULL;

  45. } else

  46. fb_init_device(fb_info);

  47.  
  48. if (fb_info->pixmap.addr == NULL) {

  49. fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL);

  50. if (fb_info->pixmap.addr) {

  51. fb_info->pixmap.size = FBPIXMAPSIZE;

  52. fb_info->pixmap.buf_align = 1;

  53. fb_info->pixmap.scan_align = 1;

  54. fb_info->pixmap.access_align = 32;

  55. fb_info->pixmap.flags = FB_PIXMAP_DEFAULT;

  56. }

  57. }

  58. fb_info->pixmap.offset = 0;

  59.  
  60. if (!fb_info->pixmap.blit_x)

  61. fb_info->pixmap.blit_x = ~(u32)0;

  62.  
  63. if (!fb_info->pixmap.blit_y)

  64. fb_info->pixmap.blit_y = ~(u32)0;

  65.  
  66. if (!fb_info->modelist.prev || !fb_info->modelist.next)

  67. INIT_LIST_HEAD(&fb_info->modelist);

  68.  
  69. fb_var_to_videomode(&mode, &fb_info->var);

  70. fb_add_videomode(&mode, &fb_info->modelist);

  71. registered_fb[i] = fb_info; //这里放入info到registered_fb

  72.  
  73. event.info = fb_info;

  74. if (!lock_fb_info(fb_info))

  75. return -ENODEV;

  76. fb_notifier_call_chain(FB_EVENT_FB_REGISTERED, &event);

  77. unlock_fb_info(fb_info);

  78. return 0;

  79. }

可以知道是通过register_framebuffer这个函数放进去的,register_framebuffer又是谁调用的?搜索代码可以知道很多文件都有调用,看S3c2410fb.c可以看到这个在s3c24xxfb_probe里面被调用的,而s3c24xxfb_probe就是s3c24xx这种CPU的LCD驱动程序,这里挂到虚拟总线上了:

 

 

 
  1. static struct platform_driver s3c2410fb_driver = {

  2. .probe = s3c2410fb_probe,

  3. .remove = s3c2410fb_remove,

  4. .suspend = s3c2410fb_suspend,

  5. .resume = s3c2410fb_resume,

  6. .driver = {

  7. .name = "s3c2410-lcd",

  8. .owner = THIS_MODULE,

  9. },

  10. };

  11.  
  12. int __init s3c2410fb_init(void)

  13. {

  14. int ret = platform_driver_register(&s3c2410fb_driver);

  15.  
  16. if (ret == 0)

  17. ret = platform_driver_register(&s3c2412fb_driver);

  18.  
  19. return ret;

  20. }

  21.  
  22. static void __exit s3c2410fb_cleanup(void)

  23. {

  24. platform_driver_unregister(&s3c2410fb_driver);

  25. platform_driver_unregister(&s3c2412fb_driver);

  26. }

  27.  
  28. module_init(s3c2410fb_init);

  29. module_exit(s3c2410fb_cleanup);

  30.  
  31. MODULE_AUTHOR("Arnaud Patard , "

  32. "Ben Dooks ");

  33. MODULE_DESCRIPTION("Framebuffer driver for the s3c2410");

  34. MODULE_LICENSE("GPL");

  35. MODULE_ALIAS("platform:s3c2410-lcd");

  36. MODULE_ALIAS("platform:s3c2412-lcd");

 

所以可以知道最开始看的那个fbmem.c就是LCD驱动的driver端(叫做FrameBuffer驱动),而这边跟平台有关的S3c2410fb.c等就是LCD驱动的divice端,这个跟之前分析的输入子系统很类似,也是分离的思想,把成熟的软件框架与硬件平台分开,软件框架(driver端)已经帮我们实现了,我们只需要编写divece端,最后把device注册到driver端就可以了。下面看看如何编写device端:

从S3c2410fb.c可以知道我们的LCD驱动就是按要求设置好这个info,然后注册到LCD驱动核心层。这里为了分析思路的清晰,先不考虑虚拟总线,我们自己写一个驱动照着填好这个info,然后设置好跟LCD有关的寄存器就差不多了,然后注册到LCD驱动核心。

1 先把框架写好:

 

 
  1. #include

  2. #include

  3. #include

  4. #include

  5. #include

  6. #include

  7. #include

  8. #include

  9. #include

  10. #include

  11. #include

  12. #include

  13. #include

  14. #include

  15. #include

  16.  
  17. #include

  18. #include

  19. #include

  20.  
  21. #include

  22. #include

  23. #include

  24. #include

  25.  
  26.  
  27. static struct fb_info *s3c_lcd;

  28.  
  29. static int lcd_init(void)

  30. {

  31. /* 1. 分配一个fb_info */

  32. s3c_lcd = framebuffer_alloc(0, NULL);

  33.  
  34. /* 2. 设置 */

  35. /* 2.1 设置固定的参数 fix */

  36. /* 2.2 设置可变的参数 var */

  37. /* 2.3 设置操作函数 fbops*/

  38. /* 2.4 其他的设置 */

  39.  
  40. /* 3. 硬件相关的操作 */

  41. /* 3.1 配置GPIO用于LCD */

  42. /* 3.2 根据LCD手册设置LCD控制器, 比如VCLK的频率等 */

  43. /* 3.3 分配显存(framebuffer), 并把地址告诉LCD控制器 */

  44.  
  45. /* 4. 注册 */

  46. register_framebuffer(s3c_lcd);

  47.  
  48. return 0;

  49. }

  50.  
  51. static void lcd_exit(void)

  52. {

  53. }

  54.  
  55. module_init(lcd_init);

  56. module_exit(lcd_exit);

  57.  
  58. MODULE_LICENSE("GPL");

  59.  

看下这个info哪些有必要设置:

 

 

 
  1. struct fb_info {

  2. int node;

  3. int flags;

  4. struct mutex lock; /* Lock for open/release/ioctl funcs */

  5. struct mutex mm_lock; /* Lock for fb_mmap and smem_* fields */

  6. struct fb_var_screeninfo var; /* Current var */

  7. struct fb_fix_screeninfo fix; /* Current fix */

  8. struct fb_monspecs monspecs; /* Current Monitor specs */

  9. struct work_struct queue; /* Framebuffer event queue */

  10. struct fb_pixmap pixmap; /* Image hardware mapper */

  11. struct fb_pixmap sprite; /* Cursor hardware mapper */

  12. struct fb_cmap cmap; /* Current cmap */

  13. struct list_head modelist; /* mode list */

  14. struct fb_videomode *mode; /* current mode */

  15.  
  16. #ifdef CONFIG_FB_BACKLIGHT

  17. /* assigned backlight device */

  18. /* set before framebuffer registration,

  19. remove after unregister */

  20. struct backlight_device *bl_dev;

  21.  
  22. /* Backlight level curve */

  23. struct mutex bl_curve_mutex;

  24. u8 bl_curve[FB_BACKLIGHT_LEVELS];

  25. #endif

  26. #ifdef CONFIG_FB_DEFERRED_IO

  27. struct delayed_work deferred_work;

  28. struct fb_deferred_io *fbdefio;

  29. #endif

  30.  
  31. struct fb_ops *fbops;

  32. struct device *device; /* This is the parent */

  33. struct device *dev; /* This is this fb device */

  34. int class_flag; /* private sysfs flags */

  35. #ifdef CONFIG_FB_TILEBLITTING

  36. struct fb_tile_ops *tileops; /* Tile Blitting */

  37. #endif

  38. char __iomem *screen_base; /* Virtual address */

  39. unsigned long screen_size; /* Amount of ioremapped VRAM or 0 */

  40. void *pseudo_palette; /* Fake palette of 16 colors */

  41. #define FBINFO_STATE_RUNNING 0

  42. #define FBINFO_STATE_SUSPENDED 1

  43. u32 state; /* Hardware state i.e suspend */

  44. void *fbcon_par; /* fbcon use-only private area */

  45. /* From here on everything is device dependent */

  46. void *par;

  47. /* we need the PCI or similiar aperture base/size not

  48. smem_start/size as smem_start may just be an object

  49. allocated inside the aperture so may not actually overlap */

  50. resource_size_t aperture_base;

  51. resource_size_t aperture_size;

  52. };

2 然后来看下info的设置:

 

 

 
  1. #include

  2. #include

  3. #include

  4. #include

  5. #include

  6. #include

  7. #include

  8. #include

  9. #include

  10. #include

  11. #include

  12. #include

  13. #include

  14. #include

  15. #include

  16.  
  17. #include

  18. #include

  19. #include

  20.  
  21. #include

  22. #include

  23. #include

  24. #include

  25.  
  26. //对显存的一些操作函数:

  27. static struct fb_ops s3c_lcdfb_ops = {

  28. .owner = THIS_MODULE,

  29. // .fb_setcolreg = atmel_lcdfb_setcolreg,

  30. .fb_fillrect = cfb_fillrect, //这三个照着写,以后再分析

  31. .fb_copyarea = cfb_copyarea,

  32. .fb_imageblit = cfb_imageblit,

  33. };

  34.  
  35.  
  36. static struct fb_info *s3c_lcd;

  37.  
  38. static int lcd_init(void)

  39. {

  40. /* 1. 分配一个fb_info */

  41. s3c_lcd = framebuffer_alloc(0, NULL);

  42.  
  43. /* 2. 设置 */

  44. /* 2.1 设置固定的参数 */

  45. strcpy(s3c_lcd->fix.id, "mylcd"); //名称

  46. s3c_lcd->fix.smem_len = 240*320*16/8; //显存大小,16bpp所以16位表示一个像素点,240x320的屏幕有240x320个点,再x16就是总位数,再/8就是总字节数

  47. s3c_lcd->fix.type = FB_TYPE_PACKED_PIXELS;

  48. s3c_lcd->fix.visual = FB_VISUAL_TRUECOLOR; /* TFT 真彩色*/

  49. s3c_lcd->fix.line_length = 240*2; //一行的长度,一行240个点,每个点两个字节(16bit),所以*2

  50.  
  51. /* 2.2 设置可变的参数 */

  52. s3c_lcd->var.xres = 240; //行

  53. s3c_lcd->var.yres = 320; //列

  54. s3c_lcd->var.xres_virtual = 240; //这里设置虚拟屏,我们设置虚拟屏为一样大小

  55. s3c_lcd->var.yres_virtual = 320;

  56. s3c_lcd->var.bits_per_pixel = 16; //每个像素16位

  57.  
  58. /* RGB:565 */

  59. s3c_lcd->var.red.offset = 11; //16位表示一个像素点的格式是R:G:B分别占5:6:5位

  60. s3c_lcd->var.red.length = 5;

  61.  
  62. s3c_lcd->var.green.offset = 5;

  63. s3c_lcd->var.green.length = 6;

  64.  
  65. s3c_lcd->var.blue.offset = 0;

  66. s3c_lcd->var.blue.length = 5;

  67.  
  68. s3c_lcd->var.activate = FB_ACTIVATE_NOW;

  69.  
  70.  
  71. /* 2.3 设置操作函数 */

  72. s3c_lcd->fbops = &s3c_lcdfb_ops; //对显存的操作函数,透明处理等操作

  73.  
  74. /* 2.4 其他的设置 */

  75. //s3c_lcd->pseudo_palette =; //

  76. //s3c_lcd->screen_base = ; /* 显存的虚拟地址 */

  77. s3c_lcd->screen_size = 240*324*16/8; //和显存大小一样设置

  78.  
  79. /* 3. 硬件相关的操作 */

  80. /* 3.1 配置GPIO用于LCD */

  81. /* 3.2 根据LCD手册设置LCD控制器, 比如VCLK的频率等 */

  82. /* 3.3 分配显存(framebuffer), 并把地址告诉LCD控制器 */

  83. //s3c_lcd->fix.smem_start = xxx; /* 显存的物理地址 */

  84.  
  85. /* 4. 注册 */

  86. register_framebuffer(s3c_lcd);

  87.  
  88. return 0;

  89. }

  90.  
  91. static void lcd_exit(void)

  92. {

  93. }

  94.  
  95. module_init(lcd_init);

  96. module_exit(lcd_exit);

  97.  
  98. MODULE_LICENSE("GPL");

  99.  

3  info一般设置这些东西,再看些硬件方面的设置:

 

 
  1. #include

  2. #include

  3. #include

  4. #include

  5. #include

  6. #include

  7. #include

  8. #include

  9. #include

  10. #include

  11. #include

  12. #include

  13. #include

  14. #include

  15. #include

  16.  
  17. #include

  18. #include

  19. #include

  20.  
  21. #include

  22. #include

  23. #include

  24. #include

  25.  
  26. static int s3c_lcdfb_setcolreg(unsigned int regno, unsigned int red,

  27. unsigned int green, unsigned int blue,

  28. unsigned int transp, struct fb_info *info);

  29.  
  30.  
  31. struct lcd_regs {

  32. unsigned long lcdcon1;

  33. unsigned long lcdcon2;

  34. unsigned long lcdcon3;

  35. unsigned long lcdcon4;

  36. unsigned long lcdcon5;

  37. unsigned long lcdsaddr1;

  38. unsigned long lcdsaddr2;

  39. unsigned long lcdsaddr3;

  40. unsigned long redlut;

  41. unsigned long greenlut;

  42. unsigned long bluelut;

  43. unsigned long reserved[9];

  44. unsigned long dithmode;

  45. unsigned long tpal;

  46. unsigned long lcdintpnd;

  47. unsigned long lcdsrcpnd;

  48. unsigned long lcdintmsk;

  49. unsigned long lpcsel;

  50. };

  51.  
  52. static struct fb_ops s3c_lcdfb_ops = {

  53. .owner = THIS_MODULE,

  54. .fb_setcolreg = s3c_lcdfb_setcolreg,

  55. .fb_fillrect = cfb_fillrect,

  56. .fb_copyarea = cfb_copyarea,

  57. .fb_imageblit = cfb_imageblit,

  58. };

  59.  
  60.  
  61. static struct fb_info *s3c_lcd;

  62. static volatile unsigned long *gpbcon;

  63. static volatile unsigned long *gpbdat;

  64. static volatile unsigned long *gpccon;

  65. static volatile unsigned long *gpdcon;

  66. static volatile unsigned long *gpgcon;

  67. static volatile struct lcd_regs* lcd_regs;

  68. static u32 pseudo_palette[16];

  69.  
  70.  
  71. /* from pxafb.c */

  72. static inline unsigned int chan_to_field(unsigned int chan, struct fb_bitfield *bf)

  73. {

  74. chan &= 0xffff;

  75. chan >>= 16 - bf->length;

  76. return chan << bf->offset;

  77. }

  78.  
  79.  
  80. static int s3c_lcdfb_setcolreg(unsigned int regno, unsigned int red,

  81. unsigned int green, unsigned int blue,

  82. unsigned int transp, struct fb_info *info)

  83. {

  84. unsigned int val;

  85.  
  86. if (regno > 16)

  87. return 1;

  88.  
  89. /* 用red,green,blue三原色构造出val */

  90. val = chan_to_field(red, &info->var.red);

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

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

  93.  
  94. //((u32 *)(info->pseudo_palette))[regno] = val;

  95. pseudo_palette[regno] = val;

  96. return 0;

  97. }

  98.  
  99. static int lcd_init(void)

  100. {

  101. /* 1. 分配一个fb_info */

  102. s3c_lcd = framebuffer_alloc(0, NULL);

  103.  
  104. /* 2. 设置 */

  105. /* 2.1 设置固定的参数 */

  106. strcpy(s3c_lcd->fix.id, "mylcd");

  107. s3c_lcd->fix.smem_len = 240*320*16/8;

  108. s3c_lcd->fix.type = FB_TYPE_PACKED_PIXELS;

  109. s3c_lcd->fix.visual = FB_VISUAL_TRUECOLOR; /* TFT */

  110. s3c_lcd->fix.line_length = 240*2;

  111.  
  112. /* 2.2 设置可变的参数 */

  113. s3c_lcd->var.xres = 240;

  114. s3c_lcd->var.yres = 320;

  115. s3c_lcd->var.xres_virtual = 240;

  116. s3c_lcd->var.yres_virtual = 320;

  117. s3c_lcd->var.bits_per_pixel = 16;

  118.  
  119. /* RGB:565 */

  120. s3c_lcd->var.red.offset = 11;

  121. s3c_lcd->var.red.length = 5;

  122.  
  123. s3c_lcd->var.green.offset = 5;

  124. s3c_lcd->var.green.length = 6;

  125.  
  126. s3c_lcd->var.blue.offset = 0;

  127. s3c_lcd->var.blue.length = 5;

  128.  
  129. s3c_lcd->var.activate = FB_ACTIVATE_NOW;

  130.  
  131.  
  132. /* 2.3 设置操作函数 */

  133. s3c_lcd->fbops = &s3c_lcdfb_ops;

  134.  
  135. /* 2.4 其他的设置 */

  136. s3c_lcd->pseudo_palette = pseudo_palette;

  137. //s3c_lcd->screen_base = ; /* 显存的虚拟地址 */

  138. s3c_lcd->screen_size = 240*324*16/8;

  139.  
  140. /* 3. 硬件相关的操作 */

  141. /* 3.1 配置GPIO用于LCD */

  142. gpbcon = ioremap(0x56000010, 8);

  143. gpbdat = gpbcon+1;

  144. gpccon = ioremap(0x56000020, 4);

  145. gpdcon = ioremap(0x56000030, 4);

  146. gpgcon = ioremap(0x56000060, 4);

  147.  
  148. *gpccon = 0xaaaaaaaa; /* GPIO管脚用于VD[7:0],LCDVF[2:0],VM,VFRAME,VLINE,VCLK,LEND */

  149. *gpdcon = 0xaaaaaaaa; /* GPIO管脚用于VD[23:8] */

  150.  
  151. *gpbcon &= ~(3); /* GPB0设置为输出引脚 */

  152. *gpbcon |= 1;

  153. *gpbdat &= ~1; /* 输出低电平 */

  154.  
  155. *gpgcon |= (3<<8); /* GPG4用作LCD_PWREN */

  156.  
  157. /* 3.2 根据LCD手册设置LCD控制器, 比如VCLK的频率等 */

  158. lcd_regs = ioremap(0x4D000000, sizeof(struct lcd_regs));

  159.  
  160. /* bit[17:8]: VCLK = HCLK / [(CLKVAL+1) x 2], LCD手册P14

  161. * 10MHz(100ns) = 100MHz / [(CLKVAL+1) x 2]

  162. * CLKVAL = 4

  163. * bit[6:5]: 0b11, TFT LCD

  164. * bit[4:1]: 0b1100, 16 bpp for TFT

  165. * bit[0] : 0 = Disable the video output and the LCD control signal.

  166. */

  167. lcd_regs->lcdcon1 = (4<<8) | (3<<5) | (0x0c<<1);

  168.  
  169.  
  170. /* 垂直方向的时间参数

  171. * bit[31:24]: VBPD, VSYNC之后再过多长时间才能发出第1行数据

  172. * LCD手册 T0-T2-T1=4

  173. * VBPD=3

  174. * bit[23:14]: 多少行, 320, 所以LINEVAL=320-1=319

  175. * bit[13:6] : VFPD, 发出最后一行数据之后,再过多长时间才发出VSYNC

  176. * LCD手册T2-T5=322-320=2, 所以VFPD=2-1=1

  177. * bit[5:0] : VSPW, VSYNC信号的脉冲宽度, LCD手册T1=1, 所以VSPW=1-1=0

  178. */

  179. lcd_regs->lcdcon2 = (3<<24) | (319<<14) | (1<<6) | (0<<0);

  180.  
  181.  
  182. /* 水平方向的时间参数

  183. * bit[25:19]: HBPD, VSYNC之后再过多长时间才能发出第1行数据

  184. * LCD手册 T6-T7-T8=17

  185. * HBPD=16

  186. * bit[18:8]: 多少列, 240, 所以HOZVAL=240-1=239

  187. * bit[7:0] : HFPD, 发出最后一行里最后一个象素数据之后,再过多长时间才发出HSYNC

  188. * LCD手册T8-T11=251-240=11, 所以HFPD=11-1=10

  189. */

  190. lcd_regs->lcdcon3 = (16<<19) | (239<<8) | (10<<0);

  191.  
  192. /* 水平方向的同步信号

  193. * bit[7:0] : HSPW, HSYNC信号的脉冲宽度, LCD手册T7=5, 所以HSPW=5-1=4

  194. */

  195. lcd_regs->lcdcon4 = 4;

  196.  
  197.  
  198. /* 信号的极性

  199. * bit[11]: 1=565 format

  200. * bit[10]: 0 = The video data is fetched at VCLK falling edge

  201. * bit[9] : 1 = HSYNC信号要反转,即低电平有效

  202. * bit[8] : 1 = VSYNC信号要反转,即低电平有效

  203. * bit[6] : 0 = VDEN不用反转

  204. * bit[3] : 0 = PWREN输出0

  205. * bit[1] : 0 = BSWP

  206. * bit[0] : 1 = HWSWP 2440手册P413

  207. */

  208. lcd_regs->lcdcon5 = (1<<11) | (0<<10) | (1<<9) | (1<<8) | (1<<0);

  209.  
  210. /* 3.3 分配显存(framebuffer), 并把地址告诉LCD控制器 */

  211. s3c_lcd->screen_base = dma_alloc_writecombine(NULL, s3c_lcd->fix.smem_len, &s3c_lcd->fix.smem_start, GFP_KERNEL);

  212.  
  213. lcd_regs->lcdsaddr1 = (s3c_lcd->fix.smem_start >> 1) & ~(3<<30);

  214. lcd_regs->lcdsaddr2 = ((s3c_lcd->fix.smem_start + s3c_lcd->fix.smem_len) >> 1) & 0x1fffff;

  215. lcd_regs->lcdsaddr3 = (240*16/16); /* 一行的长度(单位: 2字节) */

  216.  
  217. //s3c_lcd->fix.smem_start = xxx; /* 显存的物理地址 */

  218. /* 启动LCD */

  219. lcd_regs->lcdcon1 |= (1<<0); /* 使能LCD控制器 */

  220. lcd_regs->lcdcon5 |= (1<<3); /* 使能LCD本身 */

  221. *gpbdat |= 1; /* 输出高电平, 使能背光 */

  222.  
  223. /* 4. 注册 */

  224. register_framebuffer(s3c_lcd);

  225.  
  226. return 0;

  227. }

  228.  
  229. static void lcd_exit(void)

  230. {

  231. unregister_framebuffer(s3c_lcd);

  232. lcd_regs->lcdcon1 &= ~(1<<0); /* 关闭LCD本身 */

  233. *gpbdat &= ~1; /* 关闭背光 */

  234. dma_free_writecombine(NULL, s3c_lcd->fix.smem_len, s3c_lcd->screen_base, s3c_lcd->fix.smem_start);

  235. iounmap(lcd_regs);

  236. iounmap(gpbcon);

  237. iounmap(gpccon);

  238. iounmap(gpdcon);

  239. iounmap(gpgcon);

  240. framebuffer_release(s3c_lcd);

  241. }

  242.  
  243. module_init(lcd_init);

  244. module_exit(lcd_exit);

  245.  
  246. MODULE_LICENSE("GPL");

你可能感兴趣的:(驱动,lcd驱动)