锐客网

  1. 首页 > it技术 > >

Linux RTC驱动分析(一)----pcf8563驱动和class.c

linux

本文的RTC使用I2C接口操作pcf8563 ，这里针对pcf8563对Linux的RTC框架进行分析。 Linux常见的驱动在driver目录下都有一个文件夹，进入kernel主目录下的drivers/rtc，发现下面包含了许多芯片的RTC驱动，我们这里是以pcf8563为主，她是我们要分析的核心。其他几个相关联的文件分别是：alarm.c、alarm-dev.c、class.c、hctosys.c、interface.c和rtc-dev.c。
class.c：向linux设备模型核心注册了一个类RTC，提供了RTC子系统的一些公共函数，让各个RTC驱动注册集成到我们的linux内核中，向驱动程序提供了注册/注销接口。
rtc-dev.c：定义了基本的设备文件操作函数，用户程序与RTC驱动的接口函数，这里定义了每个ioctl命令需要调用的函数，还有open，read等。
interface.c：提供了ioctl各个命令需要调用的函数。
rtc-sysfs.c：与sysfs有关，提供通过sys文件系统操作pcf8563。
rtc-proc.c：与proc文件系统有关，提供通过proc文件系统操作pcf8563。
hctosys.c：系统起来之后会调用到这个文件中的rtc_hctosys()函数，主要功能是系统起来的时候去读RTC硬件中的时间，然后更新我们的系统时间。
rtc.h：定义了与RTC有关的数据结构。 pcf8563.c是最底层的直接和硬件打交道的驱动文件，pcf8563.c上面一层为interface.c，为接口文件，它主要是对pcf8563.c进行封装，给上层提供统一的接口，屏蔽底层差异化。Interface.c再往上就到了rtc-dev.c.，rtc-dev.c最终生成了/dev/rtc设备节点，上层的应用程序就是通过操作此文件来进行RTC相关的设置系统时间和闹钟等操作的。
文件关系图如下：
Linux RTC驱动分析(一)----pcf8563驱动和class.c
文章图片

【Linux RTC驱动分析(一)----pcf8563驱动和class.c】接下来我们从最底层驱动程序（pcf8563.c）到RTC核心（class.c）来逐一分析。
看一个设备驱动，一般都从模块初始化和退出函数开始，pcf8563.c的为：
static int __init pcf8563_init(void)
{
return i2c_add_driver(&pcf8563_driver);
}

static void __exit pcf8563_exit(void)
{
i2c_del_driver(&pcf8563_driver);
}
因为pcf8563为I2C接口设备，此处就是添加或者删除I2C设备。接下来看下rtc结构体pcf8563_driver：
static struct i2c_driver pcf8563_driver = {
.driver= {
.name= "rtc-pcf8563",
},
.probe= pcf8563_probe,
.remove= pcf8563_remove,
.id_table= pcf8563_id,
};
I2C设备结构体比较简单，主要就是探测和移除函数，首先看下探测设备函数pcf8563_probe：
static int pcf8563_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct pcf8563 *pcf8563;
int err = 0;
dev_dbg(&client->dev, "%s\n", __func__);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
return -ENODEV;
pcf8563 = kzalloc(sizeof(struct pcf8563), GFP_KERNEL);
if (!pcf8563)
return -ENOMEM;
dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
i2c_set_clientdata(client, pcf8563);
pcf8563->rtc = rtc_device_register(pcf8563_driver.driver.name,
&client->dev, &pcf8563_rtc_ops, THIS_MODULE);
if (IS_ERR(pcf8563->rtc)) {
err = PTR_ERR(pcf8563->rtc);
goto exit_kfree;
}
return 0;
exit_kfree:
kfree(pcf8563);
return err;
}
探测函数比较简单，比较重要的语句为红色标注部分，这里主要涉及到两个部分。
1、rtc设备注册函数rtc_device_register，此函数完成rtc设备的注册，在后面会重点讲述。
2、pcf8563_rtc_ops，此结构体定义了操作pcf8563的函数，包括读时间和设置时间等，上层调用的对时间操作就是调用此处的函数，具体如下：
static const struct rtc_class_ops pcf8563_rtc_ops = {
.read_time= pcf8563_rtc_read_time,
.set_time= pcf8563_rtc_set_time,
};
读时间函数pcf8563_rtc_read_time，就是通过I2C接口读取pcf8563时间寄存器里的值，具体如下：
static int pcf8563_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
return pcf8563_get_datetime(to_i2c_client(dev), tm);
}
static int pcf8563_get_datetime(struct i2c_client *client, struct rtc_time *tm)
{
struct pcf8563 *pcf8563 = i2c_get_clientdata(client);
unsigned char buf[13] = { PCF8563_REG_ST1 };
struct i2c_msg msgs[] = {
{ client->addr, 0, 1, buf },/* setup read ptr */
{ client->addr, I2C_M_RD, 13, buf },/* read status + date */
};
/* read registers */
if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
dev_err(&client->dev, "%s: read error\n", __func__);
return -EIO;
}
if (buf[PCF8563_REG_SC] & PCF8563_SC_LV)
dev_info(&client->dev,
"low voltage detected, date/time is not reliable.\n");
dev_dbg(&client->dev,
"%s: raw data is st1=%02x, st2=%02x, sec=%02x, min=%02x, hr=%02x, "
"mday=%02x, wday=%02x, mon=%02x, year=%02x\n",
__func__,
buf[0], buf[1], buf[2], buf[3],
buf[4], buf[5], buf[6], buf[7],
buf[8]);
tm->tm_sec = bcd2bin(buf[PCF8563_REG_SC] & 0x7F);
tm->tm_min = bcd2bin(buf[PCF8563_REG_MN] & 0x7F);
tm->tm_hour = bcd2bin(buf[PCF8563_REG_HR] & 0x3F); /* rtc hr 0-23 */
tm->tm_mday = bcd2bin(buf[PCF8563_REG_DM] & 0x3F);
tm->tm_wday = buf[PCF8563_REG_DW] & 0x07;
tm->tm_mon = bcd2bin(buf[PCF8563_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
tm->tm_year = bcd2bin(buf[PCF8563_REG_YR]);
if (tm->tm_year < 70)
tm->tm_year += 100; /* assume we are in 1970...2069 */
/* detect the polarity heuristically. see note above. */
pcf8563->c_polarity = (buf[PCF8563_REG_MO] & PCF8563_MO_C) ?
(tm->tm_year >= 100) : (tm->tm_year < 100);
dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
"mday=%d, mon=%d, year=%d, wday=%d\n",
__func__,
tm->tm_sec, tm->tm_min, tm->tm_hour,
tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
/* the clock can give out invalid datetime, but we cannot return
* -EINVAL otherwise hwclock will refuse to set the time on bootup.
*/
if (rtc_valid_tm(tm) < 0)
dev_err(&client->dev, "retrieved date/time is not valid.\n");
return 0;
}
设置时间函数pcf8563_rtc_set_time，就是通过I2C接口写pcf8563时间寄存器里的值，具体如下：
static int pcf8563_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
return pcf8563_set_datetime(to_i2c_client(dev), tm);
}
static int pcf8563_set_datetime(struct i2c_client *client, struct rtc_time *tm)
{
struct pcf8563 *pcf8563 = i2c_get_clientdata(client);
int i, err;
unsigned char buf[9];
dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
"mday=%d, mon=%d, year=%d, wday=%d\n",
__func__,
tm->tm_sec, tm->tm_min, tm->tm_hour,
tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
/* hours, minutes and seconds */
buf[PCF8563_REG_SC] = bin2bcd(tm->tm_sec);
buf[PCF8563_REG_MN] = bin2bcd(tm->tm_min);
buf[PCF8563_REG_HR] = bin2bcd(tm->tm_hour);
buf[PCF8563_REG_DM] = bin2bcd(tm->tm_mday);
/* month, 1 - 12 */
buf[PCF8563_REG_MO] = bin2bcd(tm->tm_mon + 1);
/* year and century */
buf[PCF8563_REG_YR] = bin2bcd(tm->tm_year % 100);
if (pcf8563->c_polarity ? (tm->tm_year >= 100) : (tm->tm_year < 100))
buf[PCF8563_REG_MO] |= PCF8563_MO_C;
buf[PCF8563_REG_DW] = tm->tm_wday & 0x07;
/* write register's data */
for (i = 0; i < 7; i++) {
unsigned char data[2] = { PCF8563_REG_SC + i,
buf[PCF8563_REG_SC + i] };
err = i2c_master_send(client, data, sizeof(data));
if (err != sizeof(data)) {
dev_err(&client->dev,
"%s: err=%d addr=%02x, data=https://www.it610.com/article/%02x/n",
__func__, err, data[0], data[1]);
return -EIO;
}
};
return 0;
}
class.c：
接下来讲述最重要的rtc注册函数rtc_device_register，在class.c中：
struct rtc_device *rtc_device_register(const char *name, struct device *dev,
const struct rtc_class_ops *ops,
struct module *owner)
{
struct rtc_device *rtc;
struct rtc_wkalrm alrm;
int id, err;
if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) {
err = -ENOMEM;
goto exit;
}
mutex_lock(&idr_lock);
err = idr_get_new(&rtc_idr, NULL, &id);
mutex_unlock(&idr_lock);
if (err < 0)
goto exit;
id = id & MAX_ID_MASK;
rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL); //申请rtc_device结构体
if (rtc == NULL) {
err = -ENOMEM;
goto exit_idr;
}
rtc->id = id;
rtc->ops = ops;
rtc->owner = owner;
rtc->irq_freq = 1;
rtc->max_user_freq = 64;
rtc->dev.parent = dev;
rtc->dev.class = rtc_class;
rtc->dev.release = rtc_device_release; //rtc释放函数，在后面讲述
mutex_init(&rtc->ops_lock);
spin_lock_init(&rtc->irq_lock);
spin_lock_init(&rtc->irq_task_lock);
init_waitqueue_head(&rtc->irq_queue);
/* Init timerqueue */
timerqueue_init_head(&rtc->timerqueue);
INIT_WORK(&rtc->irqwork, rtc_timer_do_work);
/* Init aie timer */
rtc_timer_init(&rtc->aie_timer, rtc_aie_update_irq, (void *)rtc);
/* Init uie timer */
rtc_timer_init(&rtc->uie_rtctimer, rtc_uie_update_irq, (void *)rtc);
/* Init pie timer */
hrtimer_init(&rtc->pie_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
rtc->pie_timer.function = rtc_pie_update_irq;
rtc->pie_enabled = 0;
/* Check to see if there is an ALARM already set in hw */
err = __rtc_read_alarm(rtc, &alrm);
if (!err && !rtc_valid_tm(&alrm.time))
rtc_initialize_alarm(rtc, &alrm);
strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE);
dev_set_name(&rtc->dev, "rtc%d", id);
rtc_dev_prepare(rtc); //rtc-dev.c中的设备结构初始化，第二部分讲述
err = device_register(&rtc->dev);
if (err) {
put_device(&rtc->dev);
goto exit_kfree;
}
rtc_dev_add_device(rtc); //rtc-dev.c中的增加设备，第二部分讲述
rtc_sysfs_add_device(rtc); //rtc-sysfs.c中创建/sys文件，第三部分讲述
rtc_proc_add_device(rtc); //rtc-proc.c中的增加proc，第三部分讲述
dev_info(dev, "rtc core: registered %s as %s\n",
rtc->name, dev_name(&rtc->dev));
return rtc;
exit_kfree:
kfree(rtc);
exit_idr:
mutex_lock(&idr_lock);
idr_remove(&rtc_idr, id);
mutex_unlock(&idr_lock);
exit:
dev_err(dev, "rtc core: unable to register %s, err = %d\n",
name, err);
return ERR_PTR(err);
}
（1）处理一个idr结构，idr在linux内核中指的就是整数ID管理机制，从本质上来说，idr是一种将整数ID号和特定指针关联在一起的机制。这个机制最早是在2003年2月加入内核的，当时是作为POSIX定时器的一个补丁。现在在内核的很多地方都可以找到idr的身影。这里从内核中获取一个idr结构，并与id相关联。
（2）分配了一个rtc_device的结构--rtc，并且初始化了相关的成员：id, rtc_class_ops等等。
（3）首先调用rtc_dev_prepare（在rtc-dev.c中定义）。因为RTC设备本质来讲还是字符设备，所以这里初始化了字符设备相关的结构：设备号以及文件操作。然后调用device_register将设备注册到linux设备模型核心。这样在模块加载的时候，udev daemon就会自动为我们创建设备文件rtc(n)。
（4）先后调用rtc_dev_add_device，rtc_sysfs_add_device，rtc_proc_add_device三个函数。 rtc_dev_add_device注册字符设备，rtc_sysfs_add_device只是为设备添加了一个闹钟属性，rtc_proc_add_device 创建proc文件系统接口。
void rtc_dev_add_device(struct rtc_device *rtc)
{
if (cdev_add(&rtc->char_dev, rtc->dev.devt, 1))
printk(KERN_WARNING "%s: failed to add char device %d:%d\n",
rtc->name, MAJOR(rtc_devt), rtc->id);
else
pr_debug("%s: dev (%d:%d)\n", rtc->name,
MAJOR(rtc_devt), rtc->id);
}
void rtc_sysfs_add_device(struct rtc_device *rtc)
{
int err;
/* not all RTCs support both alarms and wakeup */
if (!rtc_does_wakealarm(rtc))
return;
err = device_create_file(&rtc->dev, &dev_attr_wakealarm);
if (err)
dev_err(rtc->dev.parent,
"failed to create alarm attribute, %d\n", err);
}
初始化函数rtc_init()为：
static int __init rtc_init(void)
{
rtc_class = class_create(THIS_MODULE, "rtc"); //创建rtc设备类
if (IS_ERR(rtc_class)) {
printk(KERN_ERR "%s: couldn't create class\n", __FILE__);
return PTR_ERR(rtc_class);
}
rtc_class->suspend = rtc_suspend; //挂起函数，后面讲述
rtc_class->resume = rtc_resume; //恢复函数，后面讲述
rtc_dev_init(); //分配设备号，rtc-dev.c，后面讲述
rtc_sysfs_init(rtc_class); //创建sys,rtc-sysfs.c后面讲述
return 0;
}
rtc_init 首先调用class_create创建了一个类--rtc。我们知道类是一个设备的高层视图，他抽象出了底层的实现细节。类的作用就是向用户空间提供设备的信息，驱动程序不需要直接处理类。然后初始化类结构的相应成员，rtc_suspend，rtc_resume这两个函数也是在class.c中实现的。接下来调用rtc_dev_init()，这个函数为RTC设备动态分配设备号，保存在rtc_devt中。最后调用 rtc_sysfs_init，初始化rtc_class的属性。
subsys_initcall(rtc_init);
由subsys_initcall(rtc_init); 知道，此函数在系统开始运行的时候即被执行。
static int rtc_suspend(struct device *dev, pm_message_t mesg)
{
struct rtc_device*rtc = to_rtc_device(dev);
struct rtc_timetm;
if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
return 0;
rtc_read_time(rtc, &tm);
ktime_get_ts(&oldts);
rtc_tm_to_time(&tm, &oldtime);
return 0;
}
static int rtc_resume(struct device *dev)
{
struct rtc_device*rtc = to_rtc_device(dev);
struct rtc_timetm;
time_tnewtime;
struct timespectime;
struct timespecnewts;
if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
return 0;
ktime_get_ts(&newts);
rtc_read_time(rtc, &tm);
if (rtc_valid_tm(&tm) != 0) {
pr_debug("%s:bogus resume time\n", dev_name(&rtc->dev));
return 0;
}
rtc_tm_to_time(&tm, &newtime);
if (newtime <= oldtime) {
if (newtime < oldtime)
pr_debug("%s:time travel!\n", dev_name(&rtc->dev));
return 0;
}
/* calculate the RTC time delta */
set_normalized_timespec(&time, newtime - oldtime, 0);
/* subtract kernel time between rtc_suspend to rtc_resume */
time = timespec_sub(time, timespec_sub(newts, oldts));
timekeeping_inject_sleeptime(&time);
return 0;
}
void __init rtc_dev_init(void)
{
int err;
err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc");
if (err < 0)
printk(KERN_ERR "%s: failed to allocate char dev region\n",
__FILE__);
}
在rtc_device_register函数中有一个rtc释放函数rtc_device_release：
static void rtc_device_release(struct device *dev)
{
struct rtc_device *rtc = to_rtc_device(dev);
mutex_lock(&idr_lock);
idr_remove(&rtc_idr, rtc->id);
mutex_unlock(&idr_lock);
kfree(rtc);
}
退出函数：
static void __exit rtc_exit(void)
{
rtc_dev_exit();
class_destroy(rtc_class);
idr_destroy(&rtc_idr);
}
module_exit(rtc_exit);

    推荐阅读


    上一篇：android-基础知识（实现简单的拨打电话功能_intent_study）

    下一篇：单向链表增删改查的实现