驱动编程简单教程——PTC512（ADC芯片驱动）为例

最新推荐文章于 2024-03-29 22:30:16 发布
最新推荐文章于 2024-03-29 22:30:16 发布
阅读量3.6k 收藏 33
点赞数 4
分类专栏： Linux 文章标签： 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42948513/article/details/124630278
版权

1.简介

上几周硬件找了一个ADC芯片的替代料，需要我这边写一个驱动做测试。以前都是配置与修改设备树，最多查看或小改一下驱动，没有写过驱动，所有记录一下思路。大致思路就是先看原理图，再看芯片手册，知道要写驱动的芯片张怎么样，怎么工作的。

2.查看原理图

在这里插入图片描述

3.查看芯片手册

在这里插入图片描述

3.1 引脚定义

参考输入等相关引脚
在这里插入图片描述
ADC通道相关引脚
在这里插入图片描述
SPI相关引脚
在这里插入图片描述
GPIO相关功能引脚
在这里插入图片描述
电源等相关引脚
在这里插入图片描述

3.2 内部架构与相关原理

在这里插入图片描述
在这里插入图片描述

3.3 芯片寄存器的操作（重点）

我们操作一个设备一般就是操作其设备相关的寄存器

3.3.1 手动模式

在这里插入图片描述
在这里插入图片描述
SPI一次传输16bit的数据，如果设置成手动模式，相关设置如下

0001 (选择手动模式) 1(开启低字段编码) 0001(选择的通道) 1(开启2Vref量程) 0(关闭休眠模式) 0(关闭GPIO功能) 0000(GPIO0)

则驱动用SPI往此ADC芯片传0001 1000 1100 0000，就设置相关寄存器工作
在这里插入图片描述
选择的通道数据，需要延迟3个数据

3.3.2 Auto1模式

在这里插入图片描述
在这里插入图片描述
设置通道寄存器
在这里插入图片描述
在这里插入图片描述

1000 0000 0000 0000 进入auto1 program sequence，下一帧编程通道
1010 1010 0101 0101 扫描 0 2 4 6 9 11 13 15 通道

在这里插入图片描述

3.3.3 Auto2模式

在这里插入图片描述
在这里插入图片描述
设置通道寄存器
在这里插入图片描述
在这里插入图片描述

3.3.4选择模式下继续操作

在这里插入图片描述
还有GPIO和告警的设置，但因为项目没有用到，驱动没有去编写，所有不做分析

4.开始编写驱动

#include <linux/module.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/spi/spi.h>
#include <linux/gpio.h>
#include <linux/device.h>
#include <linux/mutex.h>
#include <linux/delay.h>
#include <linux/kthread.h>

#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/of_gpio.h>
#include <linux/of_platform.h>
#include <linux/fs.h>
#include <linux/input.h>

#define SPIADC_DEBUG (1)
#ifdef SPIADC_DEBUG
	#define spiadc_debug(fmt...)	printk(KERN_INFO "spiadc: "fmt)
#else
	#define spiadc_debug(fmt...)	do{}while(0)
#endif

#define FSU_SPI_DRIVER_VERSION          ("1.01.001")

/** 
  * 复位所有寄存器
  */
#define TPC5120_RESET_CHIP 	        (uint16_t)0x4200

/** 
  * 模式控制寄存器
  */
#define TPC5120_MANNUAL_MODE_REG    (uint16_t)0x0001
#define TPC5120_AUTO1_MODE_REG      (uint16_t)0x0002
#define TPC5120_AUTO2_MODE_REG 	    (uint16_t)0x0003

/** 
  * 自动模式程序寄存器
  */
#define TPC5120_AUTO1_PROG_REG      (uint16_t)0x0008
#define TPC5120_AUTO2_PROG_REG      (uint16_t)0x0009

/** 
  *  MANNUAL模式寄存器
  */ 
#define ManuLSBEN                   ((uint16_t)0x0800)
#define ManuCHnl				    ((uint16_t)0x0080)
#define ManuRangSel                 ((uint16_t)0x0040)
#define ManuPD 						((uint16_t)0x0020)
#define ManuGPIOEn					((uint16_t)0x0010)
#define ManuGPIOData				((uint16_t)0x0001)

/** 
  * AUTO1模式寄存器 
  */ 
#define Auto1LSBEN                  ((uint16_t)0x0800)       
#define Auto1CHnlRst				((uint16_t)0x0400)
#define Auto1RangSel                ((uint16_t)0x0040)       
#define Auto1PD 					((uint16_t)0x0020)
#define Auto1GPIOEn					((uint16_t)0x0010)
#define Auto1GPIOData				((uint16_t)0x0001)

/** 
  * AUTO2模式寄存器 
  */ 
#define Auto2LSBEN                  ((uint16_t)0x0800)       
#define Auto2CHnlRst				((uint16_t)0x0400)
#define Auto2RangSel                ((uint16_t)0x0040)       
#define Auto2PD 					((uint16_t)0x0020)
#define Auto2GPIOEn					((uint16_t)0x0010)
#define Auto2GPIOData				((uint16_t)0x0001)

typedef enum 
{
	Manual,
	Auto1,
	Auto2,
}TPC5120_mode_type;

typedef enum 
{
	lsd_code_disable,
	lsd_code_enabled,
}TPC5120_lsd_code;

typedef enum 
{
	power_down_disable,
	power_down_enabled,
}TPC5120_power_down;

typedef enum 
{
	chan_no_reset,
	chan_reset,
}TPC5120_chan_type;

typedef enum 
{
	range_v,
	range_2v,
}TPC5120_range_type;

typedef enum 
{
	gpio_disable,
	gpio_enabled,
}TPC5120_GPIO_type;

typedef enum 
{
	gpio_0 = 0x0,
	gpio_1 = 0x2,
	gpio_2 = 0x4,
	gpio_3 = 0x8,
}TPC5120_GPIO_number;

typedef struct 
{
	u8 value_valid;//数据更新标志
	u8 chan;
	u16 reg_value; //寄存器读取的数值
	u32 adc_value; //转换处理出来的数值

}fsu_spi_adc;

typedef struct
{
	u8 adc_valid;      //adc修改标志
	u8 adc_mode;       //adc工作模式
	u16 adc_ch_scan;   //adc扫描通道
	u32 task_sleep_time;//线程休眠时间

	int vref;
	int max;

	struct device *dev;
    struct spi_device *spi;
	struct kobject *kobj_spi_adcs;
	struct task_struct *spi_adc_task;//线程

	fsu_spi_adc f_spi_adc_data[16]; //各通道数据
}fsu_spi_dev;

/*
* 函数名： show_fsu_spi_data
* 功能：显示adc数据
*/
static ssize_t show_fsu_spi_data(struct device *dev, struct device_attribute *attr, char *buf)
{
	int i,len = 0;
	fsu_spi_dev *fsd = dev_get_drvdata(dev);

    if (NULL == fsd)
    {
       	printk(KERN_ERR ": fsu spi device empty!!!\n");
       	return 0;
    }

    len = sprintf(buf, "ChNo        RegisterValue        Value        Status \n");
	for(i = 0; i < 16; i++)
	{
		len += sprintf(buf + len, "%-16d    %-8d     %-4d          %-8s\n", \
        		fsd->f_spi_adc_data[i].chan, fsd->f_spi_adc_data[i].reg_value, \
				fsd->f_spi_adc_data[i].adc_value, fsd->f_spi_adc_data[i].value_valid ? "normal" : "fault");
	}

	return len;
}

/*
* 函数名： show_spi_driver_ver
* 功能：显示adc驱动版本
*/
static ssize_t show_spi_driver_ver(struct device *dev, struct device_attribute *attr, char *buf)
{
	fsu_spi_dev *fsd = dev_get_drvdata(dev);
	if (NULL == fsd)
	{
    	printk(KERN_ERR ": fsu spi device empty!!!\n");
    	return 0;
	}

	return ( sprintf(buf, "%s\n", FSU_SPI_DRIVER_VERSION) );
}

/*
* 函数名： show_spi_adc_chan
* 功能：显示adc 通道号
*/
static ssize_t show_spi_adc_chan(struct device *dev, struct device_attribute *attr, char *buf)
{
	fsu_spi_dev *fsd = dev_get_drvdata(dev);
	if (NULL == fsd)
	{
    	printk(KERN_ERR ": fsu spi device empty!!!\n");
    	return 0;
	}

	spiadc_debug("spi adc chan:%x\n", fsd->adc_ch_scan);
	return (sprintf(buf, "spi adc scan channl = %x \n", fsd->adc_ch_scan));
}

/*
* 函数名： set_spi_adc_chan
* 功能：设置adc扫描通道
*/
static ssize_t set_spi_adc_chan(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	u32 u32Data;
	
	fsu_spi_dev *fsd = dev_get_drvdata(dev);
	if (NULL == fsd)
	{
    	printk(KERN_ERR ": fsu spi device empty!!!\n");
    	return 0;
	}

	spiadc_debug("set buf:%s\n", buf);
	if (kstrtou32(buf, 10, &u32Data))
	{
		printk(KERN_ERR "spi adc scan channl para error!\n");
		return -EINVAL;
	}
	spiadc_debug("set Data:%d\n", u32Data);
	if(u32Data >= 0)
	{
		fsd->adc_ch_scan = u32Data & 0x0000ffff;
		fsd->adc_valid = 1;
	}
	else
	{
		spiadc_debug("spi adc scan channl input error!\n");
		fsd->adc_valid = 0;
	}

	return count;
}

/*
* 函数名： show_spi_adc_mode
* 功能：显示adc工作模式
*/
static ssize_t show_spi_adc_mode(struct device *dev, struct device_attribute *attr, char *buf)
{
	fsu_spi_dev *fsd = dev_get_drvdata(dev);
	if (NULL == fsd)
	{
    	printk(KERN_ERR ": fsu spi device empty!!!\n");
    	return 0;
	}

	spiadc_debug("spi sdc mode:%x\n", fsd->adc_mode);
	return (sprintf(buf, "Manual = 0; Auto1 = 1; Auto2 = 2;\nThe current mode = %d\n", fsd->adc_mode));
}

/*
* 函数名： set_spi_adc_mode
* 功能：设置adc工作模式
*/
static ssize_t set_spi_adc_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	u32 u32Data;
	
	fsu_spi_dev *fsd = dev_get_drvdata(dev);
	if (NULL == fsd)
	{
    	printk(KERN_ERR ": fsu spi device empty!!!\n");
    	return 0;
	}

	spiadc_debug("set buf:%s\n", buf);
	if (kstrtou32(buf, 10, &u32Data))
	{
		printk(KERN_ERR "spi adc mode para error!\n");
		return -EINVAL;
	}
	spiadc_debug("set Data:%d\n", u32Data);
	if(u32Data < 3)
	{
		fsd->adc_mode = u32Data;
		fsd->adc_valid = 1;
	}
	else
	{
		spiadc_debug("spi adc mode input error!\n");
		fsd->adc_valid = 0;
	}

	return count;
}

/*
* 函数名： show_spi_adc_sleep_time
* 功能：显示adc数据更新读取时间
*/
static ssize_t show_spi_adc_sleep_time(struct device *dev, struct device_attribute *attr, char *buf)
{	
	fsu_spi_dev *fsd = dev_get_drvdata(dev);
	if (NULL == fsd)
	{
    	printk(KERN_ERR ": fsu spi device empty!!!\n");
    	return 0;
	}

	spiadc_debug("task_sleep_time:%d\n", fsd->task_sleep_time);
	return (sprintf(buf, "%d\n", fsd->task_sleep_time));
}

/*
* 函数名： set_spi_adc_sleep_time
* 功能：设置adc数据更新读取时间
*/
static ssize_t set_spi_adc_sleep_time(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
	u32 u32Data;

	fsu_spi_dev *fsd = dev_get_drvdata(dev);
	if (NULL == fsd)
	{
    	printk(KERN_ERR ": fsu spi device empty!!!\n");
    	return 0;
	}

	spiadc_debug("set buf:%s\n", buf);
	if (kstrtou32(buf, 10, &u32Data))
	{
		printk(KERN_ERR "spi adc time para error!\n");
		return -EINVAL;
	}

	if(u32Data > 0)
	{
		spiadc_debug("set Data:%d\n", u32Data);
		fsd->task_sleep_time = u32Data;
		fsd->adc_valid = 1;
	}
	else
	{
		spiadc_debug("spi adc time input error!\n");
		fsd->adc_valid = 0;
	}

	return count;
}

static DEVICE_ATTR(fsu_spi_adc_data, S_IRUGO, show_fsu_spi_data, NULL);
static DEVICE_ATTR(fsu_spi_adc_ver, S_IRUGO, show_spi_driver_ver, NULL);
static DEVICE_ATTR(fsu_spi_adc_mode, S_IWUSR | S_IRUGO, show_spi_adc_mode, set_spi_adc_mode);
static DEVICE_ATTR(fsu_spi_adc_chan, S_IWUSR | S_IRUGO, show_spi_adc_chan, set_spi_adc_chan);
static DEVICE_ATTR(fsu_spi_adc_sleep_time, S_IWUSR | S_IRUGO, show_spi_adc_sleep_time, set_spi_adc_sleep_time);

static struct attribute *fsu_spiadc_attrs[] = {
    &dev_attr_fsu_spi_adc_data.attr,
	&dev_attr_fsu_spi_adc_ver.attr,
	&dev_attr_fsu_spi_adc_mode.attr,
	&dev_attr_fsu_spi_adc_chan.attr,
	&dev_attr_fsu_spi_adc_sleep_time.attr,
    NULL
};

static struct attribute_group fsu_spiadc_group = {
    .attrs = fsu_spiadc_attrs 
};

static int fsu_add_all_spi_data_node(struct device *dev)
{
	int ret;
	ret = sysfs_create_group(&dev->kobj, &fsu_spiadc_group);

    if (ret)
    {
       	dev_warn(dev, "Create fsu all spi data sysfs node 'fsu_spi_data' failed, ret=%d\n", ret);
    }

	return 0;
}

/*
* 函数名： spi_write_read
* 功能：写入TPC5120寄存器设置指令，并读取数据
*/
static u16 spi_write_read(fsu_spi_dev *adc, u16 cmd)
{
	u8 cmd_buf[2];
	u8 data_buf[2];
	u16 data = 0;
	cmd_buf[1] = cmd & 0x00FF;
	cmd_buf[0] = cmd >> 8;
	spi_write(adc->spi,cmd_buf,2);
	spi_read(adc->spi,data_buf,2);
	data = data_buf[0] <<8 |data_buf[1];
	spiadc_debug("==== spi_write_read cmd:%x%x data_buf:%x%x data:%x ====\n",cmd_buf[0],cmd_buf[1],data_buf[0],data_buf[1],data);
	return data;
}

/*
* 函数名： set_auto1_prog_cfg
* 参数：  chscan 扫描的通道号
* 功能：设置TPC521程序寄存器 设置指定读取的通道数据
* 例： chscan = 0xaa55 扫描 0 2 4 6 9 11 13 15通道
*/
static void set_auto1_prog_cfg(fsu_spi_dev *adc, u16 chscan)
{	
	u16 adc_cfg;
	adc_cfg=TPC5120_AUTO1_PROG_REG<<12;
	spi_write_read(adc, adc_cfg);   	// enters auto1 program sequence
	spi_write_read(adc, chscan);		// select channel to scan
}

/*
* 函数名： set_auto2_prog_cfg
* 参数： chscan 扫描的通道号
* 功能：设置TPC521程序寄存器 设置自动扫描通道的范围
* 例： chscan = 0x5 扫描 0~5通道
*/
static void set_auto2_prog_cfg(fsu_spi_dev *adc, u16 chscan)
{
	u16 adc_cfg;
	adc_cfg=(TPC5120_AUTO2_PROG_REG<<12)|((chscan&0x000f)<<6);
	spi_write_read(adc, adc_cfg);
}

/*
* 函数名： set_manual_mode_cfg
* 参数： lsbEn 是否开启第di10~0的编码
		 chan 通道号
         range 范围选择 0 0~Vref 1 0~2Vref
		 pd 休眠模式
		 ioEn GPIO功能
		 iodata 设置GPIO_x为输出模式
* 功能：设置TPC521模式寄存器 ADC为手动模式
*/
static void set_manual_mode_cfg(fsu_spi_dev *adc, u8 lsbEn, u16 chan, u8 range, u8 pd, u8 ioEn, u8 iodata)
{
	u16 adc_cfg;
	adc_cfg=(TPC5120_MANNUAL_MODE_REG<<12);
	if(lsbEn) adc_cfg|=ManuLSBEN;
	adc_cfg|=(chan&0x000f)*ManuCHnl;
	if(range) adc_cfg|=ManuRangSel;
	if(pd)    adc_cfg|=ManuPD;
	if(ioEn)  adc_cfg|=ManuGPIOEn;
	adc_cfg|=iodata*ManuGPIOData;
	spi_write_read(adc, adc_cfg);   // config mannual mode reg
}

/*
* 函数名： set_auto1_mode_cfg
* 参数： lsbEn 是否开启第di10~0的编码
         chanRst  通道是否复位
         range 范围选择 0 0~Vref 1 0~2Vref
		 pd 休眠模式
		 ioEn GPIO功能
		 iodata 设置GPIO_x为输出模式
* 功能：设置TPC521模式寄存器 ADC为自动1模式
*/
static void set_auto1_mode_cfg(fsu_spi_dev *adc, u8 lsbEn, u8 chanRst, u8 range, u8 pd, u8 ioEn, u8 iodata)
{
	u16 adc_cfg;
	adc_cfg=(TPC5120_AUTO1_MODE_REG <<12);
	if(lsbEn)   adc_cfg|=Auto1LSBEN;
	if(chanRst) adc_cfg|=Auto1CHnlRst;
	if(range)   adc_cfg|=Auto1RangSel;
	if(pd)      adc_cfg|=Auto1PD;
	if(ioEn)    adc_cfg|=Auto1GPIOEn;
	adc_cfg|=iodata*Auto1GPIOData;
	spi_write_read(adc, adc_cfg);  	// config auto1 mode reg
}

/*
* 函数名： set_auto2_mode
* 参数： lsbEn 是否开启第di10~0的编码
         chanRst  通道是否复位
         range 范围选择 0 0~Vref 1 0~2Vref
		 pd 休眠模式
		 ioEn GPIO功能
		 iodata 设置GPIO_x为输出模式
* 功能：设置TPC521模式寄存器 ADC为自动2模式
*/
static void set_auto2_mode_cfg(fsu_spi_dev *adc, u8 lsbEn, u8 chanRst, u8 range, u8 pd, u8 ioEn, u8 iodata)
{
	u16 adc_cfg;
	adc_cfg=TPC5120_AUTO2_MODE_REG<<12;
	if(lsbEn)   adc_cfg|=Auto2LSBEN;
	if(chanRst) adc_cfg|=Auto2CHnlRst;
	if(range)   adc_cfg|=Auto2RangSel;
	if(pd)      adc_cfg|=Auto2PD;
	if(ioEn)    adc_cfg|=Auto2GPIOEn;	
	adc_cfg|=iodata*Auto2GPIOData;
	spi_write_read(adc, adc_cfg);	 // config auto2 mode reg
}

/*
* 函数名： parse_adc_data
* 功能：解析spi读取到的数据，并更新
*/
static int parse_adc_data(fsu_spi_dev *adc, u16 spi_data)
{
	u16 adc_buf = spi_data;

	u8 adc_chan = adc_buf >> 12;
	u16 reg_value = adc_buf & 0x0fff;

	//换算数据
	u32  adc_value = 0;
	adc_value = (reg_value * adc->vref)/adc->max;

	int i;
	spiadc_debug("==== parse_adc_data chan:%x reg_value:%x adc_value:%d ====\n",adc_chan,reg_value,adc_value);
	for(i = 0; i < 16; i++)
	{
		if ( adc_chan == adc->f_spi_adc_data[i].chan)
		{
			if(reg_value != adc->f_spi_adc_data[i].reg_value)
			{
				adc->f_spi_adc_data[i].reg_value = reg_value;
				adc->f_spi_adc_data[i].adc_value = adc_value;
				//数据更新
				adc->f_spi_adc_data[i].value_valid = 1;
			}
			else
			{
				//数据没有更新
				adc->f_spi_adc_data[i].value_valid = 0;
			}
		}
		else
		{
			//数据没有更新
			adc->f_spi_adc_data[i].value_valid = 0;
		}
	}
}

//驱动运行线程
static int fsu_spi_adc_sample(void *arg)
{
	spiadc_debug("==== fsu_spi_adc_sample start ====\n");
	fsu_spi_dev *fspiadc = NULL;
	u16 spi_data;
	int i;
	fspiadc = (fsu_spi_dev *)arg;

	while(1)
	{
		msleep(fspiadc->task_sleep_time);
		if(kthread_should_stop()) 
		{	
			break;
		}

		if(1 == fspiadc->adc_valid)
		{
			fspiadc->adc_valid = 0;
			//复位所有寄存器
			spi_write_read(fspiadc,TPC5120_RESET_CHIP);
			//配置寄存器
			switch(fspiadc->adc_mode)
			{
				case Manual:
					//设置模式寄存器
					set_manual_mode_cfg(fspiadc,lsd_code_enabled,fspiadc->adc_ch_scan,range_2v,power_down_disable,gpio_disable,gpio_0);
				break;

				case Auto1:
					//设置模式寄存器
					set_auto1_mode_cfg(fspiadc,lsd_code_enabled,chan_reset,range_2v,power_down_disable,gpio_disable,gpio_0);
					//设置通道寄存器
					set_auto1_prog_cfg(fspiadc,fspiadc->adc_ch_scan);
				break;

				case Auto2:
					//设置模式寄存器
					set_auto2_mode_cfg(fspiadc,lsd_code_enabled,chan_reset,range_2v,power_down_disable,gpio_disable,gpio_0);
					//设置通道寄存器
					set_auto2_prog_cfg(fspiadc,fspiadc->adc_ch_scan);
				break;
			}
		}

		for(i = 0; i < 16; i++)
		{
			spi_data = spi_write_read(fspiadc,0);
			//解析数据
			parse_adc_data(fspiadc,spi_data);
		}
	}
	spiadc_debug("==== fsu_spi_adc_sample end ====\n");
	return 0;
}

static int fsu_spi_adc_init(fsu_spi_dev *spi_dev)
{
	spiadc_debug("==== fsu_spi_adc_init start ====\n");
	if (NULL == spi_dev)
	{
		return -1;
	}

	fsu_spi_dev *fspiadc = spi_dev;
	int i;
	fspiadc->adc_valid = 1;
	fspiadc->adc_mode = 2;
	fspiadc->adc_ch_scan = 0xb;
	fspiadc->task_sleep_time = 5000;

	for( i = 0;i < 16; i++)
	{
		fspiadc->f_spi_adc_data[i].value_valid = 0;
		fspiadc->f_spi_adc_data[i].chan = i;
		fspiadc->f_spi_adc_data[i].reg_value = 0;
		fspiadc->f_spi_adc_data[i].adc_value = 0;
	}
	spiadc_debug("==== fsu_spi_adc_init end ====\n");
	return 0;
}

static int fsu_spi_adc_parse_dt(fsu_spi_dev *spiadc)
{
    struct device_node *node = spiadc->dev->of_node;

    if (of_property_read_u32(node, "vref", &spiadc->vref))
    {
        dev_err(spiadc->dev, "Could not get 'vref'!!");
        return -1;
    }

    if (spiadc->vref <= 0)
    {
        spiadc->vref = 5000;
        dev_warn(spiadc->dev, "Invalid 'vref', using default %d\n", spiadc->vref);
    }

    if (of_property_read_u32(node, "max", &spiadc->max))
    {
        dev_err(spiadc->dev, "Could not get 'max'!!");
        return -1;
    }

    if (spiadc->max <= 0)
    {
        spiadc->max = 4096;
        dev_warn(spiadc->dev, "Invalid 'max', using default %d\n", spiadc->max);      
    }

	spiadc_debug("spi adc vref:%d, max:%d\n",spiadc->vref, spiadc->max);
	
    return 0;
}

static int fsu_spi_adc_probe(struct spi_device *spi)
{
	spiadc_debug("==== fsu_spi_adc_probe start ====\n");
    int ret;
	fsu_spi_dev *spiadc;

	/*
		整个内核空间的调用链上只有4KB或8KB的栈，相对于应用程序来说是非常小，如果需要大内存的空间，需要使用专门的函数进行动态分配kmalloc
	*/
	/* allocate device handle */
    spiadc = devm_kzalloc(&spi->dev, sizeof(*spiadc), GFP_KERNEL);
    if (NULL == spiadc)
    {
        return -ENOMEM;
    }

	/* init adc */
    spiadc->dev = &spi->dev;
    spiadc->spi = spi;

	spiadc_debug("==== spi dev chip_select:%d, max_speed_hz:%d, mode:%d ====\n", spi->chip_select, spi->max_speed_hz, spi->mode);

    /* setup spi */
    spi->bits_per_word = 8;
    ret = spi_setup(spi);
    if (ret < 0)
    {
        dev_err(&spi->dev, "Setup spi failed, ret = %d\n", ret);
		devm_kfree(&spi->dev, spiadc);
		return ret;
    }

	/* set drv data */
    dev_set_drvdata(&spi->dev, spiadc);

	/* parse dt */ //解析设备树
	fsu_spi_adc_parse_dt(spiadc);

	//初始化默认配置
	fsu_spi_adc_init(spiadc);

	//生成设备节点
	fsu_add_all_spi_data_node(spiadc->dev);

	//开启线程
	spiadc->spi_adc_task = kthread_create(fsu_spi_adc_sample, spiadc, "spi_adc_task");
	if(IS_ERR(spiadc->spi_adc_task))
	{
		spiadc_debug("creat spi_adc_task erro \n");
		spiadc->spi_adc_task = NULL;
	}
	else
	{
		//等待线程
		wake_up_process(spiadc->spi_adc_task);
	}
	spiadc_debug("==== fsu_spi_adc_probe end ====\n");
    return 0;
}


static int fsu_spi_adc_remove(struct spi_device *spi)
{
    fsu_spi_dev *fsd = dev_get_drvdata(&spi->dev);

	if(fsd->spi_adc_task) 
	{
		kthread_stop(fsd->spi_adc_task);
		fsd->spi_adc_task = NULL;
	}
    sysfs_remove_group(&spi->dev.kobj, &fsu_spiadc_group);
    devm_kfree(&spi->dev, fsd);	

    return 0;
}

static const struct of_device_id fsu_spiadc_match_ids[] = {
    { .compatible = "znv,fsu-spiadc", .data = NULL},
    {},
};

MODULE_DEVICE_TABLE(of, fsu_spiadc_match_ids);

static struct spi_driver fsu_spiadc_driver = {
	.probe		= fsu_spi_adc_probe,
	.remove		= fsu_spi_adc_remove,
	.driver		= {
    	.name		= FSU_SPI_ADC_NAME,
    	.owner		= THIS_MODULE,
    	.of_match_table = fsu_spiadc_match_ids,
    },
};

//驱动入口函数
static int __init fsu_spiadc_init(void)
{
    spi_register_driver(&fsu_spiadc_driver);
    return 0;
}
//驱动卸载函数
static void __exit fsu_spiadc_exit(void)
{
    spi_unregister_driver(&fsu_spiadc_driver);
}

//驱动程序的入口
module_init(fsu_spiadc_init); //运行insmod指令的时候，就会调用
//驱动程序的出口
module_exit(fsu_spiadc_exit); //运行rmmod指令的时候，会被调用

//驱动的描述
MODULE_AUTHOR("kamin");		//作者
MODULE_DESCRIPTION("ADC Driver Mode");	//模块功能说明
MODULE_LICENSE("GPL");	//许可证：驱动遵循GPL协议
KaminLuo
关注
  • 4
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
linux AD芯片 驱动程序 编写
11-18
基于Linux的MISC类设备AD7859L的驱动程序开发方法。
基于H桥驱动电路的半导体制冷片恒温控制系统
07-07
启动快，控制灵活H桥驱动电路常用于直流电机的方向控制，本系统将H桥驱动电路引入对半导体制冷片进行控制如图2所示，当控制信号PC1为高电平，PTC2为低电平时，左侧臂两个8550三极管Q1和Q2导通，由于上、下两个MOS管...
Windows驱动编程基础教程(转)
weixin_30703911的博客
06-01 358
我经常在网上遇到心如火燎的提问者。他们碰到很多工作中的技术问题，是关于驱动开发的。其实绝大部分他们碰到的“巨大困难”是被老牛们看成初级得不能再初 级的问题。比如经常有人定义一个空的UNICODE_STRING,然后往里面拷贝字符串。结果无论如何都是蓝屏。也有人在堆栈中定义一个局部 SPIN_LOCK,作为下面的同步用——这样用显然没有任何意义。我无法一一回答这些问题：因为往往要耐心的看他...
OpenHarmony：全流程讲解如何编写ADC平台驱动以及应用程序
最新发布
m0_64420071的博客
03-29 1303
ADC驱动
相见恨晚！C语言的驱动法编程详细解析（超多代码案例）
轻松学C语言
05-16 873
点击蓝字关注我们因公众号更改推送规则，请点“在看”并加“星标”第一时间获取精彩技术分享来源于网络，侵删数据压倒一切。如果选择了正确的数据结构并把一切组织的井井有条，正确的算法就不言自明。编程的核心是数据结构，而不是算法。——Rob Pike说明本文基于这样的认识：数据是易变的，逻辑是稳定的。本文例举的编程实现多为代码片段，但不影响描述的完整性。本文例举的编程虽然基于C语言，但其编程思想也适用于其他...
如何根据芯片手册时序图编写驱动程序
热门推荐
weixin_36447711的博客
09-21 1万+
如何根据芯片手册时序图编写驱动程序 对于电子开发者来说，刚刚拿到一个芯片，常用的芯片可以参考网上的例程来做深入了解，对于一个不常用的芯片来说，Datasheet几乎是使用芯片的唯一的资料，所以根据Datasheet时序图写出对应的驱动程序就尤为重要。 本文根据一个简单的例子来阐述根据时序图来编写对应的程序过程。旨在讲解对于初学者应该怎么利用芯片的时序图编写符合要求的底层驱动程序（老鸟请跳过）。 下载芯片的Datasheet，（个人常用http://www.21icsearch.com/）如..
Linux驱动编程（驱动程序基石）（上）
afddasfa的博客
05-13 817
参考内核头文件：include\linux\workqueue.h。
驱动的编写
weixin_48651223的博客
10-02 1965
驱动
Melexis PTC-04 编程器用户界面指南
01-12
Melexis PTC-04 编程器用户界面指南 Introduction This document describes the User Interface of the PTC-04 programmer. The PTC-04 User Interface groups all tooling of the PTC-04. The UI can be installed ...
一种高可靠性LED照明驱动电路
08-27
根据LED 照明灯具的特点，设计了一款恒流式驱动电路。此电路采用电容降压方式，为整个电路提供恒定的电流。利用TVS（瞬态电压抑制器） 对LED 进行过压保护，同时利用NTC（负温度系数热敏电阻） 有效地降低了浪涌电流...
LED驱动器的类别及其照明散热控制浅谈
10-21
LED驱动器是LED照明系统的核心组成部分，主要负责将电源转换为适合LED发光的电流。LED驱动器分为两类：直流驱动器和交流驱动器。 直流驱动器主要包括三种类型： 1. 串联降压型驱动器：它通过直流开关器件和电抗性...
PLM项目（PTC）——爆炸图管理蓝图设计.pptx
06-17
"PLM项目（PTC）——爆炸图管理蓝图设计" PLM 项目中的爆炸图管理蓝图设计是指对产品的设计、制造、生产、销售和服务等整个生命周期的管理。该设计旨在实现产品的爆炸图管理，包括爆炸图的设计、制造、生产、销售和...
51 单片机实战教程(15 外围芯片驱动程序之AD7683芯片驱动)
billliu66的博客
12-12 3461
前面已经介绍过AD芯片CS1237，这里再介绍一款ADC芯片AD7683。AD7683是一款16bit ADC芯片，虽然位数比CS1237少，但速度比CS1237快，标称是100kSPS。供电电压为2.5~5.5V，封装有MSOP与QFN两种。通信接口也是串口，兼容SPI/QSPI/MICROWIRE。应用场景为：数据获取、仪器、医药仪器、这款ADC芯片也比较适合用51单片机系统。 ...
树莓派IO口驱动代码的编写、微机总线地址、物理地址、虚拟地址、BCM2835芯片手册
FHNCSDN
09-24 832
地址总线： 百度百科解释： 地址总线 (Address Bus；又称：位址总线) 属于一种电脑总线 （一部份），是由CPU 或有DMA 能力的单元，用来沟通这些单元想要存取（读取/写入）电脑内存元件/地方的实体位址。 CPU寻找外部的内存单元靠的是地址总线传输的数据。 如果CPU有8根地址总线，每根线上传输0或1，那么传输的数据范围为00000000~ 11111111，每一个数值都对应内存中的一个内存单元，所以可以找到编号为00000000~ 11111111号的内存单元。如果传输的数据为 001
嵌入式编程技法之“数据驱动编程“
hy091997的博客
11-09 510
编程技法
Linux驱动编程（驱动程序基石）（下）
afddasfa的博客
05-13 1365
这里要引入虚拟地址的概念：CPU 发出的地址是虚拟地址，它经过 MMU(Memory Manage Unit，内存管理单元)映射到物理地址上，对于不同进程的同一个虚拟地址，MMU 会把它们映射到不同的物理地址。分别执行 test 程序 2 次，最后执行 ps，可以看到这 2 个程序同时存在，这 2 个程序里 a 变量的地址相同，但是值不同。② 2 个程序同时运行，它们的变量 a 的值是不一样的，一个是 12，另一个是 123。你想映射某个内核 buffer，你需要得到它的物理地址，这得由你提供。
【事件驱动编程】事件驱动编程的基础理论
Ricky的博客
01-03 1314
同步编程模式同步编程是最传统和直观的编程方式。在这种模式下，程序的执行流程是线性的，即每一个操作或函数调用都按顺序执行，而且每个操作必须完成后才能开始下一个操作。这种方式易于理解和调试，因为代码的执行顺序与其在源文件中的顺序相符。特点线性执行流程：程序按照代码的顺序执行，每个步骤依次进行。阻塞性质：如果当前的操作没有完成，程序就会在那里停顿，不会执行后续的代码。简单性和直观性：对于编程新手来说，同步编程更容易理解和实现。
深入探讨Linux驱动开发：驱动介绍与hello驱动实例
qq_52836452的博客
04-19 2569
通过之前对于IGKBoard开发板的应用层的学习与开发，现在已经进入了对Linux驱动的学习，对于Linux驱动的学习知识我也会在学习结束，总结汇总后发到我的博客当中，大家可以用作参考。对于Linux的程序开发分为应用程序开发与内核级驱动程序开发，分别对应Linux的用户态和内核态，用户态和内核态之间的交互主要通过系统调用（system call）来实现。系统调用是一种特殊的函数调用，用于在用户态的应用程序中请求操作系统内核执行特权操作，例如访问硬件设备、创建进程、进行文件操作等。
ADC测量PTC电阻
09-04
ADC测量PTC电阻需要将PTC电阻连接到ADC输入引脚上，并通过转换器将模拟信号转换为数字信号。以下是一般的步骤： 1. 将PTC电阻的一个端口连接到ADC的输入引脚上。 2. 使用合适的电源将PTC电阻供电。 3. 配置ADC的工作方式和参数，例如参考电压、采样率等。这些参数通常通过编程设置。 4. 启动ADC转换。 5. 等待一段时间，直到ADC完成转换。 6. 读取ADC的数据寄存器，获取数字信号表示的PTC电阻值。 7. 根据ADC的量程和分辨率进行相应的计算，将数字值转换为实际的PTC电阻值。 需要注意的是，具体的操作步骤会根据所使用的硬件平台和编程语言而有所不同。确保参考硬件和软件文档以获取详细的操作指南。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值