Quel appareil est Linux ADC-exploitation et maintenance Linux-php.cn

linux adc est un pilote de périphérique hybride ; dans linux2.6.30.4, le système est déjà livré avec le fichier de pilote universel ADC "arch/arm/plat-s3c24xx/adc.c", qui est une architecture de modèle de périphérique basée sur la plate-forme. Il a été écrit avec des codes relativement courants et stables.

Quel appareil est Linux ADC

L'environnement d'exploitation de ce tutoriel : système linux2.6.30.4, ordinateur Dell G3.

Quel type d'appareil est Linux ADC ?

pilote de périphérique mixte Linux adc driver

linux2.6.30.4, le système est déjà livré avec le fichier de pilote universel ADC ---arch/arm/plat-s3c24xx/adc.c, il est écrit sur la base de l'architecture du modèle de périphérique du pilote de plate-forme et contient des codes relativement courants et stables. Cependant, le fichier du pilote universel ADC de la version Linux 2.6.30.4 n'est pas complet et n'a pas de fonction de lecture. Plus tard, j'ai jeté un œil au fichier général ADC de la version Linux 3.8 - arch/arm/plat-samsung/adc.c qui est relativement complet.

Mais cette section ne vise pas à analyser ce fichier, mais à écrire le pilote ADC avec une autre architecture. Parce que le pilote ADC est relativement simple, il n'est pas écrit en utilisant le modèle de périphérique du pilote de plate-forme comme architecture. Nous utilisons un divers pilote de périphérique.

Q : Qu'est-ce qu'un pilote de périphérique divers ?

Réponse : miscdevice partage un numéro d'appareil majeur MISC_MAJOR (10), mais les numéros d'appareil mineurs sont différents. Tous les périphériques miscdevice forment une liste chaînée. Lors de l'accès au périphérique, le noyau recherche le périphérique miscdevice correspondant en fonction du numéro de périphérique, puis appelle l'interface d'opération de fichier enregistrée dans sa structure file_operations pour fonctionner.

struct miscdevice  {
	int minor;				//次设备号，如果设置为MISC_DYNAMIC_MINOR则系统自动分配
	const char *name;		//设备名
	const struct file_operations *fops;		//操作函数
	struct list_head list;
	struct device *parent;
	struct device *this_device;
};

Copier après la connexion

dev_init analyse de la fonction d'entrée :

static int __init dev_init(void)
{
	int ret;

	base_addr=ioremap(S3C2410_PA_ADC,0x20);
	if (base_addr == NULL)
	{
		printk(KERN_ERR "failed to remap register block\n");
		return -ENOMEM;
	}

	adc_clock = clk_get(NULL, "adc");
	if (!adc_clock)
	{
		printk(KERN_ERR "failed to get adc clock source\n");
		return -ENOENT;
	}
	clk_enable(adc_clock);
	
	ADCTSC = 0;

	ret = request_irq(IRQ_ADC, adcdone_int_handler, IRQF_SHARED, DEVICE_NAME, &adcdev);
	if (ret)
	{
		iounmap(base_addr);
		return ret;
	}

	ret = misc_register(&misc);

	printk (DEVICE_NAME" initialized\n");
	return ret;
}

Copier après la connexion

Tout d'abord, mappez l'adresse du registre ADC et convertissez-la en adresse virtuelle, puis obtenez l'horloge ADC et activez l'horloge ADC, puis demandez l'interruption ADC . La fonction de traitement des interruptions est

adcdone_int_handler et les indicateurs sont IRQF_SHARED, qui est une interruption partagée, car l'écran tactile doit également demander une interruption ADC et enfin enregistrer un périphérique hybride.

Lorsque l'application s'ouvre ("/dev/adc",...), la fonction open dans le pilote sera appelée. Voyons donc ce que fait la fonction open ?

static int tq2440_adc_open(struct inode *inode, struct file *filp)
{
	/* 初始化等待队列头 */
	init_waitqueue_head(&(adcdev.wait));

	/* 开发板上ADC的通道2连接着一个电位器 */
	adcdev.channel=2;	//设置ADC的通道
	adcdev.prescale=0xff;

	DPRINTK( "ADC opened\n");
	return 0;
}

Copier après la connexion

C'est très simple, initialisez d'abord une tête de file d'attente, car puisque l'interruption ADC est demandée dans la fonction d'entrée, vous devez utiliser la file d'attente, puis définir le canal ADC, car la valeur par défaut Le canal d'entrée ADC du TQ2440 est 2, définissez la valeur du préscaler sur 0xff.

Lorsque l'application lit, la fonction de lecture dans le pilote sera appelée. Voyons donc ce que fait la fonction de lecture ?

static ssize_t tq2440_adc_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
{
	char str[20];
	int value;
	size_t len;

	/* 尝试获得ADC_LOCK信号量，如果能够立刻获得，它就获得信号量并返回0 
	 * 否则，返回非零，它不会导致调用者睡眠,可以在中断上下文使用
	 */
	if (down_trylock(&ADC_LOCK) == 0)
	{
		/* 表示A/D转换器资源可用 */
		ADC_enable = 1;

		/* 使能预分频，选择ADC通道，最后启动ADC转换*/
		START_ADC_AIN(adcdev.channel, adcdev.prescale);

		/* 等待事件，当ev_adc = 0时，进程被阻塞，直到ev_adc>0 */
		wait_event_interruptible(adcdev.wait, ev_adc);

		ev_adc = 0;

		DPRINTK("AIN[%d] = 0x%04x, %d\n", adcdev.channel, adc_data, ((ADCCON & 0x80) ? 1:0));

		/* 将在ADC中断处理函数读取的ADC转换结果赋值给value */
		value = adc_data;
		sprintf(str,"%5d", adc_data);
		copy_to_user(buffer, (char *)&adc_data, sizeof(adc_data));

		ADC_enable = 0;
		up(&ADC_LOCK);
	}
	else
	{
		/* 如果A/D转换器资源不可用，将value赋值为-1 */
		value = -1;
	}

	/* 将ADC转换结果输出到str数组里，以便传给应用空间 */
	len = sprintf(str, "%d\n", value);
	if (count >= len)
	{
		/* 从str数组里拷贝len字节的数据到buffer，即将ADC转换数据传给应用空间 */
		int r = copy_to_user(buffer, str, len);
		return r ? r : len;
	}
	else
	{
		return -EINVAL;
	}
}

Copier après la connexion

La fonction tq2440_adc_read essaie d'abord d'obtenir le sémaphore ADC_LOCK, car le pilote de l'écran tactile utilise également les ressources ADC, et les deux sont en concurrence. Après avoir obtenu les ressources ADC, activez le préscaler, sélectionnez l'ADC. canal, et enfin démarrer la conversion ADC, puis appeler la fonction wait_event_interruptible pour attendre que ev_adc>0 Le processus continuera à s'exécuter L'exécution lira les données adc_data et appellera la fonction copy_to_user pour transmettre les données ADC. à l'espace d'application. Enfin, libérez le sémaphore ADC_LOCK.

Q : Quand est-ce que ev_adc>0 ? ev_adc par défaut = 0

Réponse : Dans la fonction de traitement des interruptions adcdone_int_handler, une fois les données lues, ev_adc est défini sur 1.

Gestionnaire d'interruption ADC adcdone_int_handler

/* ADC中断处理函数 */
static irqreturn_t adcdone_int_handler(int irq, void *dev_id)
{
	/* A/D转换器资源可用 */
	if (ADC_enable)
	{
		/* 读ADC转换结果数据 */
		adc_data = ADCDAT0 & 0x3ff;

		/* 唤醒标志位，作为wait_event_interruptible的唤醒条件 */
		ev_adc = 1;
		wake_up_interruptible(&adcdev.wait);
	}
	return IRQ_HANDLED;
}

Copier après la connexion

Lorsque la conversion AD est terminée, l'interruption ADC sera déclenchée et adcdone_int_handler sera entré. Cette fonction lira les données de conversion AD dans adc_. données . Définissez ensuite l'indicateur de réveil ev_adc sur 1, et enfin appelez la fonction wake_up_interruptible pour réveiller la file d'attente adcdev.wait.
Résumez le flux de travail de l'ADC :

1. Dans la fonction d'ouverture, définissez le canal d'entrée analogique et définissez la valeur du préscaler

2. Dans la fonction de lecture, démarrez la conversion AD et le processus se met en veille

三、adc_irq函数里，AD转换结束后触发ADC中断，在ADC中断处理函数将数据读出，唤醒进程

四、read函数里，进程被唤醒后，将adc转换数据传给应用程序

ADC驱动参考源码：

/*************************************

NAME:EmbedSky_adc.c
COPYRIGHT:www.embedsky.net

*************************************/

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
	 
#include 
#include 
#include 
#include 

#include "tq2440_adc.h"

#undef DEBUG
//#define DEBUG
#ifdef DEBUG
#define DPRINTK(x...) {printk(KERN_DEBUG "EmbedSky_adc: " x);}
#else
#define DPRINTK(x...) (void)(0)
#endif

#define DEVICE_NAME	"adc"		/* 设备节点: /dev/adc */

static void __iomem *base_addr;

typedef struct
{
	wait_queue_head_t wait;		/* 定义等待队列头 */
	int channel;
	int prescale;
}ADC_DEV;

DECLARE_MUTEX(ADC_LOCK);	/* 定义并初始化信号量,并初始化为1 */
static int ADC_enable = 0;			/* A/D转换器资是否可用标志位 */

static ADC_DEV adcdev;				/* 用于表示ADC设备 */
static volatile int ev_adc = 0;		/* 作为wait_event_interruptible的唤醒条件 */
static int adc_data;

static struct clk	*adc_clock;

#define ADCCON		(*(volatile unsigned long *)(base_addr + S3C2410_ADCCON))	//ADC control
#define ADCTSC		(*(volatile unsigned long *)(base_addr + S3C2410_ADCTSC))	//ADC touch screen control
#define ADCDLY		(*(volatile unsigned long *)(base_addr + S3C2410_ADCDLY))	//ADC start or Interval Delay
#define ADCDAT0		(*(volatile unsigned long *)(base_addr + S3C2410_ADCDAT0))	//ADC conversion data 0
#define ADCDAT1		(*(volatile unsigned long *)(base_addr + S3C2410_ADCDAT1))	//ADC conversion data 1
#define ADCUPDN		(*(volatile unsigned long *)(base_addr + 0x14))			//Stylus Up/Down interrupt status

#define PRESCALE_DIS	(0 << 14)
#define PRESCALE_EN		(1 << 14)
#define PRSCVL(x)		((x) << 6)
#define ADC_INPUT(x)	((x) << 3)
#define ADC_START		(1 << 0)
#define ADC_ENDCVT		(1 << 15)


/* 使能预分频，选择ADC通道，最后启动ADC转换*/
#define START_ADC_AIN(ch, prescale) \
	do{ 	ADCCON = PRESCALE_EN | PRSCVL(prescale) | ADC_INPUT((ch)) ; \
		ADCCON |= ADC_START; \
	}while(0)


/* ADC中断处理函数 */
static irqreturn_t adcdone_int_handler(int irq, void *dev_id)
{
	/* A/D转换器资源可用 */
	if (ADC_enable)
	{
		/* 读ADC转换结果数据 */
		adc_data = ADCDAT0 & 0x3ff;

		/* 唤醒标志位，作为wait_event_interruptible的唤醒条件 */
		ev_adc = 1;
		wake_up_interruptible(&adcdev.wait);
	}
	return IRQ_HANDLED;
}

static ssize_t tq2440_adc_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
{
	char str[20];
	int value;
	size_t len;

	/* 尝试获得ADC_LOCK信号量，如果能够立刻获得，它就获得信号量并返回0 
	 * 否则，返回非零，它不会导致调用者睡眠,可以在中断上下文使用
	 */
	if (down_trylock(&ADC_LOCK) == 0)
	{
		/* 表示A/D转换器资源可用 */
		ADC_enable = 1;

		/* 使能预分频，选择ADC通道，最后启动ADC转换*/
		START_ADC_AIN(adcdev.channel, adcdev.prescale);

		/* 等待事件，当ev_adc = 0时，进程被阻塞，直到ev_adc>0 */
		wait_event_interruptible(adcdev.wait, ev_adc);

		ev_adc = 0;

		DPRINTK("AIN[%d] = 0x%04x, %d\n", adcdev.channel, adc_data, ((ADCCON & 0x80) ? 1:0));

		/* 将在ADC中断处理函数读取的ADC转换结果赋值给value */
		value = adc_data;
		sprintf(str,"%5d", adc_data);
		copy_to_user(buffer, (char *)&adc_data, sizeof(adc_data));

		ADC_enable = 0;
		up(&ADC_LOCK);
	}
	else
	{
		/* 如果A/D转换器资源不可用，将value赋值为-1 */
		value = -1;
	}

	/* 将ADC转换结果输出到str数组里，以便传给应用空间 */
	len = sprintf(str, "%d\n", value);
	if (count >= len)
	{
		/* 从str数组里拷贝len字节的数据到buffer，即将ADC转换数据传给应用空间 */
		int r = copy_to_user(buffer, str, len);
		return r ? r : len;
	}
	else
	{
		return -EINVAL;
	}
}

static int tq2440_adc_open(struct inode *inode, struct file *filp)
{
	/* 初始化等待队列头 */
	init_waitqueue_head(&(adcdev.wait));

	/* 开发板上ADC的通道2连接着一个电位器 */
	adcdev.channel=2;	//设置ADC的通道
	adcdev.prescale=0xff;

	DPRINTK( "ADC opened\n");
	return 0;
}

static int tq2440_adc_release(struct inode *inode, struct file *filp)
{
	DPRINTK( "ADC closed\n");
	return 0;
}


static struct file_operations dev_fops = {
	owner:	THIS_MODULE,
	open:	tq2440_adc_open,
	read:	tq2440_adc_read,	
	release:	tq2440_adc_release,
};

static struct miscdevice misc = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = DEVICE_NAME,
	.fops = &dev_fops,
};

static int __init dev_init(void)
{
	int ret;

	base_addr=ioremap(S3C2410_PA_ADC,0x20);
	if (base_addr == NULL)
	{
		printk(KERN_ERR "failed to remap register block\n");
		return -ENOMEM;
	}

	adc_clock = clk_get(NULL, "adc");
	if (!adc_clock)
	{
		printk(KERN_ERR "failed to get adc clock source\n");
		return -ENOENT;
	}
	clk_enable(adc_clock);
	
	ADCTSC = 0;

	ret = request_irq(IRQ_ADC, adcdone_int_handler, IRQF_SHARED, DEVICE_NAME, &adcdev);
	if (ret)
	{
		iounmap(base_addr);
		return ret;
	}

	ret = misc_register(&misc);

	printk (DEVICE_NAME" initialized\n");
	return ret;
}

static void __exit dev_exit(void)
{
	free_irq(IRQ_ADC, &adcdev);
	iounmap(base_addr);

	if (adc_clock)
	{
		clk_disable(adc_clock);
		clk_put(adc_clock);
		adc_clock = NULL;
	}

	misc_deregister(&misc);
}

EXPORT_SYMBOL(ADC_LOCK);
module_init(dev_init);
module_exit(dev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("www.embedsky.net");
MODULE_DESCRIPTION("ADC Drivers for EmbedSky SKY2440/TQ2440 Board and support touch");

Copier après la connexion

ADC应用测试参考源码：

/*************************************

NAME:EmbedSky_adc.c
COPYRIGHT:www.embedsky.net

*************************************/

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/fs.h>
#include <errno.h>
#include <string.h>

int main(void)
{
	int fd ;
	char temp = 1;

	fd = open("/dev/adc", 0);
	if (fd < 0)
	{
		perror("open ADC device !");
		exit(1);
	}
	
	for( ; ; )
	{
		char buffer[30];
		int len ;

		len = read(fd, buffer, sizeof buffer -1);
		if (len > 0)
		{
			buffer[len] = '\0';
			int value;
			sscanf(buffer, "%d", &value);
			printf("ADC Value: %d\n", value);
		}
		else
		{
			perror("read ADC device !");
			exit(1);
		}
		sleep(1);
	}
adcstop:	
	close(fd);
}

Copier après la connexion

测试结果：

[WJ2440]# ./adc_test 
ADC Value: 693
ADC Value: 695
ADC Value: 694
ADC Value: 695
ADC Value: 702
ADC Value: 740
ADC Value: 768
ADC Value: 775
ADC Value: 820
ADC Value: 844
ADC Value: 887
ADC Value: 937
ADC Value: 978
ADC Value: 1000
ADC Value: 1023
ADC Value: 1023
ADC Value: 1023

Copier après la connexion