RTC子系统

---

title: RTC子系统

tags: linux

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

toc: true

RTC子系统

目录

• title: RTC子系统tags: linuxdate: 2019/1/2 17:15:27toc: true

引入

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_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