LCD驱动程序层次分析

我们内核里面自带的触摸屏驱动是fbmem.c

它肯定不止一个，根据我们驱动的分层思想，它肯定会把共性的东西抽出来

我们来看这个驱动的入口函数

static int __init
fbmem_init(void)
{
proc_create("fb", 0, NULL, &fb_proc_fops);


if (register_chrdev(FB_MAJOR,"fb",&fb_fops))
printk("unable to get major %d for fb devs\n", FB_MAJOR);  //这里 主设备号有了，fops结构体也有了


fb_class = class_create(THIS_MODULE, "graphics"); //创建类
if (IS_ERR(fb_class)) {
printk(KERN_WARNING "Unable to create fb class; errno = %ld\n", PTR_ERR(fb_class));
fb_class = NULL;
}
return 0;
}

static const struct file_operations fb_fops = {
.owner = THIS_MODULE,
.read = fb_read,
.write = fb_write,
.unlocked_ioctl = fb_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl = fb_compat_ioctl,
#endif
.mmap = fb_mmap,
.open = fb_open,
.release = fb_release,
#ifdef HAVE_ARCH_FB_UNMAPPED_AREA
.get_unmapped_area = get_fb_unmapped_area,
#endif
#ifdef CONFIG_FB_DEFERRED_IO
.fsync = fb_deferred_io_fsync,
#endif
.llseek = default_llseek,
};

我们是不是可以通过这些函数来操作LCD呢，那肯定不行，这是通用的文件

LCD驱动程序：

假设

app : open("/dev/fb0",.....); 假设主设备号是29，次设备号为0

————————————————————————————

最终会找到我们file_operations的open函数

static int
fb_open(struct inode *inode, struct file *file)
__acquires(&info->lock)
__releases(&info->lock)
{
int fbidx = iminor(inode);  //得到这个设备节点的次设备号

struct fb_info *info;          //这里有个结构体  fb是frame_buffer 是帧缓存区的意思，
int res = 0;


info = get_fb_info(fbidx);  来看看这个函数

static struct fb_info *get_fb_info(unsigned int idx)
{
struct fb_info *fb_info;


if (idx >= FB_MAX)
return ERR_PTR(-ENODEV);


mutex_lock(&registration_lock);
fb_info = registered_fb[idx];//以这个次设备号为下标，从这个数组里面得到一项，
if (fb_info)
atomic_inc(&fb_info->count);
mutex_unlock(&registration_lock);


return fb_info;
}

}

  if (!info) {

request_module("fb%d", fbidx);
info = get_fb_info(fbidx);
if (!info)
return -ENODEV;
}
if (IS_ERR(info))
return PTR_ERR(info);


mutex_lock(&info->lock);
if (!try_module_get(info->fbops->owner)) {
res = -ENODEV;
goto out;
}
file->private_data = info;
if (info->fbops->fb_open) {  //如果有open函数的话就调用open函数，没有就返回
res = info->fbops->fb_open(info,1);
if (res)
module_put(info->fbops->owner);
}
#ifdef CONFIG_FB_DEFERRED_IO
if (info->fbdefio)
fb_deferred_io_open(info, inode, file);
#endif
out:
mutex_unlock(&info->lock);
if (res)
put_fb_info(info);
return res;
}

那么读呢，假设我们想对这片内存，看看LCD上面有什么东西

怎么读呢

应用程序来读

————————————————————

最终会调用到驱动中的read函数

static ssize_t
fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
unsigned long p = *ppos;
struct fb_info *info = file_fb_info(file);

//来看看这个函数  file_fb_info(file)

static struct fb_info *file_fb_info(struct file *file)
{
struct inode *inode = file->f_path.dentry->d_inode; 
int fbidx = iminor(inode);  //得到次设备号
struct fb_info *info = registered_fb[fbidx]; 以次设备号为下标，得到这个数组里面得到一项


if (info != file->private_data)
info = NULL;
return info;
}

u8 *buffer, *dst;
u8 __iomem *src;
int c, cnt = 0, err = 0;
unsigned long total_size;

//*这些是参数的判断我们不用管
if (!info || ! info->screen_base)
return -ENODEV;


if (info->state != FBINFO_STATE_RUNNING)
return -EPERM;


if (info->fbops->fb_read)  //如果这个里面提供了fops我们就调用它的read函数
return info->fbops->fb_read(info, buf, count, ppos);

如果没有提供的话

total_size = info->screen_size;screen_size屏幕大小


if (total_size == 0)
total_size = info->fix.smem_len;


if (p >= total_size)
return 0;


if (count >= total_size)
count = total_size;


if (count + p > total_size)
count = total_size - p;


buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
 GFP_KERNEL); //分配一块缓冲期

if (!buffer)
return -ENOMEM;


src = (u8 __iomem *) (info->screen_base + p); info里面有个成员是screen_base是显存，显存的基地址加上某个偏移值


if (info->fbops->fb_sync)
info->fbops->fb_sync(info);


while (count) {
c  = (count > PAGE_SIZE) ? PAGE_SIZE : count;
dst = buffer;
fb_memcpy_fromfb(dst, src, c);
dst += c;
src += c;


if (copy_to_user(buf, buffer, c)) {
err = -EFAULT;
break;
}
*ppos += c;
buf += c;
cnt += c;
count -= c;
}


kfree(buffer);


return (err) ? err : cnt;
}

read函数主要做的事情是:如果有读函数就调用读函数，如果没有读函数，就从src = (u8 __iomem *) (info->screen_base + p); 这里来读

dst = buffer;目的等于buffer

fb_memcpy_fromfb(dst, src, c);
dst += c;
src += c; 这里的意思是 *dst++=fb_readl(src++);

然后在copy_to_user(buf, buffer, c)

可以看到open与read都依赖于一个结构体，fb_info结构体，这个结构体哪里来呢

fb_info = registered_fb[idx]；从这个数组中得到，以设备号未下标，在这个次设备号上得到的

那么这个数组在哪里被设置？？？

我们可以看到fbmem.c都是一些抽象出来的东西，最终还是要依赖与fb_info这个结构体

这个结构体在哪里被设置

在fb.h被定义

在int
register_framebuffer(struct fb_info *fb_info)
{
int ret;


mutex_lock(&registration_lock);
ret = do_register_framebuffer(fb_info);
mutex_unlock(&registration_lock);


return ret;
}

这个里面的

do_register_framebuffer 这个函数中的registered_fb[i] = fb_info;这一行

这就体现了分层的思想

fbmem.c这里提供了一些抽象的东西

硬件相关的操作通过register_framebuffer 反应给fbmem.c

我们来看一看register_framebuffer这个函数做了什么事情

static int do_register_framebuffer(struct fb_info *fb_info)
{
int i;
struct fb_event event;
struct fb_videomode mode;


if (fb_check_foreignness(fb_info))
return -ENOSYS;


do_remove_conflicting_framebuffers(fb_info->apertures, fb_info->fix.id,
 fb_is_primary_device(fb_info));


if (num_registered_fb == FB_MAX)
return -ENXIO;


num_registered_fb++;
for (i = 0 ; i < FB_MAX; i++)
if (!registered_fb[i])
break;                //先找到空项
fb_info->node = i;
atomic_set(&fb_info->count, 1);
mutex_init(&fb_info->lock);
mutex_init(&fb_info->mm_lock);


fb_info->dev = device_create(fb_class, fb_info->device,
     MKDEV(FB_MAJOR, i), NULL, "fb%d", i);  //找到空项之后在类下面创建设备，只有真正有这个硬件的时候才去创建设备节点
if (IS_ERR(fb_info->dev)) {
/* Not fatal */
printk(KERN_WARNING "Unable to create device for framebuffer %d; errno = %ld\n", i, PTR_ERR(fb_info->dev));
fb_info->dev = NULL;
} else
fb_init_device(fb_info);


if (fb_info->pixmap.addr == NULL) {
fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL);
if (fb_info->pixmap.addr) {
fb_info->pixmap.size = FBPIXMAPSIZE;
fb_info->pixmap.buf_align = 1;
fb_info->pixmap.scan_align = 1;
fb_info->pixmap.access_align = 32;
fb_info->pixmap.flags = FB_PIXMAP_DEFAULT;
}
}
fb_info->pixmap.offset = 0;


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


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


if (!fb_info->modelist.prev || !fb_info->modelist.next)
INIT_LIST_HEAD(&fb_info->modelist);


fb_var_to_videomode(&mode, &fb_info->var);
fb_add_videomode(&mode, &fb_info->modelist);
registered_fb[i] = fb_info;


event.info = fb_info;
if (!lock_fb_info(fb_info))
return -ENODEV;
fb_notifier_call_chain(FB_EVENT_FB_REGISTERED, &event);
unlock_fb_info(fb_info);
return 0;
}

我们搜索这个函数，发现很多lcd的驱动程序都调用了这个函数

这就是我们设备相关的操作

以前我们的驱动都是自己写，现在改了 内核帮我们写一部分

我们来看一看S3c2410fb.c看看人家做什么事情

看驱动程序从入口开始看

int __init s3c2410fb_init(void)
{
int ret = platform_driver_register(&s3c2410fb_driver);


if (ret == 0)
ret = platform_driver_register(&s3c2412fb_driver);


return ret;
}

注册一个平台driver

总线设备模型 我们进入它的probe函数

static int __devinit s3c24xxfb_probe(struct platform_device *pdev,
  enum s3c_drv_type drv_type)
{
struct s3c2410fb_info *info;
struct s3c2410fb_display *display;
struct fb_info *fbinfo;
struct s3c2410fb_mach_info *mach_info;
struct resource *res;
int ret;
int irq;
int i;
int size;
u32 lcdcon1;


mach_info = pdev->dev.platform_data;
if (mach_info == NULL) {
dev_err(&pdev->dev,
"no platform data for lcd, cannot attach\n");
return -EINVAL;
}


if (mach_info->default_display >= mach_info->num_displays) {
dev_err(&pdev->dev, "default is %d but only %d displays\n",
mach_info->default_display, mach_info->num_displays);
return -EINVAL;
}


display = mach_info->displays + mach_info->default_display;


irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(&pdev->dev, "no irq for device\n");
return -ENOENT;
}
  //根据平台设备，获得硬件相关的信息

fbinfo = framebuffer_alloc(sizeof(struct s3c2410fb_info), &pdev->dev);  分配一个fb_info结构体
if (!fbinfo)
return -ENOMEM;


platform_set_drvdata(pdev, fbinfo);


info = fbinfo->par;
info->dev = &pdev->dev;
info->drv_type = drv_type;


res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(&pdev->dev, "failed to get memory registers\n");
ret = -ENXIO;
goto dealloc_fb;
}


size = (res->end - res->start) + 1;
info->mem = request_mem_region(res->start, size, pdev->name);
if (info->mem == NULL) {
dev_err(&pdev->dev, "failed to get memory region\n");
ret = -ENOENT;
goto dealloc_fb;
}


info->io = ioremap(res->start, size);
if (info->io == NULL) {
dev_err(&pdev->dev, "ioremap() of registers failed\n");
ret = -ENXIO;
goto release_mem;
}
info->irq_base = info->io + ((drv_type == DRV_S3C2412) ? S3C2412_LCDINTBASE : S3C2410_LCDINTBASE);


dprintk("devinit\n");


strcpy(fbinfo->fix.id, driver_name);


/* Stop the video */
lcdcon1 = readl(info->io + S3C2410_LCDCON1);
writel(lcdcon1 & ~S3C2410_LCDCON1_ENVID, info->io + S3C2410_LCDCON1);


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->fbops    = &s3c2410fb_ops;
fbinfo->flags    = FBINFO_FLAG_DEFAULT;
fbinfo->pseudo_palette      = &info->pseudo_pal;


for (i = 0; i < 256; i++)
info->palette_buffer[i] = PALETTE_BUFF_CLEAR;


ret = request_irq(irq, s3c2410fb_irq, IRQF_DISABLED, pdev->name, info);
if (ret) {
dev_err(&pdev->dev, "cannot get irq %d - err %d\n", irq, ret);
ret = -EBUSY;
goto release_regs;
}


info->clk = clk_get(NULL, "lcd");
if (IS_ERR(info->clk)) {
printk(KERN_ERR "failed to get lcd clock source\n");
ret = PTR_ERR(info->clk);
goto release_irq;
}


clk_enable(info->clk);
dprintk("got and enabled clock\n");


msleep(1);


info->clk_rate = clk_get_rate(info->clk);


/* find maximum required memory size for display */
for (i = 0; i < mach_info->num_displays; i++) {
unsigned long smem_len = mach_info->displays[i].xres;


smem_len *= mach_info->displays[i].yres;
smem_len *= mach_info->displays[i].bpp;
smem_len >>= 3;
if (fbinfo->fix.smem_len < smem_len)
fbinfo->fix.smem_len = smem_len;
}


/* Initialize video memory */
ret = s3c2410fb_map_video_memory(fbinfo);
if (ret) {
printk(KERN_ERR "Failed to allocate video RAM: %d\n", ret);
ret = -ENOMEM;
goto release_clock;
}


dprintk("got video memory\n");


fbinfo->var.xres = display->xres;
fbinfo->var.yres = display->yres;

fbinfo->var.bits_per_pixel = display->bpp;


s3c2410fb_init_registers(fbinfo);


s3c2410fb_check_var(&fbinfo->var, fbinfo);


ret = s3c2410fb_cpufreq_register(info);
if (ret < 0) {
dev_err(&pdev->dev, "Failed to register cpufreq\n");
goto free_video_memory;
}

/前面都是硬件相关的操作，然后调用ret = register_framebuffer(fbinfo);注册framebuffer；

ret = register_framebuffer(fbinfo);

if (ret < 0) {
printk(KERN_ERR "Failed to register framebuffer device: %d\n",
ret);
goto free_cpufreq;
}


/* create device files */
ret = device_create_file(&pdev->dev, &dev_attr_debug);
if (ret) {
printk(KERN_ERR "failed to add debug attribute\n");
}


printk(KERN_INFO "fb%d: %s frame buffer device\n",
fbinfo->node, fbinfo->fix.id);


return 0;


 free_cpufreq:
s3c2410fb_cpufreq_deregister(info);
free_video_memory:
s3c2410fb_unmap_video_memory(fbinfo);
release_clock:
clk_disable(info->clk);
clk_put(info->clk);
release_irq:
free_irq(irq, info);
release_regs:
iounmap(info->io);
release_mem:
release_resource(info->mem);
kfree(info->mem);
dealloc_fb:
platform_set_drvdata(pdev, NULL);
framebuffer_release(fbinfo);
return ret;
}

所以我们硬件相关的驱动做如下几件事情

1.分配一个fb_info结构体

2.设置

3.注册

4.硬件相关的操作

我们想得到一个LCD的分辨率该怎么做呢

调用我们的fbmem里面的ioctl

static long do_fb_ioctl(struct fb_info *info, unsigned int cmd,
unsigned long arg)
{
struct fb_ops *fb;
struct fb_var_screeninfo var;
struct fb_fix_screeninfo fix;
struct fb_con2fbmap con2fb;
struct fb_cmap cmap_from;
struct fb_cmap_user cmap;
struct fb_event event;
void __user *argp = (void __user *)arg;
long ret = 0;


switch (cmd) {
case FBIOGET_VSCREENINFO:   //v是var可变的，屏幕信息，它以次设备号为小标，得到一个fb_info结构体
if (!lock_fb_info(info))
return -ENODEV;
var = info->var;
unlock_fb_info(info);


ret = copy_to_user(argp, &var, sizeof(var)) ? -EFAULT : 0;   把这个结构体体中的var拷贝到用户空间

我们来看一看这个成员里面有什么东西

/*__________________________________________________________________________________

struct fb_var_screeninfo {
__u32 xres; /* visible resolution */    
__u32 yres; x,y方向的分辨率
__u32 xres_virtual;/* virtual resolution */
__u32 yres_virtual;
__u32 xoffset;/* offset from virtual to visible */
__u32 yoffset;/* resolution */


__u32 bits_per_pixel;/* guess what */
__u32 grayscale;/* != 0 Graylevels instead of colors */


struct fb_bitfield red;/* bitfield in fb mem if true color, */
struct fb_bitfield green;/* else only length is significant */
struct fb_bitfield blue;
struct fb_bitfield transp;/* transparency */


__u32 nonstd; /* != 0 Non standard pixel format */


__u32 activate;/* see FB_ACTIVATE_* */


__u32 height; /* height of picture in mm    */
__u32 width; /* width of picture in mm     */


__u32 accel_flags;/* (OBSOLETE) see fb_info.flags */


/* Timing: All values in pixclocks, except pixclock (of course) */
__u32 pixclock;/* pixel clock in ps (pico seconds) */
__u32 left_margin;/* time from sync to picture */
__u32 right_margin;/* time from picture to sync */
__u32 upper_margin;/* time from sync to picture */
__u32 lower_margin;
__u32 hsync_len;/* length of horizontal sync */
__u32 vsync_len;/* length of vertical sync */
__u32 sync; /* see FB_SYNC_* */
__u32 vmode; /* see FB_VMODE_* */
__u32 rotate; /* angle we rotate counter clockwise */
__u32 reserved[5];/* Reserved for future compatibility */
};______________________________________________________________--*/
break;
case FBIOPUT_VSCREENINFO:
if (copy_from_user(&var, argp, sizeof(var)))
return -EFAULT;
if (!lock_fb_info(info))
return -ENODEV;
console_lock();
info->flags |= FBINFO_MISC_USEREVENT;
ret = fb_set_var(info, &var);
info->flags &= ~FBINFO_MISC_USEREVENT;
console_unlock();
unlock_fb_info(info);
if (!ret && copy_to_user(argp, &var, sizeof(var)))
ret = -EFAULT;
break;
case FBIOGET_FSCREENINFO:
if (!lock_fb_info(info))
return -ENODEV;
fix = info->fix;
unlock_fb_info(info);


ret = copy_to_user(argp, &fix, sizeof(fix)) ? -EFAULT : 0;
break;
case FBIOPUTCMAP:
if (copy_from_user(&cmap, argp, sizeof(cmap)))
return -EFAULT;
ret = fb_set_user_cmap(&cmap, info);
break;
case FBIOGETCMAP:
if (copy_from_user(&cmap, argp, sizeof(cmap)))
return -EFAULT;
if (!lock_fb_info(info))
return -ENODEV;
cmap_from = info->cmap;
unlock_fb_info(info);
ret = fb_cmap_to_user(&cmap_from, &cmap);
break;
case FBIOPAN_DISPLAY:
if (copy_from_user(&var, argp, sizeof(var)))
return -EFAULT;
if (!lock_fb_info(info))
return -ENODEV;
console_lock();
ret = fb_pan_display(info, &var);
console_unlock();
unlock_fb_info(info);
if (ret == 0 && copy_to_user(argp, &var, sizeof(var)))
return -EFAULT;
break;
case FBIO_CURSOR:
ret = -EINVAL;
break;
case FBIOGET_CON2FBMAP:
if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
return -EFAULT;
if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
return -EINVAL;
con2fb.framebuffer = -1;
event.data = &con2fb;
if (!lock_fb_info(info))
return -ENODEV;
event.info = info;
fb_notifier_call_chain(FB_EVENT_GET_CONSOLE_MAP, &event);
unlock_fb_info(info);
ret = copy_to_user(argp, &con2fb, sizeof(con2fb)) ? -EFAULT : 0;
break;
case FBIOPUT_CON2FBMAP:
if (copy_from_user(&con2fb, argp, sizeof(con2fb)))
return -EFAULT;
if (con2fb.console < 1 || con2fb.console > MAX_NR_CONSOLES)
return -EINVAL;
if (con2fb.framebuffer < 0 || con2fb.framebuffer >= FB_MAX)
return -EINVAL;
if (!registered_fb[con2fb.framebuffer])
request_module("fb%d", con2fb.framebuffer);
if (!registered_fb[con2fb.framebuffer]) {
ret = -EINVAL;
break;
}
event.data = &con2fb;
if (!lock_fb_info(info))
return -ENODEV;
event.info = info;
ret = fb_notifier_call_chain(FB_EVENT_SET_CONSOLE_MAP, &event);
unlock_fb_info(info);
break;
case FBIOBLANK:
if (!lock_fb_info(info))
return -ENODEV;
console_lock();
info->flags |= FBINFO_MISC_USEREVENT;
ret = fb_blank(info, arg);
info->flags &= ~FBINFO_MISC_USEREVENT;
console_unlock();
unlock_fb_info(info);
break;
default:
if (!lock_fb_info(info))
return -ENODEV;
fb = info->fbops;
if (fb->fb_ioctl)
ret = fb->fb_ioctl(info, cmd, arg);
else
ret = -ENOTTY;
unlock_fb_info(info);
}
return ret;
}