4.1 到底什么是驱动框架
(1)内核中驱动部分维护者针对每个种类的驱动设计一套成熟的、标准的、典型的驱动实现，然后把不同厂家的同类硬件驱动中相同的部分抽出来自己实现好，再把不同部分留出接口给具体的驱动开发工程师来实现，这就叫驱动框架。
(2)内核维护者在内核中设计了一些统一管控系统资源的体系，这些体系让内核能够对资源在各个驱动之间的使用统一协调和分配，保证整个内核的稳定健康运行。譬如系统中所有的GPIO就属于系统资源，每个驱动模块如果要使用某个GPIO就要先调用特殊的接口先申请，申请到后使用，使用完后要释放。又譬如中断号也是一种资源，驱动在使用前也必须去申请。这也是驱动框架的组成部分。
(3)一些特定的接口函数、一些特定的数据结构，这些是驱动框架的直接表现。
4.2.内核驱动框架中LED的基本情况
4.2.1、相关文件
(1)drivers/leds目录，这个目录就是驱动框架规定的LED这种硬件的驱动应该待的地方。
(2)led-class.c和led-core.c，这两个文件加起来属于LED驱动框架的第一部分，这两个文件是内核开发者提供的，他们描述的是内核中所有厂家的不同LED硬件的相同部分的逻辑。
(3)leds-xxxx.c，这个文件是LED驱动框架的第2部分，是由不同厂商的驱动工程师编写添加的，厂商驱动工程师结合自己公司的硬件的不同情况来对LED进行操作，使用第一部分提供的接口来和驱动框架进行交互，最终实现驱动的功能。基于LED驱动框架开发驱动要修改的就是这一部分的内容，一般以SoC厂商提供的驱动源码为基础，来做移植和调试。
4.2.2、案例分析驱动框架的使用
(1)以leds-s3c24xx.c为例。leds-s3c24xx.c中通过调用led_classdev_register来完成我们的LED驱动的注册，而led_classdev_register是在drivers/leds/led-class.c中定义的。所以其实SoC厂商的驱动工程师是调用内核开发者在驱动框架中提供的接口来实现自己的驱动的。
(2)驱动框架的关键点就是：分清楚内核开发者提供了什么，驱动开发者自己要提供什么
4.3 初步分析led驱动框架源码
4.3.1、涉及到的文件
(1)led-core.c
(2)led-class.c
4.3.2、subsys_initcall
(1)经过基本分析，发现LED驱动框架中内核开发者实现的部分主要是led-class.c
(2)我们发现led-class.c就是一个内核模块，对led-class.c分析应该从下往上，遵从对模块的基本分析方法。
(3)为什么LED驱动框架中内核开发者实现的部分要实现成一个模块？因为内核开发者希望这个驱动框架是可以被装载/卸载的。这样当我们内核使用者不需要这个驱动框架时可以完全去掉，需要时可以随时加上。
(4)subsys_initcall是一个宏，定义在linux/init.h中。经过对这个宏进行展开，发现这个宏的功能是：将其声明的函数放到一个特定的段：.initcall4.init。
subsys_initcall
__define_initcall(“4”,fn,4)
(5)分析module_init宏，可以看出它将函数放到了.initcall6.init段中。
module_init
__initcall
device_initcall
__define_initcall(“6”,fn,6)
(6)内核在启动过程中需要顺序的做很多事，内核如何实现按照先后顺序去做很多初始化操作。内核的解决方案就是给内核启动时要调用的所有函数归类，然后每个类按照一定的次序去调用执行。这些分类名就叫.initcalln.init。n的值从1到8。内核开发者在编写内核代码时只要将函数设置合适的级别，这些函数就会被链接的时候放入特定的段，内核启动时再按照段顺序去依次执行各个段即可。
(7)经过分析，可以看出，subsys_initcall和module_init的作用是一样的，只不过前者所声明的函数要比后者在内核启动时的执行顺序更早。
4.3.3、led_class_attrs
(1)什么是attribute，对应将来/sys/class/leds/目录里的内容，一般是文件和文件夹。这些文件其实就是sysfs开放给应用层的一些操作接口（非常类似于/dev/目录下的那些设备文件）
(2)attribute有什么用，作用就是让应用程序可以通过/sys/class/leds/目录下面的属性文件来操作驱动进而操作硬件设备。
(3)attribute其实是另一条驱动实现的路线。有区别于之前讲的file_operations那条线。
4.3.4、led_classdev_register
led_classdev_register
device_create
(1)分析可知，led_classdev_register这个函数其实就是去创建一个属于leds这个类的一个设备。其实就是去注册一个设备。所以这个函数其实就是led驱动框架中内核开发者提供给SoC厂家驱动开发者的一个注册驱动的接口。
(2)当我们使用led驱动框架去编写驱动的时候，这个led_classdev_register函数的作用类似于我们之前使用file_operations方式去注册字符设备驱动时的register_chrdev函数。
4.4.在内核中添加或去除某个驱动
4.4.1、去除九鼎移植的LED驱动
(1)九鼎移植的驱动在应用层的接口在/sys/devices/platform/x210-led/目录下，有led1、led2、led3、led4四个设备文件，各自管理一个led。
(2)要去掉九鼎自己移植的led驱动，要在make menucofig中去掉选择项，然后重新make得到zImage，然后重启时启动这个新的zImage即可。
(3)新的内核启动后，如果/sys/devices/platform/目录下已经没有了x210-led这个目录，就说明我们去掉这个驱动成功了。
(4)为什么make menuconfig就能去掉这个驱动？
4.4.2、添加led驱动框架支持
(1)参考哪里？ drivers/leds/leds-s3c24xx.c
(2)关键点：led_classdev_register
#ubuntu的内核源码树，如果要编译在ubuntu中安装的模块就打开这2个
#KERN_VER = $(shell uname -r)
#KERN_DIR = /lib/modules/$(KERN_VER)/build
# 开发板的linux内核的源码树目录
KERN_DIR = /root/driver/kernel
obj-m += leds-s5pv210.o
all:
make -C $(KERN_DIR) M=`pwd` modules
arm-linux-gcc app.c -o app
cp:
cp *.ko /root/porting_x210/rootfs/rootfs/driver_test
cp app /root/porting_x210/rootfs/rootfs/driver_test
.PHONY: clean
clean:
make -C $(KERN_DIR) M=`pwd` modules clean
rm -rf app
#include <linux/module.h> // module_init module_exit
#include <linux/init.h> // __init __exit
#include <linux/fs.h>
#include <linux/leds.h>
#include <mach/regs-gpio.h>
#include <mach/gpio-bank.h>
#include <linux/io.h>
#include <linux/ioport.h>
#define GPJ0CON S5PV210_GPJ0CON
#define GPJ0DAT S5PV210_GPJ0DAT
static struct led_classdev mydev; // 定义结构体变量
// 这个函数就是要去完成具体的硬件读写任务的
static void s5pv210_led_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
printk(KERN_INFO "s5pv210_led_set\n");
// 在这里根据用户设置的值来操作硬件
// 用户设置的值就是value
if (value == LED_OFF)
{
// 用户给了个0，希望LED灭
writel(0x11111111, GPJ0CON);
writel(((1<<3) | (1<<4) | (1<<5)), GPJ0DAT);
}
else
{
// 用户给的是非0，希望LED亮
writel(0x11111111, GPJ0CON);
writel(((0<<3) | (0<<4) | (0<<5)), GPJ0DAT);
}
}
static int __init s5pv210_led_init(void)
{
// 用户insmod安装驱动模块时会调用该函数
// 该函数的主要任务就是去使用led驱动框架提供的设备注册函数来注册一个设备
int ret = -1;
mydev.name = "myled";
mydev.brightness = 255;
mydev.brightness_set = s5pv210_led_set;
ret = led_classdev_register(NULL, &mydev);
if (ret < 0) {
printk(KERN_ERR "led_classdev_register failed\n");
return ret;
}
return 0;
}
static void __exit s5pv210_led_exit(void)
{
led_classdev_unregister(&mydev);
}
module_init(s5pv210_led_init);
module_exit(s5pv210_led_exit);
// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL"); // 描述模块的许可证
MODULE_AUTHOR("aston <1264671872@qq.com>"); // 描述模块的作者
MODULE_DESCRIPTION("s5pv210 led driver"); // 描述模块的介绍信息
MODULE_ALIAS("s5pv210_led"); // 描述模块的别名信息
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#define FILE "/dev/test" // 刚才mknod创建的设备文件名
char buf[100];
int main(void)
{
int fd = -1;
int i = 0;
fd = open(FILE, O_RDWR);
if (fd < 0)
{
printf("open %s error.\n", FILE);
return -1;
}
printf("open %s success..\n", FILE);
/*
// 读写文件
write(fd, "on", 2);
sleep(2);
write(fd, "off", 3);
sleep(2);
write(fd, "on", 2);
sleep(2);
*/
/*
write(fd, "1", 1);
sleep(2);
write(fd, "0", 1);
sleep(2);
write(fd, "1", 1);
sleep(2);
*/
while (1)
{
memset(buf, 0 , sizeof(buf));
printf("请输入 on | off \n");
scanf("%s", buf);
if (!strcmp(buf, "on"))
{
write(fd, "1", 1);
}
else if (!strcmp(buf, "off"))
{
write(fd, "0", 1);
}
else if (!strcmp(buf, "flash"))
{
for (i=0; i<3; i++)
{
write(fd, "1", 1);
sleep(1);
write(fd, "0", 1);
sleep(1);
}
}
else if (!strcmp(buf, "quit"))
{
break;
}
}
// 关闭文件
close(fd);
return 0;
}
4.5 基于驱动框架写led驱动2
4.5.1、代码实践
(1)通过分析看出：
第1：我们写的驱动确实工作了，被加载了，/sys/class/leds/目录下确实多出来了一个表示设备的文件夹。文件夹里面有相应的操控led硬件的2个属性brightness和max_brightness
第2：led-class.c中brightness方法有一个show方法和store方法，这两个方法对应用户在/sys/class/leds/myled/brightness目录下直接去读写这个文件时实际执行的代码。
当我们show brightness时，实际就会执行led_brightness_show函数
当我们echo 1 > brightness时，实际就会执行led_brightness_store函数
(2)show方法实际要做的就是读取LED硬件信息，然后把硬件信息返回给我们即可。所以show方法和store方法必要要会去操控硬件。但是led-class.c文件又属于驱动框架中的文件，它本身无法直接读取具体硬件，因此在show和store方法中使用函数指针的方式调用了struct led_classdev结构体中的相应的读取/写入硬件信息的方法。
(3)struct led_classdev结构体中的实际用来读写硬件信息的函数，就是我们自己写的驱动文件leds-s5pv210.c中要提供的。
4.6 基于驱动框架写led驱动3
4.6.1、在驱动中将4个LED分开
(1)好处。驱动层实现对各个LED设备的独立访问，并向应用层展示出4个操作接口led1、led2、led3、led4，这样应用层可以完全按照自己的需要对LED进行控制。
驱动的设计理念：不要对最终需求功能进行假定，而应该只是直接的对硬件的操作。有一个概念就是：机制和策略的问题。在硬件操作上驱动只应该提供机制而不是策略。策略由应用程序来做。
(2)如何实现
4.7 基于驱动框架写led驱动4
4.7.1、呼吸灯效果，AW9106
源码目录：drivers\leds\leds-aw9106.c
/*
* leds-aw9106.c aw9106 led module
*
* Version: v1.0.0
*
* Copyright (c) 2017 AWINIC Technology CO., LTD
*
* Author: Nick Li <liweilei@awinic.com.cn>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/i2c.h>
#include <linux/of_gpio.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/firmware.h>
#include <linux/slab.h>
#include <linux/version.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/debugfs.h>
#include <linux/miscdevice.h>
#include <asm/uaccess.h>
#include <linux/leds.h>
#include <linux/leds-aw9106.h>
/******************************************************
*
* Marco
*
******************************************************/
#define AW9106_I2C_NAME "aw9106_led"
#define AW9106_VERSION "v1.0.0"
#define AW_I2C_RETRIES 5
#define AW_I2C_RETRY_DELAY 5
#define AW_READ_CHIPID_RETRIES 5
#define AW_READ_CHIPID_RETRY_DELAY 5
#define REG_INPUT_P0 0x00
#define REG_INPUT_P1 0x01
#define REG_OUTPUT_P0 0x02
#define REG_OUTPUT_P1 0x03
#define REG_CONFIG_P0 0x04
#define REG_CONFIG_P1 0x05
#define REG_INT_P0 0x06
#define REG_INT_P1 0x07
#define REG_ID 0x10
#define REG_CTRL 0x11
#define REG_WORK_MODE_P0 0x12
#define REG_WORK_MODE_P1 0x13
#define REG_EN_BREATH 0x14
#define REG_FADE_TIME 0x15
#define REG_FULL_TIME 0x16
#define REG_DLY0_BREATH 0x17
#define REG_DLY1_BREATH 0x18
#define REG_DLY2_BREATH 0x19
#define REG_DLY3_BREATH 0x1a
#define REG_DLY4_BREATH 0x1b
#define REG_DLY5_BREATH 0x1c
#define REG_DIM00 0x20
#define REG_DIM01 0x21
#define REG_DIM02 0x22
#define REG_DIM03 0x23
#define REG_DIM04 0x24
#define REG_DIM05 0x25
#define REG_SWRST 0x7F
/* aw9106 register read/write access*/
#define REG_NONE_ACCESS 0
#define REG_RD_ACCESS 1 << 0
#define REG_WR_ACCESS 1 << 1
#define AW9106_REG_MAX 0xFF
const unsigned char aw9106_reg_access[AW9106_REG_MAX] = {
[REG_INPUT_P0 ] = REG_RD_ACCESS,
[REG_INPUT_P1 ] = REG_RD_ACCESS,
[REG_OUTPUT_P0 ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_OUTPUT_P1 ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_CONFIG_P0 ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_CONFIG_P1 ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_INT_P0 ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_INT_P1 ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_ID ] = REG_RD_ACCESS,
[REG_CTRL ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_WORK_MODE_P0] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_WORK_MODE_P1] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_EN_BREATH ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_FADE_TIME ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_FULL_TIME ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_DLY0_BREATH ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_DLY1_BREATH ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_DLY2_BREATH ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_DLY3_BREATH ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_DLY4_BREATH ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_DLY5_BREATH ] = REG_RD_ACCESS|REG_WR_ACCESS,
[REG_DIM00 ] = REG_WR_ACCESS,
[REG_DIM01 ] = REG_WR_ACCESS,
[REG_DIM02 ] = REG_WR_ACCESS,
[REG_DIM03 ] = REG_WR_ACCESS,
[REG_DIM04 ] = REG_WR_ACCESS,
[REG_DIM05 ] = REG_WR_ACCESS,
[REG_SWRST ] = REG_WR_ACCESS,
};
/******************************************************
*
* aw9106 i2c write/read
*
******************************************************/
static int aw9106_i2c_write(struct aw9106 *aw9106,
unsigned char reg_addr, unsigned char reg_data)
{
int ret = -1;
unsigned char cnt = 0;
while(cnt < AW_I2C_RETRIES) {
ret = i2c_smbus_write_byte_data(aw9106->i2c, reg_addr, reg_data);
if(ret < 0) {
pr_err("%s: i2c_write cnt=%d error=%d\n", __func__, cnt, ret);
} else {
break;
}
cnt ++;
msleep(AW_I2C_RETRY_DELAY);
}
return ret;
}
static int aw9106_i2c_read(struct aw9106 *aw9106,
unsigned char reg_addr, unsigned char *reg_data)
{
int ret = -1;
unsigned char cnt = 0;
while(cnt < AW_I2C_RETRIES) {
ret = i2c_smbus_read_byte_data(aw9106->i2c, reg_addr);
if(ret < 0) {
pr_err("%s: i2c_read cnt=%d error=%d\n", __func__, cnt, ret);
} else {
*reg_data = ret;
break;
}
cnt ++;
msleep(AW_I2C_RETRY_DELAY);
}
return ret;
}
static int aw9106_i2c_write_bits(struct aw9106 *aw9106,
unsigned char reg_addr, unsigned char mask, unsigned char reg_data)
{
unsigned char reg_val;
aw9106_i2c_read(aw9106, reg_addr, ®_val);
reg_val &= mask;
reg_val |= reg_data;
aw9106_i2c_write(aw9106, reg_addr, reg_val);
return 0;
}
/******************************************************
*
* aw9106 led
*
******************************************************/
static void aw9106_brightness_work(struct work_struct *work)
{
struct aw9106 *aw9106 = container_of(work, struct aw9106,
brightness_work);
unsigned char i;
if(aw9106->cdev.brightness > aw9106->cdev.max_brightness) {
aw9106->cdev.brightness = aw9106->cdev.max_brightness;
}
aw9106_i2c_write(aw9106, REG_WORK_MODE_P0, 0x00); // led mode
aw9106_i2c_write(aw9106, REG_WORK_MODE_P1, 0x00); // led mode
aw9106_i2c_write(aw9106, REG_EN_BREATH, 0x00); // disable breath
aw9106_i2c_write(aw9106, REG_CTRL, 0x03); // imax
for(i=0; i<6; i++) {
aw9106_i2c_write(aw9106, REG_DIM00+i,
aw9106->cdev.brightness); // dimming
}
}
static void aw9106_set_brightness(struct led_classdev *cdev,
enum led_brightness brightness)
{
struct aw9106 *aw9106 = container_of(cdev, struct aw9106, cdev);
aw9106->cdev.brightness = brightness;
schedule_work(&aw9106->brightness_work);
}
static void aw9106_led_blink(struct aw9106 *aw9106, unsigned char blink)
{
unsigned char i;
if(aw9106->cdev.brightness > aw9106->cdev.max_brightness) {
aw9106->cdev.brightness = aw9106->cdev.max_brightness;
}
if(blink) {
aw9106_i2c_write(aw9106, REG_WORK_MODE_P0, 0x00); // led mode
aw9106_i2c_write(aw9106, REG_WORK_MODE_P1, 0x00); // led mode
aw9106_i2c_write(aw9106, REG_EN_BREATH, 0x3f); // enable breath
aw9106_i2c_write(aw9106, REG_CONFIG_P0, 0x03); // blink mode
aw9106_i2c_write(aw9106, REG_CONFIG_P1, 0x0f); // blink mode
aw9106_i2c_write(aw9106, REG_FADE_TIME,
(aw9106->fall_time<<3)|(aw9106->rise_time)); // fade time
aw9106_i2c_write(aw9106, REG_FULL_TIME,
(aw9106->off_time<<3)|(aw9106->on_time)); // on/off time
for(i=0; i<6; i++) {
aw9106_i2c_write(aw9106, REG_DIM00+i,
aw9106->cdev.brightness); // dimming
}
aw9106_i2c_write(aw9106, REG_CTRL,
0x80 | aw9106->imax); // blink enable | imax
} else {
aw9106_i2c_write(aw9106, REG_WORK_MODE_P0, 0x00); // led mode
aw9106_i2c_write(aw9106, REG_WORK_MODE_P1, 0x00); // led mode
aw9106_i2c_write(aw9106, REG_EN_BREATH, 0x00); // disable breath
aw9106_i2c_write(aw9106, REG_CTRL, 0x03); // imax
for(i=0; i<6; i++) {
aw9106_i2c_write(aw9106, REG_DIM00+i, 0x00); // dimming
}
}
}
/*****************************************************
*
* device tree
*
*****************************************************/
static int aw9106_parse_dt(struct device *dev, struct aw9106 *aw9106,
struct device_node *np)
{
aw9106->reset_gpio = of_get_named_gpio(np, "reset-gpio", 0);
if (aw9106->reset_gpio < 0) {
dev_err(dev, "%s: no reset gpio provided, will not HW reset device\n", __func__);
return -1;
} else {
dev_info(dev, "%s: reset gpio provided ok\n", __func__);
}
return 0;
}
static int aw9106_hw_reset(struct aw9106 *aw9106)
{
pr_info("%s enter\n", __func__);
if (aw9106 && gpio_is_valid(aw9106->reset_gpio)) {
gpio_set_value_cansleep(aw9106->reset_gpio, 0);
msleep(1);
gpio_set_value_cansleep(aw9106->reset_gpio, 1);
msleep(1);
} else {
dev_err(aw9106->dev, "%s: failed\n", __func__);
}
return 0;
}
static int aw9106_hw_off(struct aw9106 *aw9106)
{
pr_info("%s enter\n", __func__);
if (aw9106 && gpio_is_valid(aw9106->reset_gpio)) {
gpio_set_value_cansleep(aw9106->reset_gpio, 0);
msleep(1);
} else {
dev_err(aw9106->dev, "%s: failed\n", __func__);
}
return 0;
}
/*****************************************************
*
* check chip id
*
*****************************************************/
static int aw9106_read_chipid(struct aw9106 *aw9106)
{
int ret = -1;
unsigned char cnt = 0;
unsigned char reg_val = 0;
while(cnt < AW_READ_CHIPID_RETRIES) {
ret = aw9106_i2c_read(aw9106, REG_ID, ®_val);
if (ret < 0) {
dev_err(aw9106->dev,
"%s: failed to read register aw9106_REG_ID: %d\n",
__func__, ret);
return -EIO;
}
switch (reg_val) {
case AW9106_ID:
pr_info("%s aw9106 detected\n", __func__);
aw9106->chipid = AW9106_ID;
return 0;
default:
pr_info("%s unsupported device revision (0x%x)\n",
__func__, reg_val );
break;
}
cnt ++;
msleep(AW_READ_CHIPID_RETRY_DELAY);
}
return -EINVAL;
}
/******************************************************
*
* sys group attribute: reg
*
******************************************************/
static ssize_t aw9106_reg_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct aw9106 *aw9106 = container_of(led_cdev, struct aw9106, cdev);
unsigned int databuf[2] = {0, 0};
if(2 == sscanf(buf, "%x %x", &databuf[0], &databuf[1])) {
aw9106_i2c_write(aw9106, (unsigned char)databuf[0], (unsigned char)databuf[1]);
}
return count;
}
static ssize_t aw9106_reg_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct aw9106 *aw9106 = container_of(led_cdev, struct aw9106, cdev);
ssize_t len = 0;
unsigned char i = 0;
unsigned char reg_val = 0;
for(i = 0; i < AW9106_REG_MAX; i ++) {
if(!(aw9106_reg_access[i]®_RD_ACCESS))
continue;
aw9106_i2c_read(aw9106, i, ®_val);
len += snprintf(buf+len, PAGE_SIZE-len, "reg:0x%02x=0x%02x \n", i, reg_val);
}
return len;
}
static ssize_t aw9106_hwen_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct aw9106 *aw9106 = container_of(led_cdev, struct aw9106, cdev);
unsigned int databuf[1] = {0};
if(1 == sscanf(buf, "%x", &databuf[0])) {
if(1 == databuf[0]) {
aw9106_hw_reset(aw9106);
} else {
aw9106_hw_off(aw9106);
}
}
return count;
}
static ssize_t aw9106_hwen_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct aw9106 *aw9106 = container_of(led_cdev, struct aw9106, cdev);
ssize_t len = 0;
len += snprintf(buf+len, PAGE_SIZE-len, "hwen=%d\n",
gpio_get_value(aw9106->reset_gpio));
return len;
}
static ssize_t aw9106_blink_store(struct device* dev, struct device_attribute *attr,
const char* buf, size_t len)
{
unsigned int databuf[1];
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct aw9106 *aw9106 = container_of(led_cdev, struct aw9106, cdev);
sscanf(buf,"%d",&databuf[0]);
aw9106_led_blink(aw9106, databuf[0]);
return len;
}
static ssize_t aw9106_blink_show(struct device* dev,struct device_attribute *attr, char* buf)
{
ssize_t len = 0;
len += snprintf(buf+len, PAGE_SIZE-len, "aw9106_blink()\n");
len += snprintf(buf+len, PAGE_SIZE-len, "echo 0 > blink\n");
len += snprintf(buf+len, PAGE_SIZE-len, "echo 1 > blink\n");
return len;
}
static DEVICE_ATTR(reg, S_IWUSR | S_IRUGO, aw9106_reg_show, aw9106_reg_store);
static DEVICE_ATTR(hwen, S_IWUSR | S_IRUGO, aw9106_hwen_show, aw9106_hwen_store);
static DEVICE_ATTR(blink, S_IWUSR | S_IRUGO, aw9106_blink_show, aw9106_blink_store);
static struct attribute *aw9106_attributes[] = {
&dev_attr_reg.attr,
&dev_attr_hwen.attr,
&dev_attr_blink.attr,
NULL
};
static struct attribute_group aw9106_attribute_group = {
.attrs = aw9106_attributes
};
/******************************************************
*
* led class dev
*
******************************************************/
static int aw9106_parse_led_cdev(struct aw9106 *aw9106,
struct device_node *np)
{
struct device_node *temp;
int ret = -1;
for_each_child_of_node(np, temp) {
ret = of_property_read_string(temp, "aw9106,name",
&aw9106->cdev.name);
if (ret < 0) {
dev_err(aw9106->dev,
"Failure reading led name, ret = %d\n", ret);
goto free_pdata;
}
ret = of_property_read_u32(temp, "aw9106,imax",
&aw9106->imax);
if (ret < 0) {
dev_err(aw9106->dev,
"Failure reading imax, ret = %d\n", ret);
goto free_pdata;
}
ret = of_property_read_u32(temp, "aw9106,brightness",
&aw9106->cdev.brightness);
if (ret < 0) {
dev_err(aw9106->dev,
"Failure reading brightness, ret = %d\n", ret);
goto free_pdata;
}
ret = of_property_read_u32(temp, "aw9106,max_brightness",
&aw9106->cdev.max_brightness);
if (ret < 0) {
dev_err(aw9106->dev,
"Failure reading max brightness, ret = %d\n", ret);
goto free_pdata;
}
ret = of_property_read_u32(temp, "aw9106,rise_time",
&aw9106->rise_time);
if (ret < 0) {
dev_err(aw9106->dev,
"Failure reading rise_time, ret = %d\n", ret);
goto free_pdata;
}
ret = of_property_read_u32(temp, "aw9106,on_time",
&aw9106->on_time);
if (ret < 0) {
dev_err(aw9106->dev,
"Failure reading on_time, ret = %d\n", ret);
goto free_pdata;
}
ret = of_property_read_u32(temp, "aw9106,fall_time",
&aw9106->fall_time);
if (ret < 0) {
dev_err(aw9106->dev,
"Failure reading fall_time, ret = %d\n", ret);
goto free_pdata;
}
ret = of_property_read_u32(temp, "aw9106,off_time",
&aw9106->off_time);
if (ret < 0) {
dev_err(aw9106->dev,
"Failure reading off_time, ret = %d\n", ret);
goto free_pdata;
}
}
INIT_WORK(&aw9106->brightness_work, aw9106_brightness_work);
aw9106->cdev.brightness_set = aw9106_set_brightness;
ret = led_classdev_register(aw9106->dev, &aw9106->cdev);
if (ret) {
dev_err(aw9106->dev,
"unable to register led ret=%d\n", ret);
goto free_pdata;
}
ret = sysfs_create_group(&aw9106->cdev.dev->kobj,
&aw9106_attribute_group);
if (ret) {
dev_err(aw9106->dev, "led sysfs ret: %d\n", ret);
goto free_class;
}
return 0;
free_class:
led_classdev_unregister(&aw9106->cdev);
free_pdata:
return ret;
}
/******************************************************
*
* i2c driver
*
******************************************************/
static int aw9106_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
{
struct aw9106 *aw9106;
struct device_node *np = i2c->dev.of_node;
int ret;
pr_info("%s enter\n", __func__);
if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C)) {
dev_err(&i2c->dev, "check_functionality failed\n");
return -EIO;
}
aw9106 = devm_kzalloc(&i2c->dev, sizeof(struct aw9106), GFP_KERNEL);
if (aw9106 == NULL)
return -ENOMEM;
aw9106->dev = &i2c->dev;
aw9106->i2c = i2c;
i2c_set_clientdata(i2c, aw9106);
/* aw9106 rst & int */
if (np) {
ret = aw9106_parse_dt(&i2c->dev, aw9106, np);
if (ret) {
dev_err(&i2c->dev, "%s: failed to parse device tree node\n", __func__);
goto err;
}
} else {
aw9106->reset_gpio = -1;
}
if (gpio_is_valid(aw9106->reset_gpio)) {
ret = devm_gpio_request_one(&i2c->dev, aw9106->reset_gpio,
GPIOF_OUT_INIT_LOW, "aw9106_rst");
if (ret){
dev_err(&i2c->dev, "%s: rst request failed\n", __func__);
goto err;
}
}
/* hardware reset */
aw9106_hw_reset(aw9106);
/* aw9106 chip id */
ret = aw9106_read_chipid(aw9106);
if (ret < 0) {
dev_err(&i2c->dev, "%s: aw9106_read_chipid failed ret=%d\n", __func__, ret);
goto err_id;
}
dev_set_drvdata(&i2c->dev, aw9106);
aw9106_parse_led_cdev(aw9106, np);
if (ret < 0) {
dev_err(&i2c->dev, "%s error creating led class dev\n", __func__);
goto err_sysfs;
}
pr_info("%s probe completed successfully!\n", __func__);
return 0;
err_sysfs:
err_id:
err:
return ret;
}
static int aw9106_i2c_remove(struct i2c_client *i2c)
{
struct aw9106 *aw9106 = i2c_get_clientdata(i2c);
pr_info("%s enter\n", __func__);
if (gpio_is_valid(aw9106->reset_gpio))
devm_gpio_free(&i2c->dev, aw9106->reset_gpio);
return 0;
}
static const struct i2c_device_id aw9106_i2c_id[] = {
{ AW9106_I2C_NAME, 0 },
{ }
};
MODULE_DEVICE_TABLE(i2c, aw9106_i2c_id);
static struct of_device_id aw9106_dt_match[] = {
{ .compatible = "awinic,aw9106_led" },
{ },
};
static struct i2c_driver aw9106_i2c_driver = {
.driver = {
.name = AW9106_I2C_NAME,
.owner = THIS_MODULE,
.of_match_table = of_match_ptr(aw9106_dt_match),
},
.probe = aw9106_i2c_probe,
.remove = aw9106_i2c_remove,
.id_table = aw9106_i2c_id,
};
static int __init aw9106_i2c_init(void)
{
int ret = 0;
pr_info("aw9106 driver version %s\n", AW9106_VERSION);
ret = i2c_add_driver(&aw9106_i2c_driver);
if(ret){
pr_err("fail to add aw9106 device into i2c\n");
return ret;
}
return 0;
}
module_init(aw9106_i2c_init);
static void __exit aw9106_i2c_exit(void)
{
i2c_del_driver(&aw9106_i2c_driver);
}
module_exit(aw9106_i2c_exit);
MODULE_DESCRIPTION("AW9106 LED Driver");
MODULE_LICENSE("GPL v2");
4.8 gpiolib引入
(1)一个事实：很多硬件都要用到GPIO、GPIO会复用
(2)如果同一个GPIO被2个驱动同时控制了，就会出现bug
(3)内核提供gpiolib来统一管理系统中所有GPIO
(4)gpiolib本身属于驱动框架的一部分
(5) linux内核的gpiolib概念，参考：https://blog.youkuaiyun.com/zhoutaopower/article/details/98082006
#ubuntu的内核源码树，如果要编译在ubuntu中安装的模块就打开这2个
#KERN_VER = $(shell uname -r)
#KERN_DIR = /lib/modules/$(KERN_VER)/build
# 开发板的linux内核的源码树目录
KERN_DIR = /root/driver/kernel
obj-m += leds-s5pv210.o
all:
make -C $(KERN_DIR) M=`pwd` modules
arm-linux-gcc app.c -o app
cp:
cp *.ko /root/porting_x210/rootfs/rootfs/driver_test
cp app /root/porting_x210/rootfs/rootfs/driver_test
.PHONY: clean
clean:
make -C $(KERN_DIR) M=`pwd` modules clean
rm -rf app
#include <linux/module.h> // module_init module_exit
#include <linux/init.h> // __init __exit
#include <linux/fs.h>
#include <linux/leds.h>
#include <mach/regs-gpio.h>
#include <mach/gpio-bank.h>
#include <linux/io.h>
#include <linux/ioport.h>
#define GPJ0CON S5PV210_GPJ0CON
#define GPJ0DAT S5PV210_GPJ0DAT
static struct led_classdev mydev1; // 定义结构体变量
static struct led_classdev mydev2; // 定义结构体变量
static struct led_classdev mydev3; // 定义结构体变量
// 这个函数就是要去完成具体的硬件读写任务的
static void s5pv210_led1_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
printk(KERN_INFO "s5pv210_led1_set\n");
writel(0x11111111, GPJ0CON);
// 在这里根据用户设置的值来操作硬件
// 用户设置的值就是value
if (value == LED_OFF)
{
// 用户给了个0，希望LED灭
//writel(0x11111111, GPJ0CON);
// 读改写三部曲
writel((readl(GPJ0DAT) | (1<<3)), GPJ0DAT);
}
else
{
// 用户给的是非0，希望LED亮
//writel(0x11111111, GPJ0CON);
writel((readl(GPJ0DAT) & ~(1<<3)), GPJ0DAT);
}
}
static void s5pv210_led2_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
printk(KERN_INFO "s5pv2102_led_set\n");
writel(0x11111111, GPJ0CON);
// 在这里根据用户设置的值来操作硬件
// 用户设置的值就是value
if (value == LED_OFF)
{
// 用户给了个0，希望LED灭
//writel(0x11111111, GPJ0CON);
// 读改写三部曲
writel((readl(GPJ0DAT) | (1<<4)), GPJ0DAT);
}
else
{
// 用户给的是非0，希望LED亮
//writel(0x11111111, GPJ0CON);
writel((readl(GPJ0DAT) & ~(1<<4)), GPJ0DAT);
}
}
static void s5pv210_led3_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
printk(KERN_INFO "s5pv210_led3_set\n");
writel(0x11111111, GPJ0CON);
// 在这里根据用户设置的值来操作硬件
// 用户设置的值就是value
if (value == LED_OFF)
{
// 用户给了个0，希望LED灭
//writel(0x11111111, GPJ0CON);
// 读改写三部曲
writel((readl(GPJ0DAT) | (1<<5)), GPJ0DAT);
}
else
{
// 用户给的是非0，希望LED亮
//writel(0x11111111, GPJ0CON);
writel((readl(GPJ0DAT) & ~(1<<5)), GPJ0DAT);
}
}
static int __init s5pv210_led_init(void)
{
// 用户insmod安装驱动模块时会调用该函数
// 该函数的主要任务就是去使用led驱动框架提供的设备注册函数来注册一个设备
int ret = -1;
// led1
mydev1.name = "led1";
mydev1.brightness = 255;
mydev1.brightness_set = s5pv210_led1_set;
ret = led_classdev_register(NULL, &mydev1);
if (ret < 0) {
printk(KERN_ERR "led_classdev_register failed\n");
return ret;
}
// led2
mydev2.name = "led2";
mydev2.brightness = 255;
mydev2.brightness_set = s5pv210_led2_set;
ret = led_classdev_register(NULL, &mydev2);
if (ret < 0) {
printk(KERN_ERR "led_classdev_register failed\n");
return ret;
}
// led3
mydev3.name = "led3";
mydev3.brightness = 255;
mydev3.brightness_set = s5pv210_led3_set;
ret = led_classdev_register(NULL, &mydev3);
if (ret < 0) {
printk(KERN_ERR "led_classdev_register failed\n");
return ret;
}
return 0;
}
static void __exit s5pv210_led_exit(void)
{
led_classdev_unregister(&mydev1);
led_classdev_unregister(&mydev2);
led_classdev_unregister(&mydev3);
}
module_init(s5pv210_led_init);
module_exit(s5pv210_led_exit);
// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL"); // 描述模块的许可证
MODULE_AUTHOR("aston <1264671872@qq.com>"); // 描述模块的作者
MODULE_DESCRIPTION("s5pv210 led driver"); // 描述模块的介绍信息
MODULE_ALIAS("s5pv210_led"); // 描述模块的别名信息
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#define FILE "/dev/test" // 刚才mknod创建的设备文件名
char buf[100];
int main(void)
{
int fd = -1;
int i = 0;
fd = open(FILE, O_RDWR);
if (fd < 0)
{
printf("open %s error.\n", FILE);
return -1;
}
printf("open %s success..\n", FILE);
/*
// 读写文件
write(fd, "on", 2);
sleep(2);
write(fd, "off", 3);
sleep(2);
write(fd, "on", 2);
sleep(2);
*/
/*
write(fd, "1", 1);
sleep(2);
write(fd, "0", 1);
sleep(2);
write(fd, "1", 1);
sleep(2);
*/
while (1)
{
memset(buf, 0 , sizeof(buf));
printf("请输入 on | off \n");
scanf("%s", buf);
if (!strcmp(buf, "on"))
{
write(fd, "1", 1);
}
else if (!strcmp(buf, "off"))
{
write(fd, "0", 1);
}
else if (!strcmp(buf, "flash"))
{
for (i=0; i<3; i++)
{
write(fd, "1", 1);
sleep(1);
write(fd, "0", 1);
sleep(1);
}
}
else if (!strcmp(buf, "quit"))
{
break;
}
}
// 关闭文件
close(fd);
return 0;
}
4.9.使用gpiolib完成led驱动
4.9.1、流程分析
(1)第1步：使用gpio_request申请要使用的一个GPIO
(2)第2步：gpio_direction_input/gpio_direction_output 设置输入/输出模式
(3)第3步：设置输出值gpio_set_value 获取IO口值gpio_get_value
4.9.2、代码实践
(1)在led1上编写代码测试通过
(2)扩展支持led2和led3、led4.可以分开注册也可以使用gpio_request_array去一次注册
(3)学习linux中查看gpio使用情况的方法
内核中提供了虚拟文件系统debugfs，里面有一个gpio文件，提供了gpio的使用信息。
使用方法：mount -t debugfs debugfs /tmp，然后cat /tmp/gpio即可得到gpio的所有信息，使用完后umount /tmp卸载掉debugfs
#ubuntu的内核源码树，如果要编译在ubuntu中安装的模块就打开这2个
#KERN_VER = $(shell uname -r)
#KERN_DIR = /lib/modules/$(KERN_VER)/build
# 开发板的linux内核的源码树目录
KERN_DIR = /root/driver/kernel
obj-m += leds-s5pv210.o
all:
make -C $(KERN_DIR) M=`pwd` modules
arm-linux-gcc app.c -o app
cp:
cp *.ko /root/porting_x210/rootfs/rootfs/driver_test
cp app /root/porting_x210/rootfs/rootfs/driver_test
.PHONY: clean
clean:
make -C $(KERN_DIR) M=`pwd` modules clean
rm -rf app
#include <linux/module.h> // module_init module_exit
#include <linux/init.h> // __init __exit
#include <linux/fs.h>
#include <linux/leds.h>
#include <mach/regs-gpio.h>
#include <mach/gpio-bank.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <mach/gpio.h>
#define GPIO_LED1 S5PV210_GPJ0(3)
#define GPIO_LED2 S5PV210_GPJ0(4)
#define GPIO_LED3 S5PV210_GPJ0(5)
#define X210_LED_OFF 1 // X210中LED是正极接电源，负极节GPIO
#define X210_LED_ON 0 // 所以1是灭，0是亮
static struct led_classdev mydev1; // 定义结构体变量
static struct led_classdev mydev2; // 定义结构体变量
static struct led_classdev mydev3; // 定义结构体变量
// 这个函数就是要去完成具体的硬件读写任务的
static void s5pv210_led1_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
printk(KERN_INFO "s5pv210_led1_set\n");
//writel(0x11111111, GPJ0CON);
// 在这里根据用户设置的值来操作硬件
// 用户设置的值就是value
if (value == LED_OFF)
{
// 用户给了个0，希望LED灭
//writel(0x11111111, GPJ0CON);
// 读改写三部曲
//writel((readl(GPJ0DAT) | (1<<3)), GPJ0DAT);
gpio_set_value(GPIO_LED1, X210_LED_OFF);
}
else
{
// 用户给的是非0，希望LED亮
//writel(0x11111111, GPJ0CON);
//writel((readl(GPJ0DAT) & ~(1<<3)), GPJ0DAT);
gpio_set_value(GPIO_LED1, X210_LED_ON);
}
}
static void s5pv210_led2_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
printk(KERN_INFO "s5pv2102_led_set\n");
//writel(0x11111111, GPJ0CON);
// 在这里根据用户设置的值来操作硬件
// 用户设置的值就是value
if (value == LED_OFF)
{
// 用户给了个0，希望LED灭
//writel(0x11111111, GPJ0CON);
// 读改写三部曲
//writel((readl(GPJ0DAT) | (1<<4)), GPJ0DAT);
}
else
{
// 用户给的是非0，希望LED亮
//writel(0x11111111, GPJ0CON);
//writel((readl(GPJ0DAT) & ~(1<<4)), GPJ0DAT);
}
}
static void s5pv210_led3_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
printk(KERN_INFO "s5pv210_led3_set\n");
//writel(0x11111111, GPJ0CON);
// 在这里根据用户设置的值来操作硬件
// 用户设置的值就是value
if (value == LED_OFF)
{
// 用户给了个0，希望LED灭
//writel(0x11111111, GPJ0CON);
// 读改写三部曲
//writel((readl(GPJ0DAT) | (1<<5)), GPJ0DAT);
}
else
{
// 用户给的是非0，希望LED亮
//writel(0x11111111, GPJ0CON);
//writel((readl(GPJ0DAT) & ~(1<<5)), GPJ0DAT);
}
}
static int __init s5pv210_led_init(void)
{
// 用户insmod安装驱动模块时会调用该函数
// 该函数的主要任务就是去使用led驱动框架提供的设备注册函数来注册一个设备
int ret = -1;
// 在这里去申请驱动用到的各种资源，当前驱动中就是GPIO资源
if (gpio_request(GPIO_LED1, "led1_gpj0.3"))
{
printk(KERN_ERR "gpio_request failed\n");
}
else
{
// 设置为输出模式，并且默认输出1让LED灯灭
gpio_direction_output(GPIO_LED1, 1);
}
// led1
mydev1.name = "led1";
mydev1.brightness = 0;
mydev1.brightness_set = s5pv210_led1_set;
ret = led_classdev_register(NULL, &mydev1);
if (ret < 0) {
printk(KERN_ERR "led_classdev_register failed\n");
return ret;
}
// led2
mydev2.name = "led2";
mydev2.brightness = 0;
mydev2.brightness_set = s5pv210_led2_set;
ret = led_classdev_register(NULL, &mydev2);
if (ret < 0) {
printk(KERN_ERR "led_classdev_register failed\n");
return ret;
}
// led3
mydev3.name = "led3";
mydev3.brightness = 0;
mydev3.brightness_set = s5pv210_led3_set;
ret = led_classdev_register(NULL, &mydev3);
if (ret < 0) {
printk(KERN_ERR "led_classdev_register failed\n");
return ret;
}
return 0;
}
static void __exit s5pv210_led_exit(void)
{
led_classdev_unregister(&mydev1);
led_classdev_unregister(&mydev2);
led_classdev_unregister(&mydev3);
gpio_free(GPIO_LED1);
}
module_init(s5pv210_led_init);
module_exit(s5pv210_led_exit);
// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL"); // 描述模块的许可证
MODULE_AUTHOR("aston <1264671872@qq.com>"); // 描述模块的作者
MODULE_DESCRIPTION("s5pv210 led driver"); // 描述模块的介绍信息
MODULE_ALIAS("s5pv210_led"); // 描述模块的别名信息
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#define FILE "/dev/test" // 刚才mknod创建的设备文件名
char buf[100];
int main(void)
{
int fd = -1;
int i = 0;
fd = open(FILE, O_RDWR);
if (fd < 0)
{
printf("open %s error.\n", FILE);
return -1;
}
printf("open %s success..\n", FILE);
/*
// 读写文件
write(fd, "on", 2);
sleep(2);
write(fd, "off", 3);
sleep(2);
write(fd, "on", 2);
sleep(2);
*/
/*
write(fd, "1", 1);
sleep(2);
write(fd, "0", 1);
sleep(2);
write(fd, "1", 1);
sleep(2);
*/
while (1)
{
memset(buf, 0 , sizeof(buf));
printf("请输入 on | off \n");
scanf("%s", buf);
if (!strcmp(buf, "on"))
{
write(fd, "1", 1);
}
else if (!strcmp(buf, "off"))
{
write(fd, "0", 1);
}
else if (!strcmp(buf, "flash"))
{
for (i=0; i<3; i++)
{
write(fd, "1", 1);
sleep(1);
write(fd, "0", 1);
sleep(1);
}
}
else if (!strcmp(buf, "quit"))
{
break;
}
}
// 关闭文件
close(fd);
return 0;
}
4.10.将驱动添加到内核中
4.10.1、驱动的存在形式
(1)野生，优势是方便调试开发，所以在开发阶段都是这种
(2)家养，优势可以在内核配置时make menuconfig决定内核怎么编译，方便集成
4.10.2、驱动开发的一般步骤
(1)以模块的形式在外部编写、调试
(2)将调试好的驱动代码集成到kernel中
4.10.3、实践
(1)关键点：Kconfig、Makefile、make menuconfig
(2)操作步骤：
第1步：将写好的驱动源文件放入内核源码中正确的目录下
第2步：在Makefile中添加相应的依赖
第3步：在Kconfig中添加相应的配置项
第4步：make menuconfig
目录和文件结构：
mach-s5pv210/gpiolib.c s5pv210_gpiolib_init
mach-s5pv210/include/mach/gpio.h #define S5PV210_GPA0(_nr) (S5PV210_GPIO_A0_START + (_nr))
arch/arm/plat-samsung/gpiolib.c 里面是210/6410这种4bit CON寄存器类型的操作方法
arch/arm/plat-samsung/gpio.c 里面是24XX这种2bit CON寄存器类型的操作方法
drivers/gpio/gpiolib.c 里面是内核开发者提供的gpiolib的驱动框架部分
#ubuntu的内核源码树，如果要编译在ubuntu中安装的模块就打开这2个
#KERN_VER = $(shell uname -r)
#KERN_DIR = /lib/modules/$(KERN_VER)/build
# 开发板的linux内核的源码树目录
KERN_DIR = /root/driver/kernel
obj-m += leds-s5pv210.o
all:
make -C $(KERN_DIR) M=`pwd` modules
.PHONY: clean
clean:
make -C $(KERN_DIR) M=`pwd` modules clean
rm -rf app
#include <linux/module.h> // module_init module_exit
#include <linux/init.h> // __init __exit
#include <linux/fs.h>
#include <linux/leds.h>
#include <mach/regs-gpio.h>
#include <mach/gpio-bank.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <mach/gpio.h>
#define GPIO_LED1 S5PV210_GPJ0(3)
#define GPIO_LED2 S5PV210_GPJ0(4)
#define GPIO_LED3 S5PV210_GPJ0(5)
#define X210_LED_OFF 1 // X210中LED是正极接电源，负极节GPIO
#define X210_LED_ON 0 // 所以1是灭，0是亮
static struct led_classdev mydev1; // 定义结构体变量
static struct led_classdev mydev2; // 定义结构体变量
static struct led_classdev mydev3; // 定义结构体变量
// 这个函数就是要去完成具体的硬件读写任务的
static void s5pv210_led1_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
printk(KERN_INFO "s5pv210_led1_set\n");
//writel(0x11111111, GPJ0CON);
// 在这里根据用户设置的值来操作硬件
// 用户设置的值就是value
if (value == LED_OFF)
{
// 用户给了个0，希望LED灭
//writel(0x11111111, GPJ0CON);
// 读改写三部曲
//writel((readl(GPJ0DAT) | (1<<3)), GPJ0DAT);
gpio_set_value(GPIO_LED1, X210_LED_OFF);
}
else
{
// 用户给的是非0，希望LED亮
//writel(0x11111111, GPJ0CON);
//writel((readl(GPJ0DAT) & ~(1<<3)), GPJ0DAT);
gpio_set_value(GPIO_LED1, X210_LED_ON);
}
}
static void s5pv210_led2_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
printk(KERN_INFO "s5pv2102_led_set\n");
//writel(0x11111111, GPJ0CON);
// 在这里根据用户设置的值来操作硬件
// 用户设置的值就是value
if (value == LED_OFF)
{
// 用户给了个0，希望LED灭
//writel(0x11111111, GPJ0CON);
// 读改写三部曲
//writel((readl(GPJ0DAT) | (1<<4)), GPJ0DAT);
}
else
{
// 用户给的是非0，希望LED亮
//writel(0x11111111, GPJ0CON);
//writel((readl(GPJ0DAT) & ~(1<<4)), GPJ0DAT);
}
}
static void s5pv210_led3_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
printk(KERN_INFO "s5pv210_led3_set\n");
//writel(0x11111111, GPJ0CON);
// 在这里根据用户设置的值来操作硬件
// 用户设置的值就是value
if (value == LED_OFF)
{
// 用户给了个0，希望LED灭
//writel(0x11111111, GPJ0CON);
// 读改写三部曲
//writel((readl(GPJ0DAT) | (1<<5)), GPJ0DAT);
}
else
{
// 用户给的是非0，希望LED亮
//writel(0x11111111, GPJ0CON);
//writel((readl(GPJ0DAT) & ~(1<<5)), GPJ0DAT);
}
}
static int __init s5pv210_led_init(void)
{
// 用户insmod安装驱动模块时会调用该函数
// 该函数的主要任务就是去使用led驱动框架提供的设备注册函数来注册一个设备
int ret = -1;
// 在这里去申请驱动用到的各种资源，当前驱动中就是GPIO资源
if (gpio_request(GPIO_LED1, "led1_gpj0.3"))
{
printk(KERN_ERR "gpio_request failed\n");
}
else
{
// 设置为输出模式，并且默认输出1让LED灯灭
gpio_direction_output(GPIO_LED1, 1);
}
// led1
mydev1.name = "led1";
mydev1.brightness = 0;
mydev1.brightness_set = s5pv210_led1_set;
ret = led_classdev_register(NULL, &mydev1);
if (ret < 0) {
printk(KERN_ERR "led_classdev_register failed\n");
return ret;
}
// led2
mydev2.name = "led2";
mydev2.brightness = 0;
mydev2.brightness_set = s5pv210_led2_set;
ret = led_classdev_register(NULL, &mydev2);
if (ret < 0) {
printk(KERN_ERR "led_classdev_register failed\n");
return ret;
}
// led3
mydev3.name = "led3";
mydev3.brightness = 0;
mydev3.brightness_set = s5pv210_led3_set;
ret = led_classdev_register(NULL, &mydev3);
if (ret < 0) {
printk(KERN_ERR "led_classdev_register failed\n");
return ret;
}
return 0;
}
static void __exit s5pv210_led_exit(void)
{
led_classdev_unregister(&mydev1);
led_classdev_unregister(&mydev2);
led_classdev_unregister(&mydev3);
gpio_free(GPIO_LED1);
}
module_init(s5pv210_led_init);
module_exit(s5pv210_led_exit);
// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL"); // 描述模块的许可证
MODULE_AUTHOR("aston <1264671872@qq.com>"); // 描述模块的作者
MODULE_DESCRIPTION("s5pv210 led driver"); // 描述模块的介绍信息
MODULE_ALIAS("s5pv210_led"); // 描述模块的别名信息
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
