二十一、RTC驱动

一、RTC设备驱动分析

内核的rtc驱动位于内核drivers/rtc目录下，里面包含各个平台的RTC驱动。读者可在此目录下任意选择一个单板驱动文件进行分析，我选择的是rtc-davinci.c文件。

文件链接：

https://files.cnblogs.com/files/Lioker/21_rtc.zip

首先来看init()函数：

 static struct platform_driver davinci_rtc_driver = {
     .probe        = davinci_rtc_probe,
     .remove        = __devexit_p(davinci_rtc_remove),
     .driver        = {
         .name = "rtc_davinci",
         .owner = THIS_MODULE,
     },
 };

 static int __init rtc_init(void)
 {
     return platform_driver_probe(&davinci_rtc_driver, davinci_rtc_probe);
 }

它注册了davinci_rtc_driver驱动，它对应的设备在arch/arm/mach-davinci/dm365.c中有定义：

 static struct resource dm365_rtc_resources[] = {
     {
         .start = DM365_RTC_BASE,
         .end = DM365_RTC_BASE + SZ_1K - ,
         .flags = IORESOURCE_MEM,
     },
     {
         .start = IRQ_DM365_RTCINT,
         .flags = IORESOURCE_IRQ,
     },
 };

 static struct platform_device dm365_rtc_device = {
     .name = "rtc_davinci",
     .id = ,
     .num_resources = ARRAY_SIZE(dm365_rtc_resources),
     .resource = dm365_rtc_resources,
 };

probe()函数调用关系如下：

davinci_rtc_probe
  -> davinci_rtc->irq = platform_get_irq(pdev, );                /* 获取platform_device中断 */
  -> res = platform_get_resource(pdev, IORESOURCE_MEM, );        /* 获取内存地址 */
  -> mem = request_mem_region(davinci_rtc->pbase, davinci_rtc->base_size, pdev->name);
  -> davinci_rtc->base = ioremap(davinci_rtc->pbase, davinci_rtc->base_size);    /* 对寄存器进行映射 */
  /* 注册RTC设备 */
  -> davinci_rtc->rtc = rtc_device_register(pdev->name, &pdev->dev, &davinci_rtc_ops, THIS_MODULE);
    -> rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL);
    -> rtc->id = id;      /* 设置rtc成员 */
    -> rtc->ops = ops;    /* 这个就是rtc的操作函数 */
    -> rtc_dev_prepare(rtc);
      -> cdev_init(&rtc->char_dev, &rtc_dev_fops);     /* 绑定file_operations */
    -> device_register(&rtc->dev);
      -> device_add(dev);
    -> rtc_dev_add_device(rtc);    /* 在/dev下创建rtc文件，将cdev添加到系统中 */
      -> cdev_add(&rtc->char_dev, rtc->dev.devt, )
  -> rtcif_write(davinci_rtc, , PRTCIF_INTEN);        /* 设置寄存器 */
  -> request_irq(davinci_rtc->irq, davinci_rtc_interrupt, , "davinci_rtc", davinci_rtc);    /* 请求中断 */

probe()函数所做的有以下几点：

1. 设置rtc相关寄存器

2. 分配、设置并注册rtc_device

3. 分配、设置并注册cdev

在注册rtc_device过程中，rtc_device绑定了struct rtc_class_ops davinci_rtc_ops

static struct rtc_class_ops davinci_rtc_ops = {
    .ioctl            = davinci_rtc_ioctl,
    .read_time        = davinci_rtc_read_time,              /* 读取时间 */
    .set_time        = davinci_rtc_set_time,                /* 设置时间 */
    .alarm_irq_enable    = davinci_rtc_alarm_irq_enable,    /* 中断使能 */
    .read_alarm        = davinci_rtc_read_alarm,            /* 读取闹钟时间 */
    .set_alarm        = davinci_rtc_set_alarm,              /* 设置闹钟时间 */
};

在注册cdev过程中，cdev绑定了struct file_operations rtc_dev_fops

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

当我们在应用层open("/dev/rtcx")时，它会调用rtc_dev_fops->open()：

 static int rtc_dev_open(struct inode *inode, struct file *file)
 {
     int err;
     struct rtc_device *rtc = container_of(inode->i_cdev,
                     struct rtc_device, char_dev);
     const struct rtc_class_ops *ops = rtc->ops;
 ...
     err = ops->open ? ops->open(rtc->dev.parent) : ;
 ...
     return err;
 }

open()函数最终会调用struct rtc_class_ops davinci_rtc_ops的open()函数，由于davinci_rtc_ops没有open()函数，在此不做分析。

当我们在应用层open()后，使用ioctl(int fd, unsigned long cmd, ...)时，它会调用rtc_dev_fops->ioctl()：

 static long rtc_dev_ioctl(struct file *file,
         unsigned int cmd, unsigned long arg)
 {
     int err = ;
     struct rtc_device *rtc = file->private_data;
     const struct rtc_class_ops *ops = rtc->ops;        /* 获取rtc_class_ops */
     struct rtc_time tm;
     struct rtc_wkalrm alarm;
     void __user *uarg = (void __user *) arg;

     err = mutex_lock_interruptible(&rtc->ops_lock);
 ...
     switch (cmd) {
 ...
     case RTC_RD_TIME:
         mutex_unlock(&rtc->ops_lock);

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

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

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

在此以读时间（RTC_RD_TIME）为例，调用关系如下：

rtc_read_time(rtc, &tm);
  -> __rtc_read_time(rtc, tm);
    -> err = rtc->ops->read_time(rtc->dev.parent, tm)    /* davinci_rtc_read_time */
      -> tm->tm_sec = bcd2bin(rtcss_read(davinci_rtc, PRTCSS_RTC_SEC));    /* 读数据 */
      -> day0 = rtcss_read(davinci_rtc, PRTCSS_RTC_DAY0);
      -> convertfromdays(days, tm)    /* 格式转换 */

通过对两结构体分析，我们可以确定：

1. rtc_device->cdev是对rtc的抽象，用于与应用层进行交互

2. rtc_device->ops是cdev->ops的底层实现，通过读写寄存器完成时间操作

二、修改内核支持RTC

在开发板上执行

# ls /dev/rtc*

会有部分开发板找不到该字符设备，这是因为内核里只定义了rtc平台设备，但是没有注册，所以平台驱动和设备并没有匹配，因此我们需要修改内核里的注册数组或注册平台设备。

对于itop4412，其内核里的注册数组位于arch/arm/mach-exynos/mach-itop4412.c的第2740行。

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

可以看到，它已经含有了rtc设备。若没有，读者需要根据自身情况进行添加，并重新编译烧写内核。

对于之前使用的dm365.c，它的注册方法是直接在init()函数中注册平台设备：

 static int __init dm365_init_devices(void)
 {
     if (!cpu_is_davinci_dm365())
         return ;

     davinci_cfg_reg(DM365_INT_EDMA_CC);
     platform_device_register(&dm365_edma_device);

     platform_device_register(&dm365_mdio_device);
     platform_device_register(&dm365_emac_device);
     clk_add_alias(NULL, dev_name(&dm365_mdio_device.dev),
               NULL, &dm365_emac_device.dev);

     /* Add isif clock alias */
     clk_add_alias("master", dm365_isif_dev.name, "vpss_master", NULL);
     platform_device_register(&dm365_vpss_device);
     platform_device_register(&dm365_isif_dev);
     platform_device_register(&vpfe_capture_dev);
     return ;
 }

可以看到他并没有支持rtc，因此我们可以添加如下代码让开发板支持rtc。

 davinci_cfg_reg(DM365_INT_PRTCSS);              /* 配置管脚复用 */
 platform_device_register(&dm365_rtc_device);    /* 注册平台设备 */

然后重新编译内核、烧写。

接下来，我们可以来操作rtc了。

在Linux中有两个时钟：硬件时钟（寄存器时钟）和系统时钟（内核时钟）

使用hwclock可以查看硬件时钟，使用date命令可以查看系统时钟。

date命令：

1. 查看系统时间

2. 格式化查看系统时间

%Y：年，%m：月，%d：日，%H：时，%M：分，%S：秒

3. 设置系统时间

格式为：date 月日时分年.秒

hwclock命令：

命令常用参数如下：

-r，--show：读取并打印硬件时钟

-s，--hctosys：将硬件时钟同步到系统时钟

-w，--systohc：将系统时钟同步到硬件时钟

使用方法如下图：

下一章  二十二、DMA驱动