Linux 4.33 字符设备驱动分析
Linux的外设可以分为三类：字符设备(characterdevice)、块设备(block device)和网络接口(networkinterface)。在寒假期间，我着重研究了一下字符设备驱动。
字符设备是能够像字节流（比如文件）一样被访问的设备，对它的访问是以字节为单位的。例如利用串口收发数据时就是一个一个字节进行的，在编写驱动程序时，我们可以在驱动程序中设置缓冲区来存放数据以提高效率，但是串口本身并无此要求。字符设备驱动程序中运用到了open 、close、read、write等系统调用，应用程序可以通过设备文件来访问字符设备。
在寒假期间，我着重看了一下简单的LED字符设备驱动，以三星的开发板S3c24xx为例的LED驱动。首先是模块的初始化和卸载函数：
static int __init leds_init(void)
{
leds_class = class_create(THIS_MODULE, "leds");
if (IS_ERR(leds_class))
return PTR_ERR(leds_class);
leds_class->suspend = led_suspend;
leds_class->resume = led_resume;
leds_class->dev_attrs = led_class_attrs;
return 0;
}
static void __exit leds_exit(void)
{
class_destroy(leds_class);
}
subsys_initcall(leds_init);
module_exit(leds_exit);
在初始化函数主要做了一件事情，那就是调用class_create函数注册了一个class。
然后是led_classdev_register()：
/**
*led_classdev_register - register a new object of led_classdev class.
* @parent: Thedevice to register.
* @led_cdev: theled_classdev structure for this device.
*/
intled_classdev_register(struct device *parent, struct led_classdev *led_cdev)
{
led_cdev->dev = device_create(leds_class, parent, 0, led_cdev,
"%s", led_cdev->name);
if(IS_ERR(led_cdev->dev))
return PTR_ERR(led_cdev->dev);
#ifdef CONFIG_LEDS_TRIGGERS
init_rwsem(&led_cdev->trigger_lock);
#endif
/* add tothe list of leds */
down_write(&leds_list_lock);
list_add_tail(&led_cdev->node, &leds_list);
up_write(&leds_list_lock);
if(!led_cdev->max_brightness)
led_cdev->max_brightness = LED_FULL;
led_update_brightness(led_cdev);
init_timer(&led_cdev->blink_timer);
led_cdev->blink_timer.function = led_timer_function;
led_cdev->blink_timer.data = (unsigned long)led_cdev;
#ifdefCONFIG_LEDS_TRIGGERS
led_trigger_set_default(led_cdev);
#endif
printk(KERN_DEBUG "Registered led device: %s\n",
led_cdev->name);
return 0;
}
EXPORT_SYMBOL_GPL(led_classdev_register);
在led_classdev_register函数中主要做了以下一些事情：
1.在2.6版本内核中是自动在/dev目录下创建设备节点，而在4.33中最后调用了device_register函数向系统注册了一个struct device（可以在/sys/class/leds/目录下找到这个设备，比如lcd背光驱动的lcd-backlight）。
2. 加入led_cdev加入到链表leds_list中。
3. 调用led_update_brightness函数更新led亮度值。
4. 调用init_timer初始化一个定时器。
/**
*led_classdev_unregister - unregisters a object of led_properties class.
*@led_cdev: the led device to unregister
*
*Unregisters a previously registered via led_classdev_register object.
*/
void led_classdev_unregister(structled_classdev *led_cdev)
{
#ifdef CONFIG_LEDS_TRIGGERS
down_write(&led_cdev->trigger_lock);
if (led_cdev->trigger)
led_trigger_set(led_cdev,NULL);
up_write(&led_cdev->trigger_lock);
#endif
/* Stop blinking */
led_brightness_set(led_cdev, LED_OFF);
device_unregister(led_cdev->dev);
down_write(&leds_list_lock);
list_del(&led_cdev->node);
up_write(&leds_list_lock);
}
EXPORT_SYMBOL_GPL(led_classdev_unregister);
led_classdev_unregister()函数的主要作用是注销led的这个class。 down_write(&led_cdev->trigger_lock)用于关闭led。然后调用device_unregister注销设备。list_del(&led_cdev->node)来从链表leds_list中删除节点。
在Linux2.66中，模块初始化和卸载函数如下：
/*
* 执行insmod命令时就会调用这个函数
*/
static int __init s3c24xx_leds_init(void)
//static int __initinit_module(void)
{
int ret;
int minor = 0;
gpio_va = ioremap(0x56000000, 0x100000);
if (!gpio_va) {
return -EIO;
}
/* 注册字符设备
* 参数为主设备号、设备名字、file_operations结构；
* 这样，主设备号就和具体的file_operations结构联系起来了，
* 操作主设备为LED_MAJOR的设备文件时，就会调用s3c24xx_leds_fops中的相关成员函数
* LED_MAJOR可以设为0，表示由内核自动分配主设备号
*/
ret = register_chrdev(LED_MAJOR,DEVICE_NAME, &s3c24xx_leds_fops);
if (ret < 0) {
printk(DEVICE_NAME " can't registermajor number\n");
return ret;
}
printk(DEVICE_NAME "initialized\n");
return 0;
}
/*
* 执行rmmod命令时就会调用这个函数
*/
static void __exit s3c24xx_leds_exit(void)
{
int minor;
/* 卸载驱动程序 */
unregister_chrdev(LED_MAJOR, DEVICE_NAME);
for (minor = 0; minor < 4; minor++)
{
class_device_unregister(leds_class_devs[minor]);
}
class_destroy(leds_class);
iounmap(gpio_va);
}
/* 这两行指定驱动程序的初始化函数和卸载函数 */
module_init(s3c24xx_leds_init);
module_exit(s3c24xx_leds_exit);
执行“insmod s3c24xx_led.ko”命令时就会调用s3c24xx_leds_init函数。它调用register_chrdev函数向内核注册驱动程序：将主设备号LED_MAJOR与file_operation结构s3c24xx_leds_fops联系起来。以后应用程序操作主设备号为LED_MAJOR与file_operation结构s3c24xx_leds_fops联系起来。当应用程序操作主设备为LED_MAJOR的设备文件时，就会调用s3c24xx_leds_fops中的相关成员函数，比如open、read、write、ioctl，对应于s3c24xx_leds_fops中有其对应的函数，就会调用这些函数。
而执行“remmod s3c24xx_led.ko”时，就会调用s3c24xx_leds_exit函数，它进而调用unregister_chrdev函数卸载驱动程序，功能与register_chrdev函数相反。
s3c24xx_leds_fops的组成为：
/* 这个结构是字符设备驱动程序的核心
* 当应用程序操作设备文件时所调用的open、read、write等函数，
* 最终会调用这个结构中指定的对应函数
*/
static struct file_operationss3c24xx_leds_fops = {
.owner = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
.open = s3c24xx_leds_open,
.read = s3c24xx_leds_read,
.write = s3c24xx_leds_write,
};
file_operation类型的s3c24xx_leds_fops结构是驱动中最重要的数据结构，字符设备驱动就是要填充其中各个成员。如open、ioctl成员被设为s3c24xx_leds_open和s3c24xx_leds_ioctl函数。s3c24xx_leds_open用于 初始化LED所用的GPIO引脚，s3c24xx_leds_ioctl用来根据用户传入的参数设置GPIO输出电平。s3c24xx_leds_open函数代码如下：
static ints3c24xx_leds_open(struct inode *inode, struct file *file)
{
int i;
for (i=0;i<4;i++){
//设置GPIO引脚的功能,为输出功能
s3c2410_gpio_cfgpin(led_table[i],led_cfg_table[i]);
}
return 0;
}
s3c2410_gpio_cfgpin函数是内核里实现的，它用来选择引脚的功能。其实就是设置GPIO的控制寄存器。
S3c24xx_leds_ioctl代码如下：
/* 应用程序对设备文件/dev/leds执行ioctl(...)时，
* 就会调用s3c24xx_leds_ioctl函数
*/
static int s3c2440_leds_ioctl(structinode *inode,
structfile *file,
unsignedint cmd,
unsignedlong arg)
{
if(arg > 4){
return–EINVAL;
}
switch(cmd){ //通过命令设置LED引脚电平状态
case IOCTL_LED_ON:
//设定指定引脚的输出电平为0
s3c2410_gpio_setpin(led_table[arg],0);
return 0;
case IOCTL_LED_OFF:
//设定指定引脚的输出电平为1
s3c2410_gpio_setpin(led_table[arg],1);
return 0;
default:
return –EINVAL;
}
}
应用程序执行系统调用ioctl(fd,cmd,arg)时，s3c2440_leds_ioctl函数被调用，cmd,arg参数调用s3c2410_gpio_setpinhans,来设置引脚的输出电平，输出0时点亮LED，输出1时熄灭LED。
在Linux4.33的led_s3c24xx驱动中还有两个主要的设备属性文件brightness和max_brightness。
brightness有操作函数led_brightness_show和led_birghtness_shore，led_brightness_show用于显示led的亮度值，而led_birghtness_shore用于设置led的亮度值，所以可以通过echo 120 > brightness的方式设置lcd的背光亮度为120。
而max_brightness只有一个操作函数为led_max_brightness_show用于显示led的最大亮度值。
还有led_timer_function函数
static void led_timer_function(unsigned longdata)
{
struct led_classdev *led_cdev = (void *)data;
unsigned long brightness;
unsigned long delay;
if (!led_cdev->blink_delay_on || !led_cdev->blink_delay_off) {
led_set_brightness(led_cdev,LED_OFF);
return;
}
brightness = led_get_brightness(led_cdev);
if (!brightness) {
/* Time to switch the LED on.*/
brightness =led_cdev->blink_brightness;
delay =led_cdev->blink_delay_on;
} else {
/* Store the currentbrightness value to be able
* to restore it when thedelay_off period is over.
*/
led_cdev->blink_brightness= brightness;
brightness = LED_OFF;
delay =led_cdev->blink_delay_off;
}
led_set_brightness(led_cdev, brightness);
mod_timer(&led_cdev->blink_timer, jiffies +msecs_to_jiffies(delay));
}
此函数运用定时器来控制led灯。首先判断led_cdev中的blink_delay_on和blink_delay_off，如果这两个值为0，那么直接设置led亮度值为0，并返回。
再读取brightness，这里有两个分支，如果brightness值为0，即led是关闭的，那么设置brightness为led_cdev->blink_brightness，然后设置led的亮度值，修改定时器，是它延长led_cdev->blink_delay_on再执行led_timer_function这个函数，从这里可以看到blink_delay_on为led灯亮的时间。如果brightness不为0，也就是led是亮着的，先将之前的led亮度值保存在变量led_cdev->blink_brightness中，然后关闭led，延长blink_delay_off这么长时间，所以blink_delay_off是led关闭的时间。
从这里我们可以看出，blink_delay_on和blink_delay_off是用于调节led亮和灭的时间长度，单位是毫秒，如果它们都是500毫秒，那么就会出现led500毫秒一亮一灭，这样设计的目的是为了节约用电，比如控制lcd的背光（注意：PWM控制的LCD背光不需要blink_delay_on和blink_delay_off这两个参数，因为PWM本身就具有这个功能）。
注意：每个调用led_classdev_register注册到内核的struct led_classdev都有个定时器，而且他们的定时器操作函数都是相同的，他们各自管理自己的delay_on、dealy_off。初始情况下led_timer_function是不会被执行的，除非有外界条件去触发它，例如调用了mod_timer。
led_set_brightness用来设置led亮度，在led.h中：
static inline void led_set_brightness(struct led_classdev *led_cdev,
enum led_brightness value)
{
if (value >led_cdev->max_brightness)
value =led_cdev->max_brightness;
led_cdev->brightness =value;
if (!(led_cdev->flags& LED_SUSPENDED))
led_cdev->brightness_set(led_cdev, value);
}
此函数中调用led_classdev中的brightness_set，在led_core.c中，有led_brightness_set()、led_blink_set两个接口函数。
void led_brightness_set(struct led_classdev *led_cdev,
enumled_brightness brightness)
{
led_stop_software_blink(led_cdev);
led_cdev->brightness_set(led_cdev, brightness);
}
EXPORT_SYMBOL(led_brightness_set);
void led_blink_set(struct led_classdev *led_cdev,
unsigned long*delay_on,
unsigned long*delay_off)
{
del_timer_sync(&led_cdev->blink_timer);
if (led_cdev->blink_set&&
!led_cdev->blink_set(led_cdev, delay_on, delay_off))
return;
/* blink with 1 Hz as defaultif nothing specified */
if (!*delay_on &&!*delay_off)
*delay_on = *delay_off = 500;
led_set_software_blink(led_cdev, *delay_on, *delay_off);
}
EXPORT_SYMBOL(led_blink_set);
Linux2.66中创建一个file_operation结构体。填充这个结构体，指定操作设备文件时的函数是什么，例如open、read、write等。而在Linux4.33中，如果去写一个led驱动，首先得定义一个struct led_classdev，它得有两个成员，brightness_set和blink_set，最后调用led_classdev_register函数去完成注册。以leds-s3c24xx为例：
平台驱动部分为：
staticstruct platform_driver s3c24xx_led_driver = {
.probe = s3c24xx_led_probe,
.remove = s3c24xx_led_remove,
.driver = {
.name = "s3c24xx_led",
.owner = THIS_MODULE,
};
module_platform_driver(s3c24xx_led_driver);
staticint s3c24xx_led_probe(struct platform_device *dev)
{
struct s3c24xx_led_platdata *pdata =dev->dev.platform_data;
struct s3c24xx_gpio_led *led;
int ret;
led = kzalloc(sizeof(structs3c24xx_gpio_led), GFP_KERNEL);
if (led == NULL) {
dev_err(&dev->dev,"No memory for device\n");
return -ENOMEM;
}
platform_set_drvdata(dev, led);
led->cdev.brightness_set =s3c24xx_led_set;
led->cdev.default_trigger =pdata->def_trigger;
led->cdev.name = pdata->name;
led->cdev.flags |=LED_CORE_SUSPENDRESUME;
led->pdata = pdata;
/* no point in having a pull-up if weare always driving */
if (pdata->flags &S3C24XX_LEDF_TRISTATE) {
s3c2410_gpio_setpin(pdata->gpio,0);
s3c2410_gpio_cfgpin(pdata->gpio, S3C2410_GPIO_INPUT);
} else {
s3c2410_gpio_pullup(pdata->gpio, 0);
s3c2410_gpio_setpin(pdata->gpio, 0);
s3c2410_gpio_cfgpin(pdata->gpio, S3C2410_GPIO_OUTPUT);
}
/* register our new led device */
ret =led_classdev_register(&dev->dev, &led->cdev);
if (ret < 0) {
dev_err(&dev->dev,"led_classdev_register failed\n");
kfree(led);
return ret;
}
return 0;
}
在probe函数中首先申请内存，其中就包括struct led_classdev，然后是对它的一些赋值操作，比如brightness_set为s3c24xx_led_set。再然后是初始化gpio口，最后是调用led_classdev_register函数完成注册。
下面编写一个测试程序测试它：
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
/*
* ledtest <dev> <on|off>
*/
voidprint_usage(char *file)
{
printf("Usage:\n");
printf("%s <dev><on|off>\n",file);
printf("eg. \n");
printf("%s /dev/leds on\n",file);
printf("%s /dev/leds off\n",file);
printf("%s /dev/led1 on\n",file);
printf("%s /dev/led1 off\n",file);
}
intmain(int argc, char **argv)
{
int fd;
char* filename;
char val;
if (argc != 3)
{
print_usage(argv[0]);
return 0;
}
filename = argv[1];
fd = open(filename, O_RDWR);
if (fd < 0)
{
printf("error, can't open%s\n", filename);
return 0;
}
if (!strcmp("on", argv[2]))
{
// 亮灯
val = 0;
write(fd, &val, 1);
}
else if (!strcmp("off", argv[2]))
{
// 灭灯
val = 1;
write(fd, &val, 1);
}
else
{
print_usage(argv[0]);
return 0;
}
return 0;
}
运行 ：./ledtest /dev/led1 on
可用。