title: RTC子系统

tags: linux

date: 2019/1/2 17:15:27

toc: true

RTC子系统

引入

hctosys.c

查看下内核打印的错误信息如下,很明确指定了程序的入口了

drivers/rtc/hctosys.c: unable to open rtc device (rtc0)

程序流程如下:

// 这个也就是定义了段属性,内核在启动的时候会调用的
late_initcall(rtc_hctosys);
#define late_initcall(fn) __define_initcall("7",fn,7) static int __init rtc_hctosys(void)
{
int err;
struct rtc_time tm;
struct rtc_device *rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE); if (rtc == NULL) {
printk("%s: unable to open rtc device (%s)\n",
__FILE__, CONFIG_RTC_HCTOSYS_DEVICE);
return -ENODEV;
}
....
}

interface.c

搜索下为什么打不开设备rtc_class_open,可以发现是寻找全局变量rtc_class总线的设备

struct rtc_device *rtc_class_open(char *name)
{
struct device *dev;
struct rtc_device *rtc = NULL; down(&rtc_class->sem);
list_for_each_entry(dev, &rtc_class->devices, node) {
....
}

可以看到在drivers\rtc\interface.c中包含了RTC的打开,设置事件设置闹钟等

class.c

搜索这个全局的链表,可以看到在drivers\rtc\class.c中注册的

struct class *rtc_class;
struct rtc_device *rtc_device_register(const char *name, struct device *dev,
const struct rtc_class_ops *ops,
struct module *owner)
static int __init rtc_init(void)
subsys_initcall(rtc_init); #define subsys_initcall(fn) __define_initcall("4",fn,4) #define __define_initcall(level,fn,id) \
static initcall_t __initcall_##fn##id __attribute_used__ \
__attribute__((__section__(".initcall" level ".init"))) = fn

subsys_initcall其实就是定义一个段属性,内核会主动调用的,查看该文件的入口

static int __init rtc_init(void)
{
rtc_class = class_create(THIS_MODULE, "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_sysfs_init(rtc_class);
return 0;
}

小结

  • hctosys.c中的入口rtc_hctosys是使用__define_initcall("7",fn,7)

  • class.c的入口rtc_init是使用__define_initcall("4",fn,4)

  • 内核按照先后顺序调用,内核的链接脚本如下

      __initcall_start = .;
    *(.initcall0.init) *(.initcall0s.init) *(.initcall1.init) *(.initcall1s.init) *(.initcall2.init) *(.initcall2s.init) *(.initcall3.init) *(.initcall3s.init) *(.initcall4.init) *(.initcall4s.init) *(.initcall5.init) *(.initcall5s.init) *(.initcallrootfs.init) *(.initcall6.init) *(.initcall6s.init) *(.initcall7.init) *(.initcall7s.init)
    __initcall_end = .;
  • 搜索这个链接脚本,可以看到

    extern initcall_t __initcall_start[], __initcall_end[];
    static void __init do_initcalls(void)
    {
    for (call = __initcall_start; call < __initcall_end; call++) {
    ...
    }
  • 也就是按找序号调用了,先执行rtc_init,再去打开,想想也是这样的

流程一览

RTC子系统-LMLPHP

框架分析

rtc_init

drivers\rtc\class.c这是内核入口初始化注册设备,rtc_init()->rtc_dev_init(),来注册字符设备

  • 创建类
  • 分配主次设备号
static int __init rtc_init(void)
{
rtc_class = class_create(THIS_MODULE, "rtc"); rtc_class->suspend = rtc_suspend;
rtc_class->resume = rtc_resume;
rtc_dev_init();
#define RTC_DEV_MAX 16
alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc");
rtc_sysfs_init(rtc_class);
return 0;
}

rtc_device_register

搜索这个函数,是在drivers\rtc\rtc-s3c.c调用的

rtc = rtc_device_register("s3c", &pdev->dev, &s3c_rtcops,THIS_MODULE);

具体形式如下:

  • cdev_init > cdev_add 注册字符设备驱动
struct rtc_device *rtc_device_register(const char *name, struct device *dev,
const struct rtc_class_ops *ops,
struct module *owner)
{
> 设置rtc结构体
rtc->id = id;
rtc->ops = ops;
rtc->owner = owner;
rtc->max_user_freq = 64;
rtc->dev.parent = dev;
rtc->dev.class = rtc_class; //这个是全局的,内核刚开始就注册了的在rtc_init
rtc->dev.release = rtc_device_release; //这里是总线bus 后面会有 device_add 会来匹配,如果没有对应的bus匹配
snprintf(rtc->dev.bus_id, BUS_ID_SIZE, "rtc%d", id);
//>dev->bus->probe
//drv->probe //没有dev->bus->probe执行 rtc_dev_prepare(rtc);
rtc->dev.devt = MKDEV(MAJOR(rtc_devt), rtc->id);
cdev_init(&rtc->char_dev, &rtc_dev_fops);
rtc_dev_add_device(rtc);
cdev_add(&rtc->char_dev, rtc->dev.devt, 1)
// vfs 相关 sysfs 和 proc
rtc_sysfs_add_device
rtc_proc_add_device(rtc); }

s3c_rtc_probe

简述

  • 获得硬件资源,设置寄存器

  • 设置rtc_device结构体,包含了实际的硬件操作s3c_rtcops

    static const struct rtc_class_ops s3c_rtcops = {
    .open = s3c_rtc_open,
    .release = s3c_rtc_release,
    .ioctl = s3c_rtc_ioctl,
    .read_time = s3c_rtc_gettime,
    .set_time = s3c_rtc_settime,
    .read_alarm = s3c_rtc_getalarm,
    .set_alarm = s3c_rtc_setalarm,
    .proc = s3c_rtc_proc,
    };
  • 注册字符设备驱动,操作函数为rtc_dev_fops,通用接口,最终应该会使用具体的硬件操作接口

    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;
    rtc->ops = ops;
    rtc_dev_prepare(rtc);
    >cdev_init(&rtc->char_dev, &rtc_dev_fops); } //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,
    .ioctl = rtc_dev_ioctl,
    .open = rtc_dev_open,
    .release = rtc_dev_release,
    .fasync = rtc_dev_fasync,
    };

详细

s3c_rtc_probe会调用rtc_device_register来注册rtc设备,这是一个platform平台了,资源文件如下

static struct platform_driver s3c2410_rtcdrv = {
.probe = s3c_rtc_probe,
.remove = s3c_rtc_remove,
.suspend = s3c_rtc_suspend,
.resume = s3c_rtc_resume,
.driver = {
.name = "s3c2410-rtc",
.owner = THIS_MODULE,
},
};

搜索资源文件名找到相应设备文件arch\arm\plat-s3c24xx\devs.c 包含了寄存器地址和中断号

struct platform_device s3c_device_rtc = {
.name = "s3c2410-rtc",
.id = -1,
.num_resources = ARRAY_SIZE(s3c_rtc_resource),
.resource = s3c_rtc_resource,
}; static struct resource s3c_rtc_resource[] = {
[0] = {
.start = S3C24XX_PA_RTC,
.end = S3C24XX_PA_RTC + 0xff,
.flags = IORESOURCE_MEM,
},
[1] = {
.start = IRQ_RTC,
.end = IRQ_RTC,
.flags = IORESOURCE_IRQ,
},
[2] = {
.start = IRQ_TICK,
.end = IRQ_TICK,
.flags = IORESOURCE_IRQ
}
};

具体的函数流程如下:

s3c_rtc_probe
//获得中断号 RQ_TICK节拍和RTC闹钟 ,寄存器等资源
s3c_rtc_tickno = platform_get_irq(pdev, 1);
s3c_rtc_alarmno = platform_get_irq(pdev, 0);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
//内存分配 寄存器映射
s3c_rtc_mem = request_mem_region(res->start,res->end-res->start+1,pdev->name);
s3c_rtc_base = ioremap(res->start, res->end - res->start + 1); //使能RTC,设置寄存器
s3c_rtc_enable(pdev, 1);
//读取RTC寄存器
pr_debug("s3c2410_rtc: RTCCON=%02x\n",readb(s3c_rtc_base + S3C2410_RTCCON));
//设置频率,设置TICONT寄存器,使能节拍中断,设置节拍计数值
s3c_rtc_setfreq(s3c_rtc_freq); //注册驱动
rtc_device_register("s3c", &pdev->dev, &s3c_rtcops,THIS_MODULE);
> 设置rtc结构体
rtc->id = id;
rtc->ops = ops;
rtc->owner = owner;
rtc->max_user_freq = 64;
rtc->dev.parent = dev;
rtc->dev.class = rtc_class; //这个是全局的,内核刚开始就注册了的在rtc_init
rtc->dev.release = rtc_device_release; //初始化cdev结构体,绑定file_operations
rtc_dev_prepare(rtc);
//这个应该是唤醒队列了
>init_waitqueue_head(&rtc->irq_queue);
>cdev_init(&rtc->char_dev, &rtc_dev_fops);
// 添加到内核,这里好像是udev机制
device_register(&rtc->dev); //添加到驱动设备
rtc_dev_add_device(rtc);
> cdev_add
// /sysfs/文件
rtc_sysfs_add_device(rtc);
> device_create_file(&rtc->dev, &dev_attr_wakealarm);
//创建 /proc/下的一些东西
rtc_proc_add_device(rtc);
>create_proc_entry("driver/rtc", 0, NULL)
>ent->proc_fops = &rtc_proc_fops;

open

公用

我们注册驱动的时候是注册了rtc_dev_fops,它是一个公共的,具体如何找到实际硬件的open?

static const struct file_operations rtc_dev_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.read = rtc_dev_read,
.poll = rtc_dev_poll,
.ioctl = rtc_dev_ioctl,
.open = rtc_dev_open,
.release = rtc_dev_release,
.fasync = rtc_dev_fasync,
}; static int rtc_dev_open(struct inode *inode, struct file *file)
{
int err;
//获取对应的rtc_device
struct rtc_device *rtc = container_of(inode->i_cdev,
struct rtc_device, char_dev);
//这里就能得到实际的ops了
const struct rtc_class_ops *ops = rtc->ops; //这里就调用实际的open
err = ops->open ? ops->open(rtc->dev.parent) : 0;
}

芯片级

申请了闹钟中断和tick中断

static const struct rtc_class_ops s3c_rtcops = {
.open = s3c_rtc_open,
.release = s3c_rtc_release,
.ioctl = s3c_rtc_ioctl,
.read_time = s3c_rtc_gettime,
.set_time = s3c_rtc_settime,
.read_alarm = s3c_rtc_getalarm,
.set_alarm = s3c_rtc_setalarm,
.proc = s3c_rtc_proc,
}; static int s3c_rtc_open(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
int ret; ret = request_irq(s3c_rtc_alarmno, s3c_rtc_alarmirq,
IRQF_DISABLED, "s3c2410-rtc alarm", rtc_dev); if (ret) {
dev_err(dev, "IRQ%d error %d\n", s3c_rtc_alarmno, ret);
return ret;
} ret = request_irq(s3c_rtc_tickno, s3c_rtc_tickirq,
IRQF_DISABLED, "s3c2410-rtc tick", rtc_dev); if (ret) {
dev_err(dev, "IRQ%d error %d\n", s3c_rtc_tickno, ret);
goto tick_err;
} return ret; tick_err:
free_irq(s3c_rtc_alarmno, rtc_dev);
return ret;
}

ioctl

同样的,公共级别的ioctl也会调用到芯片级的

static int rtc_dev_ioctl(struct inode *inode, 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;
if (ops->ioctl) {
err = ops->ioctl(rtc->dev.parent, cmd, arg);
...
}

芯片级

这里也就是读写时间,操作寄存器了

static int s3c_rtc_ioctl(struct device *dev,
unsigned int cmd, unsigned long arg)
{
unsigned int ret = -ENOIOCTLCMD; switch (cmd) {
case RTC_AIE_OFF:
case RTC_AIE_ON:
s3c_rtc_setaie((cmd == RTC_AIE_ON) ? 1 : 0);
ret = 0;
break; case RTC_PIE_OFF:
case RTC_PIE_ON:
tick_count = 0;
s3c_rtc_setpie((cmd == RTC_PIE_ON) ? 1 : 0);
ret = 0;
break; case RTC_IRQP_READ:
ret = put_user(s3c_rtc_freq, (unsigned long __user *)arg);
break; case RTC_IRQP_SET:
/* check for power of 2 */ if ((arg & (arg-1)) != 0 || arg < 1) {
ret = -EINVAL;
goto exit;
} pr_debug("s3c2410_rtc: setting frequency %ld\n", arg); s3c_rtc_setfreq(arg);
ret = 0;
break; case RTC_UIE_ON:
case RTC_UIE_OFF:
ret = -EINVAL;
} exit:
return ret;
}

加入时钟

可以看到内核是有驱动的,只是没有注册平台设备文件 ,添加这个设备文件

ls /dev/rtc*

arch/arm/plat-s3c24xx/Common-smdk.c加入s3c_device_rtc这个结构即可

static struct platform_device __initdata *smdk_devs[] = {
&s3c_device_nand,
.....
&s3c_device_rtc,
....
};

测试

上电启动信息如下

s3c2410-rtc s3c2410-rtc: setting the system clock to 2165-10-04 10:44:26 (1882584970)

查看下设备

# ls /dev/rtc*
/dev/rtc0

date命令

使用date命令读时间

# 查看时间
# date
Tue Aug 28 04:17:30 UTC 2029
# date "+ %Y/%m/%d %H:%M:%S"
2029/08/28 04:18:06

使用date设置时间,格式是date 月日时分年.秒

# date 010314322019.30
Thu Jan 3 14:32:30 UTC 2019 # date "+ %Y/%m/%d %H:%M:%S"
2019/01/03 14:33:04
# date "+ %Y/%m/%d %H:%M:%S"
2019/01/03 14:33:10
# date "+ %Y/%m/%d %H:%M:%S"
2019/01/03 14:33:11

hwclock命令

  -r, --show          读取并打印硬件时钟(read hardware clock and print result )
-s, --hctosys 将硬件时钟同步到系统时钟(set the system time from the hardware clock )
-w, --systohc 将系统时钟同步到硬件时钟(set the hardware clock to the current system time )

使用如下

#读取硬件时钟
# hwclock -r
Wed Dec 31 23:59:59 1969 0.000000 seconds
# 同步,设置软时钟到硬件时钟
# hwclock -w
# hwclock -r
Thu Jan 3 14:35:49 2019 0.000000 seconds
05-06 21:25