linux lcd设备驱动剖析三

上一节文章中详细地剖析了probe函数，但是从始至终都没有看到打开读写文件接口的操作函数，只看到了下面这个操作结构体

static struct fb_ops s3c2410fb_ops = {
	.owner			= THIS_MODULE,
	.fb_check_var	= s3c2410fb_check_var,
	.fb_set_par		= s3c2410fb_set_par,
	.fb_blank		= s3c2410fb_blank,
	.fb_setcolreg	= s3c2410fb_setcolreg,
	.fb_fillrect	= cfb_fillrect,
	.fb_copyarea	= cfb_copyarea,
	.fb_imageblit	= cfb_imageblit,
};

这并不是我们想要的打开读写操作函数。上一节文章链接： http://blog.csdn.net/lwj103862095/article/details/18189765
问：那到底帧缓冲设备的文件操作结构体在哪里呢？

答：在drivers/vedio/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);

	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;
}

fbmem_init注册了一个主设备号为29的字符设备，并创了graphics类（图形类）。

字符设备有一个关键的成员是文件操作结构体

static const struct file_operations fb_fops = {
	.owner 			= THIS_MODULE,
	.read 			= fb_read,
	.write 			= fb_write,
	.unlocked_ioctl = fb_ioctl,
	.mmap 			= fb_mmap,
	.open 			= fb_open,
	.release 		= fb_release,
#ifdef HAVE_ARCH_FB_UNMAPPED_AREA
	.get_unmapped_area = get_fb_unmapped_area,
#endif
};

理所当然的，我们应当首先看的函数是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;
	int res = 0;

	if (fbidx >= FB_MAX)			/* 次设备号有没有大于规定的最大值32 */
		return -ENODEV;				/* 没有这样的设备 */
	info = registered_fb[fbidx];	/* 使用次设备号得到fb_info结构体 */
	if (!info)
		request_module("fb%d", fbidx);

	/* 再次使用次设备号得到fb_info结构体 */
	info = registered_fb[fbidx];
	if (!info)
		return -ENODEV;
	
	mutex_lock(&info->lock);		/* 获取mutex */

	/* 获取模块使用计数module，成功返回非NULL */
	if (!try_module_get(info->fbops->owner)) {
		res = -ENODEV;
		goto out;
	}

	/* 从registered_fb[]数组项里找到一个fb_info结构体保存到
	 * struct file结构中的私有信息指针赋值给它呢是为了以后调用
	 * read、write、ioctl等系统调用时找到这个struct fb_info结构
	 */
	file->private_data = info;	

	/* registered_fb[]数组项里有没有默认的fb_open函数,如果有就使用它 */
	if (info->fbops->fb_open) {
		res = info->fbops->fb_open(info,1);	

		/* 有默认的fb_open并成功打开就删除模块计数 */
		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);	/* 释放mutex */
	return res;
}

发现fb_open函数是围绕fb_info来实现的，而 fb_info设置为registered_fb[fbidx]

问：registered_fb[fbidx]结构体数组是在哪里被设置？

答：register_framebuffer函数里设置registered_fb

/* register_framebuffer()函数的主要工作是设置fb_info结构体的一些成员 */
int
register_framebuffer(struct fb_info *fb_info)
{
	int i;
	struct fb_event event;
	struct fb_videomode mode;

	/* num_registered_fb代表注册帧缓冲设备的个数 */
	if (num_registered_fb == FB_MAX)
		return -ENXIO;

	if (fb_check_foreignness(fb_info))
		return -ENOSYS;

	num_registered_fb++;

	/* 当registered_fb[]项都为NULL，就会break,找到一个空的次设备号 */
	for (i = 0 ; i < FB_MAX; i++)
		if (!registered_fb[i])	
			break;
	fb_info->node = i;
	mutex_init(&fb_info->lock);		/* 初始化mutex */

	/* 因为在init加载函数里只创建了类，这里在类下面创建设备 */
	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);	/* 对struct fb_info做一些初始化 */


	/* 初始化fb_info->pixmap结构体成员 */
	if (fb_info->pixmap.addr == NULL) {
		fb_info->pixmap.addr = kmalloc(FBPIXMAPSIZE, GFP_KERNEL); /* 8K大小 */
		if (fb_info->pixmap.addr) {
			fb_info->pixmap.size = FBPIXMAPSIZE;	/* 8K */
			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);	/* 初始化modelist链表 */

	fb_var_to_videomode(&mode, &fb_info->var);
	fb_add_videomode(&mode, &fb_info->modelist);

	/* registered_fb[]数组项在这里被设置 */
	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;
}

fb_read函数源码分析

static ssize_t
fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
	unsigned long p = *ppos;
	/* 通过file结构体的成员得到inode节点 */
	struct inode *inode = file->f_path.dentry->d_inode;

	/* 获取次设备号 */
	int fbidx = iminor(inode);
	/* 以次设备号为下标找到一项fb_info结构体 */
	struct fb_info *info = registered_fb[fbidx];
	
	u32 *buffer, *dst;
	u32 __iomem *src;
	int c, i, cnt = 0, err = 0;
	unsigned long total_size;

	if (!info || ! info->screen_base) /* screen_base是虚拟(显存)基地址 */
		return -ENODEV;

	if (info->state != FBINFO_STATE_RUNNING)
		return -EPERM;		/* 禁止操作 */

	/* 如果registered_fb[]项里面提供了fb_read()函数，就调用下面的函数 */
	if (info->fbops->fb_read)
		return info->fbops->fb_read(info, buf, count, ppos);

	/* 没有默认的读函数就从下面的screen_base里读数据 */
	total_size = info->screen_size;  /* x*y*4，x,y分别为屏幕分辨率 */

	if (total_size == 0)
		total_size = info->fix.smem_len;	/* fb缓冲区的长度 */

	if (p >= total_size)			/* 调整读的偏移位置 */
		return 0;

	if (count >= total_size)
		count = total_size;  		/* 一次性最多读多少个字节 */

	if (count + p > total_size)
		count = total_size - p;		/* 调整读的位置及能读多少字节 */

	/* 分配内存，最大分配4K的大小 */
	buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
			 GFP_KERNEL);		
	if (!buffer)
		return -ENOMEM;

	src = (u32 __iomem *) (info->screen_base + p);  /* 源虚拟基地址 */

	/* 如果registered_fb[]项里面提供了fb_sync()函数，就调用下面的函数 */
	if (info->fbops->fb_sync)		
		info->fbops->fb_sync(info);

	while (count) {
		/* 读多少计数变量，单位为byte */
		c  = (count > PAGE_SIZE) ? PAGE_SIZE : count; 
		
		/* buffer是指向刚分配内存的首地址的指针 */
		dst = buffer;	/* dst指针指向buffer */

		/* 先除以4，因为每次读4个字节 */
		for (i = c >> 2; i--; )			
			*dst++ = fb_readl(src++);	/* 拷贝源虚拟机基地址的数据到目标地址 */

		/* 判断是否以字节为单位来读取 */
		if (c & 3) {					
			u8 *dst8 = (u8 *) dst;
			u8 __iomem *src8 = (u8 __iomem *) src;

			for (i = c & 3; i--;)
				*dst8++ = fb_readb(src8++);/* 拷贝源虚拟机基地址的数据到目标地址 */

			src = (u32 __iomem *) src8;
		}

		/* 从内核刚申请内存的地址buffer拷贝c长度的数据到用户空间的buf里去 */
		if (copy_to_user(buf, buffer, c)) {
			err = -EFAULT;	/* 成功拷贝，则err返回值为0 */
			break;
		}
		*ppos += c;		/* 调整偏移位置 */
		buf += c;		/* 调整用户的buf */
		cnt += c;
		/* count变量减去已经读取的c数量，用于判断while(count)是否为真*/
		count -= c;		
	}

	kfree(buffer);		/* 释放内存 */

	return (err) ? err : cnt;	/* err = 0时，返回被拷贝成功的数量cnt */
}

fb_write函数源码分析

static ssize_t
fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
	unsigned long p = *ppos;
	struct inode *inode = file->f_path.dentry->d_inode;
	int fbidx = iminor(inode);
	struct fb_info *info = registered_fb[fbidx];
	u32 *buffer, *src;
	u32 __iomem *dst;
	int c, i, 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_write)
		return info->fbops->fb_write(info, buf, count, ppos);
	
	total_size = info->screen_size;

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

	if (p > total_size)
		return -EFBIG;

	if (count > total_size) {
		err = -EFBIG;
		count = total_size;
	}

	if (count + p > total_size) {
		if (!err)
			err = -ENOSPC;

		count = total_size - p;
	}

	buffer = kmalloc((count > PAGE_SIZE) ? PAGE_SIZE : count,
			 GFP_KERNEL);
	if (!buffer)
		return -ENOMEM;

	dst = (u32 __iomem *) (info->screen_base + p);	/* 源虚拟基地址 */

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

	while (count) {
		c = (count > PAGE_SIZE) ? PAGE_SIZE : count;
		src = buffer;	/* buffer为指向刚申请的内存的指针 */


		/* 从用户空间的buf地址里拷贝c长度的数据到src内存里，成功时返回0 */
		if (copy_from_user(src, buf, c)) {
			err = -EFAULT;
			break;
		}

		for (i = c >> 2; i--; )			/* 以4字节为单位拷贝数据 */
			fb_writel(*src++, dst++);	/*     *dst++ = *src++     */

		if (c & 3) {					/* 以字节为单位拷贝数据 */
			u8 *src8 = (u8 *) src;
			u8 __iomem *dst8 = (u8 __iomem *) dst;

			for (i = c & 3; i--; )
				fb_writeb(*src8++, dst8++);

			dst = (u32 __iomem *) dst8;
		}

		*ppos += c;
		buf += c;
		cnt += c;
		count -= c;
	}

	kfree(buffer);

	return (cnt) ? cnt : err;
}

fb_ioctl函数源码分析

static long fb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	int fbidx = iminor(inode);
	struct fb_info *info = registered_fb[fbidx];

	/* 这个才是真正的fb_ioctl驱动函数 */
	return do_fb_ioctl(info, cmd, arg);	
}

do_fb_ioctl函数根据cmd来设置各种命令，这里仅举例说明：

switch (cmd) {
	case FBIOGET_VSCREENINFO:		/* 获得可变的屏幕参数 */
		if (!lock_fb_info(info))	/* 如果info->fbops不为空，则上锁，成功返回1 */
			return -ENODEV;
		var = info->var;			/* 可变参数变量的设置 */
		unlock_fb_info(info);		/* 解锁 */

		/* 从内核空间的var地址拷贝var大小的数据到用户空间的argp地址里去 */
		ret = copy_to_user(argp, &var, sizeof(var)) ? -EFAULT : 0; /* 成功返回0 */
		break;

fb_mmap源码分析：

/* 这里分配的显存是在内核空间分配的，用户空间并不能直接访问，
 * 所以需要用到这里的mmap函数，直接将这段内存空间映射到
 * 用户空间去，用户空间就能访问这段内存空间了。
 */
static int
fb_mmap(struct file *file, struct vm_area_struct * vma)
__acquires(&info->lock)
__releases(&info->lock)
{
	int fbidx = iminor(file->f_path.dentry->d_inode);
	struct fb_info *info = registered_fb[fbidx]; /* 通过次设备号找到fb_info结构体 */
	struct fb_ops *fb = info->fbops;
	unsigned long off;
	unsigned long start;
	u32 len;

	if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
		return -EINVAL;
	off = vma->vm_pgoff << PAGE_SHIFT;
	if (!fb)
		return -ENODEV;

	/* 如果registered_fb[]里有默认的fb_mmap就使用它 */
	if (fb->fb_mmap) {
		int res;
		mutex_lock(&info->lock);
		res = fb->fb_mmap(info, vma);
		mutex_unlock(&info->lock);
		return res;
	}

	mutex_lock(&info->lock);

	/* frame buffer memory */
	start = info->fix.smem_start;	/* fb缓冲内存的开始位置(物理地址) */
	len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.smem_len);
	if (off >= len) {				/* 偏移值大于len长度 */
		/* memory mapped io */		/* 内存映射的IO */
		off -= len;
		if (info->var.accel_flags) {
			mutex_unlock(&info->lock);
			return -EINVAL;
		}
		start = info->fix.mmio_start;
		len = PAGE_ALIGN((start & ~PAGE_MASK) + info->fix.mmio_len);
	}
	mutex_unlock(&info->lock);
	start &= PAGE_MASK;
	if ((vma->vm_end - vma->vm_start + off) > len)
		return -EINVAL;
	off += start;
	vma->vm_pgoff = off >> PAGE_SHIFT;
	/* This is an IO map - tell maydump to skip this VMA */
	vma->vm_flags |= VM_IO | VM_RESERVED;
	fb_pgprotect(file, vma, off);

	/* io_remap_pfn_range正式映射物理内存到用户空间虚拟地址 */
	if (io_remap_pfn_range(vma, vma->vm_start, off >> PAGE_SHIFT,
			     vma->vm_end - vma->vm_start, vma->vm_page_prot))
		return -EAGAIN;
	return 0;
}

问：怎么写LCD驱动程序？
1. 分配一个fb_info结构体: framebuffer_alloc
2. 设置
3. 注册: register_framebuffer
4. 硬件相关的操作