Allumez la LED via la fonction de sous-système GPIO
1. Fonction du sous-système GPIO
1.1 Déterminez l'étiquette GPIO de la led, vérifiez le gpiochip dans le noyau
Vérifiez gpiochip , prenez la carte de développement IMX6ULL Alpha d'atom ponctuel comme exemple
[root@100ask:/sys/class/gpio]# cat /sys/kernel/debug/gpio
Vérifiez le diagramme schématique et trouvez que la broche connectée à la led est GPIO1_IO3, ce qui correspond au groupe gpiochip0 dans /sys/kernel/debug/gpio. Le groupe gpiochip0 commence à partir de 0, donc l'étiquette correspondante de GPIO1_IO3 est 0+3 = 3 (
mais le réel Réglez-le sur 4 dans l'opération pour allumer la LED. Je ne connais pas la raison ici. Amis qui le savent, s'il vous plaît donnez-moi des conseils dans la zone de commentaire)
1.2 Demander les broches GPIO (le code est ajouté à la fonction d'entrée du module pilote)
int gpio_request(unsigned gpio, const char *label)
Paramètres :
gpio : le libellé correspondant à la broche GPIO dans gpiochip libellé
: le nom du libellé pour le GPIO
valeur de retour : inférieur à 0
exemple de code d'échec :
int err;
unsigned int led_gpio = 4; //对照原理图 led控制引脚
/*申请led_gpio引脚*/
err = gpio_request(led_gpio, "user_led");
if(err < 0){
printk("led gpio request failed!\n");
return -ENODEV;
}
Rappelez-vous le deuxième paramètre "user_led" passé ici, vous le verrez lors de la vérification ultérieure
1.3 Lire GPIO
int gpio_get_value(unsigned int gpio)
Paramètres :
gpio : le label correspondant à la broche GPIO dans gpiochip
Valeur de retour : retourne l'état de la broche, 0 ou 1
Exemple de code :
static ssize_t led_read (struct file *filp, char *buf, size_t size, loff_t *offset)
{
printk("led_drv_read\n");
/*read led_gpio value*/
buff[0] = gpio_get_value(led_gpio);
//将读取到的值传给用户程序（也可以直接通过return的方式传到用户程序）
copy_to_user(buf, buff, 1);
/*返回什么不重要，也可以直接返回gpio的值
但是最好还是按照驱动程序模式来写，使用copy_to_user*/
return buff[0];
}
1.4 Écrire GPIO
void gpio_set_value(unsigned int gpio, int value)
Paramètres :
gpio : le label correspondant à la broche GPIO dans gpiochip
valeur : write value, 0 ou 1
Return value : None
Exemple de code :
static ssize_t led_write (struct file *filp, const char *buf, size_t size, loff_t *offset)
{
printk("led_drv_write\n");
// 从应用程序获取要写入的值，buf[0]
copy_from_user(buff, buf, 1);
/*write led_gpio*/
gpio_set_value(led_gpio, buff[0]);
return led_gpio;
}
1.5 Définir la direction GPIO
int gpio_direction_output(unsigned gpio, int value)
Paramètres :
gpio : le label correspondant à la broche GPIO dans gpiochip
valeur : le niveau de sortie initial, 0 ou 1,
valeur de retour : échec inférieur à 0
Exemple de code :
/*设置led_gpio输出模式*/
gpio_direction_output(led_gpio, 1);
2. Relâchez la broche GPIO dans la fonction de déchargement du pilote
/*释放led_gpio引脚*/
gpio_free(led_gpio);
3. Complétez le programme de pilote de LED
Modifiez sur la base du pilote hello précédent, utilisez les fonctions du sous-système GPIO ci-dessus et ajoutez des codes logiques. Il convient de
noter ici qu'un fichier d'en-tête doit être ajouté
#include <linux/gpio.h>
Montrez d'abord le processus de conduite, puis collez le code
IMX6ULL - Pilote LED
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/capability.h>
#include <linux/init.h>
#include <linux/mutex.h>
#include <asm/mach-types.h>
#include <asm/uaccess.h>
#include <asm/therm.h>
#include <linux/string.h>
#include <linux/gpio.h>
static int major;
static unsigned char buff[100];
static struct class *led_class;
/*led args*/
//unsigned int led_gpio = 129; //对照原理图 蜂鸣器
//unsigned int led_gpio = 19; //对照原理图 按键
unsigned int led_gpio = 4; //对照原理图 led
static int led_open (struct inode *node, struct file *filp)
{
printk("led_open\n");
printk("%s %s %d\n",__FILE__, __FUNCTION__, __LINE__);
return 0;
}
static ssize_t led_read (struct file *filp, char *buf, size_t size, loff_t *offset)
{
printk("led_drv_read\n");
/*read led_gpio value*/
buff[0] = gpio_get_value(led_gpio);
copy_to_user(buf, buff, 1);
//返回什么不重要，也可以直接返回gpio的值，但是最好还是按照驱动程序模式来写，使用copy_to_user
return buff[0];
}
static ssize_t led_write (struct file *filp, const char *buf, size_t size, loff_t *offset)
{
printk("led_drv_write\n");
copy_from_user(buff, buf, 1);
/*write led_gpio*/
gpio_set_value(led_gpio, buff[0]);
return led_gpio;
}
static int led_release (struct inode *node, struct file *filp)
{
printk("led_release\n");
return 0;
}
/*1.定义 file_operations 结构体*/
static const struct file_operations led_fops = {
.owner = THIS_MODULE,
.read = led_read,
.write = led_write,
.open = led_open,
.release = led_release,
};
/*3.入口函数*/
static int led_init(void)
{
struct device *dev;
int err;
/************* 1.注册设备，返回设备号 ************/
major = register_chrdev(0,"led_drv",&led_fops);
/*2.在内核中创建设备*/
led_class = class_create(THIS_MODULE, "led_class");
if (IS_ERR(led_class)) {
printk("led class create failed!\n");
}
/*3.在/dev下面创建设备节点*/
device_create(led_class, NULL, MKDEV(major, 0), NULL, "led_drv");
if(IS_ERR(dev)) {
printk("led device_create failed!\n");
}
/************* 4.初始化led引脚 ************/
/*申请led_gpio引脚*/
err = gpio_request(led_gpio, "user_led");
if(err < 0){
printk("led gpio request failed!\n");
return -ENODEV;
}
/*设置led_gpio输出模式*/
gpio_direction_output(led_gpio, 1);
return 0;
}
/*4.退出函数*/
static int led_exit(void)
{
//卸载设备
unregister_chrdev(major,"led_fops");
//销毁设备
device_destroy(led_class, MKDEV(major, 0));
//删除设备类
class_destroy(led_class);
/*释放led_gpio引脚*/
gpio_free(led_gpio);
printk("led_exit\n");
return 0;
}
module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
4. Ecrire le programme d'application LED
La première étape consiste à déterminer comment l'application LED sera utilisée
./led_test /dev/led_drv on 点亮LED
./led_test /dev/led_drv off 熄灭LED
./led_test /dev/led_drv 读取LED状态
Ce n'est pas très différent de l'application hello précédente, il suffit de coller le code directement
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
/*
./led_test /dev/led_drv on
./led_test /dev/led_drv off
./led_test /dev/led_drv
*/
int main(int argc, char *argv[])
{
int len;
char buf[10];
if(argc < 2){
printf("please input at least 2 args\n");
printf("%s /dev/led_drv [on/off]\n", argv[0]);
return -1;
}
/*open*/
int fd;
fd = open(argv[1], O_RDWR);
if(fd < 0){
printf("open failed\n");
return -2;
}
/*read led*/
if(argc == 2){
int res = read(fd, buf, 1);
printf("led state : %s \n", buf[0] == 1 ? "off" : "on");
}
/*write led*/
if(argc == 3){
if(strcmp(argv[2], "on") == 0)
buf[0] = 0;
else if(strcmp(argv[2], "off") == 0)
buf[0] = 1;
write(fd, buf, 1);
}
close(fd);
return 0;
}