<Linux开发>驱动开发 -之- Linux RTC 驱动

news2024/10/7 2:27:28

<Linux开发>驱动开发 -之- Linux RTC 驱动

交叉编译环境搭建:
<Linux开发> linux开发工具-之-交叉编译环境搭建

uboot移植可参考以下:
<Linux开发> -之-系统移植 uboot移植过程详细记录(第一部分)
<Linux开发> -之-系统移植 uboot移植过程详细记录(第二部分)
<Linux开发> -之-系统移植 uboot移植过程详细记录(第三部分)(uboot移植完结)

Linux内核及设备树移植可参考以下:
<Linux开发>系统移植 -之- linux内核移植过程详细记录(第一部分)
<Linux开发>系统移植 -之- linux内核移植过程详细记录(第二部分完结)

Linux文件系统构建移植参考以下:
<Linux开发>系统移植 -之- linux构建BusyBox根文件系统及移植过程详细记录
<Linux开发>系统移植 -之-使用buildroot构建BusyBox根文件系统

Linux驱动开发参考以下:
<Linux开发>驱动开发 -之-pinctrl子系统
<Linux开发>驱动开发 -之-gpio子系统
<Linux开发>驱动开发 -之-基于pinctrl/gpio子系统的LED驱动
<Linux开发>驱动开发 -之-基于pinctrl/gpio子系统的beep驱动
<Linux开发>驱动开发 -之-资源的并发与竞争处理
<Linux开发>驱动开发 -之-内核定时器与中断
<Linux开发>驱动开发 -之-阻塞、非阻塞IO和异步通知
<Linux开发>驱动开发 -之-Linux MISC 驱动
<Linux开发>驱动开发 -之-Linux INPUT 子系统
<Linux开发>驱动开发 -之- Linux LCD 驱动

一 前言

本文主要分析Linux系统下的RTC,也就是实时时钟,RTC时钟是用来记录当前系统时间的;对于Linux系统来说,时间是一个非常重要的功能;比如我们的windows/linux电脑,会需要时间,还比如 我们的手机、平板,都需要时间;而且在很多app 或功能内都需要与时间打交道如导航等。本文就来分析一下linux系统下的RTC时钟。

二 Linux内核RTC驱动

2.1 Linux内核RTC设备结构体rtc_device

对于RTC设备来说,RTC设备驱动也是一个标准的字符设备驱动。字符设备驱动我们在前面其它文章也介绍过了。通常情况下,应用程序可以通过系统调用函数 open、release、read、write和ioctl等函数完成对设备驱动的调用而操作设备。

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

至于 RTC 设备的操作肯定是用一个操作集合(结构体)来表示的,我们先来看一下 rtc_device 结构体,此结构体定义在 include/linux/rtc.h 文件中,结构体内容如下:

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

	int id;					/* ID */
	char name[RTC_DEVICE_NAME_SIZE];	/* 名字 */

	const struct rtc_class_ops *ops;		/* RTC 设备底层操作函数 */
	struct mutex ops_lock;

	struct cdev char_dev;				/* 字符设备 */
	unsigned long flags;

	unsigned long irq_data;
	spinlock_t irq_lock;
	wait_queue_head_t irq_queue;
	struct fasync_struct *async_queue;

	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
};

2.2 Linux内核RTC操作函数集rtc_class_ops

我们需要重点关注的是 ops 成员变量,这是一个 rtc_class_ops 类型的指针变量,rtc_class_ops为 RTC 设备的最底层操作函数集合,包括从 RTC 设备中读取时间、向 RTC 设备写入新的时间值等。因此,rtc_class_ops 是需要用户根据所使用的 RTC 设备编写的,此结构体定义在include/linux/rtc.h 文件中,内容如下:

路径: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_class_ops 中的这些函数只是最底层的 RTC 设备操作函数,并不是提供给应用层的file_operations 函数操作集。

2.3 Linux内核RTC驱动file_operations 操作函数集rtc_dev_fops

RTC 是个字符设备,那么肯定有字符设备的 file_operations 函数操作集,Linux 内核提供了一个 RTC 通用字符设备驱动文件,文件名为 drivers/rtc/rtc-dev.c,rtc-dev.c 文件提供了所有 RTC 设备共用的 file_operations 函数操作集,如下所示:

路径:drivers/rtc/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,
};

上述代码可以看出是标准的字符设备操作集。应用程序可以通过 ioctl 函数来设置/读取时间、设置/读取闹钟的操作,那么对应的 rtc_dev_ioctl 函数就会执行。

2.4 Linux内核RTC驱动rtc_dev_ioctl 操作函数

rtc_dev_ioctl 最终会通过操作 rtc_class_ops 中的 read_time、set_time 等函数来对具体 RTC 设备的读写操作。我们简单来看一下 rtc_dev_ioctl 函数,函数内容如下:

路径:drivers/rtc/rtc-dev.c
static long rtc_dev_ioctl(struct file *file,
		unsigned int cmd, unsigned long arg)
{
	int err = 0;
	struct rtc_device *rtc = file->private_data;
	const struct rtc_class_ops *ops = rtc->ops;
	struct rtc_time tm;
	struct rtc_wkalrm alarm;
	void __user *uarg = (void __user *) arg;

	err = mutex_lock_interruptible(&rtc->ops_lock);
	if (err)
		return err;

	/* check that the calling task has appropriate permissions
	 * for certain ioctls. doing this check here is useful
	 * to avoid duplicate code in each driver.
	 */
	switch (cmd) {
	case RTC_EPOCH_SET:
	case RTC_SET_TIME:
		if (!capable(CAP_SYS_TIME))
			err = -EACCES;
		break;

	case RTC_IRQP_SET:
		if (arg > rtc->max_user_freq && !capable(CAP_SYS_RESOURCE))
			err = -EACCES;
		break;

	case RTC_PIE_ON:
		if (rtc->irq_freq > rtc->max_user_freq &&
				!capable(CAP_SYS_RESOURCE))
			err = -EACCES;
		break;
	}

	if (err)
		goto done;

	/*
	 * Drivers *SHOULD NOT* provide ioctl implementations
	 * for these requests.  Instead, provide methods to
	 * support the following code, so that the RTC's main
	 * features are accessible without using ioctls.
	 *
	 * RTC and alarm times will be in UTC, by preference,
	 * but dual-booting with MS-Windows implies RTCs must
	 * use the local wall clock time.
	 */

	switch (cmd) {
	case RTC_ALM_READ:  /* 读取闹钟设定值 */
		mutex_unlock(&rtc->ops_lock);

		err = rtc_read_alarm(rtc, &alarm);
		if (err < 0)
			return err;

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

	case RTC_ALM_SET:			/* 设置闹钟 */
		mutex_unlock(&rtc->ops_lock);

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

		alarm.enabled = 0;
		alarm.pending = 0;
		alarm.time.tm_wday = -1;
		alarm.time.tm_yday = -1;
		alarm.time.tm_isdst = -1;

		/* RTC_ALM_SET alarms may be up to 24 hours in the future.
		 * Rather than expecting every RTC to implement "don't care"
		 * for day/month/year fields, just force the alarm to have
		 * the right values for those fields.
		 *
		 * RTC_WKALM_SET should be used instead.  Not only does it
		 * eliminate the need for a separate RTC_AIE_ON call, it
		 * doesn't have the "alarm 23:59:59 in the future" race.
		 *
		 * NOTE:  some legacy code may have used invalid fields as
		 * wildcards, exposing hardware "periodic alarm" capabilities.
		 * Not supported here.
		 */
		{
			time64_t now, then;

			err = rtc_read_time(rtc, &tm);
			if (err < 0)
				return err;
			now = rtc_tm_to_time64(&tm);

			alarm.time.tm_mday = tm.tm_mday;
			alarm.time.tm_mon = tm.tm_mon;
			alarm.time.tm_year = tm.tm_year;
			err  = rtc_valid_tm(&alarm.time);
			if (err < 0)
				return err;
			then = rtc_tm_to_time64(&alarm.time);

			/* alarm may need to wrap into tomorrow */
			if (then < now) {
				rtc_time64_to_tm(now + 24 * 60 * 60, &tm);
				alarm.time.tm_mday = tm.tm_mday;
				alarm.time.tm_mon = tm.tm_mon;
				alarm.time.tm_year = tm.tm_year;
			}
		}

		return rtc_set_alarm(rtc, &alarm);

	case RTC_RD_TIME:		/* 读取时间 */
		mutex_unlock(&rtc->ops_lock);

		err = rtc_read_time(rtc, &tm);
		if (err < 0)
			return err;

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

	case RTC_SET_TIME:		/* 设定RTC时间 */
		mutex_unlock(&rtc->ops_lock);

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

		return rtc_set_time(rtc, &tm);

	case RTC_PIE_ON:
		err = rtc_irq_set_state(rtc, NULL, 1);
		break;

	case RTC_PIE_OFF:
		err = rtc_irq_set_state(rtc, NULL, 0);
		break;

	case RTC_AIE_ON:
		mutex_unlock(&rtc->ops_lock);
		return rtc_alarm_irq_enable(rtc, 1);

	case RTC_AIE_OFF:
		mutex_unlock(&rtc->ops_lock);
		return rtc_alarm_irq_enable(rtc, 0);

	case RTC_UIE_ON:
		mutex_unlock(&rtc->ops_lock);
		return rtc_update_irq_enable(rtc, 1);

	case RTC_UIE_OFF:
		mutex_unlock(&rtc->ops_lock);
		return rtc_update_irq_enable(rtc, 0);

	case RTC_IRQP_SET:
		err = rtc_irq_set_freq(rtc, NULL, arg);
		break;

	case RTC_IRQP_READ:
		err = put_user(rtc->irq_freq, (unsigned long __user *)uarg);
		break;

	case RTC_WKALM_SET:
		mutex_unlock(&rtc->ops_lock);
		if (copy_from_user(&alarm, uarg, sizeof(alarm)))
			return -EFAULT;

		return rtc_set_alarm(rtc, &alarm);

	case RTC_WKALM_RD:
		mutex_unlock(&rtc->ops_lock);
		err = rtc_read_alarm(rtc, &alarm);
		if (err < 0)
			return err;

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

	default:
		/* Finally try the driver's ioctl interface */
		if (ops->ioctl) {
			err = ops->ioctl(rtc->dev.parent, cmd, arg);
			if (err == -ENOIOCTLCMD)
				err = -ENOTTY;
		} else
			err = -ENOTTY;
		break;
	}

done:
	mutex_unlock(&rtc->ops_lock);
	return err;
}

第 117行,RTC_RD_TIME 为时间读取命令。
第 120行,如果是读取时间命令的话就调用 rtc_read_time 函数获取当前 RTC 时钟,rtc_read_time 函数,rtc_read_time 会调用__rtc_read_time 函数,__rtc_read_time 函数内容如下:

rtc_read_time()->__rtc_read_time()

路径:drivers/rtc/interface.c
static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
{
	int err;
	if (!rtc->ops)
		err = -ENODEV;
	else if (!rtc->ops->read_time)
		err = -EINVAL;
	else {
		memset(tm, 0, sizeof(struct rtc_time));
		err = rtc->ops->read_time(rtc->dev.parent, tm);
		if (err < 0) {
			dev_dbg(&rtc->dev, "read_time: fail to read: %d\n",
				err);
			return err;
		}

		err = rtc_valid_tm(tm);
		if (err < 0)
			dev_dbg(&rtc->dev, "read_time: rtc_time isn't valid\n");
	}
	return err;
}

从上述代码33 行可以看出,__rtc_read_time 函数会通过调用 rtc_class_ops 中的
read_time 来从 RTC 设备中获取当前时间。rtc_dev_ioctl 函数对其他的命令处理都是类似的,比如 RTC_ALM_READ 命令会通过 rtc_read_alarm 函数获取到闹钟值,而 rtc_read_alarm 函数经过层层调用,最终会调用 rtc_class_ops 中的 read_alarm 函数来获取闹钟值。

2.5 Linux内核RTC驱动流程

Linux 内核中 RTC 驱动调用流程如下图所示:
在这里插入图片描述

当 rtc_class_ops 准备好以后需要将其注册到 Linux 内核中,这里我们可以使用rtc_device_register函数完成注册工作。此函数会申请一个rtc_device并且初始化这个rtc_device,最后向调用者返回这个 rtc_device,此函数原型如下:

struct rtc_device *rtc_device_register(const char *name, 
									 struct device *dev,
									 const struct rtc_class_ops *ops,
									 struct module *owner)

函数参数和返回值含义如下:
name:设备名字。
dev:设备。
ops:RTC 底层驱动函数集。
owner:驱动模块拥有者。
返回值:注册成功的话就返回 rtc_device,错误的话会返回一个负值。

当卸载 RTC 驱动的时候需要调用 rtc_device_unregister 函数来注销注册的 rtc_device,函数原型如下:

void rtc_device_unregister(struct rtc_device *rtc)

函数参数和返回值含义如下:
rtc:要删除的 rtc_device。
返回值:无。
还有另外一对 rtc_device 注册函数 devm_rtc_device_register 和 devm_rtc_device_unregister,分别为注册和注销 rtc_device。

三 I.MX6U RTC

3.1 I.MX6U RTC简介

如果学习过 STM32 的话应该知道,STM32 内部有一个 RTC 外设模块,这个模块需要一个32.768KHz 的晶振,对这个 RTC 模块进行初始化就可以得到一个实时时钟。I.MX6U 内部也有个 RTC 模块,但是不叫作“RTC”,而是叫做“SNVS”,这一点要注意!本章我们参考《I.MX6UL参考手册》,而不是《I.MX6ULL 参考手册》,因为《I.MX6ULL 参考手册》很多 SNVS 相关的寄存器并没有给出来,不知道是为何?但是《I.MX6UL 参考手册》里面是完整的。所以本章我们使用《I.MX6UL 参考手册》,如果直接在《I.MX6UL 参考手册》的书签里面找“RTC”相关的字眼是找不到的。I.MX6U 系列的 RTC 是在 SNVS 里面,也就是《I.MX6UL 参考手册》的第46 章“Chapter 46 Secure Non-Volatile Storage(SNVS)”。

SNVS 直译过来就是安全的非易性存储,SNVS 里面主要是一些低功耗的外设,包括一个安全的实时计数器(RTC)、一个单调计数器(monotonic counter)和一些通用的寄存器,本章我们肯定只使用实时计数器(RTC)。SNVS 里面的外设在芯片掉电以后由电池供电继续运行,I.MX6U 开发板上有一个纽扣电池,这个纽扣电池就是在主电源关闭以后为 SNVS 供电的。

因为纽扣电池在掉电以后会继续给 SNVS 供电,因此实时计数器就会一直运行,这样的话时间信息就不会丢失,除非纽扣电池没电了。在有纽扣电池作为后备电源的情况下,不管系统主电源是否断电,SNVS 都正常运行。SNVS 有两部分:SNVS_HP 和 SNVS_LP,系统主电源断电以后 SNVS_HP 也会断电,但是在后备电源支持下,SNVS_LP 是不会断电的,而且 SNVS_LP是和芯片复位隔离开的,因此 SNVS_LP 相关的寄存器的值会一直保存着。

SNVS 分为两个子模块:SNVS_HP 和 SNVS_LP,也就是高功耗域(SNVS_HP)和低功耗域(SNVS_LP),这两个域的电源来源如下:
SNVS_LP:专用的 always-powered-on 电源域,系统主电源和备用电源都可以为其供电。
SNVS_HP:系统(芯片)电源。
SNVS 的这两个子模块的电源如下图所示:
在这里插入图片描述
图 3.1

图 25.1.2 中各个部分功能如下:
①、VDD_HIGH_IN 是系统(芯片)主电源,这个电源会同时供给给 SNVS_HP 和 SNVS_LP。
②、VDD_SNVS_IN 是纽扣电池供电的电源,这个电源只会供给给 SNVS_LP,保证在系
统主电源 VDD_HIGH_IN 掉电以后 SNVS_LP 会继续运行。
③、SNVS_HP 部分。
④、SNVS_LP 部分,此部分有个 SRTC,这个就是我们本章要使用的 RTC。

其实不管是 SNVS_HP 还是 SNVS_LP,其内部都有一个 SRTC,但是因为SNVS_HP 在系统电源掉电以后就会关闭,所以我们本章使用的是 SNVS_LP 内部的 SRTC。毕竟我们肯定都不想开发板或者设备每次关闭以后时钟都被清零,然后开机以后先设置时钟。

其实不管是 SNVS_HP 里面的 RTC,还是 SNVS_LP 里面的 SRTC,其本质就是一个定时器,和 EPIT 定时器一样,只要给它提供时钟,它就会一直运行。SRTC 需要外界提供一个 32.768KHz 的时钟,I.MX6U核心板上的 32.768KHz 的晶振就是提供这个时钟的。寄存器 SNVS_LPSRTCMR 和 SNVS_LPSRTCLR 保存着秒数,直接读取这两个寄存器的值就知道过了多长时间了。一般以 1970 年 1 月 1 日为起点,加上经过的秒数即可得到现在的时间和日期,原理还是很简单的。SRTC 也是带有闹钟功能的,可以在寄存器 SNVS_LPAR 中写入闹钟时间值,当时钟值和闹钟值匹配的时候就会产生闹钟中断,要使用时钟功能的话还需要进行一些设置。

3.2 I.MX6U SNVS_HPCOMR 寄存器

接下来我们看一下本章要用到的与 SRTC 相关的部分寄存器,首先是 SNVS_HPCOMR 寄存器,这个寄存器我们只用到了位:NPSWA_EN(bit31),这个位是非特权软件访问控制位,如果非特权软件要访问 SNVS 的话此位必须为 1。
在这里插入图片描述
图 3.2

3.3 I.MX6U SNVS_LPCR 寄存器

接下来看一下寄存器SNVS_LPCR寄存器,此寄存器也只用到了一个位:SRTC_ENV(bit0),此位为 1 的话就使能 STC 计数器。
在这里插入图片描述
在这里插入图片描述

3.4 I.MX6U SNVS_SRTCMR和SNVS_SRTCLR 寄存器

最后来看一下寄存器 SNVS_SRTCMR 和 SNVS_SRTCLR,这两个寄存器保存着 RTC 的秒数,按照NXP官方的《IMX6UL参考手册》中的说法,SNVS_SRTCMR保存着高15位,SNVS_SRTCLR保存着低 32 位,因此 SRTC 的计数器一共是 47 位。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

:::注意:::查找 NXP 提供的 SDK 包中的 fsl_snvs_hp.c 以及 Linux 内核中的 rtc-snvs.c 这两个驱动文件以后发现《IMX6UL 参考手册》上对 SNVS_SRTCMR 和 SNVS_SRTCLR 的
解释是错误的,经过查阅这两个文件,得到如下结论:
①、SRTC 计数器是 32 位的,不是 47 位!
②、SNVS_SRTCMR 的 bit14:0 这 15 位是 SRTC 计数器的高 15 位。
③、SNVS_SRTCLR 的 bit31:bit15 这 17 位是 SRTC 计数器的低 17 位。
按照上面的解释去读取这两个寄存器就可以得到正确的时间,如果要调整时间的话也是向这两个寄存器写入要设置的时间值对应的秒数就可以了,但是要修改这两个寄存器的话要先关闭 SRTC。

3.4 I.MX6U RTC使用

根据手册说明,使用 I.MX6U 的 SNVS_LP 的 SRTC,配置步骤如下:
1、初始化 SNVS_SRTC
初始化 SNVS_LP 中的 SRTC。
2、设置 RTC 时间
第一次使用 RTC 肯定要先设置时间。
3、使能 RTC
配置好 RTC 并设置好初始时间以后就可以开启 RTC 了。

四 官方I.MX6U Linux RTC驱动

I.MX6U 的 RTC 驱动我们不用自己编写,因为 NXP 已经写好了。其实对于大多数的 SOC 来讲,内部 RTC 驱动都不需要我们去编写,半导体厂商会编写好。但是这不代表我们就偷懒了,虽然不用编写 RTC 驱动,但是我们得看一下这些原厂是怎么编写 RTC 驱动的。

4.1 官方I.MX6U RTC设备树

分析驱动,先从设备树入手,打开 imx6ull.dtsi,在里面找到如下 snvs_rtc 设备节点,节点内容如下所示:

路径:arch/arm/boot/dts/imx6ull.dtsi
snvs_rtc: snvs-rtc-lp {
					compatible = "fsl,sec-v4.0-mon-rtc-lp";
					regmap = <&snvs>;
					offset = <0x34>;
					interrupts = <GIC_SPI 19 IRQ_TYPE_LEVEL_HIGH>, <GIC_SPI 20 IRQ_TYPE_LEVEL_HIGH>;
				};

第 3 行设置兼容属性 compatible 的值为“fsl,sec-v4.0-mon-rtc-lp”,因此在 Linux 内核源码中搜索此字符串即可找到对应的驱动文件。

4.2 官方I.MX6U RTC设备驱动

属性 compatible搜索后可找到如下内容:

路径:drivers/rtc/rtc-snvs.c
static const struct of_device_id snvs_dt_ids[] = {
	{ .compatible = "fsl,sec-v4.0-mon-rtc-lp", },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, snvs_dt_ids);

static struct platform_driver snvs_rtc_driver = {
	.driver = {
		.name	= "snvs_rtc",
		.pm	= SNVS_RTC_PM_OPS,
		.of_match_table = snvs_dt_ids,
	},
	.probe		= snvs_rtc_probe,
};
module_platform_driver(snvs_rtc_driver);

第 1~4行,设备树 ID 表,有一条 compatible 属性,值为“fsl,sec-v4.0-mon-rtc-lp”,因此 imx6ull.dtsi 中的 snvs_rtc 设备节点会和此驱动匹配。

第 7~14行,标准的 platform 驱动框架,当设备和驱动匹配成功以后 snvs_rtc_probe 函数就会执行。

我们来看一下 snvs_rtc_probe 函数,函数内容如下:

路径:drivers/rtc/rtc-snvs.c
static int snvs_rtc_probe(struct platform_device *pdev)
{
	struct snvs_rtc_data *data;
	struct resource *res;
	int ret;
	void __iomem *mmio;

	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->regmap = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "regmap");

	if (IS_ERR(data->regmap)) {
		dev_warn(&pdev->dev, "snvs rtc: you use old dts file, please update it\n");
		res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

		mmio = devm_ioremap_resource(&pdev->dev, res);
		if (IS_ERR(mmio))
			return PTR_ERR(mmio);

		data->regmap = devm_regmap_init_mmio(&pdev->dev, mmio, &snvs_rtc_config);
	} else {
		data->offset = SNVS_LPREGISTER_OFFSET;
		of_property_read_u32(pdev->dev.of_node, "offset", &data->offset);
	}

	if (!data->regmap) {
		dev_err(&pdev->dev, "Can't find snvs syscon\n");
		return -ENODEV;
	}

	data->irq = platform_get_irq(pdev, 0);
	if (data->irq < 0)
		return data->irq;

	data->clk = devm_clk_get(&pdev->dev, "snvs-rtc");
	if (IS_ERR(data->clk)) {
		data->clk = NULL;
	} else {
		ret = clk_prepare_enable(data->clk);
		if (ret) {
			dev_err(&pdev->dev,
				"Could not prepare or enable the snvs clock\n");
			return ret;
		}
	}

	platform_set_drvdata(pdev, data);

	/* Initialize glitch detect */
	regmap_write(data->regmap, data->offset + SNVS_LPPGDR, SNVS_LPPGDR_INIT);

	/* Clear interrupt status */
	regmap_write(data->regmap, data->offset + SNVS_LPSR, 0xffffffff);

	/* Enable RTC */
	snvs_rtc_enable(data, true);

	device_init_wakeup(&pdev->dev, true);

	ret = devm_request_irq(&pdev->dev, data->irq, snvs_rtc_irq_handler,
			       IRQF_SHARED, "rtc alarm", &pdev->dev);
	if (ret) {
		dev_err(&pdev->dev, "failed to request irq %d: %d\n",
			data->irq, ret);
		goto error_rtc_device_register;
	}

	data->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
					&snvs_rtc_ops, THIS_MODULE);
	if (IS_ERR(data->rtc)) {
		ret = PTR_ERR(data->rtc);
		dev_err(&pdev->dev, "failed to register rtc: %d\n", ret);
		goto error_rtc_device_register;
	}

	return 0;

error_rtc_device_register:
	if (data->clk)
		clk_disable_unprepare(data->clk);

	return ret;
}

第 17 行,调用 platform_get_resource 函数从设备树中获取到 RTC 外设寄存器基地址。

第 19 行,调用函数 devm_ioremap_resource 完成内存映射,得到 RTC 外设寄存器物理基地址对应的虚拟地址。

第 23 行,Linux3.1 引入了一个全新的 regmap 机制,regmap 用于提供一套方便的 API 函数去操作底层硬件寄存器,以提高代码的可重用性。snvs-rtc.c 文件会采用 regmap 机制来读写RTC 底层硬件寄存器。这里使用 devm_regmap_init_mmio 函数将 RTC 的硬件寄存器转化为regmap 形式,这样 regmap 机制的 regmap_write、regmap_read 等 API 函数才能操作寄存器

第 34 行,从设备树中获取 RTC 的中断号。

第 53 行,设置 RTC_ LPPGDR 寄存器值为 SNVS_LPPGDR_INIT= 0x41736166,这里就是用的 regmap 机制的 regmap_write 函数完成对寄存器进行写操作。

第 56 行,设置 RTC_LPSR 寄存器,写入 0xffffffff,LPSR 是 RTC 状态寄存器,写 1 清零,因此这一步就是清除 LPSR 寄存器。

第 59 行,调用 snvs_rtc_enable 函数使能 RTC,此函数会设置 RTC_LPCR 寄存器。

第 63 行,调用devm_request_irq函数请求RTC中断,中断服务函数为snvs_rtc_irq_handler,用于 RTC 闹钟中断。

第 71 行,调用 devm_rtc_device_register 函数向系统注册 rtc_devcie,RTC 底层驱动集为snvs_rtc_ops。snvs_rtc_ops操作集包含了读取/设置RTC时间,读取/设置闹钟等函数。

snvs_rtc_ops内容如下:

路径:drivers/rtc/rtc-snvs.c
static const struct rtc_class_ops snvs_rtc_ops = {
	.read_time = snvs_rtc_read_time,
	.set_time = snvs_rtc_set_time,
	.read_alarm = snvs_rtc_read_alarm,
	.set_alarm = snvs_rtc_set_alarm,
	.alarm_irq_enable = snvs_rtc_alarm_irq_enable,
};

我们就以第 3 行的 snvs_rtc_read_time 函数为例讲解一下 rtc_class_ops 的各个 RTC 底层操作函数该如何去编写。

snvs_rtc_read_time 函数用于读取 RTC 时间值,此函数内容如下所示:

路径:drivers/rtc/rtc-snvs.c
static int snvs_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	struct snvs_rtc_data *data = dev_get_drvdata(dev);
	unsigned long time = rtc_read_lp_counter(data);

	rtc_time_to_tm(time, tm);

	return 0;
}

第 5 行,调用 rtc_read_lp_counter 获取 RTC 计数值,这个时间值是秒数。

第 7 行,调用 rtc_time_to_tm 函数将获取到的秒数转换为时间值,也就是 rtc_time 结构体类型;
rtc_time 结构体定义如下:

路径:include/uapi/linux/rtc.h
struct rtc_time {
	int tm_sec;
	int tm_min;
	int tm_hour;
	int tm_mday;
	int tm_mon;
	int tm_year;
	int tm_wday;
	int tm_yday;
	int tm_isdst;
};

接着看一下 rtc_read_lp_counter 函数,此函数用于读取 RTC 计数值,函数内容如下:

路径:drivers/rtc/rtc-snvs.c
static u32 rtc_read_lp_counter(struct snvs_rtc_data *data)
{
	u64 read1, read2;
	u32 val;

	do {
		regmap_read(data->regmap, data->offset + SNVS_LPSRTCMR, &val);
		read1 = val;
		read1 <<= 32;
		regmap_read(data->regmap, data->offset + SNVS_LPSRTCLR, &val);
		read1 |= val;

		regmap_read(data->regmap, data->offset + SNVS_LPSRTCMR, &val);
		read2 = val;
		read2 <<= 32;
		regmap_read(data->regmap, data->offset + SNVS_LPSRTCLR, &val);
		read2 |= val;
	/*
	 * when CPU/BUS are running at low speed, there is chance that
	 * we never get same value during two consecutive read, so here
	 * we only compare the second value.
	 */
	} while ((read1 >> CNTR_TO_SECS_SH) != (read2 >> CNTR_TO_SECS_SH));

	/* Convert 47-bit counter to 32-bit raw second count */
	return (u32) (read1 >> CNTR_TO_SECS_SH);
}

第 7~24行,读取 RTC_LPSRTCMR 和 RTC_LPSRTCLR 这两个寄存器,得到 RTC 的计数值,单位为秒,这个秒数就是当前时间。这里读取了两次 RTC 计数值,因为要读取两个寄存器,
因此可能存在读取第二个寄存器的时候时间数据更新了,导致时间不匹配,因此这里连续读两次,如果两次的时间值相等那么就表示时间数据有效。

第 27行,返回时间值,注意这里将前面读取到的 RTC 计数值右移了 15 位。

这个就是 snvs_rtc_read_time 函数读取 RTC 时间值的过程,至于其他的底层操作函数大家自行分析即可,都是大同小异的,这里就不再分析了。关于 I.MX6U 内部 RTC 驱动源码就讲解到这里。

五 RTC驱动测试

5.1 驱动使用配置

虽然RTC驱动不用我们写,NXP官方已经写好了;我们在第四节也介绍了RTC驱动,那么我们来看下如何配置使能呢?

NXP官方驱动使用,配置如下:
使用命令进入配置界面:

make menuconfig

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
NXP官方配套的kernel源码已经是使能的了。如果读者使用的是其它SOC或时钟芯片,可自行查阅。

5.2 RTC 时间查看与设置

1、时间 RTC 查看
我们所使用的kernel已经有了RTC,我们就来看下如何查看系统的时间和设置。
在开机过程中,我们可以看到如下Log输出:

snvs_rtc 20cc000.snvs:snvs-rtc-lp: rtc core: registered 20cc000.snvs:snvs-r as rtc0
......
snvs_rtc 20cc000.snvs:snvs-rtc-lp: setting system clock to 1970-01-02 00:23:17 UTC (87797)

在这里插入图片描述

可以看出,Linux 内核在启动的时候将 snvs_rtc 设置为 rtc0,大家的启动信息可能会和图中的不同,但是内容基本上都是一样的。

开机完成后可在终端输入date命令查看当前时间:
在这里插入图片描述
看出当前时间为 1970 年 1 月 1 日 00:06:11,很明显是时间不对,我们需要重新设置 RTC 时间。

2、设置 RTC 时间
RTC 时间设置也是使用的 date 命令,输入“date --help”命令即可查看 date 命令如何设置系统时间,结果如下图所示:
在这里插入图片描述
现在我要设置当前时间为 2023 年 6 月 24 日 14:59:00,因此输入如下命令:

date -s "2023-06-24 14:59:00"

在这里插入图片描述
大家注意我们使用“date -s”命令仅仅是将当前系统时间设置了,此时间还没有写入到I.MX6U 内部 RTC 里面或其他的 RTC 芯片里面,因此系统重启以后时间又会丢失。我们需要将当前的时间写入到 RTC 里面,这里要用到 hwclock 命令,输入如下命令将系统时间写入到 RTC里面:

hwclock -w //将当前系统时间写入到 RTC 里面

在这里插入图片描述
时间写入到 RTC 里面以后就不怕系统重启以后时间丢失了,如果 I.MX6U开发板底板接了纽扣电池,那么开发板即使断电了时间也不会丢失。大家可以尝试一下不断电重启和断电重启这两种情况下开发板时间会不会丢失。

六 总结

对于RTC驱动,虽然大部分不用我们自己写,单不排除有些厂商会外挂RTC芯片,这个时候驱动工程师就得写RTC驱动了,所以多了解linux的RTC驱动流程和细节,总归有好处。关于IMX6U的RTC相关驱动就分析那么,后续笔者会结合应用程序,在应用程序中使用系统时间和RTC。欢迎持续关注。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/679826.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

Dubbo【 Dubbo概念(什么是分布式系统、什么是RPC、核心组件、Zookeeper注册中心 )】(一)-全面详解(学习总结---从入门到深化)

目录 Dubbo概念_什么是分布式系统 什么是分布式 Dubbo概念_什么是RPC Dubbo概念_简介 Dubbo概念_核心组件 Dubbo配置开发环境_Zookeeper注册中心 Dubbo配置开发环境_管理控制台 Dubbo入门案例_需求介绍 Dubbo入门案例_配置开发环境 Dubbo入门案例_服务生产者配置…

VLC-QT源码编译(Windows10+VS2020+MSVC20019+QT5.15)

参考VLC-Qt的编译与使用 windows10VS2019qt5.15 下载源码 VLC-QT https://github.com/vlc-qt/vlc-qt可以通过git或者直接下载ZIP文件&#xff0c;但是里面的libvlc-header和packaging没有下载下来&#xff0c;需要再自行下载。 VLC https://download.videolan.org/vlc/las…

行为型模式--备忘录模式

目录 概述 结构 案例实现 “白箱”备忘录模式 总结&#xff1a; “黑箱”备忘录模式 优缺点 优点&#xff1a; 缺点&#xff1a; 使用场景 概述 又叫快照模式&#xff0c;在不破坏封装性的前提下&#xff0c;捕获一个对象的内部状态&#xff0c;并在该对象之外保存这…

zeromq的学习笔记

ctx_t 在创建ctx_t时&#xff0c;会设置以下参数 _io_thread_count io线程数默认是1 _max_sockets最大socket数是1023 _starting标识设置为true,此时socket还没有创建 _terminating设置为false,在调用zmq_ctx_term时该标识会设置为true _tag设置为ZMQ_CTX_TAG_VALUE_GOOD&…

mySql和VSC++

确认主机服务里的mysql服务已打开 使用组合键“winR”运行“services.msc”&#xff0c;进入本地服务窗口&#xff1b; 2.进入本地服务窗口后&#xff0c;在右侧服务列表中&#xff0c;查找到“ mysql ”服务选项&#xff1b; 3.查找到mysql服务选项后&#xff0c;双击打开mysq…

C++ 面向对象(3)——重载运算符和重载函数

C 允许在同一作用域中的某个函数和运算符指定多个定义&#xff0c;分别称为函数重载和运算符重载。 重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明&#xff0c;但是它们的参数列表和定义&#xff08;实现&#xff09;不相同。 当您调用一个重…

FDM3D打印系列——3、常用打印材料介绍

大家好&#xff0c;我是阿赵。 FDM3D打印机一般都可以支持多种打印材料的&#xff0c;下面来介绍一下几种常用的打印材料 一、PLA 使用FDM打印&#xff0c;最常见的材料就是PLA了 PLA&#xff08;Polylactic acid&#xff09;&#xff0c;中文名为生物降解塑料聚乳酸&#…

网络安全面试题,渗透测试面试总结

1.什么是WebShell? WebShell就是以asp、php、jsp或者cgi等网页文件形式存在的─种命令执行环境&#xff0c;也可以将其称做为─种网页后门。黑客在入侵了─个网站后&#xff0c;通常会将这些asp或php后门文件与网站服务器WEB目录下正常的网页文件混在─起&#xff0c;然后就可…

【Vue3】生命周期(钩子)函数

在 Vue 3 中&#xff0c;生命周期函数已经被重新设计为钩子函数&#xff0c;并且与 Vue 2 中的生命周期函数有所不同&#xff0c;可以在 setup 函数中使用 onXXX 形式的钩子函数来执行对应的操作。以下是选项式 API 和组合式 API 中常用的几个钩子函数对比&#xff1a; beforeC…

【Java】PriorityQueue--优先级队列

目录 一、优先级队列 &#xff08;1&#xff09;概念 二、优先级队列的模拟实现 &#xff08;1&#xff09;堆的概念 &#xff08;2&#xff09;堆的存储方式 &#xff08;3&#xff09;堆的创建 堆向下调整 &#xff08;4&#xff09;堆的插入与删除 堆的插入 堆的…

Kubernetes(k8s)容器编排组件介绍

目录 1 整体架构1.1 Master 架构1.2 Node 架构 2 k8s部署组件介绍2.1 K8s 集群架构图2.2 k8s控制组件2.2.1 控制平面2.2.2 kube-apiserver2.2.3 kube-scheduler2.2.4 kube-controller-manager2.2.5 etcd 2.3 k8s运行组件2.3.1 k8s节点2.3.2 容器集2.3.3 容器运行时引擎2.3.4 ku…

机试复试准备中--梦校真题

一、矩阵转置二、统计单词写法一&#xff1a;读取一整行写法二&#xff1a;依次读入每一个单词 三、二叉排序树&#xff08;DFS&#xff09;四、IP地址五、特殊排序六、ab&#xff08;高精度加法&#xff09;七、奇偶校验八、最大的两个数九、二叉树遍历(DFS)十、成绩排序十一、…

【C++学习】C++入门 | 引用 | 引用的底层原理 | auto关键字 | 范围for(语法糖)

写在前面&#xff1a; 上一篇文章我介绍了缺省参数和函数重载&#xff0c; 探究了C为什么能够支持函数重载而C语言不能&#xff0c; 这里是传送门&#xff0c;有兴趣可以去看看&#xff1a;http://t.csdn.cn/29ycJ 这篇我们继续来学习C的基础知识。 目录 写在前面&#x…

正交编码与正交沃尔什函数详解

本专栏包含信息论与编码的核心知识&#xff0c;按知识点组织&#xff0c;可作为教学或学习的参考。markdown版本已归档至【Github仓库&#xff1a;https://github.com/timerring/information-theory 】或者公众号【AIShareLab】回复 信息论 获取。 文章目录 正交编码正交编码的…

Spring Boot 集成 WebSocket 实现服务端推送消息到客户端

假设有这样一个场景&#xff1a;服务端的资源经常在更新&#xff0c;客户端需要尽量及时地了解到这些更新发生后展示给用户&#xff0c;如果是 HTTP 1.1&#xff0c;通常会开启 ajax 请求询问服务端是否有更新&#xff0c;通过定时器反复轮询服务端响应的资源是否有更新。 在长…

css基础(二)

目录 1. CSS 的复合选择器 1.1 什么是复合选择器 1.2 后代选择器(重要&#xff09; 1.3 子选择器(重要&#xff09; 1.4 并集选择器(重要&#xff09; 1.5 伪类选择器 1.6 链接伪类选择器 1.7 :focus伪类选择器 1.8 复合选择器总结 二、 CSS 的元素显示模式 2.1什么是元素显示模…

多线程编程和并行计算的实例:期货交易及打车软件算法

多线程编程和并行计算的实例:期货交易及打车软件算法 解决现实生活中的问题时&#xff0c;多处理器和多核系统的普及使并行计算成为一个关键的性能提升手段。在这篇博客中&#xff0c;我们将通过深入讨论两个引人入胜而又具有实际意义的场景——期货交易和打车匹配算法&#xf…

CSS圆角进化论

CSS圆角发展过程 大致经历了3个阶段&#xff0c;包括&#xff1a; 背景图片实现圆角CSS2.0标签模拟圆角CSS3.0圆角属性&#xff08;border-radius属性)实现圆角 ☛背景图片实现圆角&#xff1a;使用背景图片实现圆角的方式很多&#xff0c;实现的方式和圆角的切图方式关系密…

AI绘图软件分享:Midjourney 基础教程(三)

大家好&#xff0c;我是权知星球&#xff0c;今天继续给大家分享Midjourney 基础教程&#xff08;三&#xff09;&#xff1a;Midjourney 图生图。 刚开始学习使⽤ AI 绘画时&#xff0c;⼤部分⼈的绘画⽅式&#xff1a; 有⼀个想象中的画⾯&#xff0c;⽤中⽂将这个画⾯描述…

【文件操作与IO】Java中如何操作文件

目录 Java 中操作文件 File 概述 属性 构造方法 方法 代码示例 文件内容的读写 —— 数据流 InputStream 概述 FileInputStream 概述 利用 Scanner 进行字符读取 OutputStream 概述 利用 OutputStreamWriter 进行字符写入 利用 PrintWriter 找到我们熟悉的方法 代码…