Linux下SPI子系统配置1.8寸LCD屏

最新推荐文章于 2024-08-21 09:02:37 发布
最新推荐文章于 2024-08-21 09:02:37 发布
阅读量1.3k 收藏 12
点赞数 7
分类专栏： rk3288
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43737424/article/details/107672511
版权

平台：rk3288-firefly
内核：Linux4.4
编译工具：arm-linux-gnueabihf-
小屏幕：128x160lcd ST7735

配置设备树：

&spi0 {
        status = "okay";
        max-freq = <48000000>;
         spidev@00 {
                compatible = "spi,oled";
                reg = <0x00>;
                spi-max-frequency = <48000000>;
                spi-cpha = <1>;
                spi-cpol = <1>;
                poll_mode = <0>;
                type = <0>;
                spi-rst = <&gpio5 8 GPIO_ACTIVE_LOW>;
                spi-dc = <&gpio5 9 GPIO_ACTIVE_LOW>;
		 	};
    };

代码：“显示部分已经改进，但是坐标设置不太准确”

#include <linux/init.h>
#include <linux/module.h>
#include <linux/spi/spi.h>
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
// #include "picc.h"
// LCD TFT 4-line-serial mode
#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

#define DRIVER_NAME     "spi-lcd_driver"
#define LCDDEV_CNT     1
#define LCDDEV_NAME    "gpio-lcd-kevin"

#define Width       128
#define Height      160

struct spi_lcd_dev {
    dev_t               devid;
    struct cdev         cdev;
    struct class*       class;
    struct device*      device;
    struct device_node  *nd;
    int                 major;
    int                 minor;
    void                *private_data;      //私有数据
    int                 dc_gpio;
    int                 rest_gpio;
};

static struct spi_lcd_dev lcd_dev;




static int LCD_WriteCommand(struct spi_lcd_dev *dev, unsigned char c)
{
    int ret;
    struct spi_message m;
    struct spi_transfer *t;
    struct spi_device *spi = dev->private_data;
    unsigned char txdata = c;
    t = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);   /* 申请内存 */
    if(t == NULL)
    {
        printk(KERN_ALERT "alloc spi transfer failed !\r\n");
        return -EINVAL;
    }

    gpio_set_value(dev->dc_gpio, 0);    /* 拉低发命令 */

    t->tx_buf = &txdata;
    t->len = 1;
    t->bits_per_word = 8;

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

static int LCD_WriteData(struct spi_lcd_dev *dev, unsigned char dat)
{
    int ret;
    struct spi_message m;
    struct spi_transfer *t;
    struct spi_device *spi = dev->private_data;
    unsigned char txdata = dat;

    t = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);   /* 申请内存 */
    if(t == NULL)
    {
        printk(KERN_ALERT "alloc spi transfer failed !\r\n");
        return -EINVAL;
    }

    gpio_set_value(dev->dc_gpio, 1);    /* 拉高发数据 */

    t->tx_buf = &txdata;
    t->len = 1;
    t->bits_per_word = 8;

    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;

}

static int LCD_WriteData_16bit(struct spi_lcd_dev *dev, unsigned short dat)
{
    int ret;
    struct spi_message m;
    struct spi_transfer *t;
    struct spi_device *spi = dev->private_data;
    unsigned char txdata = dat>>8;

    t = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);   /* 申请内存 */
    if(t == NULL)
    {
        printk(KERN_ALERT "alloc spi transfer failed !\r\n");
        return -EINVAL;
    }

    gpio_set_value(dev->dc_gpio, 1);    /* 拉高发数据 */

    t->tx_buf = &txdata;
    t->len = 1;
    t->bits_per_word = 8;

    spi_message_init(&m);   /* 初始化spi_message */
    spi_message_add_tail(t, &m);    /* 将spi_transfer添加到spi_message队列 */

    ret = spi_sync(spi, &m);        /* 使用同步发送 */

    txdata = dat&0xFF;
    t->tx_buf = &txdata;
    ret = spi_sync(spi, &m);        /* 使用同步发送 */



    kfree(t);
    return ret;

}



static void LCD_Set_Window(struct spi_lcd_dev *dev,u16 xstart,u16 ystart,u16 xend,u16 yend)
{
    LCD_WriteCommand(dev, 0x2A);
    LCD_WriteData(dev, 0x00);   //测试
    LCD_WriteData(dev, xstart);
    LCD_WriteData(dev, 0x00); 
    LCD_WriteData(dev, xend);  

    LCD_WriteCommand(dev, 0x2B); 
    LCD_WriteData(dev, 0x00); 
    LCD_WriteData(dev, ystart); 
    LCD_WriteData(dev, 0x00); 
    LCD_WriteData(dev, yend);   

    LCD_WriteCommand(dev, 0x2C); 
}



void LCD_Disp_Pic(void)
{
    struct spi_lcd_dev *dev = &lcd_dev;
    int i,j;
    static char pic[128];

    for(i=0; i<128; i++)
    {
        pic[i] = 0xf8;
    }

    /* 设置屏幕和显示部分 */
    LCD_Set_Window(dev, 0, 0, 159, 127);
    for(i=0; i<128; i++)
    {
        for(j=0; j<160;j++)
        {
            LCD_WriteData_16bit(dev, GRAY2);
        }
    }




    LCD_Set_Window(dev, 0, 0, 79, 63);
    for(i=0; i<79; i++)
    {
        for(j=0; j<63;j++)
        {
            LCD_WriteData_16bit(dev, WHITE);
        }
    }

    LCD_Set_Window(dev, 0, 63, 79, 127);
    for(i=0; i<79; i++)
    {
        for(j=0; j<63;j++)
        {
            LCD_WriteData_16bit(dev, RED);
        }
    }

    LCD_Set_Window(dev, 79, 0, 159, 63);
    for(i=0; i<79; i++)
    {
        for(j=0; j<63;j++)
        {
            LCD_WriteData_16bit(dev, GREEN);
        }
    }

    LCD_Set_Window(dev, 79, 63, 159, 127);
    for(i=0; i<79; i++)
    {
        for(j=0; j<63;j++)
        {
            LCD_WriteData_16bit(dev, YELLOW);
        }
    }


    mdelay(10);




    printk(KERN_ALERT "LCD display picture ok!\r\n");
}



static void lcd_reg_init(void)
{
    struct spi_lcd_dev *dev = &lcd_dev;
    printk(KERN_ALERT "This is lcd reg init func!\r\n");

    gpio_set_value(lcd_dev.rest_gpio, 1);
    mdelay(5);
    gpio_set_value(lcd_dev.rest_gpio, 0);
    mdelay(5);
    gpio_set_value(lcd_dev.rest_gpio, 1);
    mdelay(20);
    /******************************/
    LCD_WriteCommand(dev, 0x01);    // software reset
    mdelay(20);
    LCD_WriteCommand(dev, 0x11);    //sleep out
    mdelay(50);

    LCD_WriteCommand(dev, 0xB1);    //Frame Rate Control (In normal mode/ Full colors)
    LCD_WriteData(dev, 0x02); 
    LCD_WriteData(dev, 0x35); 
    LCD_WriteData(dev, 0x36); 
    LCD_WriteCommand(dev, 0xB2); 
    LCD_WriteData(dev, 0x02); 
    LCD_WriteData(dev, 0x35); 
    LCD_WriteData(dev, 0x36); 
    LCD_WriteCommand(dev, 0xB3); 
    LCD_WriteData(dev, 0x02); 
    LCD_WriteData(dev, 0x35); 
    LCD_WriteData(dev, 0x36); 
    LCD_WriteData(dev, 0x02); 
    LCD_WriteData(dev, 0x35); 
    LCD_WriteData(dev, 0x36); 

    LCD_WriteCommand(dev, 0xB4); //Dot inversion 
    LCD_WriteData(dev, 0x03); 

    LCD_WriteCommand(dev, 0xC0); 
    LCD_WriteData(dev, 0xA2); 
    LCD_WriteData(dev, 0x02); 
    LCD_WriteData(dev, 0x84); 
    LCD_WriteCommand(dev, 0xC1); 
    LCD_WriteData(dev, 0XC5); 
    LCD_WriteCommand(dev, 0xC2); 
    LCD_WriteData(dev, 0x0D); 
    LCD_WriteData(dev, 0x00); 
    LCD_WriteCommand(dev, 0xC3); 
    LCD_WriteData(dev, 0x8D); 
    LCD_WriteData(dev, 0x2A); 
    LCD_WriteCommand(dev, 0xC4); 
    LCD_WriteData(dev, 0x8D); 
    LCD_WriteData(dev, 0xEE); 

    LCD_WriteCommand(dev, 0xC5); //VCOM 
    LCD_WriteData(dev, 0x0A);    //1a
    LCD_WriteCommand(dev, 0x36); //MX, MY, RGB mode 
    // LCD_WriteData(dev, 0xEC); 
    LCD_WriteData(dev, 0xE0);   //change test

    LCD_WriteCommand(dev, 0xE0); //Gamma
    LCD_WriteData(dev, 0x12); 
    LCD_WriteData(dev, 0x1C); 
    LCD_WriteData(dev, 0x10); 
    LCD_WriteData(dev, 0x18); 
    LCD_WriteData(dev, 0x33); 
    LCD_WriteData(dev, 0x2C); 
    LCD_WriteData(dev, 0x25); 
    LCD_WriteData(dev, 0x28); 
    LCD_WriteData(dev, 0x28); 
    LCD_WriteData(dev, 0x27); 
    LCD_WriteData(dev, 0x2F); 
    LCD_WriteData(dev, 0x3C); 
    LCD_WriteData(dev, 0x00); 
    LCD_WriteData(dev, 0x03); 
    LCD_WriteData(dev, 0x03); 
    LCD_WriteData(dev, 0x10); 
    LCD_WriteCommand(dev, 0xE1); 
    LCD_WriteData(dev, 0x12); 
    LCD_WriteData(dev, 0x1C); 
    LCD_WriteData(dev, 0x10); 
    LCD_WriteData(dev, 0x18); 
    LCD_WriteData(dev, 0x2D); 
    LCD_WriteData(dev, 0x28); 
    LCD_WriteData(dev, 0x23); 
    LCD_WriteData(dev, 0x28); 
    LCD_WriteData(dev, 0x28); 
    LCD_WriteData(dev, 0x26); 
    LCD_WriteData(dev, 0x2F); 
    LCD_WriteData(dev, 0x3B); 
    LCD_WriteData(dev, 0x00); 
    LCD_WriteData(dev, 0x03); 
    LCD_WriteData(dev, 0x03); 
    LCD_WriteData(dev, 0x10); 

    LCD_WriteCommand(dev, 0x3A); //65k mode 5:6:5
    LCD_WriteData(dev, 0x05);   //18bit
    LCD_WriteCommand(dev, 0x29); //Display on 

    mdelay(50);



    printk(KERN_ALERT "LCD init ok!\r\n");
    LCD_Disp_Pic();
}




static int lcd_gpio_init(struct spi_device *spi)
{
    int ret;
    int flag1,flag2;
    lcd_dev.nd = spi->dev.of_node;  //找到设备树中节点
    if(lcd_dev.nd == NULL)
    {
        printk(KERN_ALERT "lcd node cant find !\r\n");
        return -EINVAL;
    }
    printk(KERN_ALERT "find lcd node okay !\r\n");

    /* 获取GPIO */
    lcd_dev.dc_gpio = of_get_named_gpio_flags(lcd_dev.nd, "spi-dc", 0, (enum of_gpio_flags *)&flag1);
    ret = gpio_is_valid(lcd_dev.dc_gpio);
    if(ret < 0)
    {
        printk(KERN_ALERT "get dc gpio failed !\r\n");
        return -EINVAL;
    }
    ret = gpio_request(lcd_dev.dc_gpio,"spi-dc");
    if(ret < 0)
    {
        printk(KERN_ALERT "request gpio dc failed !\r\n");
        gpio_free(lcd_dev.dc_gpio);
    }
    printk(KERN_ALERT "dc gpio num is %d !\r\n",lcd_dev.dc_gpio);

    lcd_dev.rest_gpio = of_get_named_gpio_flags(lcd_dev.nd, "spi-rst", 0, (enum of_gpio_flags *)&flag2);
    ret = gpio_is_valid(lcd_dev.rest_gpio);
    if(ret < 0)
    {
        printk(KERN_ALERT "get rest gpio failed !\r\n");
        return -EINVAL;
    }
    ret = gpio_request(lcd_dev.rest_gpio,"spi-rst");
    if(ret < 0)
    {
        printk(KERN_ALERT "request gpio rest failed !\r\n");
        gpio_free(lcd_dev.rest_gpio);
    }
    printk(KERN_ALERT "rest gpio num is %d !\r\n",lcd_dev.rest_gpio);

    /* 设置方向 */
	gpio_direction_output(lcd_dev.dc_gpio,0);
	gpio_direction_output(lcd_dev.rest_gpio,0);

    return ret;
}






// static int lcd_open(struct inode *inode, struct file *filp)
// {
//     filp->private_data = &lcd_dev;
    
//     return 0;
// }

static struct file_operations lcd_dev_fops = {
    .owner = THIS_MODULE,
    // .open = lcd_open,
    // .write = lcd_write,
};



static int spi_lcd_probe(struct spi_device *spi)
{
    int ret = 0;
    if(!spi)
    {
        return -ENOMEM;
    }   
    /**************************字符设备框架**********************************/
    alloc_chrdev_region(&lcd_dev.devid, 0, LCDDEV_CNT, LCDDEV_NAME);
    lcd_dev.major = MAJOR(lcd_dev.devid);
    lcd_dev.minor = MINOR(lcd_dev.devid);
    printk(KERN_ALERT "lcd_dev:major = %d \r\n",lcd_dev.major);
    printk(KERN_ALERT "lcd_dev:minor = %d \r\n",lcd_dev.minor);

    lcd_dev.cdev.owner = THIS_MODULE;

    cdev_init(&lcd_dev.cdev, &lcd_dev_fops);
    ret = cdev_add(&lcd_dev.cdev, lcd_dev.devid, LCDDEV_CNT);
    if(ret < 0)
    {
        printk(KERN_ALERT "add cdev failed!\r\n");
        unregister_chrdev_region(lcd_dev.devid, LCDDEV_CNT);
        return ret;
    }

    lcd_dev.class = class_create(THIS_MODULE, LCDDEV_NAME);
    if(IS_ERR(lcd_dev.class))
    {
        cdev_del(&lcd_dev.cdev);
        unregister_chrdev_region(lcd_dev.devid, LCDDEV_CNT);
        return PTR_ERR(lcd_dev.class);
    }

    lcd_dev.device = device_create(lcd_dev.class, NULL, lcd_dev.devid, NULL, LCDDEV_NAME);
    if(IS_ERR(lcd_dev.device))
    {
        cdev_del(&lcd_dev.cdev);
        unregister_chrdev_region(lcd_dev.devid, LCDDEV_CNT);
        class_destroy(lcd_dev.class);
        return PTR_ERR(lcd_dev.device);
    }
    /******************************************************************/

    /* 初始化spi_device */
    spi->mode = SPI_MODE_0;
    spi_setup(spi);

    /* 设置私有数据 */
    lcd_dev.private_data = spi;

    /* 初始化lcd屏的dc rest管脚 */
    lcd_gpio_init(spi);

    /* 内部寄存器初始化 */
    lcd_reg_init();


    printk(KERN_ALERT "spi_lcd_probe ok!\r\n");
    return 0;
}


static int spi_lcd_remove(struct spi_device *spi)
{
    gpio_free(lcd_dev.dc_gpio);
    gpio_free(lcd_dev.rest_gpio);
    cdev_del(&lcd_dev.cdev);
    unregister_chrdev_region(lcd_dev.devid, LCDDEV_CNT);
    device_destroy(lcd_dev.class, lcd_dev.devid);
    class_destroy(lcd_dev.class);
    return 0;
}


static const struct of_device_id spi_lcd_of_match[] = {
    {.compatible = "spi,oled",},
    {/* 空 */},
};

static struct spi_driver spi_lcd_driver = {
    .driver = {
        .owner = THIS_MODULE,
        .name = DRIVER_NAME,
        .of_match_table = of_match_ptr(spi_lcd_of_match),
    },
    .probe = spi_lcd_probe, 
    .remove = spi_lcd_remove,
};

static int __init spi_lcd_drv_init(void)
{
    printk(KERN_ALERT "This is spi-lcd-driver init func ...\r\n");
    return spi_register_driver(&spi_lcd_driver);	//SPI驱动注册进内核
}

static void __exit spi_lcd_drv_exit(void)
{
    spi_unregister_driver(&spi_lcd_driver);  //从内核中注销SPI驱动
}

module_init(spi_lcd_drv_init);
module_exit(spi_lcd_drv_exit);

MODULE_AUTHOR("Kevin");
MODULE_LICENSE("GPL");

最后再附上一张效果图，有瑕疵
在这里插入图片描述
还有屏幕的接线图：
在这里插入图片描述

啊哈也在撸代码
关注
专栏目录
Linux字符设备驱动–SPI LCD驱动
badbayyj的博客
09-07 1027
在中介绍了的驱动，本章会介绍如何从零开始写一个LCD驱动，我手上的是接口的驱动，在中，有一个专门为接口设立的子驱动（TFT），但本章并没有使用驱动来完成该程序，而是直接使用驱动来完成。本次使用的是驱动芯片，屏幕大小是1.3寸，240*240的屏幕，十几块钱一个，我们会用到的数据线有四根，分别是、两个数据传输线，复位线，数据与命令切换线。百度上该资料的屏幕很多，可以自行去查看，本章着重讲如何去写一个的驱动。屏幕采用的是总线，加上和线，所以我们需要一个的驱动框架打底，这是一切的基础。 驱动会去设备树中寻找匹配设
嵌入式Linux 中常见外设屏接口分析
嵌入式技术开发
06-20 121
b. 数字接口，同时传输视频和音频c. 传输非压缩视频数据和压缩/非压缩的数字音频数据接口功耗接线复杂度使用领域MCU低简单低分辨率、嵌入式系统、字符型液晶屏等RGB中等中等高质量图像显示、计算机显示器、电视等LVDS低中等高分辨率、工业控制、医疗设备、汽车信息娱乐MIPI低低/中等移动设备、嵌入式系统、虚拟现实、相机模块等EDP低中等高分辨率笔记本电脑、平板电脑、嵌入式系统等HDMI高中等/高高清晰度电视、监视器、投影仪、消费电子等DP高高。
SPI LCD Linux驱动
08-30
支持ST7735R、ILI9340、ST7735R、SSD1289、ILI9341、ILI9325等液晶。
SPI LCD Linux Driver
03-26
支持ST7735R、ILI9340、ST7735R、SSD1289、ILI9341、ILI9325等液晶。
RK3568 驱动RGB屏（带SPI初始化序列）
weixin_43536180的博客
06-27 598
RK3568 RGB
在linux上使用spi-lcd屏 ST7735
QQ135102692的博客
05-27 4585
一、ST7735介绍 ST7735是一款spi驱动的lcd屏，通过spi发送用于操作lcd的寄存器指令和显示数据​​​​​​​ 二、ST7735操作模式 当DC引脚为低，命令模式，目的是设置芯片显示参数等 当DC引脚为高，数据模式，发送的数据应该为图像rgb数据，保存在display ram并显示 BLK是控制LCD背光（不开背光，无法显示） 三、ST7735 ...
linux SPI操作LCD12864液晶
与其用泪水悔恨昨天，不如用汗水拼搏今天
08-18 3609
液晶型号为JLX12864 COG液晶，资料网上有，linux下面通过SPI与IO控制，IO控制使用的是文件方式，SPI是开发板提供的驱动，这个SPI驱动应该每家提供的都不一样，需要自己去按照驱动文档操作，主要不通电就是底层的配置不一样。 //SPI.c这个是打开SPI驱动 /* * SPI.c * * Created on: 2018年8月2日 * Author: cf...
68 linux framebuffer设备驱动之spi lcd屏驱动
jklinux的博客
07-06 9863
前面驱动的spi lcd仅仅是刷了一下图而已，　如果要让QT图形程序在此lcd上显示的话，还需要实现标准的framebuffer设备驱动才可以.实现一个fb设备驱动好，　QT程序就可以在显存里显示出来。　只需要在设备驱动把显存的数据通过spi控制器发送到屏的驱动ic，就可以让QT程序在spi lcd屏上显示出来.　但显存的数据有可能经常发生变化（界面切换），　spi lcd屏也应跟着显示出改变过的画
linux嵌入式内核配置与裁剪浅析
zhanjianshinian的专栏
06-21 8273
Linux内核裁减 （1）安装新内核: i)将新内核copy到/usr/src下, #tar xzvf linux-2.6.38.4.tar.gz -----解压缩. ii) 将名为linux的符号链接删掉,这是旧版本内核的符号链接. #ln -s linux-2.6.38.4 linux ------建立linux-2.6.38.4的符号链接linux. （2）设置内核. # cd /u
基于STM32+Qt上位机设计的智慧停车场管理系统(207)
08-14 459
本项目设计了一套基于STM32+Qt上位机的智慧停车场管理系统。该系统融合了先进的嵌入式技术、图像识别技术、数据库技术和移动互联网技术，通过STM32硬件端实时采集车库现场信息，包括车牌识别、车位占用状态监测等，并将数据上传至Qt上位机进行处理与展示。利用MySQL数据库存储车辆出入库记录及车位使用情况，确保数据的安全性和可追溯性；通过Android手机APP为用户提供查询、支付等功能，实现远程交互与便捷服务。
基于STM32的智能婴儿床控制系统设计(手机APP+蓝牙无线控制)(210)
最新发布
08-21 324
项目充分运用先进的嵌入式技术和物联网理念，打造出一款集安全性、便利性、舒适性于一体的智能婴儿床控制系统，旨在减轻育儿负担，提高育儿效率，保障婴幼儿健康成长，满足现代家庭对高品质育儿生活的追求。
linux 软件spi协议驱动0.96寸OLED
08-30
linux 软件spi协议驱动0.96寸OLED，端口可以任意修改，不像硬件SPI端口是固定的几个
1.8寸LCD-STM32F103C8测试程序
10-10
基于STM32F103C8T6单片机的1.8寸TFT_LCD液晶屏（ST7735S）测试程序，完整版测试程序代码。
Linux Spi Lcd驱动
jianfei55的博客
12-19 610
最近整一个项目，需要用到SPI通讯的LCD屏幕12832（12864也差不多），芯片ST7567，系统板STM32MP135D（正点原子核心板）。复制spilcd.ko到Linux以下目录/lib/modules/5.15.24。覆盖设备树文件到Linux系统的/lib/modules。当然，也可以显示中文字库，图像等。生成的字模数据，可以用于字符显示。
Linux下的LCD驱动(一)
热门推荐
weiqing的专栏
12-18 1万+
版权所有，转载必须说明转自 http://my.csdn.net/weiqing1981127  原创作者：南京邮电大学  通信与信息系统专业 研二 魏清   一．LCD屏理论 1.1 LCD屏基本概念 我们知道，诸如PCI、I2C和USB等外围设备总线都来自于系统PC机的南桥，今天我们看到的视频控制器则来自于北桥。LCD主要由TN(扭转向列型)、STN(超扭转向列型)、DSTN(双层超
Linux下的LCD驱动(二)
weiqing的专栏
12-19 4277
版权所有，转载请说明转自 http://my.csdn.net/weiqing1981127   3.3 LCD文件层 帧缓冲设备作为一个字符设备，其文件操作函数就定义在文件层fbmem.c中 static const struct file_operations fb_fops = {        .owner =       THIS_MODULE,        .read =
记录为Linux配置spi屏幕（st7735s）
qq_46604211的博客
05-06 6921
Linux配置spi屏幕（st7735s,使用我的板子需要增加底板） ps：st7735s可用st7735r的驱动（但是我打算使用7789v的驱动来修改）参考老哥 的文章：https://www.bilibili.com/read/cv9947785 1.修改fb_st7789v.c文件 该文件在：linux-5.10/drivers/staging/fbtft 1.1 修改init_display函数： static int init_display(struct fbtft_par *par) { p
【Linux】NanoPi-NEO2外接spi-lcd
qq_37280428的博客
04-15 1431
写在前面机缘巧合咸鱼上收了一块nanopi得开发板，抽空研究研究玩一玩，记录一下心得体会。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值