4线串行接口是啥意思,SI4模式指的是否SPI模式?Sitronix7036的LCD驱动芯片,很急

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了4线串行接口是啥意思,SI4模式指的是否SPI模式?Sitronix7036的LCD驱动芯片,很急相关的知识,希望对你有一定的参考价值。

不是SPI模式

4线串口是指控制线和数据共4条,分别是 SI(串行数据输入),SO(串行数据输出),SCK(串行时钟),CS(片选).ST7036的4线串口是SI(串行数据输入),SCK(串行时钟),CS(片选),A0(数据和指令选择).
参考技术A 4线串口是指控制线和数据共4条,分别是 SI(串行数据输入),SO(串行数据输出),SCK(串行时钟),CS(片选).ST7036的4线串口是SI(串行数据输入),SCK(串行时钟),CS(片选),A0(数据和指令选择).常用方法:
void write_command(unsigned char rs,unsigned char dat)

unsigned char i;
CS = 0;
if(rs) A0 = 0;
else A0 = 1;
for(i = 0; i < 8; i++)

SCK = 1;
if(dat & 0x80) SI = 1;
else SI = 0;
SCK = 0;
dat <<= 1;

CS = 1;

可参考:http://baike.baidu.com/view/140064.htm追问

能否给我一段写数据的程序。。。。。并且把写ST7036更详细的跟我说一下。。。。。
并且把时序说一说,我菜鸟,如果可以的话真的十分感激。。。。。

本回答被提问者采纳

SPI接口及驱动

1. 简介

  • SPI接口是Motorola 首先提出的全双工三线同步串行外围接口,采用主从模式(Master Slave)架构。支持多slave模式应用,一般仅支持单Master。时钟由Master控制,在时钟移位脉冲下,数据按位传输,高位在前,低位在后(MSB first)。SPI接口有2根单向数据线,为全双工通信,目前应用中的数据速率可达几Mbps的水平。
  • SPI接口优点:
    • 支持全双工操作
    • 操作简单
    • 数据传输速率较高(相对的)
  • SPI接口缺点:
    • 多个spi设备需要占用主机较多的管脚(每个从机都需要一根片选线)
    • 只支持单个主机
    • 没有指定的流控制,没有应答机制确认是否接收到数据

2. 接口

2.1 总线结构

2.2 硬件接口

  • SPI接口共有4根信号线,分别是:设备选择线、时钟线、串行输出数据线、串行输入数据线。
    • MOSI:主器件数据输出,从器件数据输入
    • MISO:主器件数据输入,从器件数据输出
    • SCLK: 时钟信号,由主器件产生
    • S S ˉ \\barSS SSˉ: 从器件使能信号,由主器件控制

2.3 SPI工作模式

  • SPI有四种工作模式,具体由CPOL(Clock Polarity 时钟极性),CPHA(Clock Phase时钟相位)决定
    • 当CPOL为0时,空闲的时候SCLK电平是低电平
    • 当CPOL为1时,空闲的时候SCLK电平是高电平
    • 当CPHA为0时,采集数据发生在时钟周期的前边缘(第一个边缘,可能是上升缘也可能是下降缘,由CPOL决定),这同时意味着输出数据发生在后边缘
    • 当CPHA为1时,采集数据发生在时钟周期的后边缘(第二个边缘,可能是上升缘也可能是下降缘,由CPOL决定),这同时意味着输出数据发生在前边缘

3. Linux驱动代码

  • Linux SPI驱动框架主要分为

    • 核心层
    • 控制器驱动层
    • 设备驱动层
  • 最下层是硬件空间,SPI总线控制器,总线控制器负责硬件上的数据交互。内核空间中,需要有对应的控制器驱动,对硬件进行操作。

  • 核心层的作用:向控制器驱动层提供注册SPI控制器驱动的接口,并提供一些需要控制器驱动实现的回调函数。核心层向上,对SPI设备驱动,提供标准的SPI收发API,以及设备注册函数。

  • 当有SPI设备驱动发起一次传输时,设备驱动会调用SPI核心层的收发函数(spi_sync/spi_async),核心层的收发函数,会回调控制器驱动层实现的硬件相关的发送回调函数。从而实现SPI数据的收发。

  • 我们编写SPI接口的设备驱动程序的时候,最需要关心的就是SPI控制器的部分和SPI设备采用的是那种模式,确定模式后,我们得将SPI控制器配置成一样的模式才能正常工作

  • SPI驱动代码:位于 kernel/drivers/spi目录下 (这个目录和一些层次比较明显的驱动目录布局不同,全放在这个文件夹下,因此还是只好通过看Kconfig 和 Makefile来找找思路)

  • 相关数据结构

    • spi_master:SPI控制器
    • spi_driver:SPI设备驱动
    • spi_device:SPI设备
    • spi_message:SPI传输数据结构体
    • spi_transfer:该结构体是spi_message下的子单元
  • spi_driver和spi_device的关系

    • spi_driver对应一套驱动方法,包含probe,remove等方法。spi_device对应真实的物理设备,每个spi设备都需要一个spi_device来描述。spi_driver与spi_device是一对多的关系,一个spi_driver上可以支持多个同类型的spi_device
  • spi_master和spi_device

    • spi_master 与 spi_device 的关系和硬件上控制器与设备的关系一致,即spi_device依附于spi_master
  • spi_message和spi_transfer

    • spi传输数据是以 spi_message 为单位的,我们需要传输的内容在 spi_transfer 中。spi_transfer是spi_message的子单元
    • 将本次需要传输的 spi_transfer 以 spi_transfer->transfer_list 为链表项,连接成一个transfer_list链表,挂接在本次传输的spi_message spi_message->transfers链表下
    • 将所有等待传输的 spi_message 以 spi_message->queue 为链表项,连接成个链表挂接在queue下
  • 相关API函数

//分配一个spi_master
struct spi_master *spi_alloc_master(struct device *dev, unsigned size)

//注册和注销spi_master
int spi_register_master(struct spi_master *master)
void spi_unregister_master(struct spi_master *master)

//注册和注销spi_driver
int spi_register_driver(struct spi_driver *sdrv)
void spi_unregister_driver(struct spi_driver *sdrv)

//初始化spi_message
void spi_message_init(struct spi_message *m)
//向spi_message添加transfers
void spi_message_add_tail(struct spi_transfer *t, struct spi_message *m)
//异步发送spi_message
int spi_async(struct spi_device *spi, struct spi_message *message)
//同步发送spi_message
int spi_sync(struct spi_device *spi, struct spi_message *message)

//spi同步写(封装了上面的函数)
int spi_write(struct spi_device *spi, const void *buf, size_t len)
//spi同步读(封装了上面的函数)
int spi_read(struct spi_device *spi, void *buf, size_t len)
//同步写并读取(封装了上面的函数)
int spi_write_then_read(struct spi_device *spi,
    const void *txbuf, unsigned n_tx,
    void *rxbuf, unsigned n_rx)

3.1 SPI核心层

  • 实现代码:kernel/drivers/spi/spi.c (头文件位于: kernel/include/linux/spi/spi.h)
  • 功能:(实现函数:spi_init)
    • 对SPI子系统进行初始化工作
    • 注册SPI总线
    • 注册一个spi master(控制器)类
    • 提供SPI设备驱动对SPI总线进行操作的API
struct bus_type spi_bus_type = 
	.name		= "spi",
	.dev_groups	= spi_dev_groups,
	.match		= spi_match_device,
	.uevent		= spi_uevent,
;

static struct class spi_master_class = 
	.name		= "spi_master",
	.owner		= THIS_MODULE,
	.dev_release	= spi_master_release,
	.dev_groups	= spi_master_groups,
;
  • spi_bus_type为spi总线类型,通过bus_register()函数将SPI 总线注册进总线,成功注册后,在/sys/bus 下即可找到spi 文件目录
  • spi_master_class为spi控制器设备类,通过调用class_register()函数注册设备类,成功注册后,在/sys/class目录下即可找到spi_master文件目录
  • spi子系统初始化函数spi_init,仅仅是注册了spi bus,以及spi_master class。
static int __init spi_init(void)

	int	status;

	buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
	if (!buf) 
		status = -ENOMEM;
		goto err0;
	
	status = bus_register(&spi_bus_type);			/*注册spi bus*/
	if (status < 0)
		goto err1;
	status = class_register(&spi_master_class);		/* 注册spi_master类 */
	if (status < 0)
		goto err2;
	if (IS_ENABLED(CONFIG_OF_DYNAMIC))
		WARN_ON(of_reconfig_notifier_register(&spi_of_notifier));
	if (IS_ENABLED(CONFIG_ACPI))
		WARN_ON(acpi_reconfig_notifier_register(&spi_acpi_notifier));
	return 0;
err2:
	bus_unregister(&spi_bus_type);
err1:
	kfree(buf);
	buf = NULL;
err0:
	return status;

3.2 SPI控制器驱动

  • SPI控制器驱动:即SPI硬件控制器对应的驱动,核心部分需要实现硬件SPI数据收发功能。这样SPI设备驱动,才能通过SPI读写数据
  • SPI是一种平台特定的资源,所以它是以platform device的方式注册进内核的,因此它的struct platform_device结构是已经静态定义好了的,现在只待它的struct platform_driver注册,然后和platform_device匹配。
  • 描述SPI控制器的设备树节点:
		spi0: spi@0xA5004000 
			compatible = "my,my-spi";   /* 描述,和驱动匹配 */
			reg = <0 0xA5004000 0 0x1000>; /* 控制器IO地址 */
			clocks = <&spi0_mclk>;  /* 控制器时钟 */
			clock-names = "spi_mclk";  /* 时钟名 */
			interrupt-parent = <&gic>;
			interrupts = <0 33 4>;   /* 控制器中断 */
			resets = <&rst 0x50 4>;  /* 复位寄存器 */
			reset-names = "spi0";     
			pinctrl-names = "default";
			pinctrl-0 = <&spi0_func>;   /* 引脚复用功能配置 */
			status = "disabled";     /* 暂时disable */
			#address-cells = <1>;
			#size-cells = <0>;
		;
  • 实现一个platform_driver
static struct platform_driver my_spi_driver = 
    .probe = my_spi_probe,
    .remove = my_spi_remove,
    .driver = 
        .name = MY_SPI_NAME,
        .of_match_table = my_spi_of_match,
		.pm = &my_spi_dev_pm_ops,
    ,
;

3.2.1 probe函数功能

  • 申请struct spi_master内存以及私有数据内存(struct my_spi)
  • 将struct spi_master设置为platform_device的private_data
  • 从设备树获取IO地址,对应设备树reg节点
  • 将IO内存映射为虚拟地址
  • 从设备树获取中断,对应设备树interrupts节点
  • 申请中断,设置中断服务函数
  • 设置核心层回调的片选使能函数,设置spi_master的transfer_one函数,如果控制器驱动不实现transfer和transfer_one_message,内核会自动填充默认的,最终控制器驱动只需要实现transfer_one。
  • 根据时钟名,从设备树获取时钟
  • 根据设备树的reset节点,操作寄存器spi控制器对应的BIT进行复位
  • 调用devm_spi_register_master,把spi_master->device注册到设备模型中。核心层篇中以及详细介绍了devm_spi_register_master函数,

3.2.2 数据收发

  • 数据收发部分主要有两个函数
  • 1)控制收发的函数,即spi_master的spi_transfer_one函数
    - 以看到全志这里代码的逻辑,一个是初始化完成量。然后进行一系列硬件操作后,睡眠等待完成信号,同时设置超时时间,超时了没有得到信号量,证明硬件出问题了,不应该一直等待,应该返回错误。
    - 这个完成信号由中断来发送,硬件上会有发送完成中断。
  • 2)配合发送的中断服务函数
    • 读取中断状态寄存器,判断发送完成的BIT是否置位,如果置位,则表示硬件已经发送完数据了,那么发送完成信号量,给正在睡眠等待的spi_transfer_one函数。spi_transfer_one函数接收到信号量后被唤醒,知道硬件以及发送完数据了,返回0(表示发送成功)

3.3 SPI设备驱动

  • 实现一个spi_driver, 并注册到SPI核心层
  • 直接调用spi核心层提供的函数注册,也就是说它不需要关心是哪个控制器来实现最终的spi数据传输。从这里也可以看出核心层的作用,分隔了控制器和设备驱动的关联性,主要两边的驱动都容易实现
  • 以内核中spidev设备驱动为例,对基于设备树的SPI设备驱动进行说明
  • spidev驱动代码位于kernel/drivers/spi/spidev.c
  • 设备树部分
dac0: dh2228@2 
	compatible = "rohm,dh2228fv";
	reg = <2>;
	spi-max-frequency = <100000>;
;
  • 设备树部分很简单,只是写了compatible描述,用于和驱动匹配。这里reg的意思是spi cs引脚序号。并不像其他平台设备一样是IO地址,或者像I2C一样是从机地址

3.3.1 spidev_init

static int __init spidev_init(void)

	int status;

	/* Claim our 256 reserved device numbers.  Then register a class
	 * that will key udev/mdev to add/remove /dev nodes.  Last, register
	 * the driver which manages those device numbers.
	 */
	BUILD_BUG_ON(N_SPI_MINORS > 256);
	status = register_chrdev(SPIDEV_MAJOR, "spidev_test", &spidev_fops);
	if (status < 0)
		return status;

	spidev_class = class_create(THIS_MODULE, "spidev");
	if (IS_ERR(spidev_class)) 
		unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
		return PTR_ERR(spidev_class);
	

	status = spi_register_driver(&spidev_spi_driver);
	if (status < 0) 
		class_destroy(spidev_class);
		unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
	
	return status;

module_init(spidev_init);

static void __exit spidev_exit(void)

	spi_unregister_driver(&spidev_spi_driver);
	class_destroy(spidev_class);
	unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);

module_exit(spidev_exit);
  • 这里设置的spidev的file_operations(spidev_fops),设备操作函数后文详细介绍。然后创建了spidev的class,创建完成后在用户空间/sys/class/下可以看到spidev目录结构。然后调用spi_register_driver注册spi从设备。

3.3.2 spi_driver

static const struct of_device_id spidev_dt_ids[] = 
	 .compatible = "rohm,dh2228fv" ,
	 .compatible = "lineartechnology,ltc2488" ,
	 .compatible = "ge,achc" ,
	 .compatible = "semtech,sx1301" ,
	,
;
MODULE_DEVICE_TABLE(of, spidev_dt_ids);
static struct spi_driver spidev_spi_driver = 
	.driver = 
		.name =		"spidev",
		.of_match_table = of_match_ptr(spidev_dt_ids),
		.acpi_match_table = ACPI_PTR(spidev_acpi_ids),
	,
	.probe =	spidev_probe,
	.remove =	spidev_remove,

	/* NOTE:  suspend/resume methods are not necessary here.
	 * We don't do anything except pass the requests to/from
	 * the underlying controller.  The refrigerator handles
	 * most issues; the controller driver handles the rest.
	 */
;
  • 描述,与设备树相对应,会调用probe函数
  • probe函数,匹配时调用

3.3.3 probe

static int spidev_probe(struct spi_device *spi)

	struct spidev_data	*spidev;
	int			status;
	unsigned long		minor;

	/*
	 * spidev should never be referenced in DT without a specific
	 * compatible string, it is a Linux implementation thing
	 * rather than a description of the hardware.
	 */
	if (spi->dev.of_node && !of_match_device(spidev_dt_ids, &spi->dev)) 
		dev_err(&spi->dev, "buggy DT: spidev listed directly in DT\\n");
		WARN_ON(spi->dev.of_node &&
			!of_match_device(spidev_dt_ids, &spi->dev));
	

	spidev_probe_acpi(spi);

	/* Allocate driver data */
	spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
	if (!spidev)
		return -ENOMEM;

	/* Initialize the driver data */
	spidev->spi = spi;
	spin_lock_init(&spidev->spi_lock);
	mutex_init(&spidev->buf_lock);

	INIT_LIST_HEAD(&spidev->device_entry);

	/* If we can allocate a minor number, hook up this device.
	 * Reusing minors is fine so long as udev or mdev is working.
	 */
	mutex_lock(&device_list_lock);
	minor = find_first_zero_bit(minors, N_SPI_MINORS);
	if (minor < N_SPI_MINORS) 
		struct device *dev;

		spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
		dev = device_create(spidev_class, &spi->dev, spidev->devt,
				    spidev, "spidev%d.%d",
				    spi->master->bus_num, spi->chip_select);
		status = PTR_ERR_OR_ZERO(dev);
	 else 
		dev_dbg(&spi->dev, "no minor number available!\\n");
		status = -ENODEV;
	
	if (status == 0) 
		set_bit(minor, minors);
		list_add(&spidev->device_entry, &device_list);
	
	mutex_unlock(&device_list_lock);

	spidev->speed_hz = spi->max_speed_hz;

	if (status == 0)
		spi_set_drvdata(spi, spidev);
	else
		kfree(spidev);

	return status;

  • spidev的probe函数,申请了私有结构体spidev的内存空间,初始化了spidev的一些成员,自旋锁、互斥锁等。并将spidev指针设置为struct spi_device的私有数据(private_data)
  • 调用device_create创建了/dev/下的spidev节点,如spi总线0上cs1设备,则设备名为/dev/spidev0.1,其他以此类推
  • 在编写spi、i2c等驱动时,所做的操作也和spidev相差无几。初始化一些自己需要的资源等。但是一般情况下,这类涉及外设的驱动,会读取一下SPI、I2C从设备的ID寄存器等,来判断硬件是否就位,spi总线能否读写数据

3.3.4 spidev_fops

static const struct file_operations spidev_fops = 
	.owner =	THIS_MODULE,
	.write =	spidev_write,
	.read =		spidev_read,
	.unlocked_ioctl = spidev_ioctl,
	.compat_ioctl = spidev_compat_ioctl,
	.open =		spidev_open,
	.release =	spidev_release,
	.llseek =	no_llseek,
;

  • open和release:判断是否申请txbuff和rxbuff内存,如果没申请就申请。并维护了一个user count,用户空间每打开一次就+1,关闭一次就-1。所有都关闭后release释放申请的内存。

3.3.4.1 spidev_write

static ssize_t
spidev_write(struct file *filp, const char __user *buf,
		size_t count, loff_t *f_pos)

	struct spidev_data	*spidev;
	ssize_t			status = 0;
	unsigned long		missing;

	if (count > bufsiz)
		return -EMSGSIZE;
	spidev = filp->private_data;
	
	mutex_lock(&spidev->buf_lock);
	missing = copy_from_user(spidev->tx_buffer, buf, count);		(1)
	if (missing == 0)
		status = spidev_sync_write(spidev, count);					(2)
	else
		status = -EFAULT;
	mutex_unlock(&spidev->buf_lock);

	return status;


static inline ssize_t
spidev_sync_write(struct spidev_data *spidev, size_t len)

	struct spi_transfer	t = 
			.tx_buf		= spidev->tx_buffer,
			.len		= len,
			.speed_hz	= spidev->speed_hz,
		;
	struct spi_message	m;

	spi_message_init(&m);
	spi_message_add_tail(&t, &m);
	return spidev_sync(spidev, &m);									(3)


static ssize_t
spidev_sync(struct spidev_data *spidev, struct spi_message *message)

	int status;
	struct spi_device *spi;
	spin_lock_irq(&spidev->spi_lock);
	spi = spidev->spi;
	spin_unlock_irq(&spidev->spi_lock);
	if (spi == NULL)
		status = -ESHUTDOWN;
	else
		status = spi_sync(spi, message);							(4)
	if (status == 0)
		status = message->actual_length;
	return status;


  • copy_from_user:从用户空间拷贝要发送的数据到内核空间
  • 调用spidev_sync_write函数发送数据,这个函数实现代码也在上面贴出来了
  • spidev_sync_write代码实现,定义spi_transfer和spi_message,然后通过spidev_sync发送
  • spidev_sync中仅仅是判断了spi_device是否为空,不为空则调用spi_sync函数将spi_message发送出去
  • spidev_read函数与write函数如出一辙,不同的是write先从用户空间拷贝数据,然后调用发送函数发出去。struct spi_transfer填充的是tx_buff。而read则是先调用接受函数,struct spi_transfer填充的是rx_buff,然后将接收到的rx_buff,通过copy_to_user拷贝给用户空间。

3.3.4.2 ioctl

#define SPI_IOC_MAGIC			'k'

/* Read / Write of SPI mode (SPI_MODE_0..SPI_MODE_3) (limited to 8 bits) */
#define SPI_IOC_RD_MODE			_IOR(SPI_IOC_MAGIC, 1, __u8)
#define SPI_IOC_WR_MODE			_IOW(SPI_IOC_MAGIC, 1, __u8)

/* Read / Write SPI bit justification */
#define SPI_IOC_RD_LSB_FIRST		_IOR(SPI_IOC_MAGIC, 2, __u8)
#define SPI_IOC_WR_LSB_FIRST		_IOW(

以上是关于4线串行接口是啥意思,SI4模式指的是否SPI模式?Sitronix7036的LCD驱动芯片,很急的主要内容,如果未能解决你的问题,请参考以下文章

SPI总线介绍

各位大神单片机中的SPI是啥意思应该怎样理解?

SPI通信四大模式

第四季-专题20-SPI驱动程序设计

SSP和SPI接口有啥不一样?

spi flash是啥,和其他有啥区别?