资讯详情

嵌入式Linux设备驱动程序开发指南17（IIO子系统一）——读书笔记

IIO子系统一

  • 十七、IIO子系统(1)
    • 17.1 简介
    • 17.2 数模转换——DAC实验
      • 17.2.1 IIO缓冲区
      • 17.2.2 触发器
      • 17.2.3 工业I/O事件
      • 17.2.4 iio工具
      • 17.2.5 LTC2607——DAC模块介绍
      • 17.2.5.1 设备树
      • 17.2.5.2 LTC介绍2607驱动模块
      • 17.2.5.2.1 用作I2C互动工业框架
      • 17.2.5.2.2 用作IIO工业框架的设备
      • 17.2.5.3 源代码
    • 17.3 模数转换——ADC实验
      • 17.3.1 ADC模块设备树
      • 17.3.2 ADC模块用作spi互动产业框架分析
      • 17.3.3 ADC模块用作iio设备工业框架分析
      • 17.3.4 ADC模块源代码
      • 17.3.5 应用代码
      • 17.3.6 ADC调试

十七、IIO子系统(1)

17.1 简介

IIO支持模数转换/数模转换，即ADC/DAC还有各种传感器Linux子系统。

以下是IIO支持子系统的传感器： ******* ADC——模-数转换器 ******* DAC——数模转换器 ******* CDC——电容-数字转换器 ******* 加速度计 ******* 陀螺仪 ******* IMU——惯性测量仪 ******* 颜色和光传感器 ******* 磁力计 ******* 压力传感器 ******* 距离传感器 ******* 温度传感器

关于Linux工业I/O子系统详细位置Linux驱动实现API指南如下：

https://www.kernel.org/doc/html/latest/driver-api/iio/core.html

IIO核心提供以下功能： 为编制各种嵌入式传感器驱动程序提供统一的框架； 为操作传感器的用户应用程序提供以下标准接口； 在这里插入图片描述

IIO框架提供以下几个接口： ******* 1、/sys/bus/iio/iio:deviceX  根据通道呈现硬件传感器； ******* 2、/dev/iio:deviceX 可用于输出事件和传感器数据，代表字符设备节点open()、read()、write()、close()函数访问；

iio使用内存申请函数如下：

devm_iio_device_alloc()

将设备注册为内核，如下：

devm_iio_device_register()

IIO设备的sysfs接口

在 /sys/bus/iio/iio:deviceX/目录下的部分属性如下： ******* name 描述物理芯片 ******* dev 节点对应的主/设备号 ******* 设备配置属性 ******* 如数据通道访问属性，out_voltage0_raw

17.2 数模转换——DAC实验

iio属性定义来下：

driver/iio/industrialio-core.c

17.2.1 IIO缓冲区

IIO缓冲区的使用可以减少CPU消耗。

17.2.2 触发器

在大多数情况下，驱动程序是基于外部事件（触发器）来捕获数据的。而不是定期的轮询数据。该驱动程序可以有一个产生硬件事件的设备或一个独立的终端源，如接收外部GPIO线、定时器中断或用户态特定sysfs提供文件写作操作的驱动。

17.2.3 工业I/O事件

 显示用户状态sysfs事件属性，几乎所有的IIO事件对应于从传感器监控一个或多个原始数据阈值，例如： ******* 超过电压阈值； ******* 均值超过阈值； ******* 运动检测器； ******* 平方和均方根的阈值； ******* 变化率阈值；

传递到用户状态IIO事件

include<linux/iio/events.h>  iio_push_event()

17.2.4 iio工具

位于/tools/iio/目录如下： ******* lsiio ******* iio_event_monitor ******* iio_generic_buffer ******* libiio

17.2.5 LTC2607——DAC模块介绍

核心模块将被操作Analog Device 公司的LTC2607设备。双路12bit、100kHZ和400KHZ 电压输出的DAC，使用I2C串行接口。

该驱动包括三部分： ******* 设备树 ******* 操作I2C互动工业框架 ******* IIO设备工业框架

17.2.5.1 设备树

   i2c2: i2c@600 
       
        { 
         compatible 
        = 
        "atmel,sama5d2-i2c"
        ; reg 
        = 
        <0x600 0x20
        0>
        ; interrupts 
        = 
        <
        20 IRQ_TYPE_LEVEL_HIGH 
        7>
        ; dmas 
        = 
        <
        0>, 
        <
        0>
        ; dma-names 
        = 
        "tx", 
        "rx"
        ; 
        #address-cells = <1>; 
        #size-cells = <0>; clocks 
        = 
        <&flx1_clk
        >
        ; pinctrl-names 
        = 
        "default"
        ; pinctrl-0 
        = 
        <&pinctrl_mikrobus_i2c
        >
        ; atmel,fifo-size 
        = 
        <
        1
        6>
        ; status 
        = 
        "okay"
        ; ltc2607@72 
        { 
          compatible 
        = 
        "arrow,ltc2607"
        ; reg 
        = 
        <0x7
        2>
        ; 
        #I2C设备地址 
        }
        ; ltc2607@73 
        { 
          compatible 
        = 
        "arrow,ltc2607"
        ; reg 
        = 
        <0x7
        3>
        ; 
        #I2C设备地址 
        }
        ; 
        }
        ;

17.2.5.2 LTC2607驱动模块介绍

17.2.5.2.1 用作I2C交互的工业框架

必须包含的头文件，如下：

#include <linux/i2c.h>
通过包含该头文件，可以引用 struct i2c_driver、 struct i2c_client()、i2c_get_clientdata()、i2c_set_clientdata()

创建有一个i2c_driver数据结构，如下：

static struct i2c_driver ltc2607_driver = { 
        
	.driver = { 
        
		.name	= LTC2607_DRV_NAME,
		.owner	= THIS_MODULE,
		.of_match_table = dac_dt_ids,
	},
	.probe		= ltc2607_probe,
	.remove		= ltc2607_remove,
	.id_table	= ltc2607_id,
};

作为i2c驱动注册到I2C总线，如下：

module_i2c_driver(ltc2607_driver);

添加到驱动支持的设备列表，如下：

static const struct of_device_id dac_dt_ids[] = { 
        
	{ 
         .compatible = "arrow,ltc2607", },
	{ 
         }
};
MODULE_DEVICE_TABLE(of, dac_dt_ids);

定义i2c_device_id类型数组，如下：

static const struct i2c_device_id ltc2607_id[] = { 
        
	{ 
         "ltc2607", 0 },
	{ 
         }
};
MODULE_DEVICE_TABLE(i2c, ltc2607_id);

17.2.5.2.2 用作IIO设备的工业框架

包含的头文件，如下：

#include <linux/iio/iio.h>
通过引用上面头文件，可以使用 iio_priv、devm_iio_device_alloc()

LTC2607驱动力的物理和逻辑设备数据结构之间关联，如下： 

static const struct iio_info ltc2607_info = { 
        

	.write_raw = ltc2607_write_raw,
	.driver_module = THIS_MODULE,
};

ltc2607_write_raw()函数，调用 ltc2607_set_value()函数再调用，i2c_master_send()函数。

计算公式： DAC值的范围是0 ~ 0xFFFF(65535) 输出电压 = Vref * DAC值 / 65535 Vref = 5V

17.2.5.3 源代码

#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/iio/iio.h>


#define LTC2607_DRV_NAME "ltc2607"

struct ltc2607_device { 
        
	struct i2c_client *client;
	char name[8];
};

static const struct iio_chan_spec ltc2607_channel[] = { 
        
{ 
        
	.type		= IIO_VOLTAGE,
	.indexed	= 1,
	.output		= 1,
	.channel	= 0,
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
},{ 
        
	.type		= IIO_VOLTAGE,
	.indexed	= 1,
	.output		= 1,
	.channel	= 1,
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
},{ 
        
	.type		= IIO_VOLTAGE,
	.indexed	= 1,
	.output		= 1,
	.channel	= 2,
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
}

};

static int ltc2607_set_value(struct iio_dev *indio_dev, int val, int channel)
{ 
        
	struct ltc2607_device *data = iio_priv(indio_dev);
	u8 outbuf[3];
	int ret;
	int chan;

	if (channel == 2)
		chan = 0x0F;
	else
		chan = channel;

	if (val >= (1 << 16) || val < 0)
		return -EINVAL;

	outbuf[0] = 0x30 | chan; /* write and update DAC */
	outbuf[1] = (val >> 8) & 0xff; /* MSB byte of dac_code */
	outbuf[2] = val & 0xff; /* LSB byte of dac_code */

	ret = i2c_master_send(data->client, outbuf, 3);
	if (ret < 0)
		return ret;
	else if (ret != 3)
		return -EIO;
	else
		return 0;
}

static int ltc2607_write_raw(struct iio_dev *indio_dev,
			       struct iio_chan_spec const *chan,
			       int val, int val2, long mask)
{ 
        
	int ret;

	switch (mask) { 
        
	case IIO_CHAN_INFO_RAW:
		ret = ltc2607_set_value(indio_dev, val, chan->channel);
		return ret;
	default:
		return -EINVAL;
	}
}

static const struct iio_info ltc2607_info = { 
        

	.write_raw = ltc2607_write_raw,
	.driver_module = THIS_MODULE,
};

static int ltc2607_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{ 
        
	static int counter = 0;
	struct iio_dev *indio_dev;
	struct ltc2607_device *data;
	u8 inbuf[3];
	u8 command_byte;
	int err;
	dev_info(&client->dev, "DAC_probe()\n");
	
	command_byte = 0x30 | 0x00; /* Write and update register with value 0xFF*/
	inbuf[0] = command_byte;
	inbuf[1] = 0xFF;
	inbuf[2] = 0xFF;

	/* allocate the iio_dev structure */
	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
	if (indio_dev == NULL) 
		return -ENOMEM;
	
	data = iio_priv(indio_dev);	
	i2c_set_clientdata(client, data);
	data->client = client;
	
	sprintf(data->name, "DAC%02d", counter++);
	dev_info(&client->dev, "data_probe is entered on %s\n", data->name);

	indio_dev->name = data->name;
	indio_dev->dev.parent = &client->dev;
	indio_dev->info = &ltc2607_info;
	indio_dev->channels = ltc2607_channel;
	indio_dev->num_channels = 3;
	indio_dev->modes = INDIO_DIRECT_MODE;

	err = i2c_master_send(client, inbuf, 3); /* write DAC value */
	if (err < 0) { 
        
		dev_err(&client->dev, "failed to write DAC value");
		return err;
	}
	
	dev_info(&client->dev, "the dac answer is: %x.\n", err);
	
	err = devm_iio_device_register(&client->dev, indio_dev);
	if (err)
		return err;

	dev_info(&client->dev, "ltc2607 DAC registered\n");

	return 0;
}

static int ltc2607_remove(struct i2c_client *client)
{ 
        
	dev_info(&client->dev, "DAC_remove()\n");
	return 0;
}

static const struct of_device_id dac_dt_ids[] = { 
        
	{ 
         .compatible = "arrow,ltc2607", },
	{ 
         }
};
MODULE_DEVICE_TABLE(of, dac_dt_ids);

static const struct i2c_device_id ltc2607_id[] = { 
        
	{ 
         "ltc2607", 0 },
	{ 
         }
};
MODULE_DEVICE_TABLE(i2c, ltc2607_id);

static struct i2c_driver ltc2607_driver = { 
        
	.driver = { 
        
		.name	= LTC2607_DRV_NAME,
		.owner	= THIS_MODULE,
		.of_match_table = dac_dt_ids,
	},
	.probe		= ltc2607_probe,
	.remove		= ltc2607_remove,
	.id_table	= ltc2607_id,
};
module_i2c_driver(ltc2607_driver);

MODULE_AUTHOR(" ");
MODULE_DESCRIPTION("LTC2607 16-bit DAC");
MODULE_LICENSE("GPL");

17.3 模数转换——ADC实验

首先，介绍开发一个不具有硬件触发功能的ADC，该ADC——SPI设备LTC2422. LTC2422是20bit 双通道ADC，即模拟——数字转换芯片，LTC串行输出数据流，如下： 

LTC2422输出数据流长度是24bit.
******* 片选引脚——CS
******* 数据线——SDO  即MISO管脚
******* 串行时钟——SCK

在driver/spi/spidev.c是通用SPI设备驱动，可以通过内核配置来启动它，即 CONFIG_SPI_SPIDEV.

17.3.1 ADC模块设备树

				spi3: spi@400 { 
        
					compatible = "atmel,at91rm9200-spi";
					reg = <0x400 0x200>;
					interrupts = <23 IRQ_TYPE_LEVEL_HIGH 7>;
					clocks = <&flx4_clk>;
					clock-names = "spi_clk";
					#address-cells = <1>;
					#size-cells = <0>;
					pinctrl-names = "default";
					pinctrl-0 = <&pinctrl_mikrobus_spi &pinctrl_mikrobus1_spi_cs &pinctrl_mikrobus2_spi_cs>;
					atmel,fifo-size = <16>;
					status = "okay"; /* Conflict with uart6 and i2c3. */

					spidev@0 { 
        
						compatible = "spidev";
						spi-max-frequency = <2000000>;
						reg = <0>;
					};
				   
				    ADC: ltc2422@0 { 
        
						compatible = "arrow,ltc2422";
						spi-max-frequency = <2000000>;
						reg = <0>;  #片选信号CS值
						pinctrl-0 = <&pinctrl_key_gpio_default>;
						int-gpios = <&pioA PIN_PA29 GPIO_ACTIVE_LOW>;
						interrupt-parent = <&pioA>;
						interrupts = <29  IRQ_TYPE_EDGE_FALLING>;
					};
				};

17.3.2 ADC模块用作spi交互的工业框架分析

包含头文件，如下：

#include <linux/spi/spi.h>

定义spi_driver数据结构，如下：


static struct spi_driver ltc2422_driver = { 
        
	.driver = { 
        
		.name	= "ltc2422",
		.owner	= THIS_MODULE,
		.of_match_table = ltc2422_dt_ids,
	},
	.probe		= ltc2422_probe,
	.id_table	= ltc2422_id,
};

将其作为驱动注册到SPI总线上，如下：

module_spi_driver(ltc2422_driver);

定义一个spi_device_id数据结构数组，如下：


static const struct spi_device_id ltc2422_id[] = { 
        
	{ 
         .name = "ltc2422", },
	{ 
         }
};
MODULE_DEVICE_TABLE(spi, ltc2422_id);

17.3.3 ADC模块用作iio设备的工业框架分析

包含头文件，如下：

#include <linux/iio/iio.h>
用于devm_iio_alloc()、iio_priv()

创建用于管理设备的私有数据结构，如下：

struct ltc2422_state { 
        
	struct spi_device *spi;
	u8 buffer[4];
};

将设备注册到IIO核心里，如下：

devm_iio_device_register(&spi->dev, indio_dev);

一个IIO设备代表一个数据通道，一个IIO设备可以有一个或多个数据通道。添加iio:device生成多个通道，如下：

static const struct iio_chan_spec ltc2422_channel[] = { 
        

{ 
        
	.type		= IIO_VOLTAGE,
	.indexed	= 1,
	.output		= 1,
	.channel	= 0,
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
}

};

给iio_info数据结构赋值，用户态对sysfs数据通道属性的操作都会被映射到内核的回调函数上，如下：

static const struct iio_info ltc2422_info = { 
        
	.read_raw = &ltc2422_read_raw,
	.driver_module = THIS_MODULE,
};

ltc2422_read_raw()函数调用spi_read()函数，如下：

static int ltc2422_read_raw(struct iio_dev *indio_dev,
	struct iio_chan_spec const *chan, int *val, int *val2, long m)
{ 
        
	int ret;
	struct ltc2422_state *st = iio_priv(indio_dev);

	switch (m) { 
        
	case IIO_CHAN_INFO_RAW:

		ret = spi_read(st->spi, &st->buffer, 3);
		if (ret < 0)
			return ret;

		*val  = st->buffer[0] << 16;
		*val |= st->buffer[1] << 8;
		*val |= st->buffer[2];

		dev_info(&st->spi->dev, "the value is %x\n", *val);

		return IIO_VAL_INT;

	default:
		return -EINVAL;
	}
}

17.3.4 ADC模块源代码

#include <linux/module.h>
#include <linux/spi/spi.h>
#include <linux/iio/iio.h>

struct ltc2422_state { 
        
	struct spi_device *spi;
	u8 buffer[4];
};

static const struct iio_chan_spec ltc2422_channel[] = { 
        

{ 
        
	.type		= IIO_VOLTAGE,
	.indexed	= 1,
	.output		= 1,
	.channel	= 0,
	
        标签： 加速度传感器3023a2h
 
锐单商城拥有海量元器件数据手册、
          IC替代型号，打造
          电子元器件IC百科大全！

锐单商城 - 一站式电子元器件采购平台