Linux驱动编程 - RTC子系统

目录

简介：

一、代码分析

1、RTC子系统初始化

2、注册RTC设备驱动

[2.1 rtc_dev_prepare(rtc)](#2.1 rtc_dev_prepare(rtc))

3、总结

[二、ds1302 驱动分析](#二、ds1302 驱动分析)

三、rtc设置和测试工具

1、date读/写系统时间

2、hwclock读/写RTC

---

简介：

---

Linux中RTC设备驱动是一个标准的字符设备驱动，应用程序通过 open、 release、 read、 write 和 ioctl 等函数完成对 RTC 设备的操作。

rtc子系统分为三部分：

• rtc core：负责rtc设备注册注销；对用户空间提供rtc字符设备文件，以及rtc类sysfs接口；
• rtc driver：将rtc设备注册到rtc子系统，提供针对rtc设备的底层操作函数集；
• 用户空间sysfs节点：/dev/rtcX字符设备文件，以及其他调试接口；

图中，RTC Core已经在kernel中实现了，它初始化RTC子系统并向用户空间提供 file_operations 操作集（open、 read、 write 和 ioctl 等）。我们只需实现 RTC Driver(RTC 设备驱动) 和 设备树中对RTC的配置，RTC Driver中实现对RTC芯片的底层操作集。

一、代码分析

---

Linux 内核将 RTC 设备抽象为 rtc_device 结构体，因此 RTC 设备驱动就是申请并初始化 rtc_device，最后将 rtc_device 注册到 Linux 内核里面。

/* 路径：include/linux/rtc.h */
struct rtc_device
{
	struct device dev;
	struct module *owner;

	int id;                            //当前rtc设备在rtc子系统的子序号
	char name[RTC_DEVICE_NAME_SIZE];

	const struct rtc_class_ops *ops;
	struct mutex ops_lock;

	struct cdev char_dev;             //rtc设备对应的字符设备
	unsigned long flags;

	unsigned long irq_data;
	spinlock_t irq_lock;
	wait_queue_head_t irq_queue;       //和用户空间同步的poll调用所使用的等待队列，由中断唤醒
	struct fasync_struct *async_queue; //和用户空间同步基于文件的fasync调用，由中断触发

	struct rtc_task *irq_task;
	spinlock_t irq_task_lock;
	int irq_freq;
	int max_user_freq;

	struct timerqueue_head timerqueue;
	struct rtc_timer aie_timer;
	struct rtc_timer uie_rtctimer;
	struct hrtimer pie_timer; /* sub second exp, so needs hrtimer */
	int pie_enabled;
	struct work_struct irqwork;
	/* Some hardware can't support UIE mode */
	int uie_unsupported;

#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
	struct work_struct uie_task;
	struct timer_list uie_timer;
	/* Those fields are protected by rtc->irq_lock */
	unsigned int oldsecs;
	unsigned int uie_irq_active:1;
	unsigned int stop_uie_polling:1;
	unsigned int uie_task_active:1;
	unsigned int uie_timer_active:1;
#endif
};

重点关注 struct rtc_class_ops *ops 成员变量，rtc_class_ops 为 RTC 设备的最底层操作函数集合，包括从 RTC 设备中读取时间、向 RTC 设备写入新的时间等。因此，rtc_class_ops 操作集需要用户根据所使用的 RTC 设备自己实现。

/* 路径：include/linux/rtc.h */
struct rtc_class_ops {
	int (*open)(struct device *);
	void (*release)(struct device *);
	int (*ioctl)(struct device *, unsigned int, unsigned long);
	int (*read_time)(struct device *, struct rtc_time *);
	int (*set_time)(struct device *, struct rtc_time *);
	int (*read_alarm)(struct device *, struct rtc_wkalrm *);
	int (*set_alarm)(struct device *, struct rtc_wkalrm *);
	int (*proc)(struct device *, struct seq_file *);
	int (*set_mmss64)(struct device *, time64_t secs);
	int (*set_mmss)(struct device *, unsigned long secs);
	int (*read_callback)(struct device *, int data);
	int (*alarm_irq_enable)(struct device *, unsigned int enabled);
};

注意：rtc_class_ops 中的这些函数只是最底层对 RTC 设备的操作函数，并不是提供给应用层的file_operations 函数操作集。Linux 内核提供了一个 RTC 通用字符设备驱动文件 drivers/rtc/rtc-dev.c，rtc-dev.c 文件提供了所有 RTC 设备共用的 file_operations 函数操作集。

1、RTC子系统初始化

---

drivers/rtc/class.c 中运行 rtc_init() 函数，实现对RTC子系统的初始化。此部分Linux已经做好了，不需要我们实现。

/* linux/drivers/rtc/class.c */
static int __init rtc_init(void)
{
	rtc_class = class_create(THIS_MODULE, "rtc");
	if (IS_ERR(rtc_class)) {
		pr_err("couldn't create class\n");
		return PTR_ERR(rtc_class);
	}
	rtc_class->pm = RTC_CLASS_DEV_PM_OPS;
	rtc_dev_init();
	return 0;
}
subsys_initcall(rtc_init);

RTC子系统初始化，主要分配rtc_class类，以及rtc设备的rtc_devt。alloc_chrdev_region 用来动态分配号，调用过程如下：

rtc_init
--->class_create(THIS_MODULE, "rtc")         //创建rtc_class类
--->rtc_dev_init()
--->--->alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc")    //为rtc设备分配子设备号范围0~15。主设备号随机分配。最终结果放入rtc_devt

2、注册RTC设备驱动

---

devm_rtc_device_register() 函数用来注册RTC设备驱动。编写RTC设备驱动时，我们需要先实现 struct rtc_class_ops 结构体，它是对RTC设备最底层的操作函数集合。然后调用 devm_rtc_device_register() 将 rtc_class_ops 注册到内核中。

/* linux/drivers/rtc/class.c */
/*
参数：
    dev： 设备
    name：设备名字
    ops： RTC 底层驱动函数集
    owner：驱动模块拥有者
*/
struct rtc_device *devm_rtc_device_register(struct device *dev,
					    const char *name,
					    const struct rtc_class_ops *ops,
					    struct module *owner)
{
	struct rtc_device *rtc;
	int err;

	rtc = devm_rtc_allocate_device(dev);    //分配 struct rtc_device 结构
	if (IS_ERR(rtc))
		return rtc;

	rtc->ops = ops;        //设置 rtc_class_ops 底层操作

	err = __rtc_register_device(owner, rtc);    //注册rtc设备
	if (err)
		return ERR_PTR(err);

	return rtc;
}

rtc->ops = ops 设置 rtc_class_ops 底层操作集。主要分析下 __rtc_register_device()

int __rtc_register_device(struct module *owner, struct rtc_device *rtc)
{
    /* ... ... */
    dev_set_name(&rtc->dev, "rtc%d", id);    //设置device名字

	rtc_dev_prepare(rtc);					//初始化cdev结构体，file_operations

	err = cdev_device_add(&rtc->char_dev, &rtc->dev);	//添加设备到内核 cdev_add、device_add 注册设备
	/* ... ... */

	rtc_proc_add_device(rtc);

    /* ... ... */

#ifdef CONFIG_RTC_HCTOSYS_DEVICE
	if (!strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE))
		rtc_hctosys();
#endif

	return 0;
}

rtc_dev_prepare(rtc) 和 cdev_device_add 其实就是实现字符设备那套固定流程，初始化cdev并添加到kernel，注册device等。

2.1 rtc_dev_prepare(rtc)

rtc_dev_prepare先分配设备号，调用cdev_init初始化cdev并添加file_operations操作集。file_operations 操作集提供给应用层调用：

/* 路径：linux/drivers/rtc/dev.c */
static const struct file_operations rtc_dev_fops = {
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.read		= rtc_dev_read,
	.poll		= rtc_dev_poll,
	.unlocked_ioctl	= rtc_dev_ioctl,
	.open		= rtc_dev_open,
	.release	= rtc_dev_release,
	.fasync		= rtc_dev_fasync,
};

/* insertion/removal hooks */

void rtc_dev_prepare(struct rtc_device *rtc)
{
	if (!rtc_devt)
		return;

	if (rtc->id >= RTC_DEV_MAX) {
		dev_dbg(&rtc->dev, "too many RTC devices\n");
		return;
	}

	rtc->dev.devt = MKDEV(MAJOR(rtc_devt), rtc->id);

#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
	INIT_WORK(&rtc->uie_task, rtc_uie_task);
	timer_setup(&rtc->uie_timer, rtc_uie_timer, 0);
#endif

	cdev_init(&rtc->char_dev, &rtc_dev_fops);
	rtc->char_dev.owner = rtc->owner;
}

应用程序可以通过 ioctl 函数来设置/读取时间、设置/读取闹钟等操作，那么对应的 rtc_dev_ioctl 函数就会执行， rtc_dev_ioctl 最终会通过操作 rtc_class_ops 底层操作集中的 read_time、 set_time 等函数来对具体 RTC 设备的读写操作。

/* linux/drivers/rtc/dev.c */
static long rtc_dev_ioctl(struct file *file,
			  unsigned int cmd, unsigned long arg)
{
	/* ... ... */
	case RTC_RD_TIME:
		mutex_unlock(&rtc->ops_lock);

		err = rtc_read_time(rtc, &tm);    //最终会调用 rtc->ops->read_time
		if (err < 0)
			return err;

		if (copy_to_user(uarg, &tm, sizeof(tm)))
			err = -EFAULT;
		return err;

	case RTC_SET_TIME:
		mutex_unlock(&rtc->ops_lock);

		if (copy_from_user(&tm, uarg, sizeof(tm)))
			return -EFAULT;

		return rtc_set_time(rtc, &tm);
    /* ... ... */
}

以读RTC为例，rtc_read_time会调用到 __rtc_read_time()

/* 路径：linux/drivers/rtc/interface.c */
static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
{
	... ...
    /* devm_rtc_device_register() 中将 rtc->ops 赋值为我们实现的 rtc_class_ops */
	err = rtc->ops->read_time(rtc->dev.parent, tm);
	... ...
}

__rtc_read_time 函数会通过调用 rtc_class_ops 中的read_time 来从 RTC 设备中获取当前时间。 rtc_dev_ioctl 函数对其他的命令处理都是类似的。

3、结论

3.1 编写RTC驱动时，我们只用实现 rtc_class_ops ，然后调用devm_rtc_device_register() 将其注册到 Linux 内核中即可

3.2 Linux 内核中 RTC 驱动调用流程如图

注意，系统启动时注册RTC设备调用 rtc_hctosys，会将RTC时间设置到系统时间：

rtc_hctosys
--->rtc_read_time
--->rtc_tm_to_time64
--->do_settimeofday64

二、ds1302 驱动分析

---

Linux中自带的linux/drivers/rtc/rtc-ds1302.c驱动代码如下：

#include <linux/bcd.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/rtc.h>
#include <linux/spi/spi.h>

#define DRV_NAME	"rtc-ds1302"

#define	RTC_CMD_READ	0x81		/* Read command */
#define	RTC_CMD_WRITE	0x80		/* Write command */

#define	RTC_CMD_WRITE_ENABLE	0x00		/* Write enable */
#define	RTC_CMD_WRITE_DISABLE	0x80		/* Write disable */

#define RTC_ADDR_RAM0	0x20		/* Address of RAM0 */
#define RTC_ADDR_TCR	0x08		/* Address of trickle charge register */
#define RTC_CLCK_BURST	0x1F		/* Address of clock burst */
#define	RTC_CLCK_LEN	0x08		/* Size of clock burst */
#define	RTC_ADDR_CTRL	0x07		/* Address of control register */
#define	RTC_ADDR_YEAR	0x06		/* Address of year register */
#define	RTC_ADDR_DAY	0x05		/* Address of day of week register */
#define	RTC_ADDR_MON	0x04		/* Address of month register */
#define	RTC_ADDR_DATE	0x03		/* Address of day of month register */
#define	RTC_ADDR_HOUR	0x02		/* Address of hour register */
#define	RTC_ADDR_MIN	0x01		/* Address of minute register */
#define	RTC_ADDR_SEC	0x00		/* Address of second register */

static int ds1302_rtc_set_time(struct device *dev, struct rtc_time *time)
{
	struct spi_device	*spi = dev_get_drvdata(dev);
	u8		buf[1 + RTC_CLCK_LEN];
	u8		*bp;
	int		status;

	/* spi将时间写入ds1302 */
	/* Enable writing */
	bp = buf;
	*bp++ = RTC_ADDR_CTRL << 1 | RTC_CMD_WRITE;
	*bp++ = RTC_CMD_WRITE_ENABLE;

	status = spi_write_then_read(spi, buf, 2,
			NULL, 0);
	if (status)
		return status;

	/* Write registers starting at the first time/date address. */
	bp = buf;
	*bp++ = RTC_CLCK_BURST << 1 | RTC_CMD_WRITE;

	*bp++ = bin2bcd(time->tm_sec);
	*bp++ = bin2bcd(time->tm_min);
	*bp++ = bin2bcd(time->tm_hour);
	*bp++ = bin2bcd(time->tm_mday);
	*bp++ = bin2bcd(time->tm_mon + 1);
	*bp++ = time->tm_wday + 1;
	*bp++ = bin2bcd(time->tm_year % 100);
	*bp++ = RTC_CMD_WRITE_DISABLE;

	/* use write-then-read since dma from stack is nonportable */
	return spi_write_then_read(spi, buf, sizeof(buf),
			NULL, 0);
}

static int ds1302_rtc_get_time(struct device *dev, struct rtc_time *time)
{
	struct spi_device	*spi = dev_get_drvdata(dev);
	u8		addr = RTC_CLCK_BURST << 1 | RTC_CMD_READ;
	u8		buf[RTC_CLCK_LEN - 1];
	int		status;

	/* spi从ds1302读取时间数据 */
	status = spi_write_then_read(spi, &addr, sizeof(addr),
			buf, sizeof(buf));
	if (status < 0)
		return status;

	/* Decode the registers */
	time->tm_sec = bcd2bin(buf[RTC_ADDR_SEC]);
	time->tm_min = bcd2bin(buf[RTC_ADDR_MIN]);
	time->tm_hour = bcd2bin(buf[RTC_ADDR_HOUR]);
	time->tm_wday = buf[RTC_ADDR_DAY] - 1;
	time->tm_mday = bcd2bin(buf[RTC_ADDR_DATE]);
	time->tm_mon = bcd2bin(buf[RTC_ADDR_MON]) - 1;
	time->tm_year = bcd2bin(buf[RTC_ADDR_YEAR]) + 100;

	return 0;
}

static const struct rtc_class_ops ds1302_rtc_ops = {
	.read_time	= ds1302_rtc_get_time,
	.set_time	= ds1302_rtc_set_time,
};

static int ds1302_probe(struct spi_device *spi)
{
	struct rtc_device	*rtc;
	u8		addr;
	u8		buf[4];
	u8		*bp;
	int		status;

	/* spi初始化ds1302 */
	... ...

	spi_set_drvdata(spi, spi);

	rtc = devm_rtc_device_register(&spi->dev, "ds1302",
			&ds1302_rtc_ops, THIS_MODULE);
	if (IS_ERR(rtc)) {
		status = PTR_ERR(rtc);
		dev_err(&spi->dev, "error %d registering rtc\n", status);
		return status;
	}

	return 0;
}

static int ds1302_remove(struct spi_device *spi)
{
	spi_set_drvdata(spi, NULL);
	return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id ds1302_dt_ids[] = {
	{ .compatible = "maxim,ds1302", },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, ds1302_dt_ids);
#endif

static struct spi_driver ds1302_driver = {
	.driver.name	= "rtc-ds1302",
	.driver.of_match_table = of_match_ptr(ds1302_dt_ids),
	.probe		= ds1302_probe,
	.remove		= ds1302_remove,
};

module_spi_driver(ds1302_driver);

MODULE_DESCRIPTION("Dallas DS1302 RTC driver");
MODULE_AUTHOR("Paul Mundt, David McCullough");
MODULE_LICENSE("GPL v2");

rtc_class_ops结构体中实现了 ds1302_rtc_get_time 和 ds1302_rtc_set_time 分别读取/设置时间。读取/设置时间就是通过spi总线读写ds1302的寄存器。最终，ds1302_probe() 函数调用 devm_rtc_device_register() 将 rtc_class_ops 注册到RTC子系统中。我们可以参照此代码来添加自己的RTC设备驱动。

三、rtc设置和测试工具

---

1、date读/写系统时间

$ date -s "2024-10-14 10:10:10" #设置当前系统时间

" date -s"命令仅仅是将当前系统时间设置了，此时间还没有写入到RTC设备中

2、hwclock读/写RTC

$ hwclock -w #将当前系统时间设置到RTC硬件中。

$ hwclock -r #读取当前RTC硬件时间

$ hwclock -s #将RTC时间设置到系统时间。

如果要设置RTC时间，先通过date设置系统时间，然后通过hwclock将系统时间设置到rtc硬件中。

$ date -s "2024-10-14 10:10:10"

$ hwclock -s

---