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

一时失言乱红尘 2022-12-23 11:24 331阅读 0赞

### 目录 ###

*  参考博客
 *  一、配置设备树
 *  二、编写驱动程序
 *   *  1.驱动程序
     *   *  （1）0.96寸显示屏驱动（spi\_driver.c）
         *  （2）1.3寸显示屏驱动 240\*240（spi\_driver.c）
         *  （3）驱动测试程序
     *  2.驱动应用程序
     *  2. makefile文件
 *  三、更改开机图片
 *  四、驱动测试

# 参考博客 #

*  [嵌入式Linux驱动笔记(二十四)------framebuffer之使用spi-tft屏幕（上）][Linux_------framebuffer_spi-tft]
 *  [68 linux framebuffer设备驱动之spi lcd屏驱动][68 linux framebuffer_spi lcd]
 *  [65 linux spi设备驱动之spi LCD屏驱动][65 linux spi_spi LCD]
 *  [正点原子Linux开发板 spi内核驱动 0.96寸ips屏教程][Linux_ spi_ 0.96_ips]
 *  [imx6ull Linux 开发板spi驱动st7789][imx6ull Linux _spi_st7789]
 *  [linux spi][]
 *  [imx6ull Linux spi + frambuffer 实现st7789运行显示QT程序 且可实现大小屏双屏同显][imx6ull Linux spi _ frambuffer _st7789_QT_]

# 一、配置设备树 #

//功能引脚节点
    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设备上。

[Linux_------framebuffer_spi-tft]: https://blog.csdn.net/Guet_Kite/article/details/88766022
[68 linux framebuffer_spi lcd]: https://blog.csdn.net/jklinux/article/details/74531245
[65 linux spi_spi LCD]: https://blog.csdn.net/jklinux/article/details/74411470
[Linux_ spi_ 0.96_ips]: https://blog.csdn.net/Raymond_97_/article/details/106875085
[imx6ull Linux _spi_st7789]: https://blog.csdn.net/Raymond_97_/article/details/107025346
[linux spi]: https://blog.csdn.net/chenliang0224/article/details/78948128
[imx6ull Linux spi _ frambuffer _st7789_QT_]: https://blog.csdn.net/Raymond_97_/article/details/107097450