36.【linux驱动】spi framebuffer驱动(切换并显示虚拟终端)

最新推荐文章于 2023-08-13 23:38:20 发布
最新推荐文章于 2023-08-13 23:38:20 发布
阅读量1.2k 收藏 9
点赞数 2
分类专栏： # linux驱动 文章标签： linux驱动 framebuffer spi ILI9488
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16054639/article/details/107620360
版权

1.framebuffer驱动
2.spi framebuffer驱动
3.spi framebuffer驱动(切换并显示虚拟终端)

切换终端输出

接这上一节
spi framebuffer驱动实现了，但是只有刷屏。6个虚拟终端并没有显示在屏幕上，要想办法让虚拟终端显示到我们的fb上面来。最总虚拟终端的源代码（过程不详述），发现了这么个地方：
/driver/video/console/fbcon.c

static int fbcon_event_notify(struct notifier_block *self,
			      unsigned long action, void *data)
{
	struct fb_event *event = data;
	struct fb_info *info = event->info;
	struct fb_videomode *mode;
	struct fb_con2fbmap *con2fb;
	struct fb_blit_caps *caps;
	int idx, ret = 0;

	/*
	 * ignore all events except driver registration and deregistration
	 * if fbcon is not active
	 */
	if (fbcon_has_exited && !(action == FB_EVENT_FB_REGISTERED ||
				  action == FB_EVENT_FB_UNREGISTERED))
		goto done;

	switch(action) {
	case FB_EVENT_SUSPEND:
		fbcon_suspended(info);
		break;
	case FB_EVENT_RESUME:
		fbcon_resumed(info);
		break;
	case FB_EVENT_MODE_CHANGE:
		fbcon_modechanged(info);
		break;
	case FB_EVENT_MODE_CHANGE_ALL:
		fbcon_set_all_vcs(info);
		break;
	case FB_EVENT_MODE_DELETE:
		mode = event->data;
		ret = fbcon_mode_deleted(info, mode);
		break;
	case FB_EVENT_FB_UNBIND:
		idx = info->node;
		ret = fbcon_fb_unbind(idx);
		break;
	case FB_EVENT_FB_REGISTERED:
		ret = fbcon_fb_registered(info);
		break;
	case FB_EVENT_FB_UNREGISTERED:
		ret = fbcon_fb_unregistered(info);
		break;
	case FB_EVENT_SET_CONSOLE_MAP:
		con2fb = event->data;
		ret = set_con2fb_map(con2fb->console - 1,
				     con2fb->framebuffer, 1);
		break;
	case FB_EVENT_GET_CONSOLE_MAP:
		con2fb = event->data;
		con2fb->framebuffer = con2fb_map[con2fb->console - 1];
		break;
	case FB_EVENT_BLANK:
		fbcon_fb_blanked(info, *(int *)event->data);
		break;
	case FB_EVENT_NEW_MODELIST:
		fbcon_new_modelist(info);
		break;
	case FB_EVENT_GET_REQ:
		caps = event->data;
		fbcon_get_requirement(info, caps);
		break;
	case FB_EVENT_REMAP_ALL_CONSOLE:
		idx = info->node;
		fbcon_remap_all(idx);
		break;
	}
done:
	return ret;
}

切换虚拟终端输出就在这个地方了，只需要发送一个fb_notify消息即可。我们使用最后这个

	case FB_EVENT_REMAP_ALL_CONSOLE:
		idx = info->node;
		fbcon_remap_all(idx);
		break;

切换所有终端。源码

struct fb_info * fb_init(struct spi_device *spi) //此函数在spi设备驱动的probe函数里被调用
{
    struct fb_info *fbi;
    u8 *v_addr;
    u32 p_addr;
    lcd_data_t *data;
    struct fb_event event;

    v_addr = dma_alloc_coherent(NULL, LCD_W * LCD_H * 3, &p_addr, GFP_KERNEL);

    //额外分配lcd_data_t类型空间
    fbi = framebuffer_alloc(sizeof(lcd_data_t), NULL);
    data = fbi->par; //data指针指向额外分配的空间

    data->spi = spi;

    fbi->var.xres = LCD_W;
    fbi->var.yres = LCD_H;
    fbi->var.xres_virtual = LCD_W;
    fbi->var.yres_virtual = LCD_H;
    fbi->var.bits_per_pixel = 24;
    fbi->var.red.offset = 16;
    fbi->var.red.length = 5;
    fbi->var.green.offset = 8;
    fbi->var.green.length = 6;
    fbi->var.blue.offset = 0;
    fbi->var.blue.length = 5;
    // fbi->var.pixclock   = 93006;
    fbi->var.activate    = FB_ACTIVATE_NOW;

    strcpy(fbi->fix.id, "hello_fb");
    fbi->fix.smem_start = p_addr; //显存的物理地址
    fbi->fix.smem_len = LCD_W * LCD_H * 3;
    fbi->fix.type = FB_TYPE_PACKED_PIXELS;
    fbi->fix.visual = FB_VISUAL_TRUECOLOR;
    fbi->fix.line_length = LCD_W * 3;

    fbi->fbops = &fops;
    fbi->screen_base = v_addr; //显存虚拟地址
    fbi->screen_size = LCD_W * LCD_H * 3; //显存大小

    spi_set_drvdata(spi, fbi);
    register_framebuffer(fbi);
    data->thread = kthread_run(thread_func, fbi, spi->modalias);
    event.info = fbi;
    fb_notifier_call_chain(FB_EVENT_REMAP_ALL_CONSOLE, &event);

    return fbi;
}

void fb_del(struct spi_device *spi) //此函数在spi设备驱动remove时被调用
{
    struct fb_info *fbi = spi_get_drvdata(spi);
    lcd_data_t *data = fbi->par;

    kthread_stop(data->thread); //让刷图线程退出
    unregister_framebuffer(fbi);
    dma_free_coherent(NULL, fbi->fix.smem_len, fbi->screen_base, fbi->fix.smem_start);
    framebuffer_release(fbi);
}

在framebuffer驱动注册完成的最后发送一个fb_notifier_call_chain(FB_EVENT_REMAP_ALL_CONSOLE, &event);就切换完成了。

适配显示

终端切换成功了，但是图像没有办法显示，都是乱码。手头的屏幕是控制器是ILI9488，spi传送的图像数据一个像素由三个字节组成，分别是蓝绿红。三个字节并不代表是24位，其中有效数据只占16位，蓝5位，绿6位，红5位。也就是rgb565，奇葩的是这三个颜色在一个字节中还是高位对齐，也就是说低位并没有使用，注意并不是大端对齐模式。为了对齐最后蓝和红也占6位了，最后变成了奇葩的rgb666吧。附上数据手册中的数据结构图
在这里插入图片描述
这种摆放方式不知道内核中有没有，软件支持性也不清楚。索性直接转换吧。为了使绘图效率达到最高，就不在spi传输的时候做转换了，而是在写入fb缓冲内存的时候就吧格式摆放正确。先做一下虚拟终端的绘图部分。虚拟终端主要调用fb_ops结构体中的几个函数完成字符绘制，我们只需要重写其中两个：fb_imageblit fb_fillrect。fb_imageblit是绘制文本的主要函数，他接收矢量字符，坐标，向fb缓冲区绘图。

fb_imageblit

适量字符每一位代表一个像素，比如Z的适量字符：

	/* 90 0x5a 'Z' */
	0x00, 0x00, /* 0000000000 */
	0x3f, 0x80, /* 0011111110 */
	0x21, 0x80, /* 0010000110 */
	0x01, 0x80, /* 0000000110 */
	0x03, 0x00, /* 0000001100 */
	0x03, 0x00, /* 0000001100 */
	0x06, 0x00, /* 0000011000 */
	0x06, 0x00, /* 0000011000 */
	0x0c, 0x00, /* 0000110000 */
	0x0c, 0x00, /* 0000110000 */
	0x18, 0x00, /* 0001100000 */
	0x18, 0x00, /* 0001100000 */
	0x30, 0x00, /* 0011000000 */
	0x30, 0x80, /* 0011000010 */
	0x3f, 0x80, /* 0011111110 */
	0x00, 0x00, /* 0000000000 */
	0x00, 0x00, /* 0000000000 */
	0x00, 0x00, /* 0000000000 */

根据矢量字符以我们的特殊rgb666绘图：

void fb_imageblit(struct fb_info *info, const struct fb_image *image) {
    unsigned char *p, *p2, shift, *src;
    u32 dx, dy, width, height, bpp, i, j;
    dx = image->dx;
    dy = image->dy;
    width = image->width;
    height = image->height;
    bpp = info->var.bits_per_pixel;
    src = image->data;

    p = info->screen_base + info->fix.line_length * dy + dx * bpp;
    for (i = 0; i < height; ++i)
    {
        p2 = p;
        shift = 8;
        for (j = 0; j < width; ++j)
        {
            shift--;
            if (*src & (1 << shift)) {
                p2[0] = 0xf8;
                p2[1] = 0xf8;
                p2[2] = 0xf8;
            } else {
                p2[0] = 0x00;
                p2[1] = 0x00;
                p2[2] = 0x00;
            }
            if (!shift) { shift = 8; src++; };
            p2 += 3;
        }
        p += info->fix.line_length;
    }
}
fb_fillrect

fb_fillrect是清除字符调用的函数，在需要的区域填充黑色即可。

static void fb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
{
    unsigned char *p, *p2;
    u32 dx, dy, width, height, bpp, i, j;
    dx = rect->dx;
    dy = rect->dy;
    width = rect->width;
    height = rect->height;
    bpp = info->var.bits_per_pixel;

    p = info->screen_base + info->fix.line_length * dy + dx * bpp;
    for (i = 0; i < height; ++i)
    {
        p2 = p;
        for (j = 0; j < width; ++j)
        {
                p2[0] = 0x00;
                p2[1] = 0xf8;
                p2[2] = 0x00;
                p2 += 3;
        }
        p += info->fix.line_length;
    }
}
整体代码

framebuffer.c


#include <linux/init.h>
#include <linux/module.h>
#include <linux/fb.h>
#include <linux/spi/spi.h>
#include <linux/dma-mapping.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/delay.h>
#include "fb_spi.h"

typedef struct {
    struct spi_device *spi;
    struct task_struct *thread;
} lcd_data_t;

static void fb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
{
    unsigned char *p, *p2;
    u32 dx, dy, width, height, bpp, i, j;
    dx = rect->dx;
    dy = rect->dy;
    width = rect->width;
    height = rect->height;
    bpp = info->var.bits_per_pixel;

    p = info->screen_base + info->fix.line_length * dy + dx * bpp;
    for (i = 0; i < height; ++i)
    {
        p2 = p;
        for (j = 0; j < width; ++j)
        {
                p2[0] = 0x00;
                p2[1] = 0xf8;
                p2[2] = 0x00;
                p2 += 3;
        }
        p += info->fix.line_length;
    }
}

void fb_imageblit(struct fb_info *info, const struct fb_image *image) {
    unsigned char *p, *p2, shift, *src;
    u32 dx, dy, width, height, bpp, i, j;
    dx = image->dx;
    dy = image->dy;
    width = image->width;
    height = image->height;
    bpp = info->var.bits_per_pixel;
    src = image->data;

    p = info->screen_base + info->fix.line_length * dy + dx * bpp;
    for (i = 0; i < height; ++i)
    {
        p2 = p;
        shift = 8;
        for (j = 0; j < width; ++j)
        {
            shift--;
            if (*src & (1 << shift)) {
                p2[0] = 0xf8;
                p2[1] = 0xf8;
                p2[2] = 0xf8;
            } else {
                p2[0] = 0x00;
                p2[1] = 0x00;
                p2[2] = 0x00;
            }
            if (!shift) { shift = 8; src++; };
            p2 += 3;
        }
        p += info->fix.line_length;
    }
}

struct fb_ops fops = {
    .owner          = THIS_MODULE,
    .fb_imageblit   = fb_imageblit,
    .fb_fillrect = fb_fillrect,
};

/* from pxafb.c */
static inline unsigned int chan_to_field(unsigned int chan, struct fb_bitfield *bf)
{
    chan &= 0xffff;
    chan >>= 16 - bf->length;
    return chan << bf->offset;
}

extern void show_fb(struct fb_info *fbi, struct spi_device *spi);
int thread_func(void *data)
{
    struct fb_info *fbi = (struct fb_info *)data;
    lcd_data_t *ldata = fbi->par;

    while (1)
    {
        if (kthread_should_stop())
            break;
        show_fb(fbi, ldata->spi);
    }

    return 0;
}

struct fb_info * fb_init(struct spi_device *spi) //此函数在spi设备驱动的probe函数里被调用
{
    struct fb_info *fbi;
    u8 *v_addr;
    u32 p_addr;
    lcd_data_t *data;
    struct fb_event event;

    v_addr = dma_alloc_coherent(NULL, LCD_W * LCD_H * 3, &p_addr, GFP_KERNEL);

    //额外分配lcd_data_t类型空间
    fbi = framebuffer_alloc(sizeof(lcd_data_t), NULL);
    data = fbi->par; //data指针指向额外分配的空间

    data->spi = spi;

    fbi->var.xres = LCD_W;
    fbi->var.yres = LCD_H;
    fbi->var.xres_virtual = LCD_W;
    fbi->var.yres_virtual = LCD_H;
    fbi->var.bits_per_pixel = 24;
    fbi->var.red.offset = 16;
    fbi->var.red.length = 5;
    fbi->var.green.offset = 8;
    fbi->var.green.length = 6;
    fbi->var.blue.offset = 0;
    fbi->var.blue.length = 5;
    // fbi->var.pixclock   = 93006;
    fbi->var.activate    = FB_ACTIVATE_NOW;

    strcpy(fbi->fix.id, "hello_fb");
    fbi->fix.smem_start = p_addr; //显存的物理地址
    fbi->fix.smem_len = LCD_W * LCD_H * 3;
    fbi->fix.type = FB_TYPE_PACKED_PIXELS;
    fbi->fix.visual = FB_VISUAL_TRUECOLOR;
    fbi->fix.line_length = LCD_W * 3;

    fbi->fbops = &fops;
    fbi->screen_base = v_addr; //显存虚拟地址
    fbi->screen_size = LCD_W * LCD_H * 3; //显存大小

    spi_set_drvdata(spi, fbi);
    register_framebuffer(fbi);
    data->thread = kthread_run(thread_func, fbi, spi->modalias);
    event.info = fbi;
    fb_notifier_call_chain(FB_EVENT_REMAP_ALL_CONSOLE, &event);

    return fbi;
}

void fb_del(struct spi_device *spi) //此函数在spi设备驱动remove时被调用
{
    struct fb_info *fbi = spi_get_drvdata(spi);
    lcd_data_t *data = fbi->par;

    kthread_stop(data->thread); //让刷图线程退出
    unregister_framebuffer(fbi);
    dma_free_coherent(NULL, fbi->fix.smem_len, fbi->screen_base, fbi->fix.smem_start);
    framebuffer_release(fbi);
}

spi.h


struct  Lcd_dev
{										    
	unsigned short width;			//LCD 宽度
	unsigned short height;			//LCD 高度
	unsigned short id;				//LCD ID
	unsigned char  dir;			//横屏还是竖屏控制：0，竖屏；1，横屏。	
	unsigned short	 wramcmd;		//开始写gram指令
	unsigned short  setxcmd;		//设置x坐标指令
	unsigned short  setycmd;		//设置y坐标指令	 
};

//画笔颜色
#define WHITE            0xFFFF
#define BLACK            0x0000   
#define BLUE           0x001F  
#define BRED             0XF81F
#define GRED       0XFFE0
#define GBLUE      0X07FF
#define RED              0xF800
#define MAGENTA          0xF81F
#define GREEN            0x07E0
#define CYAN             0x7FFF
#define YELLOW           0xFFE0
#define BROWN        0XBC40 //棕色
#define BRRED        0XFC07 //棕红色
#define GRAY         0X8430 //灰色
//GUI颜色

#define DARKBLUE         0X01CF //深蓝色
#define LIGHTBLUE        0X7D7C //浅蓝色  
#define GRAYBLUE         0X5458 //灰蓝色
//以上三色为PANEL的颜色 
 
#define LIGHTGREEN       0X841F //浅绿色
#define LGRAY        0XC618 //浅灰色(PANNEL),窗体背景色

#define LGRAYBLUE        0XA651 //浅灰蓝色(中间层颜色)
#define LBBLUE           0X2B12 //浅棕蓝色(选择条目的反色)

//LCD的画笔颜色和背景色	   
#define POINT_COLOR (0x0000)	//画笔颜色
#define BACK_COLOR (0xFFFF)		//背景色
//定义LCD的尺寸
#define LCD_W 320
#define LCD_H 480

#define USE_HORIZONTAL  	0	//定义液晶屏顺时针旋转方向 	0-0度旋转，1-90度旋转，2-180度旋转，3-270度旋转

spi.c


#include <linux/init.h>
#include <linux/module.h>
#include <linux/spi/spi.h>
#include <linux/vmalloc.h>
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/fb.h>
#include "fb_dev.h"
#include "fb_spi.h"

struct spi_lcd_cmd {
    u8  d_or_r;
    u8  data; // command
    int delay_ms; //此命令发送数据完成后，需延时多久
} cmds[] = {
    {0, 0XF7, 0},
    {1, 0xA9, 0},
    {1, 0x51, 0},
    {1, 0x2C, 0},
    {1, 0x82, 0},
    {0, 0xC0, 0},
    {1, 0x11, 0},
    {1, 0x09, 0},
    {0, 0xC1, 0},
    {1, 0x41, 0},
    {0, 0XC5, 0},
    {1, 0x00, 0},
    {1, 0x0A, 0},
    {1, 0x80, 0},
    {0, 0xB1, 0},
    {1, 0xB0, 0},
    {1, 0x11, 0},
    {0, 0xB4, 0},
    {1, 0x02, 0},
    {0, 0xB6, 0},
    {1, 0x02, 0},
    {1, 0x42, 0},
    {0, 0xB7, 0},
    {1, 0xc6, 0},
    {0, 0xBE, 0},
    {1, 0x00, 0},
    {1, 0x04, 0},
    {0, 0xE9, 0},
    {1, 0x00, 0},
    {0, 0x36, 0},
    {1, (1 << 3) | (0 << 7) | (1 << 6) | (1 << 5), 0},
    {0, 0x3A, 0},
    {1, 0x66, 0},
    {0, 0xE0, 0},
    {1, 0x00, 0},
    {1, 0x07, 0},
    {1, 0x10, 0},
    {1, 0x09, 0},
    {1, 0x17, 0},
    {1, 0x0B, 0},
    {1, 0x41, 0},
    {1, 0x89, 0},
    {1, 0x4B, 0},
    {1, 0x0A, 0},
    {1, 0x0C, 0},
    {1, 0x0E, 0},
    {1, 0x18, 0},
    {1, 0x1B, 0},
    {1, 0x0F, 0},
    {0, 0XE1, 0},
    {1, 0x00, 0},
    {1, 0x17, 0},
    {1, 0x1A, 0},
    {1, 0x04, 0},
    {1, 0x0E, 0},
    {1, 0x06, 0},
    {1, 0x2F, 0},
    {1, 0x45, 0},
    {1, 0x43, 0},
    {1, 0x02, 0},
    {1, 0x0A, 0},
    {1, 0x09, 0},
    {1, 0x32, 0},
    {1, 0x36, 0},
    {1, 0x0F, 0},
    {0, 0x11, 0},
    {0, 0x29, 0},
};

struct  Lcd_dev lcddev;

static inline void write_u8(struct spi_device * spi, u8 d_or_r, u8 cmd)
{
    struct fb_data *pdata = spi->dev.platform_data;
    gpio_set_value(pdata->rs, d_or_r);
    spi_write(spi, &cmd, 1);
}

static void write_u24s(struct spi_device * spi, u8 * data, unsigned int len)
{
    struct fb_data *pdata = spi->dev.platform_data;
    gpio_set_value(pdata->rs, 1);
    spi_write(spi, data, len);
}

void lcd_set_window(struct spi_device * spi, unsigned short xStar, unsigned short yStar, unsigned short xEnd, unsigned short yEnd)
{
    write_u8(spi, 0, lcddev.setxcmd);
    write_u8(spi, 1, xStar >> 8);
    write_u8(spi, 1, 0x00FF & xStar);
    write_u8(spi, 1, xEnd >> 8);
    write_u8(spi, 1, 0x00FF & xEnd);

    write_u8(spi, 0, lcddev.setycmd);
    write_u8(spi, 1, yStar >> 8);
    write_u8(spi, 1, 0x00FF & yStar);
    write_u8(spi, 1, yEnd >> 8);
    write_u8(spi, 1, 0x00FF & yEnd);

    write_u8(spi, 0, lcddev.wramcmd);
}

void lcd_clear(struct spi_device * spi, struct fb_info * fbi, unsigned short Color)
{
    unsigned int i;
    unsigned char *p;
    lcd_set_window(spi, 0, 0, lcddev.width - 1, lcddev.height - 1);
    p = fbi->screen_base;
    for (i = 0; i < fbi->var.xres * fbi->var.yres; i++)
    {
        p[i * 3] = (Color >> 8) & 0xF8;
        p[i * 3 + 1] = (Color >> 3) & 0xFC;
        p[i * 3 + 2] = (Color << 3);
    }
}

void lcd_direction(struct spi_device * spi, unsigned char direction)
{
    lcddev.setxcmd = 0x2A;
    lcddev.setycmd = 0x2B;
    lcddev.wramcmd = 0x2C;
    switch (direction) {
    case 0:
        lcddev.width = LCD_W;
        lcddev.height = LCD_H;
        write_u8(spi, 0, 0x36);
        write_u8(spi, 1, (1 << 3) | (0 << 6) | (0 << 7)); //BGR==1,MY==0,MX==0,MV==0
        break;
    case 1:
        lcddev.width = LCD_H;
        lcddev.height = LCD_W;
        write_u8(spi, 0, 0x36);
        write_u8(spi, 1, (1 << 3) | (0 << 7) | (1 << 6) | (1 << 5)); //BGR==1,MY==1,MX==0,MV==1
        break;
    case 2:
        lcddev.width = LCD_W;
        lcddev.height = LCD_H;
        write_u8(spi, 0, 0x36);
        write_u8(spi, 1, (1 << 3) | (1 << 6) | (1 << 7)); //BGR==1,MY==0,MX==0,MV==0
        break;
    case 3:
        lcddev.width = LCD_H;
        lcddev.height = LCD_W;
        write_u8(spi, 0, 0x36);
        write_u8(spi, 1, (1 << 3) | (1 << 7) | (1 << 5)); //BGR==1,MY==1,MX==0,MV==1
        break;
    default: break;
    }
}

//初始化spi_lcd
static void spi_lcd_init(struct spi_device * spi)
{
    struct fb_data *pdata = spi->dev.platform_data;
    int i, n;

    // 屏复位
    gpio_set_value(pdata->reset, 0);
    mdelay(100);
    gpio_set_value(pdata->reset, 1);
    mdelay(100);

    n = 0; // n用于记录数据数组spi_lcd_datas的位置
    //发命令，并发出命令所需的数据
    for (i = 0; i < ARRAY_SIZE(cmds); i++) //命令
    {
        write_u8(spi, cmds[i].d_or_r, cmds[i].data);
        if (cmds[i].delay_ms)
            mdelay(cmds[i].delay_ms);
    }
}

void show_fb(struct fb_info * fbi, struct spi_device * spi)
{
    u8 *p = (u8 *)(fbi->screen_base);

    lcd_set_window(spi, 0, 0, lcddev.width - 1, lcddev.height - 1); //从屏的0,0坐标开始刷
    write_u24s(spi, p, fbi->screen_size/2);
    write_u24s(spi, p + fbi->screen_size/2, fbi->screen_size/2);
}

extern struct fb_info * fb_init(struct spi_device *);
static int spi_probe(struct spi_device * spi)
{
    struct fb_data *pdata = spi->dev.platform_data;
    int ret;
    struct fb_info * fbi;
    fbi = NULL;

    ret = gpio_request(pdata->reset, spi->modalias);
    if (ret < 0)
        goto err0;
    ret = gpio_request(pdata->rs, spi->modalias);
    if (ret < 0)
        goto err1;

    gpio_direction_output(pdata->rs, 0);
    gpio_direction_output(pdata->reset, 1);
    spi_lcd_init(spi); //初始化
    lcd_direction(spi, USE_HORIZONTAL); //设置LCD显示方向
    fbi = fb_init(spi); //fb设备初始化
    // lcd_clear(spi, fbi, BLUE);

    printk("probe ...%s\n", spi->modalias);
    return 0;

err1:
    gpio_free(pdata->reset);
err0:
    return ret;
}

extern void fb_del(struct spi_device *);
static int spi_remove(struct spi_device * spi)
{
    struct fb_data *pdata = spi->dev.platform_data;

    fb_del(spi); //fb设备回收

    gpio_free(pdata->rs);
    gpio_free(pdata->reset);
    printk("%s remove\n", spi->modalias);
    return 0;
}

static struct spi_driver spi_drv = {
    .driver = {
        .owner = THIS_MODULE,
        .name = "hello_spi_fb",
    },
    .probe = spi_probe,
    .remove = spi_remove,
};

static int __init hello_init(void) {
    int ret;
    ret = spi_register_driver(&spi_drv);
    if (ret) {
        printk("hello driver fail\n");
    } else {
        printk("hello driver init\n");
    }
    return ret;
}

static void __exit hello_exit(void) {
    spi_unregister_driver(&spi_drv);
    printk("hello device exit\n");
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

dev.h

#ifndef __FB_DEV__
#define __FB_DEV__

struct fb_data{
	int reset;
	int rs;	
};
#endif

dev.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <mach/gpio.h>
#include <mach/platform.h>
#include <linux/spi/spi.h>
#include <linux/amba/pl022.h>
#include "fb_dev.h"

static struct fb_data fb1_plat_data = {
	.reset  = PAD_GPIO_D + 21,
	.rs    = PAD_GPIO_D + 17,
};

struct pl022_config_chip spi0_info = {
	/* available POLLING_TRANSFER, INTERRUPT_TRANSFER, DMA_TRANSFER */
	.com_mode = CFG_SPI0_COM_MODE,
	.iface = SSP_INTERFACE_MOTOROLA_SPI,
	/* We can only act as master but SSP_SLAVE is possible in theory */
	.hierarchy = SSP_MASTER,
	/* 0 = drive TX even as slave, 1 = do not drive TX as slave */
	.slave_tx_disable = 1,
	.rx_lev_trig = SSP_RX_4_OR_MORE_ELEM,
	.tx_lev_trig = SSP_TX_4_OR_MORE_EMPTY_LOC,
	.ctrl_len = SSP_BITS_8,
	.wait_state = SSP_MWIRE_WAIT_ZERO,
	.duplex = SSP_MICROWIRE_CHANNEL_FULL_DUPLEX,
	.clkdelay = SSP_FEEDBACK_CLK_DELAY_1T,
};

static struct spi_board_info spi_plat_board = {
	.modalias        = "hello_spi_fb",    /* fixup */
	.max_speed_hz    = 25000000,     /* max spi clock (SCK) speed in HZ */
	.bus_num         = 0,           /* Note> set bus num, must be smaller than ARRAY_SIZE(spi_plat_device) */
	.chip_select     = 1,           /* Note> set chip select num, must be smaller than spi cs_num */
	.controller_data = &spi0_info,
	.mode            = SPI_MODE_3 | SPI_CPOL | SPI_CPHA,
	.platform_data   = &fb1_plat_data,
};

__attribute__ ((unused)) static void device_spi_delete(struct spi_master *master, unsigned cs)
{
	struct device *dev;
	char str[32];

	snprintf(str, sizeof(str), "%s.%u", dev_name(&master->dev), cs);

	dev = bus_find_device_by_name(&spi_bus_type, NULL, str);
	if (dev) {
		printk(": Deleting %s\n", str);
		device_del(dev);
	}
}

static struct spi_device *spi_device;
static int __init hello_init(void) {
	struct spi_master *master;

	master = spi_busnum_to_master(spi_plat_board.bus_num);
	if (!master) {
		printk(":  spi_busnum_to_master(%d) returned NULL\n",
		       spi_plat_board.bus_num);
		return -EINVAL;
	}
	/* make sure it's available */
	// device_spi_delete(master, spi_plat_board.chip_select);
	spi_device = spi_new_device(master, &spi_plat_board);
	put_device(&master->dev);
	if (!spi_device) {
		printk(":    spi_new_device() returned NULL\n");
		return -EPERM;
	}
	return 0;
	printk("hello device init\n");
	return 0;
}

static void __exit hello_exit(void) {
	if (spi_device) {
		if (spi_device->master->cleanup) {
			spi_device->master->cleanup(spi_device);
		}
		device_del(&spi_device->dev);
		kfree(spi_device);
	}
}

module_init(hello_init);
module_exit(hello_exit);

MODULE_LICENSE("GPL");
运行效果

在这里插入图片描述

mini-coco
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Linux终端输出到fb,自学Linux Shell11.4-重定向输入输出
weixin_42310572的博客
05-06 694
11.4-重定向输入输出Linux 命令默认从标准输入设备(stdin)获取输入，将结果输出到标准输出设备(stdout)显示。一般情况下，标准输入设备就是键盘，标准输出设备就是终端，即显示器。重定向命令列表如下：命令说明command > file将输出重定向到 file。command < file将输入重定向到 file。command >> file将输出以追加的方...
了解LCD驱动(FrameBuffer)的实例开发
07-11
通过LCD控制器就可以产生LCD驱动器所需要的控制信号来控制STN/TFT屏了。
linux2.6.30.4_framebuffer移植LCD驱动
09-08
lcd驱动资料，s3c2440核心，有图片显示应用程序
在树莓派下framebuffer+spi驱动
07-31
在树莓派下，通过framebuffer的方式，结合spi驱动，对屏幕进行显示
fbcon的注册和bind
jason的笔记
05-10 2473
之前讲过console ---> fbcon ---> fbdev drivers ---> hardware，这个flow的fbdev drivers的产生， 从video/console下面的makefile obj-$(CONFIG_DUMMY_CONSOLE)       += dummycon.o obj-$(CONFIG_SGI_NEWPORT_CONSOLE) += newpo
【嵌入式环境下linux内核及驱动学习笔记-（19）LCD驱动框架2-FrameBuffer】
weixin_45499326的博客
08-13 1132
qquadLinux是工作在保护模式下，Linux抽象出FrameBuffer这个设备来供用户态进程实现直接写屏。\qquadFramebuffer机制模仿显卡的功能，将显卡硬件结构抽象掉，可以通过Framebuffer的读写直接对显存进行操作。用户可以将Framebuffer看成是显示内存的一个映像，将其映射到进程地址空间之后，就可以直接进行读写操作，而写操作可以立即反应在屏幕上。这种操作是抽象的，统一的。用户不必关心物理显存的位置、换页机制等等具体细节。
linux hdmi /dev/fb操作,HDMI接口学习笔记
weixin_42117485的博客
05-16 3289
1. HDMI接口内部还有一个i2c接口，用于读取EDID数据2. HDMI接口比一般的接口多出① 多个显示源：Framebuffer数量变多，VideoProcess模块(Tiny4412上是这样的，不同平台不同)② 混合器：Mixer③ HDMI还支持音频传输④ HDMI接口里面集成了一个i2c接口，用于EDID(显示屏参数数据)和HDCP(版权保护)⑤ CEC遥控⑥ HPD:热插拔检测3.t...
tty0 显示的过程
jason的笔记
05-04 1979
我们知道在调用prink输出的时候最终都会调用到call_console_drivers static void call_console_drivers(int level,                  const char *ext_text, size_t ext_len,                  const char *text, size_t len) {   
linux查看fb设备,Ubuntu使用fbterm无法打开fb设备的解决及fcitx-fbterm安装
weixin_27828313的博客
05-08 780
"Ubuntu 12.04.1 LTS" fbterm can't open frame buffer device 的解决 及fcitx-fbterm的安装1.修改grub2文件/etc/default/grub添加GRUB_GFXMODE=1280x800x32GRUB_GFXPAYLOAD_LINUX=keep不加不知道行不行，反正我加了sudo grub-mkconfigsudo reb...
linux中如何在fb上显示
hbcbgcx的博客
06-24 1178
转载 注明 ；http://blog.csdn.net/u011046042/article/details/68066091 最简单的代码如下： #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <fcntl.h> #include <string.h&gt...
如何让linux fb0显示命令行,linux – 如何将/ dev / fb0用作来自用户空间的控制台,或者将文本输出到它...
weixin_39859052的博客
05-03 1109
所以我有一个Palm Pre(原始P100EWW)模型,我启用了开发人员模式,并安装了Debian Squeeze chroot.效果很好.我计划将这个用于任何东西(bittorrent peer,web server)但是一部手机.我注意到我是否做了猫/ dev / urandom> / dev / fb0它实际上将随机像素写入屏幕,直到生成设备错误上没有剩余空格.真棒,现在我可以使用显示...
Linux设备驱动之Framebuffer分析.pdf
09-27
Linux设备驱动之Framebuffer分析.pdf
Linux设备驱动之Framebuffer分析[归纳].pdf
10-11
Linux设备驱动之Framebuffer分析[归纳].pdf
37.【linux驱动】pcie驱动入门
柏鑫的博客
08-05 2364
pcie总线向下兼容pci总线，文中所述pci默认等于pcie pcie拓扑结构 pcie拓扑主要由总线、桥和设备卡组成，桥将父总线与子总线连接在一起形成树型结构。桥主要分为一下三类： Host/PCI桥：用于连接CPU与PCI根总线，在PC中，内存控制器也通常被集成到Host/PCI桥设备芯片，Host/PCI桥通常被称 为“北桥芯片组”。 PCI/ISA桥：用于连接旧的ISA总线。PCI/ISA桥也被称为“南桥芯片组”。 PCI-to-PCI桥：用于连接PCI主总线与次总线。 pci总线编号采用
14.【linux驱动】spi(GPIO模拟)
柏鑫的博客
06-22 1828
代码
16.【linux驱动】spi驱动TFT液晶屏
柏鑫的博客
06-22 1607
代码
1.Linux内核从远程nfs启动（踩坑记录）
柏鑫的博客
06-02 1356
目录前言配置内核支持NFS启动搭建NFS服务器 前言 本次实验的启动方式是：通过网络挂载rootfs，内核从sd卡加载，并没有通过网络下载 关于uboot的两点配置bootargs，bootcmd bootargs：传递给内核使用的参数，对uboot来说只是一个环境变量 bootcmd：uboot启动命令，主要是加载内核，设备树，rootfs，然后用bootm启动内核 1.先将随便烧写个官方镜像到sd卡（也不能太随便，只要你要编译的内核要接近镜像的，否则后面替换内核可能导致uboot和内核版本不匹配，从而无
19.【linux驱动】IIC驱动（OLED屏）
柏鑫的博客
06-18 1317
代码
35.【linux驱动】spi framebuffer驱动
柏鑫的博客
07-27 1284
spi framebuffer驱动 上一节实现了一个framebuffer驱动，但是没有具体操作硬件，这节做一个SPI屏驱动，整个代码作为一个spi驱动去写。spi相关内容可以看()[]。 首先是spi驱动，屏幕的操作由厂家C51代码改编而来。屏幕控制器是ILI9488，分辨率320 * 480 spi部分 spi.h struct Lcd_dev { unsigned short width; //LCD 宽度 unsigned short height; //L
linux framebuffer 驱动开发
最新发布
09-16
Linux framebuffer驱动开发是一种在Linux内核中开发与管理framebuffer设备的过程。framebuffer是一个虚拟设备，它提供了一个统一的接口，用于控制和管理显示设备。framebuffer驱动负责将图形数据从内存映射到显示...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值