framebuffer 设备即帧缓冲设备（简写fb）提供了显示接口的抽象描述。他同时代表着显示接口的存储区，应用程序通过定义好的函数访问，不需要知道底层的任何操作。 Framebuffer 驱动使用的设备节点，通常位于/dev 目录，如/dev/fb*.从用户角度看，fb 设备和其他/dev 下面的设备类似：普通的字符设备，主设备号29，次设备号定义fb 的索引。通常，使用如下方式（前面的数字表示次设备号）0 = /dev/fb0 第一个fb 设备，1 = /dev/fb1 第二个fb 设备，fb 也是一种普通的内存设备，可以读写其内容。例如，屏幕抓屏：cp /dev/fb0 myfile，fb 虽然可以像内存设备（/dev/mem）一样，对其read,write,seek 以及mmap。但区别在于fb 使用的不是整个内存区，而是显存部分。通过ioctl 可以读取或设定fb 设备参数，很重要的一点，颜色表(cmap)也要通过Ioctl 设定。你可以获取设备一些不变的信息，如设备名，屏幕的组织（平面，象素,...)对应内存区的长度和起始地址。也可以获取能够改变的信息，例如位深，颜色格式，时序等。如果你改变这些值，驱动程序将对值进行优化，以满足设备特性。framebuffer是LCD控制器相关的驱动，CPU可以通过寻址的方式访问LCD控制器，所以framebuffer一般是platform driver，所以用platform driver的架构来编写framebuffer驱动。
当我们想编写一个FB设备驱动时，一个比较好的方法是注册platform设备，然后将FB设备的注册，IO映射操作，硬件初始化等操作放在在probe中进行，从而整体上结构清晰。
一. 重要数据结构
1. 帧缓冲区描述符 fb_info
struct fb_info {
atomic_t count;
int node;
int flags;
struct mutex lock; /* Lock for open/release/ioctl funcs */
struct mutex mm_lock; /* Lock for fb_mmap and smem_* fields */
struct fb_var_screeninfo var; /* Current var */ //缓冲区可变参数
struct fb_fix_screeninfo fix; /* Current fix */ //缓冲区固定参数
struct fb_monspecs monspecs; /* Current Monitor specs */ //当前显示器
struct work_struct queue; /* Framebuffer event queue */ //事件工作队列
struct fb_pixmap pixmap; /* Image hardware mapper */ //图像硬件映射
struct fb_pixmap sprite; /* Cursor hardware mapper */ //光标硬件映射
struct fb_cmap cmap; /* Current cmap */
struct list_head modelist; /* mode list */ //视频模式链表
struct fb_videomode *mode; /* current mode */ //当前视频模式
#ifdef CONFIG_FB_BACKLIGHT //支持背光的参数
struct backlight_device *bl_dev;
struct mutex bl_curve_mutex;
u8 bl_curve[FB_BACKLIGHT_LEVELS];
#endif
#ifdef CONFIG_FB_DEFERRED_IO
struct delayed_work deferred_work;
struct fb_deferred_io *fbdefio;
#endif
struct fb_ops *fbops; //帧缓冲区操作函数，framebuffer驱动的核心数据结构
struct device *device; /* This is the parent */ //父设备
struct device *dev; /* This is this fb device */ //FB设备
int class_flag; /* private sysfs flags */
#ifdef CONFIG_FB_TILEBLITTING
struct fb_tile_ops *tileops; /* Tile Blitting */
#endif
char __iomem *screen_base; /* Virtual address */
unsigned long screen_size; /* Amount of ioremapped VRAM or 0 */
void *pseudo_palette; /* Fake palette of 16 colors */
#define FBINFO_STATE_RUNNING 0
#define FBINFO_STATE_SUSPENDED 1
u32 state; /* Hardware state i.e suspend */
void *fbcon_par; /* fbcon use-only private area */
void *par;
struct apertures_struct {
unsigned int count;
struct aperture {
resource_size_t base;
resource_size_t size;
} ranges[0];
} *apertures;
};
2. 帧缓冲区操作函数表 fb_ops
struct fb_ops {
struct module *owner; //模块所有者
int (*fb_open)(struct fb_info *info, int user); //FB打开操作
int (*fb_release)(struct fb_info *info, int user); //FB释放操作
ssize_t (*fb_read)(struct fb_info *info, char __user *buf,size_t count, loff_t *ppos); //FB读操作
ssize_t (*fb_write)(struct fb_info *info, const char __user *buf,size_t count, loff_t *ppos); //FB写操作
int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);//检查FB可变变量，并调整为可用值
int (*fb_set_par)(struct fb_info *info); //设置视频模式
int (*fb_setcolreg)(unsigned regno, unsigned red, unsigned green,unsigned blue, unsigned transp, struct fb_info *info); //设置颜色寄存器
int (*fb_setcmap)(struct fb_cmap *cmap, struct fb_info *info); //批量设置颜色寄存器，并设置颜色表
int (*fb_blank)(int blank, struct fb_info *info); //空白显示
int (*fb_pan_display)(struct fb_var_screeninfo *var, struct fb_info *info); //面板显示
void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect); //画矩形
void (*fb_copyarea) (struct fb_info *info, const struct fb_copyarea *region);//把数据拷贝到另外一个区域
void (*fb_imageblit) (struct fb_info *info, const struct fb_image *image);//在帧缓冲去中显示一个图片
int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor); //绘制光标
void (*fb_rotate)(struct fb_info *info, int angle); //旋转显示
int (*fb_sync)(struct fb_info *info); //等待并同步图像显示完成
int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,unsigned long arg);//FB的IOCTL操作
int (*fb_compat_ioctl)(struct fb_info *info, unsigned cmd,unsigned long arg);
int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma); //FB的内存映射MMAP操作
void (*fb_get_caps)(struct fb_info *info, struct fb_blit_caps *caps,struct fb_var_screeninfo *var);
void (*fb_destroy)(struct fb_info *info);
int (*fb_debug_enter)(struct fb_info *info);
int (*fb_debug_leave)(struct fb_info *info);
};
3. 固定参数描述符
struct fb_fix_screeninfo {
char id[16]; /* identification string eg "TT Builtin" *///FB ID
unsigned long smem_start; /* Start of frame buffer mem */ //FB缓存开始位置
/* (physical address) */ //物理地址相关
__u32 smem_len; /* Length of frame buffer mem */ //FB缓存长度
__u32 type; /* see FB_TYPE_* */ //FB类型
__u32 type_aux; /* Interleave for interleaved Planes *///FB分界
__u32 visual; /* see FB_VISUAL_* */ //FB色彩模式
__u16 xpanstep; /* zero if no hardware panning */ //没有硬件PAN则赋0
__u16 ypanstep; /* zero if no hardware panning */
__u16 ywrapstep; /* zero if no hardware ywrap */
__u32 line_length; /* length of a line in bytes */ //1行的字节数
unsigned long mmio_start; /* Start of Memory Mapped I/O*///内存IO映射的开始地址
/* (physical address) */
__u32 mmio_len; /* Length of Memory Mapped I/O *///IO 长度
__u32 accel; /* Indicate to driver which */
/* specific chip/card we have */
__u16 capabilities; /* see FB_CAP_* */
__u16 reserved[2]; /* Reserved for future compatibility */
};
4. 可变参数描述符
struct fb_var_screeninfo {
__u32 xres; /* visible resolution */ //可见解析度，分辨率的X轴宽度
__u32 yres; //可见解析度，分辨率的Y轴宽度
__u32 xres_virtual; /* virtual resolution */ //虚拟解析度X轴宽度
__u32 yres_virtual; //虚拟解析度Y轴宽度
__u32 xoffset; /* offset from virtual to visible */ //虚拟与可见解析度之间X轴偏移
__u32 yoffset; /* resolution */ //虚拟与可见解析度之间Y轴偏移
__u32 bits_per_pixel; /* guess what */ //每像素点的位数
__u32 grayscale; /* 0 = color, 1 = grayscale, */ //灰度级别，0表示彩色
/* >1 = FOURCC */
struct fb_bitfield red; /* bitfield in fb mem if true color, */ //RGB位域的红色
struct fb_bitfield green; /* else only length is significant */ //RGB位域的绿色
struct fb_bitfield blue; //RGB位域的蓝色
struct fb_bitfield transp; /* transparency */ //透明色
__u32 nonstd; /* != 0 Non standard pixel format */ //如果该值不为0，非标准像素格式
__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 */
__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 colorspace; /* colorspace for FOURCC-based modes *///颜色空间
__u32 reserved[5]; /* Reserved for future compatibility */
};
5. 调色板描述符
struct fb_cmap {
__u32 start; /* First entry */ //第一个颜色入口
__u32 len; /* Number of entries */ //颜色总数
__u16 *red; /* Red values */ //RGB红色值
__u16 *green; //RGB红绿值
__u16 *blue; //RGB红蓝值
__u16 *transp; /* transparency, can be NULL */ //透明度值
};
二. 主要函数
1. framebuffer_alloc, 为FB驱动分配内存空间并初始化，这个函数的核心的作用是申请一块空间，并转换为struct fb_info 指针返回，在这个申请过程私有数据空间size并非是必须的，需要的话可以有但并非必须。
struct fb_info *framebuffer_alloc(size_t size, struct device *dev)
{
#define BYTES_PER_LONG (BITS_PER_LONG/8)
#define PADDING (BYTES_PER_LONG - (sizeof(struct fb_info) % BYTES_PER_LONG))
int fb_info_size = sizeof(struct fb_info);
struct fb_info *info;
char *p;
if (size)
fb_info_size += PADDING;
p = kzalloc(fb_info_size + size, GFP_KERNEL);
if (!p)
return NULL;
info = (struct fb_info *) p;
if (size)
info->par = p + fb_info_size;
info->device = dev;
#ifdef CONFIG_FB_BACKLIGHT
mutex_init(&info->bl_curve_mutex);
#endif
return info;
#undef PADDING
#undef BYTES_PER_LONG
}
2. register_framebuffer，向系统注册FB。
int register_framebuffer(struct fb_info *fb_info)
{
int ret;
mutex_lock(®istration_lock);
ret = do_register_framebuffer(fb_info);
mutex_unlock(®istration_lock);
return ret;
}
三. 实现framebuffer驱动程序的一个例子的步骤
1. 包含头文件
#include <linux/fb.h>
#include <linux/device.h>
#include <linux/platform_device.h>
2. 定义及初始化相关FB参数结构体
struct fb_var_screeninfo dnfb_var__devinitdata = {
.xres = 1280,
.yres = 1024,
.xres_virtual = 2048,
.yres_virtual = 1024,
.bits_per_pixel = 1,
.height = -1,
.width = -1,
.vmode = FB_VMODE_NONINTERLACED,
};
static struct fb_fix_screeninfo dnfb_fix__devinitdata = {
.id = "Apollo Mono",
.smem_start = (FRAME_BUFFER_START + IO_BASE),
.smem_len = FRAME_BUFFER_LEN,
.type = FB_TYPE_PACKED_PIXELS,
.visual = FB_VISUAL_MONO10,
.line_length = 256,
};
3. 定义及实现结构 fb_ops与它的成员函数
static int dnfb_blank(int blank, struct fb_info *info)
{
if (blank)
out_8(AP_CONTROL_3A, 0x0);
else
out_8(AP_CONTROL_3A, 0x1);
return 0;
}
void cfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect)
{
unsigned long pat, pat2, fg;
unsigned long width = rect->width, height = rect->height;
int bits = BITS_PER_LONG, bytes = bits >> 3;
u32 bpp = p->var.bits_per_pixel;
unsigned long __iomem *dst;
int dst_idx, left;
if (p->state != FBINFO_STATE_RUNNING)
return;
if (p->fix.visual == FB_VISUAL_TRUECOLOR || p->fix.visual == FB_VISUAL_DIRECTCOLOR )
fg = ((u32 *) (p->pseudo_palette))[rect->color];
else
fg = rect->color;
pat = pixel_to_pat(bpp, fg);
dst = (unsigned long __iomem *)((unsigned long)p->screen_base & ~(bytes-1));
dst_idx = ((unsigned long)p->screen_base & (bytes - 1))*8;
dst_idx += rect->dy*p->fix.line_length*8+rect->dx*bpp;
left = bits % bpp;
if (p->fbops->fb_sync)
p->fbops->fb_sync(p);
if (!left) {
u32 bswapmask = fb_compute_bswapmask(p);
void (*fill_op32)(struct fb_info *p,unsigned long __iomem *dst, int dst_idx,unsigned long pat, unsigned n, int bits,u32 bswapmask) = NULL;
switch (rect->rop) {
case ROP_XOR:
fill_op32 = bitfill_aligned_rev;
break;
case ROP_COPY:
fill_op32 = bitfill_aligned;
break;
default:
printk( KERN_ERR "cfb_fillrect(): unknown rop, defaulting to ROP_COPY\n");
fill_op32 = bitfill_aligned;
break;
}
while (height--) {
dst += dst_idx >> (ffs(bits) - 1);
dst_idx &= (bits - 1);
fill_op32(p, dst, dst_idx, pat, width*bpp, bits, bswapmask);
dst_idx += p->fix.line_length*8;
}
} else {
int right, r;
void (*fill_op)(struct fb_info *p, unsigned long __iomem *dst,int dst_idx, unsigned long pat, int left,int right, unsigned n, int bits) = NULL;
right = bpp - left;
switch (rect->rop) {
case ROP_XOR:
fill_op = bitfill_unaligned_rev;
break;
case ROP_COPY:
fill_op = bitfill_unaligned;
break;
default:
printk(KERN_ERR "cfb_fillrect(): unknown rop, defaulting to ROP_COPY\n");
fill_op = bitfill_unaligned;
break;
}
while (height--) {
dst += dst_idx / bits;
dst_idx &= (bits - 1);
r = dst_idx % bpp;
pat2 = le_long_to_cpu(rolx(cpu_to_le_long(pat), r, bpp));
fill_op(p, dst, dst_idx, pat2, left, right,width*bpp, bits);
dst_idx += p->fix.line_length*8;
}
}
}
static void dnfb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
{
}
void cfb_imageblit(struct fb_info *p, const struct fb_image *image)
{
u32 fgcolor, bgcolor, start_index, bitstart, pitch_index = 0;
u32 bpl = sizeof(u32), bpp = p->var.bits_per_pixel;
u32 width = image->width;
u32 dx = image->dx, dy = image->dy;
u8 __iomem *dst1;
if (p->state != FBINFO_STATE_RUNNING)
return;
bitstart = (dy * p->fix.line_length * 8) + (dx * bpp);
start_index = bitstart & (32 - 1);
pitch_index = (p->fix.line_length & (bpl - 1)) * 8;
bitstart /= 8;
bitstart &= ~(bpl - 1);
dst1 = p->screen_base + bitstart;
if (p->fbops->fb_sync)
p->fbops->fb_sync(p);
if (image->depth == 1) {
if (p->fix.visual == FB_VISUAL_TRUECOLOR || p->fix.visual == FB_VISUAL_DIRECTCOLOR) {
fgcolor = ((u32*)(p->pseudo_palette))[image->fg_color];
bgcolor = ((u32*)(p->pseudo_palette))[image->bg_color];
} else {
fgcolor = image->fg_color;
bgcolor = image->bg_color;
}
if (32 % bpp == 0 && !start_index && !pitch_index && ((width & (32/bpp-1)) == 0) && bpp >= 8 && bpp <= 32)
fast_imageblit(image, p, dst1, fgcolor, bgcolor);
else
slow_imageblit(image, p, dst1, fgcolor, bgcolor,start_index, pitch_index);
} else
color_imageblit(image, p, dst1, start_index, pitch_index);
}
static struct fb_ops dn_fb_ops = {
.owner = THIS_MODULE,
.fb_blank = dnfb_blank,
.fb_fillrect = cfb_fillrect,
.fb_copyarea = dnfb_copyarea,
.fb_imageblit = cfb_imageblit,
};
4. 定义及实现总线驱动结构体及成员函数，如果FB驱动是挂载在platform总线上，则定义platform_driver结构，如果是别的总线，比如PCI总线，在定义pci_driver结构。一般会在总线驱动成员的probe函数中调用FB的函数framebuffer_alloc与register_framebuffer来申请FB设备及注册到系统。
static int __devinit dnfb_probe(struct platform_device *dev)
{
struct fb_info *info;
int err = 0;
info = framebuffer_alloc(0, &dev->dev);
if (!info)
return -ENOMEM;
info->fbops = &dn_fb_ops;
info->fix = dnfb_fix;
info->var = dnfb_var;
info->var.red.length = 1;
info->var.red.offset = 0;
info->var.green = info->var.blue = info->var.red;
info->screen_base = (u_char *) info->fix.smem_start;
err = fb_alloc_cmap(&info->cmap, 2, 0);
if (err < 0) {
framebuffer_release(info);
return err;
}
err = register_framebuffer(info);
if (err < 0) {
fb_dealloc_cmap(&info->cmap);
framebuffer_release(info);
return err;
}
platform_set_drvdata(dev, info);
out_8(AP_CONTROL_3A, RESET_CREG);
out_be16(AP_WRITE_ENABLE, 0x0);
out_8(AP_CONTROL_0, NORMAL_MODE);
out_8(AP_CONTROL_1, (AD_BLT | DST_EQ_SRC | NORM_CREG1));
out_8(AP_CONTROL_2, S_DATA_PLN);
out_be16(AP_ROP_1, SWAP(0x3));
return err;
}
static struct platform_driver dnfb_driver = {
.probe = dnfb_probe,
.driver = {
.name = "dnfb",
},
};
static struct platform_device dnfb_device = {
.name = "dnfb",
};
5. 调用总线驱动注册函数把FB驱动注册到系统。
int __init dnfb_init(void)
{
int ret;
if (!MACH_IS_APOLLO)
return -ENODEV;
if (fb_get_options("dnfb", NULL))
return -ENODEV;
ret = platform_driver_register(&dnfb_driver);
if (!ret) {
ret = platform_device_register(&dnfb_device);
if (ret)
platform_driver_unregister(&dnfb_driver);
}
return ret;
}
module_init(dnfb_init);
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
