嵌入式Linux--ST7735驱动芯片TFT屏

最新推荐文章于 2024-07-27 11:47:16 发布
最新推荐文章于 2024-07-27 11:47:16 发布
阅读量3.4k 收藏 25
点赞数 2
分类专栏： 嵌入式linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28877125/article/details/110100587
版权

目录

参考博客

一、配置设备树

//功能引脚节点
pinctrl_ipsRes: ipsRes {    //屏幕复位u引脚
	fsl,pins = <
		MX6UL_PAD_GPIO1_IO01__GPIO1_IO01        0x10B0 /* LED0 */
	>;
};  
pinctrl_ipsDc: ipsDc {      //屏幕dc(data or command)u引脚
	fsl,pins = <
		MX6UL_PAD_GPIO1_IO04__GPIO1_IO04        0x10B0 
	>;
};
..............//附加节点
&ecspi3 {
	fsl,spi-num-chipselects = <1>;
	cs-gpio = <&gpio1 20 GPIO_ACTIVE_LOW>; /* cant't use cs-gpios! */
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_ecspi3>;
	status = "okay";

spidev: ipsTft@0 {
	compatible = "alientek,ipsTft";
	spi-max-frequency = <1000000000>;
	reg = <0>;
	};
};

二、编写驱动程序

1.驱动程序

  • （1）0.96寸 st7735驱动芯片
  • （2）1.3寸 st7735驱动芯片

（1）0.96寸显示屏驱动（spi_driver.c）

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/i2c.h>
#include <linux/spi/spi.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/platform_device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/spi/spi.h>
#define ipsTft_CNT	1
#define ipsTft_NAME	"ipsTft"
#define LCD_W 240
#define LCD_H 240
#define X_MAX_PIXEL	        160
#define Y_MAX_PIXEL	        80
#define RED  	0xf800
#define GREEN	0x07e0
#define BLUE 	0x001f
#define WHITE	0xffff
#define BLACK	0x0000
#define YELLOW  0xFFE0
#define GRAY0   0xEF7D   	//»ÒÉ«0 3165 00110 001011 00101
#define GRAY1   0x8410      	//»ÒÉ«1      00000 000000 00000
#define GRAY2   0x4208      	//»ÒÉ«2  1111111111011111
u8 buf[9] = {
RED, GREEN,	BLUE,WHITE,	BLACK,	YELLOW,GRAY0 ,GRAY1 ,GRAY2 
};
struct ipsTft_dev {
	dev_t devid;				/* 设备号 	 */
	struct cdev cdev;			/* cdev 	*/
	struct class *class;		/* 类 		*/
	struct device *device;		/* 设备 	 */
	struct device_node	*nd; 	/* 设备节点 */
	int major;					/* 主设备号 */
	void *private_data;			/* 私有数据 		*/
	int dc_gpio;				/* 片选所使用的GPIO编号		*/
    int res_gpio;                 /*ips屏幕复位引脚*/
    int cs_gpio;                    /*磁力计的cs*/
};
static struct ipsTft_dev ipsTftdev;
void ipsTft_reginit(struct ipsTft_dev *dev);
struct spi_lcd_cmd{
    u8  reg_addr; // command
    u8  len;  //需要从spi_lcd_datas数组里发出数据字节数
    int delay_ms; //此命令发送数据完成后，需延时多久
}cmds[] = {
    {0x11, 0, 120},
    {0x21, 0, 0},
    {0x21, 0, 0},
    {0xB1, 3, 0},
    {0xB2, 3, 0},
    {0xB3, 6, 0},
    {0xB4, 1, 0},
    {0xC0, 3, 0},
    {0xC1, 1, 0},
    {0xC2, 2, 0},
    {0xC3, 2, 0},
    {0xC4, 2, 0},
    {0xC5, 1, 0},
    {0xE0, 16, 0},
    {0xE1, 16, 0},
    {0x3A, 1, 0},
    {0x36, 1, 0},
    {0x29, 0, 0},
};
u8 spi_lcd_datas[] = {
   0x05,0x3A,0x3A,
   0x05,0x3A,0x3A,
   0x05,0x3A,0x3A,0x05,0x3A,0x3A,
   0x03,
   0x62,0x02,0x04,
   0xC0,
   0x0D,0x00,
   0x8D,0x6A,
   0x8D,0xEE,
   0x0E,
   0x10,0x0E,0x02,0x03,0x0E,0x07,0x02,0x07,0x0A,0x12,0x27,0x37,0x00,0x0D,0x0E,0x10,
   0x10,0x0E,0x03,0x03,0x0F,0x06,0x02,0x08,0x0A,0x13,0x26,0x36,0x00,0x0D,0x0E,0x10,
   0x05,    
   0xA8,
};
/*
 * @description	: 向ipsTft多个寄存器写入数据
 * @param - dev:  ipsTft设备
 * @param - reg:  要写入的寄存器首地址
 * @param - val:  要写入的数据缓冲区
 * @param - len:  要写入的数据长度
 * @return 	  :   操作结果
 */
static s32 ipsTft_write_regs(struct ipsTft_dev *dev,u8 *buf, u8 len)
{
	int ret;
	struct spi_message m;
	struct spi_transfer *t;
	struct spi_device *spi = (struct spi_device *)dev->private_data;
	t = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);	/* 申请内存 */
	/* 发送要写入的数据 */
	t->tx_buf = buf;			/* 要写入的数据 */
	t->len = len;				/* 写入的字节数 */
	spi_message_init(&m);		/* 初始化spi_message */
	spi_message_add_tail(t, &m);/* 将spi_transfer添加到spi_message队列 */
	ret = spi_sync(spi, &m);	/* 同步发送 */
	kfree(t);					/* 释放内存 */
	return ret;
}
/*
 * @description	: 向ipsTft指定寄存器写入指定的值，写一个寄存器
 * @param - dev:  ipsTft设备
 * @param - reg:  要写的寄存器
 * @param - data: 要写入的值
 * @return   :    无
 */	
static void ipsTft_write_onereg(struct ipsTft_dev *dev, u8 buf)
{
	ipsTft_write_regs(dev,&buf, 1);
    //spi_write(dev,&buf, 1);
}
/*
    funciton: 写一个命令
*/
void write_command(struct ipsTft_dev *dev, u8 cmd)
{
    // dc , command:0
    gpio_set_value(dev->dc_gpio, 0); 
    ipsTft_write_onereg(dev,cmd);
}
/*
    funciton: 写一个数据
*/
void write_data(struct ipsTft_dev *dev, u8 data)
{
    gpio_set_value(dev->dc_gpio, 1);
    ipsTft_write_onereg(dev,data);
}
/*
    funciton: 写一个数据
*/
static void write_datas(struct ipsTft_dev *dev, int data,int len)
{
    gpio_set_value(dev->dc_gpio, 1);
    ipsTft_write_regs(dev,(u8 *)&data,len);
}
/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做pr似有ate_data的成员变量
 * 					  一般在open的时候将private_data似有向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int ipsTft_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &ipsTftdev; /* 设置私有数据 */
    ipsTft_reginit(&ipsTftdev);
	return 0;
}
/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int ipsTft_release(struct inode *inode, struct file *filp)
{
	return 0;
}
/* ipsTft操作函数 */
static const struct file_operations ipsTft_ops = {
	.owner = THIS_MODULE,
	.open = ipsTft_open,
	.release = ipsTft_release,
};
void Address_set(struct ipsTft_dev *dev,unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2)
{ 
    write_command(dev,0x2a);
    write_data(dev,x1>>8);
    write_data(dev,x1);
    write_data(dev,x2>>8);
    write_data(dev,x2);
    write_command(dev,0x2b);
    write_data(dev,y1>>8);
    write_data(dev,y1);
    write_data(dev,y2>>8);
    write_data(dev,y2);
    write_command(dev,0x2C);					 						 
}
/*
    刷屏函数
*/
void LCD_Clear(struct ipsTft_dev *dev)
{
	u16 i,j;  	
	Address_set(dev,0,0,LCD_W-1,LCD_H-1);
    for(i=0;i<LCD_W;i++)
	 {
	  for (j=0;j<LCD_H;j++)
	   	{
        	//write_datas(dev,0xF800,2);	    //全红 		
            write_data(dev,0xF800>>8);
            write_data(dev,0xF800&0xFF);
	    }
	  }
}
/*************************************************

0.96'

*************************************************/
void Lcd_SetRegion(struct ipsTft_dev *dev,u16 x_start,u16 y_start,u16 x_end,u16 y_end)
{		
	write_command(dev,0x2a);
	write_data(dev,0x00);
	write_data(dev,x_start+1);
	write_data(dev,0x00);
	write_data(dev,x_end+1);
	write_command(dev,0x2b);
	write_data(dev,0x00);
	write_data(dev,y_start+0x1A);
	write_data(dev,0x00);
	write_data(dev,y_end+0x1A);	
	write_command(dev,0x2c);
}
/*************************************************
0.96'显示屏填充函数
*************************************************/
void Lcd_Clear_small(struct ipsTft_dev *dev,u16 Color)            
{	
   unsigned int i,m;
   Lcd_SetRegion(dev,0,0,X_MAX_PIXEL-1,Y_MAX_PIXEL-1);
   write_command(dev,0x2C);
   for(i=0;i<X_MAX_PIXEL;i++)
    for(m=0;m<Y_MAX_PIXEL;m++)
    {	
	  	//LCD_WriteData_16Bit(Color);
          write_data(dev,Color>>8);
          write_data(dev,Color&0xFF);
    }   
}
/*
 * ipsTft内部寄存器初始化函数 
 * @param  	: 无
 * @return 	: 无
 */
void ipsTft_reginit(struct ipsTft_dev *dev)
{
     int i, j, n;
    gpio_set_value(ipsTftdev.res_gpio, 0);
    mdelay(500);
    gpio_set_value(ipsTftdev.res_gpio, 1);
    mdelay(500);
    n = 0; // n用于记录数据数组spi_lcd_datas的位置
    //发命令，并发出命令所需的数据
    for (i = 0; i < ARRAY_SIZE(cmds); i++) //命令
    {
        write_command(dev, cmds[i].reg_addr);
        for (j = 0; j < cmds[i].len; j++) //发出命令后，需要发出的数据
            if(cmds[i].len!=0)
                write_data(dev, spi_lcd_datas[n++]);
        printk("the n is %d\n",n);
        if (cmds[i].delay_ms) //如有延时则延时
            mdelay(cmds[i].delay_ms);
    }
    n=0;
    while(n<9){
         Lcd_Clear_small(dev,*(buf+n));
         n++;
         mdelay(1000);
    }
    printk("ips init finish!\n");
}
 /*
  * @description     : spi驱动的probe函数，当驱动与
  *                    设备匹配以后此函数就会执行
  * @param - client  : spi设备
  * @param - id      : spi设备ID
  * 
  */	
static int ipsTft_probe(struct spi_device *spi)
{
	int ret = 0;
	/* 1、构建设备号 */
	if (ipsTftdev.major) {
		ipsTftdev.devid = MKDEV(ipsTftdev.major, 0);
		register_chrdev_region(ipsTftdev.devid, ipsTft_CNT, ipsTft_NAME);
	} else {
		alloc_chrdev_region(&ipsTftdev.devid, 0, ipsTft_CNT, ipsTft_NAME);
		ipsTftdev.major = MAJOR(ipsTftdev.devid);
	}
	/* 2、注册设备 */
	cdev_init(&ipsTftdev.cdev, &ipsTft_ops);
	cdev_add(&ipsTftdev.cdev, ipsTftdev.devid, ipsTft_CNT);
	/* 3、创建类 */
	ipsTftdev.class = class_create(THIS_MODULE, ipsTft_NAME);
	if (IS_ERR(ipsTftdev.class)) {
		return PTR_ERR(ipsTftdev.class);
	}
	/* 4、创建设备 */
	ipsTftdev.device = device_create(ipsTftdev.class, NULL, ipsTftdev.devid, NULL, ipsTft_NAME);
	if (IS_ERR(ipsTftdev.device)) {
		return PTR_ERR(ipsTftdev.device);
	}
	/* 获取设备树中cs片选信号 */
	ipsTftdev.nd = of_find_node_by_path("/soc/aips-bus@02000000/spba-bus@02000000/ecspi@02010000");
	if(ipsTftdev.nd == NULL) {
		printk("ecspi3 node not find!\r\n");
		return -EINVAL;
	}
	/* 2、 获取设备树中的gpio属性，得到BEEP所使用的BEEP编号 */
	ipsTftdev.cs_gpio = of_get_named_gpio(ipsTftdev.nd, "cs-gpio", 0);
	if(ipsTftdev.cs_gpio < 0) {
		printk("can't get cs-gpio");
		return -EINVAL;
	}
    ipsTftdev.nd = of_find_node_by_path("/ipsRes");
	if(ipsTftdev.nd == NULL) {
		printk("res-gpio node not find!\r\n");
		return -EINVAL;
        }
    ipsTftdev.res_gpio = of_get_named_gpio(ipsTftdev.nd, "res-gpio", 0);
    if(ipsTftdev.res_gpio < 0) {
		printk("can't get res-gpio");
		return -EINVAL;
	}
    ipsTftdev.nd = of_find_node_by_path("/ipsDc");
	if(ipsTftdev.nd == NULL) {
		printk("ipsDcgpio node not find!\r\n");
		return -EINVAL;
        }
    ipsTftdev.dc_gpio = of_get_named_gpio(ipsTftdev.nd, "dc-gpio", 0);
    if(ipsTftdev.dc_gpio < 0) {
		printk("can't get ipsDc-gpio");
		return -EINVAL;
	}
	/* 3、设置GPIO1_IO20为输出，并且输出高电平 */
	ret = gpio_direction_output(ipsTftdev.cs_gpio, 1);
	if(ret < 0) {
		printk("can't set cs gpio!\r\n");
	}
    ret = gpio_direction_output(ipsTftdev.res_gpio, 1);
	if(ret < 0) {
		printk("can't set res gpio!\r\n");
	}
    ret = gpio_direction_output(ipsTftdev.dc_gpio, 1);
	if(ret < 0) {
		printk("can't set dc gpio!\r\n");
	}
	/*初始化spi_device */
	spi->mode = SPI_MODE_0;	/*MODE0，CPOL=0，CPHA=0*/
	spi_setup(spi);
	ipsTftdev.private_data = spi; /* 设置私有数据 */
	/* 初始化ipsTft内部寄存器 */
	ipsTft_reginit(&ipsTftdev);		
	return 0;
}
/*
 * @description     : spi驱动的remove函数，移除spi驱动的时候此函数会执行
 * @param - client 	: spi设备
 * @return          : 0，成功;其他负值,失败
 */
static int ipsTft_remove(struct spi_device *spi)
{
	/* 删除设备 */
	cdev_del(&ipsTftdev.cdev);
	unregister_chrdev_region(ipsTftdev.devid, ipsTft_CNT);
	/* 注销掉类和设备 */
	device_destroy(ipsTftdev.class, ipsTftdev.devid);
	class_destroy(ipsTftdev.class);
	return 0;
}
/* 传统匹配方式ID列表 */
static const struct spi_device_id ipsTft_id[] = {
	{"alientek,ipsTft", 0},  
	{}
};
/* 设备树匹配列表 */
static const struct of_device_id ipsTft_of_match[] = {
	{ .compatible = "alientek,ipsTft" },
	{ /* Sentinel */ }
};
/* SPI驱动结构体 */	
static struct spi_driver ipsTft_driver = {
	.probe = ipsTft_probe,
	.remove = ipsTft_remove,
	.driver = {
			.owner = THIS_MODULE,
		   	.name = "ipsTft",
		   	.of_match_table = ipsTft_of_match, 
		   },
	.id_table = ipsTft_id,
};
/*
 * @description	: 驱动入口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init ipsTft_init(void)
{
	return spi_register_driver(&ipsTft_driver);
}
/*

 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit ipsTft_exit(void)
{
	spi_unregister_driver(&ipsTft_driver);
}
module_init(ipsTft_init);
module_exit(ipsTft_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("raymond");

（2）1.3寸显示屏驱动 240*240（spi_driver.c）

需注意点:
spi->mode = SPI_MODE_2; /MODE2，CPOL=1，CPHA=0 //出问题的地方!!!/

spi模式设置为模式二

#include <linux/types.h> 
#include <linux/kernel.h> 
#include <linux/delay.h> 
#include <linux/ide.h> 
#include <linux/init.h> 
#include <linux/module.h> 
#include <linux/errno.h> 
#include <linux/gpio.h> 
#include <linux/cdev.h> 
#include <linux/device.h> 
#include <linux/of_gpio.h> 
#include <linux/semaphore.h> 
#include <linux/timer.h> 
#include <linux/i2c.h> 
#include <linux/spi/spi.h> 
#include <linux/of.h> 
#include <linux/of_address.h> 
#include <linux/of_gpio.h> 
#include <linux/platform_device.h> 
#include <asm/mach/map.h> 
#include <asm/uaccess.h> 
#include <asm/io.h> 
#include <linux/spi/spi.h> 
#define ipsTft_CNT	1 
#define ipsTft_NAME	"ipsTft" 
#define LCD_W 240 
#define LCD_H 240 
#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 //»ÒÉ« 
u8 buf[9] = { 
RED, GREEN,	BLUE,WHITE,	BLACK,	YELLOW,GRAY ,BRRED ,CYAN 
}; 
struct ipsTft_dev { 
	dev_t devid;				/* 设备号 	 */ 
	struct cdev cdev;			/* cdev 	*/ 
	struct class *class;		/* 类 		*/ 
	struct device *device;		/* 设备 	 */ 
	struct device_node	*nd; 	/* 设备节点 */ 
	int major;					/* 主设备号 */ 
	void *private_data;			/* 私有数据 		*/ 
	int dc_gpio;				/* 片选所使用的GPIO编号		*/ 
    int res_gpio;                 /*ips屏幕复位引脚*/ 
    int cs_gpio;                    /*磁力计的cs*/ 
}; 
static struct ipsTft_dev ipsTftdev; 
void ipsTft_reginit(struct ipsTft_dev *dev); 
//1.3寸屏幕 
struct spi_lcd_cmd{ 
    u8  reg_addr; // command 
    u8  len;  //需要从spi_lcd_datas数组里发出数据字节数 
    int delay_ms; //此命令发送数据完成后，需延时多久 
} cmds[] = { 
    {0x36, 1, 30}, 
    {0x3A, 1, 30}, 
    {0xB2, 5, 30}, 
    {0xB7, 1, 30}, 
    {0xBB, 1, 30}, 
    {0xC0, 1, 30}, 
    {0xC2, 1, 30}, 
    {0xC3, 1, 30}, 
    {0xC4, 1, 30}, 
    {0xC6, 1, 30}, 
    {0xD0, 2, 30}, 
    {0xE0, 14, 30}, 
    {0xE1, 14, 30}, 
    {0x21, 0, 30}, 
    {0x11, 0, 120}, 
    {0x29, 0, 30}, 
}; 
u8 spi_lcd_datas[] = { 
    0x00, 
    0x05, 
    0x0c,0x0c,0x00,0x33,0x33, 
    0x35, 
    0x19, 
    0x2c, 
    0x01, 
    0x12, 
    0x20, 
    0x0F, 
    0xA4,0xA1, 
    0xD0,0x04,0x0D,0x11,0x13,0x2B,0x3F,0x54,0x4C,0x18,0x0D,0x0B,0x1F,0x23, 
    0xD0,0x04,0x0C,0x11,0x13,0x2C,0x3F,0x44,0x51,0x2F,0x1F,0x1F,0x20,0x23 
}; 
/* 
 * @description	: 向ipsTft多个寄存器写入数据 
 * @param - dev:  ipsTft设备 
 * @param - reg:  要写入的寄存器首地址 
 * @param - val:  要写入的数据缓冲区 
 * @param - len:  要写入的数据长度 
 * @return 	  :   操作结果 
 */ 
static s32 ipsTft_write_regs(struct ipsTft_dev *dev,u8 *buf, u8 len) 
{ 
	int ret; 
	struct spi_message m; 
	struct spi_transfer *t; 
	struct spi_device *spi = (struct spi_device *)dev->private_data; 
	t = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);	/* 申请内存 */ 
	t->tx_buf = buf;			/* 要写入的数据 */ 
	t->len = len;				/* 写入的字节数 */ 
	spi_message_init(&m);		/* 初始化spi_message */ 
	spi_message_add_tail(t, &m);/* 将spi_transfer添加到spi_message队列 */ 
	ret = spi_sync(spi, &m);	/* 同步发送 */ 
	kfree(t);					/* 释放内存 */ 
	return ret; 
} 
/* 
 * @description	: 向ipsTft指定寄存器写入指定的值，写一个寄存器 
 * @param - dev:  ipsTft设备 
 * @param - reg:  要写的寄存器 
 * @param - data: 要写入的值 
 * @return   :    无 
 */ 
static void ipsTft_write_onereg(struct ipsTft_dev *dev, u8 buf) 
{ 
	ipsTft_write_regs(dev,&buf, 1); 
    //spi_write(dev,&buf, 1); 
} 
/* 
    funciton: 写一个命令 
*/ 
void write_command(struct ipsTft_dev *dev, u8 cmd) 
{ 
    // dc , command:0 
    gpio_set_value(dev->dc_gpio, 0); 
    ipsTft_write_onereg(dev,cmd); 
} 
/* 
    funciton: 写一个数据 
*/ 
void write_data(struct ipsTft_dev *dev, u8 data) 
{ 
    gpio_set_value(dev->dc_gpio, 1); 
    ipsTft_write_onereg(dev,data); 
} 
/* 
    funciton: 写一个数据 
*/ 
static void write_datas(struct ipsTft_dev *dev, int data,int len) 
{ 
    gpio_set_value(dev->dc_gpio, 1); 
    ipsTft_write_regs(dev,(u8 *)&data,len); 
} 
/* 
 * @description		: 打开设备 
 * @param - inode 	: 传递给驱动的inode 
 * @param - filp 	: 设备文件，file结构体有个叫做pr似有ate_data的成员变量 
 * 					  一般在open的时候将private_data似有向设备结构体。 
 * @return 			: 0 成功;其他 失败 
 */ 
static int ipsTft_open(struct inode *inode, struct file *filp) 
{ 
	filp->private_data = &ipsTftdev; /* 设置私有数据 */ 
	return 0; 
} 
/* 
 * @description		: 关闭/释放设备 
 * @param - filp 	: 要关闭的设备文件(文件描述符) 
 * @return 			: 0 成功;其他 失败 
 */ 
static int ipsTft_release(struct inode *inode, struct file *filp) 
{ 
	return 0; 
} 
/* ipsTft操作函数 */ 
static const struct file_operations ipsTft_ops = { 
	.owner = THIS_MODULE, 
	.open = ipsTft_open, 
	.release = ipsTft_release, 
}; 
void Address_set(struct ipsTft_dev *dev,unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2) 
{ 
    write_command(dev,0x2a); 
    write_data(dev,x1>>8); 
    write_data(dev,x1); 
    write_data(dev,x2>>8); 
    write_data(dev,x2); 
    write_command(dev,0x2b); 
    write_data(dev,y1>>8); 
    write_data(dev,y1); 
    write_data(dev,y2>>8); 
    write_data(dev,y2); 
    write_command(dev,0x2C); 
} 
/* 
    刷屏函数 
*/ 
void LCD_Clear(struct ipsTft_dev *dev,u16 Color) 
{ 
	u16 i,j; 
	Address_set(dev,0,0,LCD_W-1,LCD_H-1); 
    write_command(dev,0x2C); 
    for(i=0;i<LCD_W;i++) 
	 { 
	  for (j=0;j<LCD_H;j++) 
	   	{ 
        	//write_datas(dev,0xF800,2);	    //全红 
            write_data(dev,Color>>8); 
            write_data(dev,Color); 
	    } 
	  } 
} 
/* 
 * ipsTft内部寄存器初始化函数 
 * @param  	: 无 
 * @return 	: 无 
 */ 
void ipsTft_reginit(struct ipsTft_dev *dev) 
{ 
     int i, j, n; 
    gpio_set_value(ipsTftdev.res_gpio, 0); 
    mdelay(20); 
    gpio_set_value(ipsTftdev.res_gpio, 1); 
    mdelay(20); 
    n = 0; // n用于记录数据数组spi_lcd_datas的位置 
    //发命令，并发出命令所需的数据 
    for (i = 0; i < ARRAY_SIZE(cmds); i++) //命令 
    { 
        write_command(dev, cmds[i].reg_addr); 
        for (j = 0; j < cmds[i].len; j++) //发出命令后，需要发出的数据 
            if(cmds[i].len!=0) 
                write_data(dev, spi_lcd_datas[n++]); 
        if (cmds[i].delay_ms) //如有延时则延时 
            mdelay(cmds[i].delay_ms); 
    } 
    n=0; 
    LCD_Clear(dev,WHITE); 
    printk("ips init finish!\n"); 
} 
 /* 
  * @description     : spi驱动的probe函数，当驱动与 
  *                    设备匹配以后此函数就会执行 
  * @param - client  : spi设备 
  * @param - id      : spi设备ID 
  * 
  */ 
static int ipsTft_probe(struct spi_device *spi) 
{ 
	int ret = 0; 
	/* 1、构建设备号 */ 
	if (ipsTftdev.major) { 
		ipsTftdev.devid = MKDEV(ipsTftdev.major, 0); 
		register_chrdev_region(ipsTftdev.devid, ipsTft_CNT, ipsTft_NAME); 
	} else { 
		alloc_chrdev_region(&ipsTftdev.devid, 0, ipsTft_CNT, ipsTft_NAME); 
		ipsTftdev.major = MAJOR(ipsTftdev.devid); 
	} 
	/* 2、注册设备 */ 
	cdev_init(&ipsTftdev.cdev, &ipsTft_ops); 
	cdev_add(&ipsTftdev.cdev, ipsTftdev.devid, ipsTft_CNT); 
	/* 3、创建类 */ 
	ipsTftdev.class = class_create(THIS_MODULE, ipsTft_NAME); 
	if (IS_ERR(ipsTftdev.class)) { 
		return PTR_ERR(ipsTftdev.class); 
	} 
	/* 4、创建设备 */ 
	ipsTftdev.device = device_create(ipsTftdev.class, NULL, ipsTftdev.devid, NULL, ipsTft_NAME); 
	if (IS_ERR(ipsTftdev.device)) { 
		return PTR_ERR(ipsTftdev.device); 
	} 
	/* 获取设备树中cs片选信号 */ 
	ipsTftdev.nd = of_find_node_by_path("/soc/aips-bus@02000000/spba-bus@02000000/ecspi@02010000"); 
	if(ipsTftdev.nd == NULL) { 
		printk("ecspi3 node not find!\r\n"); 
		return -EINVAL; 
	} 
	/* 2、 获取设备树中的gpio属性，得到BEEP所使用的BEEP编号 */ 
	ipsTftdev.cs_gpio = of_get_named_gpio(ipsTftdev.nd, "cs-gpio", 0); 
	if(ipsTftdev.cs_gpio < 0) { 
		printk("can't get cs-gpio"); 
		return -EINVAL; 
	} 
    ipsTftdev.nd = of_find_node_by_path("/ipsRes"); 
	if(ipsTftdev.nd == NULL) { 
		printk("res-gpio node not find!\r\n"); 
		return -EINVAL; 
        } 
    ipsTftdev.res_gpio = of_get_named_gpio(ipsTftdev.nd, "res-gpio", 0); 
    if(ipsTftdev.res_gpio < 0) { 
		printk("can't get res-gpio"); 
		return -EINVAL; 
	} 
    ipsTftdev.nd = of_find_node_by_path("/ipsDc"); 
	if(ipsTftdev.nd == NULL) { 
		printk("ipsDcgpio node not find!\r\n"); 
		return -EINVAL; 
        } 
    ipsTftdev.dc_gpio = of_get_named_gpio(ipsTftdev.nd, "dc-gpio", 0); 
    if(ipsTftdev.dc_gpio < 0) { 
		printk("can't get ipsDc-gpio"); 
		return -EINVAL; 
	} 
	/* 3、设置GPIO1_IO20为输出，并且输出高电平 */ 
	ret = gpio_direction_output(ipsTftdev.cs_gpio, 1); 
	if(ret < 0) { 
		printk("can't set cs gpio!\r\n"); 
	} 
    ret = gpio_direction_output(ipsTftdev.res_gpio, 1); 
	if(ret < 0) { 
		printk("can't set res gpio!\r\n"); 
	} 
    ret = gpio_direction_output(ipsTftdev.dc_gpio, 1); 
	if(ret < 0) { 
		printk("can't set dc gpio!\r\n"); 
	} 
	/*初始化spi_device */ 
	spi->mode = SPI_MODE_2;	/*MODE0，CPOL=0，CPHA=0 //出问题的地方!!!*/ 
	spi_setup(spi); 
	ipsTftdev.private_data = spi; /* 设置私有数据 */ 
	/* 初始化ipsTft内部寄存器 */ 
	ipsTft_reginit(&ipsTftdev); 
	return 0; 
} 
/* 
 * @description     : spi驱动的remove函数，移除spi驱动的时候此函数会执行 
 * @param - client 	: spi设备 
 * @return          : 0，成功;其他负值,失败 
 */ 
static int ipsTft_remove(struct spi_device *spi) 
{ 
	/* 删除设备 */ 
	cdev_del(&ipsTftdev.cdev); 
	unregister_chrdev_region(ipsTftdev.devid, ipsTft_CNT); 
	/* 注销掉类和设备 */ 
	device_destroy(ipsTftdev.class, ipsTftdev.devid); 
	class_destroy(ipsTftdev.class); 
	return 0; 
} 
/* 传统匹配方式ID列表 */ 
static const struct spi_device_id ipsTft_id[] = { 
	{"alientek,ipsTft", 0}, 
	{} 
}; 
/* 设备树匹配列表 */ 
static const struct of_device_id ipsTft_of_match[] = { 
	{ .compatible = "alientek,ipsTft" }, 
	{ /* Sentinel */ } 
}; 
/* SPI驱动结构体 */ 
static struct spi_driver ipsTft_driver = { 
	.probe = ipsTft_probe, 
	.remove = ipsTft_remove, 
	.driver = { 
			.owner = THIS_MODULE, 
		   	.name = "ipsTft", 
		   	.of_match_table = ipsTft_of_match, 
		   }, 
	.id_table = ipsTft_id, 
}; 
/* 
 * @description	: 驱动入口函数 
 * @param 		: 无 
 * @return 		: 无 
 */ 
static int __init ipsTft_init(void) 
{ 
	return spi_register_driver(&ipsTft_driver); 
} 
/* 
 * @description	: 驱动出口函数 
 * @param 		: 无 
 * @return 		: 无 
 */ 
static void __exit ipsTft_exit(void) 
{ 
	spi_unregister_driver(&ipsTft_driver); 
} 
module_init(ipsTft_init); 
module_exit(ipsTft_exit); 
MODULE_LICENSE("GPL"); 
MODULE_AUTHOR("raymond");

（3）驱动测试程序

  • 使用insmode命令安装模块
  • probe函数调用后会触发屏幕初始化配置函数，配置完后屏幕会刷新几种颜色（纯用于测试，加载自动测试，岂不美哉），APP文件只需要open一下就会重复刷新操作。

app.c

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "sys/ioctl.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include <poll.h>
#include <sys/select.h>
#include <sys/time.h>
#include <signal.h>
#include <fcntl.h>
/*
 * @description		: main主程序
 * @param - argc 	: argv数组元素个数
 * @param - argv 	: 具体参数
 * @return 			: 0 成功;其他 失败
 */
int main(int argc, char *argv[])
{
	int fd;
	char *filename;
	int ret = 0;
	if (argc != 2) {
		printf("Error Usage!\r\n");
		return -1;
	}
	filename = argv[1];
	fd = open(filename, O_RDWR);
	if(fd < 0) {
		printf("can't open file %s\r\n", filename);
		return -1;
	}else{
        printf("open the ips!\n");
    }
	close(fd);	/* 关闭文件 */	
	return 0;
}

通过shell命令进行测试：

./ipsApp /dev/ipsTft

2.驱动应用程序

st7735_tft_app.c

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/i2c.h>
#include <linux/spi/spi.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/platform_device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/fb.h>
#include <linux/dma-mapping.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include "ipsDriver.h"
#include "image.h"
#include <linux/fs.h> 
#include <linux/module.h> 
#include <linux/uaccess.h> 

typedef struct {
    struct spi_device *spi; //记录fb_info对象对应的spi设备对象
    struct task_struct *thread; //记录线程对象的地址，此线程专用于把显存数据发送到屏的驱动ic
}lcd_data_t;
struct fb_info *fbi;
void show_fb(struct fb_info *fbi, struct spi_device *spi);
static int tft_lcdfb_setcolreg(unsigned int regno, unsigned int red,
			     unsigned int green, unsigned int blue,
			     unsigned int transp, struct fb_info *info);
void LCD_Clear(struct ipsTft_dev *dev);
struct fb_ops fops = {
    .owner		= THIS_MODULE,
    .fb_setcolreg	= tft_lcdfb_setcolreg,
    .fb_fillrect	= cfb_fillrect,
	.fb_copyarea	= cfb_copyarea,
	.fb_imageblit	= cfb_imageblit,
};

int thread_func(void *data)
{
   
    lcd_data_t *ldata = fbi->par;

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

    return 0;
}

static u32 pseudo_palette[240*240];
static inline unsigned int chan_to_field(unsigned int chan, struct fb_bitfield *bf)
{
	chan &= 0xffff;
	chan >>= 16 - bf->length;
	return chan << bf->offset;
}

static int tft_lcdfb_setcolreg(unsigned int regno, unsigned int red,
			     unsigned int green, unsigned int blue,
			     unsigned int transp, struct fb_info *info)
{
	unsigned int val;
	
	if (regno > 16)
	{
		return 1;
	}

	/* 用red,green,blue三原色构造出val  */
	val  = chan_to_field(red,	&info->var.red);
	val |= chan_to_field(green, &info->var.green);
	val |= chan_to_field(blue,	&info->var.blue);
	
	pseudo_palette[regno] = val;
	return 0;
}


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

    /*
        coherent:连贯的
        分配连贯的物理内存
    */
    v_addr = dma_alloc_coherent(NULL, X*Y*4, &p_addr, GFP_KERNEL);
    
    //额外分配lcd_data_t类型空间
    fbi = framebuffer_alloc(sizeof(lcd_data_t), NULL);
    if(fbi == NULL){
		printk("fbi allow error!\n");
        return -1;
    }
    data = fbi->par; //data指针指向额外分配的空间
    data->spi = spi;

    fbi->pseudo_palette = pseudo_palette;
	fbi->var.activate       = FB_ACTIVATE_NOW;

    fbi->var.xres = X;
    fbi->var.yres = Y;
    fbi->var.xres_virtual = X;
    fbi->var.yres_virtual = Y;
    fbi->var.bits_per_pixel = 32; // 屏是rgb565, 但QT程序只能支持32位.还需要在刷图时把32位的像素数据转换成rgb565
    // fbi->var.red.offset = 11;
    // fbi->var.red.length = 5;
    // fbi->var.green.offset = 5;
    // fbi->var.green.length = 6;
    // fbi->var.blue.offset = 0;
    // fbi->var.blue.length = 5;
    fbi->var.red.offset = 16;
    fbi->var.red.length = 8;
    fbi->var.green.offset = 8;
    fbi->var.green.length = 8;
    fbi->var.blue.offset = 0;
    fbi->var.blue.length = 8;

    strcpy(fbi->fix.id, "myfb");
    fbi->fix.smem_start = p_addr; //显存的物理地址
    fbi->fix.smem_len = X*Y*4; 
    fbi->fix.type = FB_TYPE_PACKED_PIXELS;
    fbi->fix.visual = FB_VISUAL_TRUECOLOR;
    fbi->fix.line_length = X*4;

    fbi->fbops = &fops;
    fbi->screen_base = v_addr; //显存虚拟地址
    fbi->screen_size = X*Y*4; //显存大小

    register_framebuffer(fbi);
    data->thread = kthread_run(thread_func, fbi, spi->modalias);
    return 0;    
}

void myfb_del(void) //此函数在spi设备驱动remove时被调用
{
    lcd_data_t *data = fbi->par;
    kthread_stop(data->thread); //让刷图线程退出
    unregister_framebuffer(fbi);
    dma_free_coherent(NULL, fbi->screen_size, fbi->screen_base, fbi->fix.smem_start);
    framebuffer_release(fbi);
}

/*
 * @description	: 向ipsTft多个寄存器写入数据
 * @param - dev:  ipsTft设备
 * @param - reg:  要写入的寄存器首地址
 * @param - val:  要写入的数据缓冲区
 * @param - len:  要写入的数据长度
 * @return 	  :   操作结果
 */
static s32 ipsTft_write_regs(struct spi_device *spi,u8 *buf, u32 len)
{
    int ret;
	struct spi_message m;
	struct spi_transfer *t;
	t = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);	/* 申请内存 */
	t->tx_buf = buf;			/* 要写入的数据 */
	t->len = len;				/* 写入的字节数 */
	spi_message_init(&m);		/* 初始化spi_message */
	spi_message_add_tail(t, &m);/* 将spi_transfer添加到spi_message队列 */
	ret = spi_sync(spi, &m);	/* 同步发送 */
	kfree(t);					/* 释放内存 */
	return ret;
}

/*
 * @description	: 向ipsTft指定寄存器写入指定的值，写一个寄存器
 * @param - dev:  ipsTft设备
 * @param - reg:  要写的寄存器
 * @param - data: 要写入的值
 * @return   :    无
 */	

static void ipsTft_write_onereg(struct spi_device *spi, u8 buf)
{
	ipsTft_write_regs(spi,&buf, 1);
}

/*
    funciton: 写一个命令
*/
void write_command(struct spi_device *spi, u8 cmd)
{
    // dc , command:0
    gpio_set_value(ipsTftdev.dc_gpio, 0); 
    ipsTft_write_onereg(spi,cmd);
}
/*
    funciton: 写一个数据
*/
void write_data(struct spi_device *spi, u8 data)
{
    gpio_set_value(ipsTftdev.dc_gpio, 1);
    ipsTft_write_onereg(spi,data);
}
/*
    funciton: 写多个数据
*/
static void write_datas(struct spi_device *spi, u8 *data,u32 len)
{
    gpio_set_value(ipsTftdev.dc_gpio, 1);
    ipsTft_write_regs(spi,data,len);
}

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做pr似有ate_data的成员变量
 * 					  一般在open的时候将private_data似有向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int ipsTft_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &ipsTftdev; /* 设置私有数据 */
	return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int ipsTft_release(struct inode *inode, struct file *filp)
{
	return 0;
}

/* ipsTft操作函数 */
static const struct file_operations ipsTft_ops = {
	.owner = THIS_MODULE,
	.open = ipsTft_open,
	.release = ipsTft_release,
};

void Address_set(struct spi_device *spi,unsigned int x1,unsigned int y1,unsigned int x2,unsigned int y2)
{ 
    write_command(spi,0x2a);
    write_data(spi,x1>>8);
    write_data(spi,x1);
    write_data(spi,x2>>8);
    write_data(spi,x2);
  
    write_command(spi,0x2b);
    write_data(spi,y1>>8);
    write_data(spi,y1);
    write_data(spi,y2>>8);
    write_data(spi,y2);

    write_command(spi,0x2C);					 						 
}

/*
    刷屏函数
*/
void LCD_Clear(struct ipsTft_dev *dev)
{
	u16 i,j;
     u16 *memory;
     memory = (u16 *)kzalloc(240*240*2, GFP_KERNEL);	/* 申请内存 */
	Address_set(dev->private_data,0,0,LCD_W-1,LCD_H-1);
    write_command(dev->private_data,0x2C);
    msleep(3000);//延迟显示，显示完上面钢铁侠图片
    memcpy(memory,gImage_q,240*240*2);
     int count = 0,split=10;
    while (count < split)//split 用于设置分批发送数据，有时候st7789spi速率跟不上容易丢数据，偶尔会提示spi2 send ....类似的错误
    {
        write_datas(dev->private_data,(u8 *)memory+count*240*240*2/split,240*240*2/split);
        count++;
    }
      kfree(memory);
}
/*
 * ipsTft内部寄存器初始化函数 
 * @param  	: 无
 * @return 	: 无
 */
void ipsTft_reginit(struct ipsTft_dev *dev)
{
     int i, j, n;
    gpio_set_value(ipsTftdev.res_gpio, 0);
    mdelay(20);
    gpio_set_value(ipsTftdev.res_gpio, 1);
    mdelay(20);
    n = 0; // n用于记录数据数组spi_lcd_datas的位置
    //发命令，并发出命令所需的数据
    for (i = 0; i < ARRAY_SIZE(cmds); i++) //命令
    {
        write_command(dev->private_data, cmds[i].reg_addr);
        for (j = 0; j < cmds[i].len; j++) //发出命令后，需要发出的数据
            if(cmds[i].len!=0)
                write_data(dev->private_data, spi_lcd_datas[n++]);
        if (cmds[i].delay_ms) //如有延时则延时
            mdelay(cmds[i].delay_ms);
    }
    n=0;
    LCD_Clear(dev);
    msleep(5000);
    printk("ips init finish!\n");
}

//show frambuffer
//framebuffer线程刷屏函数
void show_fb(struct fb_info *fbi, struct spi_device *spi)
{
    int x, y;
    u32 k;
    u32 *p = (u16 *)(fbi->screen_base);
    u16 c;
    u8 *pp;
    u16 *memory;
    memory = kzalloc(240*2*240, GFP_KERNEL);	/* 申请内存 */
    Address_set(spi,0,0,LCD_W-1,LCD_H-1);
    write_command(spi,0x2C);
    for (y = 0; y < fbi->var.yres; y++)
    {
        for (x = 0; x < fbi->var.xres; x++)
        {
            k = p[y*fbi->var.xres+x];//取出一个像素点的32位数据
            // rgb8888 --> rgb565       
            pp = (u8 *)&k;
            c = pp[0] >> 3; //蓝色
            c |= (pp[1]>>2)<<5; //绿色
            c |= (pp[2]>>3)<<11; //红色
            //发出像素数据的rgb565
            *((u16 *)memory+y*fbi->var.yres+x) = ((c&0xff)<<8)|((c&0xff00)>>8);
        }
    }
    //split 用于设置分批发送数据，有时候st7789spi速率跟不上容易丢数据，偶尔会提示spi2 send ....类似的错误
    int count = 0,split=1;  
    while (count < split)
    {
        write_datas(spi,(u8 *)memory+count*fbi->var.yres*fbi->var.xres*2/split,fbi->var.yres*fbi->var.xres*2/split);
        count++;
    }
    kfree(memory);
}

 /*
  * @description     : spi驱动的probe函数，当驱动与
  *                    设备匹配以后此函数就会执行
  * @param - client  : spi设备
  * @param - id      : spi设备ID
  * 
  */	
static int ipsTft_probe(struct spi_device *spi)
{
	int ret = 0;

	/* 1、构建设备号 */
	if (ipsTftdev.major) {
		ipsTftdev.devid = MKDEV(ipsTftdev.major, 0);
		register_chrdev_region(ipsTftdev.devid, ipsTft_CNT, ipsTft_NAME);
	} else {
		alloc_chrdev_region(&ipsTftdev.devid, 0, ipsTft_CNT, ipsTft_NAME);
		ipsTftdev.major = MAJOR(ipsTftdev.devid);
	}

	/* 2、注册设备 */
	cdev_init(&ipsTftdev.cdev, &ipsTft_ops);
	cdev_add(&ipsTftdev.cdev, ipsTftdev.devid, ipsTft_CNT);

	/* 3、创建类 */
	ipsTftdev.class = class_create(THIS_MODULE, ipsTft_NAME);
	if (IS_ERR(ipsTftdev.class)) {
		return PTR_ERR(ipsTftdev.class);
	}

	/* 4、创建设备 */
	ipsTftdev.device = device_create(ipsTftdev.class, NULL, ipsTftdev.devid, NULL, ipsTft_NAME);
	if (IS_ERR(ipsTftdev.device)) {
		return PTR_ERR(ipsTftdev.device);
	}

	/* 获取设备树中cs片选信号 */
	ipsTftdev.nd = of_find_node_by_path("/soc/aips-bus@02000000/spba-bus@02000000/ecspi@02010000");
	if(ipsTftdev.nd == NULL) {
		printk("ecspi3 node not find!\r\n");
		return -EINVAL;
	}
	/* 2、 获取设备树中的gpio属性，得到BEEP所使用的BEEP编号 */
	ipsTftdev.cs_gpio = of_get_named_gpio(ipsTftdev.nd, "cs-gpio", 0);
	if(ipsTftdev.cs_gpio < 0) {
		printk("can't get cs-gpio");
		return -EINVAL;
	}
    ipsTftdev.nd = of_find_node_by_path("/ipsRes");
	if(ipsTftdev.nd == NULL) {
		printk("res-gpio node not find!\r\n");
		return -EINVAL;
        }
    ipsTftdev.res_gpio = of_get_named_gpio(ipsTftdev.nd, "res-gpio", 0);
    if(ipsTftdev.res_gpio < 0) {
		printk("can't get res-gpio");
		return -EINVAL;
	}

    ipsTftdev.nd = of_find_node_by_path("/ipsDc");
	if(ipsTftdev.nd == NULL) {
		printk("ipsDcgpio node not find!\r\n");
		return -EINVAL;
        }
    ipsTftdev.dc_gpio = of_get_named_gpio(ipsTftdev.nd, "dc-gpio", 0);
    if(ipsTftdev.dc_gpio < 0) {
		printk("can't get ipsDc-gpio");
		return -EINVAL;
	}

	/* 3、设置GPIO1_IO20为输出，并且输出高电平 */
	ret = gpio_direction_output(ipsTftdev.cs_gpio, 1);//失能板子上的磁力计
	if(ret < 0) {
		printk("can't set cs gpio!\r\n");
	}
    gpio_set_value(ipsTftdev.cs_gpio,1);
    ret = gpio_direction_output(ipsTftdev.res_gpio, 1);
	if(ret < 0) {
		printk("can't set res gpio!\r\n");
	}
    ret = gpio_direction_output(ipsTftdev.dc_gpio, 1);
	if(ret < 0) {
		printk("can't set dc gpio!\r\n");
	}

	/*初始化spi_device */
	spi->mode = SPI_MODE_2;	/*MODE0，CPOL=0，CPHA=0 //出问题的地方!!!*/
	spi_setup(spi);
	ipsTftdev.private_data = spi; /* 设置私有数据 */

	/* 初始化ipsTft内部寄存器 */
	ipsTft_reginit(&ipsTftdev);
    myfb_new(spi); //fb设备初始化		
	return 0;
}

/*
 * @description     : spi驱动的remove函数，移除spi驱动的时候此函数会执行
 * @param - client 	: spi设备
 * @return          : 0，成功;其他负值,失败
 */
static int ipsTft_remove(struct spi_device *spi)
{
    myfb_del();//注销fb

	/* 删除设备 */
	cdev_del(&ipsTftdev.cdev);
	unregister_chrdev_region(ipsTftdev.devid, ipsTft_CNT);

	/* 注销掉类和设备 */
	device_destroy(ipsTftdev.class, ipsTftdev.devid);
	class_destroy(ipsTftdev.class);
   
	return 0;
}

/* 传统匹配方式ID列表 */
static const struct spi_device_id ipsTft_id[] = {
	{"alientek,ipsTft", 0},  
	{}
};

/* 设备树匹配列表 */
static const struct of_device_id ipsTft_of_match[] = {
	{ .compatible = "alientek,ipsTft" },
	{ /* Sentinel */ }
};

/* SPI驱动结构体 */	
static struct spi_driver ipsTft_driver = {
	.probe = ipsTft_probe,
	.remove = ipsTft_remove,
	.driver = {
			.owner = THIS_MODULE,
		   	.name = "ipsTft",
		   	.of_match_table = ipsTft_of_match, 
		   },
	.id_table = ipsTft_id,
};

/*
 * @description	: 驱动入口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init ipsTft_init(void)
{
	return spi_register_driver(&ipsTft_driver);
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit ipsTft_exit(void)
{
	spi_unregister_driver(&ipsTft_driver);
}

module_init(ipsTft_init);
module_exit(ipsTft_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("raymond");

2. makefile文件

KERNELDIR := /home/raymond/linux/iMX6ULL/MyArmLinuxProgram/linuxKernal
CURRENT_PATH := $(shell pwd)
obj-m := ipsDriver.o
build: kernel_modules
kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

三、更改开机图片

在image.h里面含有一张240*240的图片，用于开机显示图片，可自定义数组（用图像转换器转换）。

按照屏幕配置（St7789按图片配置即可），来选择进行转换。输出的数组替换image.h即可。

四、驱动测试

加载内核之后输入命令：ls /dev/ 可以看到在/dev下已经有了一个fb设备节点。
还需要设置环境变量：

export QT_QPA_PLATFORM=linuxfb:fb=/dev/fb1

目的是指定Qt显示在新创建的fb设备上。

liefyuan
关注
专栏目录
nanopi 2 fire s5p4418 初次体验 (4)驱动1.8寸 128*160 SPI屏（st7735）
m0_58844968的博客
08-09 1264
nanopi 2 fire s5p4418 初次体验 (4)驱动1.8寸 128*160 SPI屏（st7735）
stm32 带通滤波器_带通滤波 - 基于STM32芯片和TFT-LCD的便携式心电图仪设计
weixin_39959569的博客
12-20 1034
相关推荐3月10日，纽约州州长安德鲁-库默(Andrew Cuomo)曾在上月宣布，纽约大都市圈的公共交通系...发表于 2018-04-16 08:50•88次阅读 LCD驱动我们只需要写硬件这一块的代码就可以了，下面有三个函数内核已经帮我们写好了，我们只需要调用就...发表于 2018-04-16 08:43•12次阅读 ...
ST7735S彩屏 SPI驱动代码( msp430)
11-21
本代码采用SPI驱动，为自己做项目时整理，用该屏做简单的UI界面，LCD驱动部分有详细讲解，希望对有用的人能有些帮助。 支持中英文、位图显示(电量，信号灯简单图形)，字库均自己制作；支持横屏和竖屏。该代码仅供学习参考。
imx6ull Linux spi + frambuffer 实现st7789运行显示QT程序 且可实现大小屏双屏同显
Raymond
07-03 4099
前序 之前实现了简单的spi驱动（刷屏else，类似于单片机刷点绘图），但是那些太麻烦，上了系统咱就干点系统的事，没必要一个一个点绘制 还要找字库，麻烦得很。接下来就来例举如何通过frambuffer把之前的spi驱动变高效率，即能够在上面运行QT程序。 前世 之前的基础连接blog如下： Linux St7789 1.3寸屏驱动 Linux St7735 0.96寸屏驱动 参考的文章如下：感谢这几位老哥 连接一 连接二 今生 显示效果： 原子的QT QDesk demo 步骤一 配置设备树： //功能引
ST7735和ST7735S指令差异对比, ST7796S和ILI9488指令差异对比
qq_37749995的博客
07-27 685
常见TFT驱动芯片指令差异对比
STM32驱动屏ST7735
09-17
STM32驱动屏ST7735，有英文字符显示，删除
Micropython ST7735驱动
09-28
Micropython ST7735驱动
ST7735S_initial_code.c TFT屏驱动程序
03-29
ST7735S_initial_code.cTFT屏驱动程序 ST7735S_initial_code.cTFT屏驱动程序
stm32 st7789 320240驱动,STM32驱动ST7701S芯片
09-11
在本文中，我们将深入探讨如何在STM32上驱动ST7789和ST7701S这两种TFT液晶显示模块，它们通常用于创建320x240像素分辨率的显示屏。 ST7789和ST7701S是两种常见的TFT液晶控制器，用于彩色图形显示。ST7789是一款高...
st7539-g4 IIC驱动程序
最新发布
08-16
ST7539-G4是一款专为液晶显示器设计的I2C接口控制芯片，它支持彩色TFT屏，常用于嵌入式系统中。ST7539-G4的驱动程序主要是为了简化硬件与显示控制器之间的通信，使得上位机（如微控制器或计算机）能够通过I2C总线...
JpegPlayer_ST7701S_ST7701_
10-04
综上所述，"JpegPlayer_ST7701S_ST7701_"项目提供了一个在Linux系统平台上运行的JPEG图像播放解决方案，专门针对配备了ST7701S和ST7701显示驱动芯片的设备。这个解决方案对于那些需要在嵌入式设备上展示JPEG图像的...
51驱动ST7735.zip_C51 ST7735_ST7735 串口_ST7735 驱动_st7735驱动51_Ｃ５１
07-15
ST7735驱动IC，SPI串口4线驱动代码
STM32F103C8T6+1.44寸ST7735TFT LCD彩屏驱动程序
01-05
资源是STM32F103C8T6的1.44寸ST7735芯片SPI驱动的TFT液晶屏驱动程序完整KEIL工程，需要的朋友可以下载，改个IO口就能够使用，非常方便！说明文档连接为：https://blog.csdn.net/pang9998/article/details/85837421
ST7735/ITL9163B STM32F1 8位并口驱动_20pin
09-19
1.8寸ST7735 ITL9163B TFT 8位并口驱动keil项目； STM32F103R8 MCU //======液晶屏数据线接线==========// //本模块默认数据总线类型为8位并行模式 //8位模式接线：8位模式模块接低8位总线，即: //液晶屏LCD_D0对应单片机PC0 //液晶屏LCD_D1对应单片机PC1 //液晶屏LCD_D2对应单片机PC2 //液晶屏LCD_D3对应单片机PC3 //液晶屏LCD_D4对应单片机PC4 //液晶屏LCD_D5对应单片机PC5 //液晶屏LCD_D6对应单片机PC6 //液晶屏LCD_D7对应单片机PC7 //========== 液晶屏控制线接线 ================// //LCD_RST 接PB4 //复位信号 //LCD_CS 接PB3 //片选信号 //LCD_RS 接PB5 //寄存器/数据选择信号 /
STM32单片机硬件SPI驱动TFTLCD（ST7735驱动）软件例程源码+Proteus仿真.zip
06-08
STM32单片机硬件SPI驱动TFTLCD（ST7735驱动）软件例程源码+Proteus仿真 /**ST7735驱动**/ #include "ST7735.h" #include "usart.h" u16 BACK_COLOR, POINT_COLOR; //背景色，画笔色 void WriteCommand_7735(u8 CmdData) //写指令 { SPI_LCD_CS_LOW; //片选 SPI_LCD_COMMAND_W;//写指令 SPI_I2S_SendData(LCD_SPIx,CmdData); while (SPI_I2S_GetFlagStatus(LCD_SPIx, SPI_I2S_FLAG_TXE) == RESET){} SPI_LCD_CS_HIGH; } void WriteDate_7735(u8 Data) //写8位数据 { SPI_LCD_CS_LOW; //片选 SPI_LCD_DATA_W;//写数据 SPI_I2S_SendData(LCD_SPIx,Data); wh
STM32F030R8-ST7735S驱动程序
07-29
ST77 35是一种用于262K颜色的单片控制器/驱动器，即图形型TFT-LCD。它由396个源极线和162个门线驱动电路组成。接受串行外围接口（SPI）、8位/9位/ 16位/ 18位并行接口。显示数据可存储在132×162×x 18位的片上显示数据RAM中。H~（NO）外运算 将功率消耗降至最小，即，由于“集成”电源供应电路的必要性，即“驱动”液体晶体，它是可能的，从而成为一个具有较少成分的显示系统。
(STM32)从零开始的RT-Thread之旅--SPI驱动ST7735(1)
飞临云的博客
11-16 3927
我使用的开发板是WeAct的H743板子，板子带一个0.96的SPI驱动的LCD，给的有现成的测试用例，看源码应该是ST的工程师写的ST7735的驱动，打算把这个驱动直接拿到RTT工程里面使用。这里按正常流程来，先打通SPI，再进行上层功能实现。一般当我们用SPI读取到LCD的ID时，即认为SPI没问题了。这里这块由ST7735驱动的LCD屏幕的SPI接口和一般的不太一样，接线如下：首先SPI是3线制的，MOSI可以读也可以写，然后通过一根线控制读写的是寄存器还是缓存。
(Github开源)IMX6ULL嵌入式Linux平台st7735s显示屏芯片SPI设备驱动(支持framebuffer)
weixin_42816477的博客
07-06 707
IMX6ULL嵌入式Linux平台的系统st7735s显示屏芯片驱动程序，可作为使用SPI总线的LCD/OLED显示驱动移植参考。
ST7735STFT屏幕的驱动
热门推荐
优信电子的博客
08-27 3万+
ST7735S 是 262K 彩色图形型 TFT-LCD 的单芯片控制器/驱动程序。它由396条源线和162门线驱动电路组成。该芯片能够直接连接到外部微处理器，并接受串行外围接口 （SPI）、8 位/9 位/16 位/18 位并行接口。显示数据可以存储在 132 x 162 x 18 位的片上显示数据 RAM 中。它可以在没有外部操作时钟时执行显示数据 RAM 读写操作，以最大限度地降低功耗。此外，由于驱动液晶所需的集成电源电路，因此可以制造出组件较少的显示系统。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值