Linux驱动入门（三）Led驱动

copy from：https://blog.csdn.net/weixin_42462202/article/details/99979562

Linux驱动入门（三）Led驱动
一、注册字符设备驱动
二、操作硬件
2.1 控制led
2.2 通用方式实现
2.3 gpiolib实现
三、源码
3.1 通用方式实现
3.2 gpiolib实现
四、测试

目的：实现一个led驱动，应用层写入1led亮，写0led灭
一、注册字符设备驱动
led驱动是一个字符设备驱动，编写led驱动首先要注册字符设备，生成设备节点，然后再是完善文件操作集合

关于如何注册字符设备和生成设备字节，在Linux驱动入门（一）字符设备驱动基础中讲得比较详细了，这里给出代码

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>

#include <asm/io.h>
#include <asm/uaccess.h>

static dev_t dev_id;
static struct cdev *led_dev;
static struct class *led_class;

int led_open(struct inode *inode, struct file *file)
{
/* 设置gpio */

return 0;
}

ssize_t led_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
{
int val, ret;

/* 从用户空间拷贝数据 */
ret = copy_from_user(&val, data, sizeof(val));

if(val == 0)
{
/* 熄灭led */
}
else if(val == 1)
{
/* 点亮 */
}

return 0;
}

static struct file_operations led_fops = {
.owner = THIS_MODULE,
.open = led_open,
.write = led_write,
};

static __init int led_init(void)
{
/* 申请设备号 */
alloc_chrdev_region(&dev_id, 1, 1, "led");

/* 分配字符设备 */
led_dev = cdev_alloc();

/* 设置字符设备 */
cdev_init(led_dev, &led_fops);

/* 注册字符设备 */
cdev_add(led_dev, dev_id, 1);

/* 创建设备节点 */
led_class = class_create(THIS_MODULE, "led"); //创建类
device_create(led_class, NULL, dev_id, NULL, "led"); //创建设备节点

return 0;
}

static __exit void led_exit(void)
{
/* 注销设备节点 */
device_destroy(led_class, dev_id);
class_destroy(led_class);

/* 注销字符设备 */
cdev_del(led_dev);
kfree(led_dev);

/* 注销注册的设备号 */
unregister_chrdev_region(dev_id, 1);
}

module_init(led_init);
module_exit(led_exit);

MODULE_LICENSE("GPL");

编译上面的驱动程序，加载模块，就会生成/dev/led设备节点，这是我们led驱动的基本框架，我们还要在led_open、led_write中操作硬件

从上面代码中可以看到，在led_open中去设置gpio，在led_write中，如果写1就点亮led，写0就熄灭led

这里介绍一个知识点，用户空间和内核空间不能通过指针直接访问，必须使用内核提供的函数

从用户空间到内核空间使用

static inline long copy_from_user(void *to,
const void __user * from, unsigned long n)

从内核空间到用户空间使用

static inline long copy_to_user(void __user *to,
const void *from, unsigned long n)

此时还未涉及到操作硬件，下面来具体介绍如何在驱动程序中去操作led

二、操作硬件
2.1 控制led
下面开始来介绍如何去操作led

首先打开开发板的原理图，找到led，如下

这里我要操作nLED1，发现其有GPJ0_3引脚控制，当GPJ0_3引脚高电平，led被点亮，当GPJ0_3引脚为低电平，led被熄灭

下面查看芯片的datasheet，看如何控制GPJ0_3引脚的高低电平

找到了两个相关的寄存器GPJ0CON和GPJ0DAT

从图中可以看到GPJ0CON寄存器的地址为0xE020_0240，该寄存器32位有效，其中GPJ0CON[3]（12-15位）设置引脚的功能

GPJ0DAT寄存器的地址为0xE0020_0244，该寄存器8位有效，其中GPJ0DAT[3]（第3位）控制引脚的高低电平

那么想要设置引脚的高低电平可以这样做

GPJ0CON |= 1<<12; //配置GPJ0_3为输出状态

GPJ0DAT |= 1<<3; //输出高电平
GPJ0DAT &= ~(1<<3); //输出低电平

从而达到控制led亮灭的目的

在Linux驱动入门（二）操作硬件中详细地讲解了如何去操作硬件，分别有通用方法和使用gpiolib的方法，下面将介绍这两种方法

2.2 通用方式实现
使用通用的方法来设置gpio高低电平

首先找到寄存器的物理地址

#define GPJ0CON_PHY_ADDR 0xE0200240
#define GPJ0DAT_PHY_ADDR 0xE0200244

然后映射物理地址

static volatile unsigned int *gpj0_con = NULL;
static volatile unsigned int *gpj0_dat = NULL;

gpj0_con = (volatile unsigned int *)ioremap(GPJ0CON_PHY_ADDR, 8);
gpj0_dat = gpj0_con+1;

配置引脚的功能

unsigned int cfg;

/* 将GPIO设置为输出模式 */
cfg = readl(gpj0_con);
writel(cfg | (1<<12), gpj0_con);

设置引脚高低电平

/* 高电平 */
cfg = readl(gpj0_dat);
writel(cfg | (1<<3), gpj0_dat);

/* 低电平 */
cfg = readl(gpj0_dat);
writel(cfg & ~(1<<3), gpj0_dat);

取消地址映射

iounmap(gpj0_con);

稍后将给出驱动源码

2.3 gpiolib实现
使用gpiolib可以不用直接操作寄存器，这就变得非常简单了

申请gpio

gpio_request(S5PV210_GPJ0(3), "led");

设置gpio为输出模式

gpio_direction_output(S5PV210_GPJ0(3), 1);

设置gpio的高低电平

gpio_set_value(S5PV210_GPJ0(3), 1); //高电平
gpio_set_value(S5PV210_GPJ0(3), 0); //低电平

三、源码
3.1 通用方式实现
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>

#include <asm/io.h>
#include <asm/uaccess.h>

#define GPJ0CON_PHY_ADDR 0xE0200240
#define GPJ0DAT_PHY_ADDR 0xE0200244

static dev_t dev_id;
static struct cdev *led_dev;
static struct class *led_class;

static volatile unsigned int *gpj0_con = NULL;
static volatile unsigned int *gpj0_dat = NULL;

int led_open(struct inode *inode, struct file *file)
{
unsigned int cfg;

/* 将GPIO设置为输出模式 */
cfg = readl(gpj0_con);
writel(cfg | (1<<12), gpj0_con);

/* 熄灭led */
cfg = readl(gpj0_dat);
writel(cfg | (1<<3), gpj0_dat);

return 0;
}

ssize_t led_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
{
int val, ret;
unsigned int cfg;

/* 从用户空间拷贝数据 */
ret = copy_from_user(&val, data, sizeof(val));

cfg = readl(gpj0_dat);

if(val == 0) //熄灭
{
writel(cfg | (1<<3), gpj0_dat);
}
else if(val == 1) //点亮
{
writel(cfg & ~(1<<3), gpj0_dat);
}
else
return -1;

return 0;
}

static struct file_operations led_fops = {
.owner = THIS_MODULE,
.open = led_open,
.write = led_write,
};

static __init int led_init(void)
{
/* 申请设备号 */
alloc_chrdev_region(&dev_id, 1, 1, "led");

/* 分配字符设备 */
led_dev = cdev_alloc();

/* 设置字符设备 */
cdev_init(led_dev, &led_fops);

/* 注册字符设备 */
cdev_add(led_dev, dev_id, 1);

/* 创建设备节点 */
led_class = class_create(THIS_MODULE, "led"); //创建类
device_create(led_class, NULL, dev_id, NULL, "led"); //创建设备节点

/* 映射物理地址 */
gpj0_con = (volatile unsigned int *)ioremap(GPJ0CON_PHY_ADDR, 8);
gpj0_dat = gpj0_con+1;

return 0;
}

static __exit void led_exit(void)
{
/* 注销设备节点 */
device_destroy(led_class, dev_id);
class_destroy(led_class);

/* 注销字符设备 */
cdev_del(led_dev);
kfree(led_dev);

/* 注销注册的设备号 */
unregister_chrdev_region(dev_id, 1);

/* 注销映射的地址 */
iounmap(gpj0_con);
}

module_init(led_init);
module_exit(led_exit);

MODULE_LICENSE("GPL");

3.2 gpiolib实现
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/gpio.h>

#include <asm/io.h>
#include <asm/uaccess.h>

#include <mach/gpio.h>

static dev_t dev_id;
static struct cdev *led_dev;
static struct class *led_class;

int led_open(struct inode *inode, struct file *file)
{
gpio_direction_output(S5PV210_GPJ0(3), 1);

return 0;
}

ssize_t led_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
{
int val, ret;

/* 从用户空间拷贝数据 */
ret = copy_from_user(&val, data, sizeof(val));

if(val == 0) //熄灭
{
gpio_set_value(S5PV210_GPJ0(3), 1);
}
else if(val == 1) //点亮
{
gpio_set_value(S5PV210_GPJ0(3), 0);
}
else
return -1;

return 0;
}

static struct file_operations led_fops = {
.owner = THIS_MODULE,
.open = led_open,
.write = led_write,
};

static __init int led_init(void)
{
/* 申请设备号 */
alloc_chrdev_region(&dev_id, 1, 1, "led");

/* 分配字符设备 */
led_dev = cdev_alloc();

/* 设置字符设备 */
cdev_init(led_dev, &led_fops);

/* 注册字符设备 */
cdev_add(led_dev, dev_id, 1);

/* 创建设备节点 */
led_class = class_create(THIS_MODULE, "led"); //创建类
device_create(led_class, NULL, dev_id, NULL, "led"); //创建设备节点

/* 申请gpio */
gpio_request(S5PV210_GPJ0(3), "led");

return 0;
}

static __exit void led_exit(void)
{
/* 注销设备节点 */
device_destroy(led_class, dev_id);
class_destroy(led_class);

/* 注销字符设备 */
cdev_del(led_dev);
kfree(led_dev);

/* 注销注册的设备号 */
unregister_chrdev_region(dev_id, 1);

gpio_free(S5PV210_GPJ0(3));
}

module_init(led_init);
module_exit(led_exit);

MODULE_LICENSE("GPL");

四、测试
将上面两个驱动程序中任意一个保存为led_drv.c

下面是一个Makefile

KERN_DIR = /work/linux/kernel

all:
make -C $(KERN_DIR) M=`pwd` modules

clean:
make -C $(KERN_DIR) M=`pwd` modules clean
rm -rf modules.order

obj-m += led_drv.o

修改你的内核源码树，执行make，生成led_drv.ko，通过insmod led_drv.ko加载模块

此时将生成/dev/led的设备节点

测试应用程序

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define LED_DEV "/dev/led"

int main(int argc, char* argv[])
{
int val;
int fd;

if(argc != 2)
{
printf("Usage: %s <on|off> ", argv[0]);
return -1;
}

fd = open(LED_DEV, O_RDWR);
if(fd < 0)
{
printf("failed to open %s ", LED_DEV);
return -1;
}

if(!strcmp(argv[1], "on"))
val = 1;
else if(!strcmp(argv[1], "off"))
val = 0;
else
{
printf("Usage: %s <on|off> ", argv[0]);
return -1;
}

write(fd, &val, sizeof(val));

close(fd);

return 0;
}

将此应用程序保存为led_test.c，编译arm-linux-gcc -o led_test led_test.c

执行led_test on，led被点亮

执行led_test off，led被熄灭
————————————————
版权声明：本文为CSDN博主「JT同学」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_42462202/article/details/99979562