【正点原子Linux连载】第六十章Linux RTC驱动实验--摘自【正点原子】I.MX6U嵌入式Linux驱动开发指南

正点原子

1）实验平台：正点原子阿尔法Linux开发板
2）平台购买地址：https://item.taobao.com/item.htm?id=603672744434
3）全套实验源码+手册+视频下载地址：http://www.openedv.com/thread-300792-1-1.html  
4）对正点原子Linux感兴趣的同学可以加群讨论：876919289
5）关注正点原子公众号，获取最新资料

第六十章Linux RTC驱动实验

        RTC也就是实时时钟，用于记录当前系统时间，对于Linux系统而言时间是非常重要的，就和我们使用Windows电脑或手机查看时间一样，我们在使用Linux设备的时候也需要查看时间。本章我们就来学习一下如何编写Linux下的RTC驱动程序。

60.1 Linux内核RTC驱动简介        
        RTC设备驱动是一个标准的字符设备驱动，应用程序通过open、release、read、write和ioctl等函数完成对RTC设备的操作，关于RTC硬件原理部分我们已经在裸机篇中的第二十五章进行了详细的讲解，这里就不再废话了。
Linux内核将RTC设备抽象为rtc_device结构体，因此RTC设备驱动就是申请并初始化rtc_device，最后将rtc_device注册到Linux内核里面，这样Linux内核就有一个RTC设备的。至于RTC设备的操作肯定是用一个操作集合(结构体)来表示的，我们先来看一下rtc_device结构体，此结构体定义在include/linux/rtc.h文件中，结构体内容如下(删除条件编译)：
示例代码60.1.1 rtc_device结构体

1. 104struct rtc_device
   
2. 105{
   
3. 106struct device dev;                        /* 设备                                */
   
4. 107struct module *owner;
   
5. 108
   
6. 109int id;                        /* ID                                         */
   
7. 110char name[RTC_DEVICE_NAME_SIZE];/* 名字                                */
   
8. 111
   
9. 112conststruct rtc_class_ops *ops;        /* RTC设备底层操作函数        */
   
10. 113struct mutex ops_lock;
    
11. 114
    
12. 115struct cdev char_dev;                /* 字符设备                        */
    
13. 116unsignedlong flags;
    
14. 117
    
15. 118unsignedlong irq_data;
    
16. 119     spinlock_t irq_lock;
    
17. 120     wait_queue_head_t irq_queue;
    
18. 121struct fasync_struct *async_queue;
    
19. 122
    
20. 123struct rtc_task *irq_task;
    
21. 124     spinlock_t irq_task_lock;
    
22. 125int irq_freq;
    
23. 126int max_user_freq;
    
24. 127
    
25. 128struct timerqueue_head timerqueue;
    
26. 129struct rtc_timer aie_timer;
    
27. 130struct rtc_timer uie_rtctimer;
    
28. 131struct hrtimer pie_timer;/* sub second exp, so needs hrtimer */
    
29. 132int pie_enabled;
    
30. 133struct work_struct irqwork;
    
31. 134/* Some hardware can't support UIE mode */
    
32. 135int uie_unsupported;
    
33. ......
    
34. 147};

复制代码

        我们需要重点关注的是ops成员变量，这是一个rtc_class_ops类型的指针变量，rtc_class_ops为RTC设备的最底层操作函数集合，包括从RTC设备中读取时间、向RTC设备写入新的时间值等。因此，rtc_class_ops是需要用户根据所使用的RTC设备编写的，此结构体定义在include/linux/rtc.h文件中，内容如下：
示例代码60.1.2 rtc_class_ops结构体
字就知道rtc_class_ops操作集合中的这些函数是做什么的了，但是我们要注意，rtc_class_ops中的这些函数只是最底层的RTC设备操作函数，并不是提供给应用层的file_operations函数操作集。RTC是个字符设备，那么肯定有字符设备的file_operations函数操作集，Linux内核提供了一个RTC通用字符设备驱动文件，文件名为drivers/rtc/rtc-dev.c，rtc-dev.c文件提供了所有RTC设备共用的file_operations函数操作集，如下所示：
示例代码60.1.3 RTC通用file_operations操作集

1. 448staticconststruct file_operations rtc_dev_fops ={
   
2. 449.owner           = THIS_MODULE,
   
3. 450.llseek           = no_llseek,
   
4. 451.read             = rtc_dev_read,
   
5. 452.poll              = rtc_dev_poll,
   
6. 453.unlocked_ioctl = rtc_dev_ioctl,
   
7. 454.open             = rtc_dev_open,
   
8. 455.release         = rtc_dev_release,
   
9. 456.fasync          = rtc_dev_fasync,
   
10. 457};

复制代码

        看到示例代码60.1.3是不是很熟悉了，标准的字符设备操作集。应用程序可以通过ioctl函数来设置/读取时间、设置/读取闹钟的操作，那么对应的rtc_dev_ioctl函数就会执行， rtc_dev_ioctl最终会通过操作rtc_class_ops中的read_time、set_time等函数来对具体RTC设备的读写操作。我们简单来看一下rtc_dev_ioctl函数，函数内容如下(有省略)：
示例代码60.1.4 rtc_dev_ioctl函数代码段

1. 218staticlong rtc_dev_ioctl(struct file *file,
   
2. 219unsignedint cmd,unsignedlong arg)
   
3. 220{
   
4. 221int err =0;
   
5. 222struct rtc_device *rtc = file->private_data;
   
6. 223conststruct rtc_class_ops *ops = rtc->ops;
   
7. 224struct rtc_time tm;
   
8. 225struct rtc_wkalrm alarm;
   
9. 226void __user *uarg =(void __user *) arg;
   
10. 227
    
11. 228     err = mutex_lock_interruptible(&rtc->ops_lock);
    
12. 229if(err)
    
13. 230return err;
    
14. ......
    
15. 269switch(cmd){
    
16. ......
    
17. 333case RTC_RD_TIME:/* 读取时间 */
    
18. 334         mutex_unlock(&rtc->ops_lock);
    
19. 335
    
20. 336         err = rtc_read_time(rtc,&tm);
    
21. 337if(err <0)
    
22. 338return err;
    
23. 339
    
24. 340if(copy_to_user(uarg,&tm,sizeof(tm)))
    
25. 341             err =-EFAULT;
    
26. 342return err;
    
27. 343
    
28. 344case RTC_SET_TIME:/* 设置时间 */
    
29. 345         mutex_unlock(&rtc->ops_lock);
    
30. 346
    
31. 347if(copy_from_user(&tm, uarg,sizeof(tm)))
    
32. 348return-EFAULT;
    
33. 349
    
34. 350return rtc_set_time(rtc,&tm);
    
35. ......
    
36. 401default:
    
37. 402/* Finally try the driver's ioctl interface */
    
38. 403if(ops->ioctl){
    
39. 404             err = ops->ioctl(rtc->dev.parent, cmd, arg);
    
40. 405if(err ==-ENOIOCTLCMD)
    
41. 406                 err =-ENOTTY;
    
42. 407}else
    
43. 408             err =-ENOTTY;
    
44. 409break;
    
45. 410}
    
46. 411
    
47. 412 done:
    
48. 413     mutex_unlock(&rtc->ops_lock);
    
49. 414return err;
    
50. 415}

复制代码

        第333行，RTC_RD_TIME为时间读取命令。
        第336行，如果是读取时间命令的话就调用rtc_read_time函数获取当前RTC时钟，rtc_read_time函数，rtc_read_time会调用__rtc_read_time函数，__rtc_read_time函数内容如下：
示例代码60.1.5 __rtc_read_time函数代码段

1. 23staticint __rtc_read_time(struct rtc_device *rtc,
   
2. struct rtc_time *tm)
   
3. 24{
   
4. 25        int err;
   
5. 26        if(!rtc->ops)
   
6. 27        err =-ENODEV;
   
7. 28        elseif(!rtc->ops->read_time)
   
8. 29        err =-EINVAL;
   
9. 30        else{
   
10. 31        memset(tm,0,sizeof(struct rtc_time));
    
11. 32        err = rtc->ops->read_time(rtc->dev.parent, tm);
    
12. 33        if(err <0){
    
13. 34                dev_dbg(&rtc->dev,"read_time: fail to read: %d\n",
    
14. 35                err);
    
15. 36                return err;
    
16. 37                }
    
17. 38
    
18. 39        err = rtc_valid_tm(tm);
    
19. 40        if(err <0)
    
20. 41                dev_dbg(&rtc->dev,"read_time: rtc_time isn't valid\n");
    
21. 42        }
    
22. 43        return err;
    
23. 44}

复制代码

        从示例代码60.1.5中的32行可以看出，__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函数来获取闹钟值。
        至此，Linux内核中RTC驱动调用流程就很清晰了，如图60.1.1所示：

图60.1.1 Linux RTC驱动调用流程

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

1. struct rtc_device *rtc_device_register(const char                                 *name,
   
2.                                                           struct device                         *dev,
   
3.                                                           const struct rtc_class_ops         *ops,
   
4.                                                           struct module                         *owner)

复制代码

函数参数和返回值含义如下：
        name：设备名字。
        dev：设备。
        ops：RTC底层驱动函数集。
        owner：驱动模块拥有者。
        返回值：注册成功的话就返回rtc_device，错误的话会返回一个负值。
        当卸载RTC驱动的时候需要调用rtc_device_unregister函数来注销注册的rtc_device，函数原型如下：

1. void rtc_device_unregister(struct rtc_device  *rtc)

复制代码

函数参数和返回值含义如下：
        rtc：要删除的rtc_device。
        返回值：无。
        还有另外一对rtc_device注册函数devm_rtc_device_register和devm_rtc_device_unregister，分别为注册和注销rtc_device。
60.2 I.MX6U内部RTC驱动分析
        先直接告诉大家，I.MX6U的RTC驱动我们不用自己编写，因为NXP已经写好了。其实对于大多数的SOC来讲，内部RTC驱动都不需要我们去编写，半导体厂商会编写好。但是这不代表我们就偷懒了，虽然不用编写RTC驱动，但是我们得看一下这些原厂是怎么编写RTC驱动的。
        分析驱动，先从设备树入手，打开imx6ull.dtsi，在里面找到如下snvs_rtc设备节点，节点内容如下所示：
示例代码60.2.1 imx6ull.dtsi文件rtc设备节点

1. 1 snvs_rtc: snvs-rtc-lp {
   
2. 2     compatible ="fsl,sec-v4.0-mon-rtc-lp";
   
3. 3     regmap =<&snvs>;
   
4. 4     offset =<0x34>;
   
5. 5     interrupts =<GIC_SPI 19 IRQ_TYPE_LEVEL_HIGH>,<GIC_SPI 20
   
6. IRQ_TYPE_LEVEL_HIGH>;
   
7. 6};

复制代码

        第2行设置兼容属性compatible的值为“fsl,sec-v4.0-mon-rtc-lp”，因此在Linux内核源码中搜索此字符串即可找到对应的驱动文件，此文件为drivers/rtc/rtc-snvs.c，在rtc-snvs.c文件中找到如下所示内容：
示例代码60.2.2 rtc设备platform驱动框架

1. 380staticconststruct of_device_id snvs_dt_ids[]={
   
2. 381{.compatible ="fsl,sec-v4.0-mon-rtc-lp",},
   
3. 382{/* sentinel */}
   
4. 383};
   
5. 384 MODULE_DEVICE_TABLE(of, snvs_dt_ids);
   
6. 385
   
7. 386staticstruct platform_driver snvs_rtc_driver ={
   
8. 387.driver ={
   
9. 388.name   ="snvs_rtc",
   
10. 389.pm = SNVS_RTC_PM_OPS,
    
11. 390.of_match_table = snvs_dt_ids,
    
12. 391},
    
13. 392.probe      = snvs_rtc_probe,
    
14. 393};
    
15. 394 module_platform_driver(snvs_rtc_driver);

复制代码

        第380~383行，设备树ID表，有一条compatible属性，值为“fsl,sec-v4.0-mon-rtc-lp”，因此imx6ull.dtsi中的snvs_rtc设备节点会和此驱动匹配。
        第386~393行，标准的platform驱动框架，当设备和驱动匹配成功以后snvs_rtc_probe函数就会执行。我们来看一下snvs_rtc_probe函数，函数内容如下(有省略)：
示例代码60.2.3 snvs_rtc_probe函数代码段

1. 238staticint snvs_rtc_probe(struct platform_device *pdev)
   
2. 239{
   
3. 240struct snvs_rtc_data *data;
   
4. 241struct resource *res;
   
5. 242int ret;
   
6. 243void __iomem *mmio;
   
7. 244
   
8. 245     data = devm_kzalloc(&pdev->dev,sizeof(*data), GFP_KERNEL);
   
9. 246if(!data)
   
10. 247return-ENOMEM;
    
11. 248
    
12. 249     data->regmap =
    
13. syscon_regmap_lookup_by_phandle(pdev->dev.of_node,"regmap");
    
14. 250
    
15. 251if(IS_ERR(data->regmap)){
    
16. 252         dev_warn(&pdev->dev,"snvs rtc: you use old dts file,
    
17. please update it\n");
    
18. 253         res = platform_get_resource(pdev, IORESOURCE_MEM,0);
    
19. 254
    
20. 255         mmio = devm_ioremap_resource(&pdev->dev, res);
    
21. 256if(IS_ERR(mmio))
    
22. 257return PTR_ERR(mmio);
    
23. 258
    
24. 259         data->regmap = devm_regmap_init_mmio(&pdev->dev, mmio,
    
25. &snvs_rtc_config);
    
26. 260}else{
    
27. 261         data->offset = SNVS_LPREGISTER_OFFSET;
    
28. 262         of_property_read_u32(pdev->dev.of_node,"offset",
    
29. &data->offset);
    
30. 263}
    
31. 264
    
32. 265if(!data->regmap){
    
33. 266         dev_err(&pdev->dev,"Can't find snvs syscon\n");
    
34. 267return-ENODEV;
    
35. 268}
    
36. 269
    
37. 270     data->irq = platform_get_irq(pdev,0);
    
38. 271if(data->irq <0)
    
39. 272return data->irq;
    
40. ......
    
41. 285
    
42. 286     platform_set_drvdata(pdev, data);
    
43. 287
    
44. 288/* Initialize glitch detect */
    
45. 289     regmap_write(data->regmap, data->offset + SNVS_LPPGDR,
    
46. SNVS_LPPGDR_INIT);
    
47. 290
    
48. 291/* Clear interrupt status */
    
49. 292     regmap_write(data->regmap, data->offset + SNVS_LPSR,
    
50. 0xffffffff);
    
51. 293
    
52. 294/* Enable RTC */
    
53. 295     snvs_rtc_enable(data, true);
    
54. 296
    
55. 297     device_init_wakeup(&pdev->dev, true);
    
56. 298
    
57. 299     ret = devm_request_irq(&pdev->dev, data->irq,
    
58. snvs_rtc_irq_handler,
    
59. 300                             IRQF_SHARED,"rtc alarm",&pdev->dev);
    
60. 301if(ret){
    
61. 302         dev_err(&pdev->dev,"failed to request irq %d: %d\n",
    
62. 303             data->irq, ret);
    
63. 304goto error_rtc_device_register;
    
64. 305}
    
65. 306
    
66. 307     data->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
    
67. 308&snvs_rtc_ops, THIS_MODULE);
    
68. 309if(IS_ERR(data->rtc)){
    
69. 310         ret = PTR_ERR(data->rtc);
    
70. 311         dev_err(&pdev->dev,"failed to register rtc: %d\n", ret);
    
71. 312goto error_rtc_device_register;
    
72. 313}
    
73. 314
    
74. 315return0;
    
75. 316
    
76. 317 error_rtc_device_register:
    
77. 318if(data->clk)
    
78. 319         clk_disable_unprepare(data->clk);
    
79. 320
    
80. 321return ret;
    
81. 322}

复制代码

        第253行，调用platform_get_resource函数从设备树中获取到RTC外设寄存器基地址。
        第255行，调用函数devm_ioremap_resource完成内存映射，得到RTC外设寄存器物理基地址对应的虚拟地址。
        第259行，Linux3.1引入了一个全新的regmap机制，regmap用于提供一套方便的API函数去操作底层硬件寄存器，以提高代码的可重用性。snvs-rtc.c文件会采用regmap机制来读写RTC底层硬件寄存器。这里使用devm_regmap_init_mmio函数将RTC的硬件寄存器转化为regmap形式，这样regmap机制的regmap_write、regmap_read等API函数才能操作寄存器。
        第270行，从设备树中获取RTC的中断号。
        第289行，设置RTC_ LPPGDR寄存器值为SNVS_LPPGDR_INIT= 0x41736166，这里就是用的regmap机制的regmap_write函数完成对寄存器进行写操作。
        第292行，设置RTC_LPSR寄存器，写入0xffffffff，LPSR是RTC状态寄存器，写1清零，因此这一步就是清除LPSR寄存器。
        第295行，调用snvs_rtc_enable函数使能RTC，此函数会设置RTC_LPCR寄存器。
        第299行，调用devm_request_irq函数请求RTC中断，中断服务函数为snvs_rtc_irq_handler，用于RTC闹钟中断。
        第307行，调用devm_rtc_device_register函数向系统注册rtc_devcie，RTC底层驱动集为snvs_rtc_ops。snvs_rtc_ops操作集包含了读取/设置RTC时间，读取/设置闹钟等函数。snvs_rtc_ops内容如下：
示例代码60.2.4 snvs_rtc_ops操作集

1. 200staticconststruct rtc_class_ops snvs_rtc_ops ={
   
2. 201.read_time = snvs_rtc_read_time,
   
3. 202.set_time = snvs_rtc_set_time,
   
4. 203.read_alarm = snvs_rtc_read_alarm,
   
5. 204.set_alarm = snvs_rtc_set_alarm,
   
6. 205.alarm_irq_enable = snvs_rtc_alarm_irq_enable,
   
7. 206};

复制代码

        我们就以第201行的snvs_rtc_read_time函数为例讲解一下rtc_class_ops的各个RTC底层操作函数该如何去编写。snvs_rtc_read_time函数用于读取RTC时间值，此函数内容如下所示：
示例代码60.2.5 snvs_rtc_read_time函数代码段

1. 126staticint snvs_rtc_read_time(struct device *dev,
   
2. struct rtc_time *tm)
   
3. 127{
   
4. 128struct snvs_rtc_data *data = dev_get_drvdata(dev);
   
5. 129unsignedlong time = rtc_read_lp_counter(data);
   
6. 130
   
7. 131     rtc_time_to_tm(time, tm);
   
8. 132
   
9. 133return0;
   
10. 134}

复制代码

        第129行，调用rtc_read_lp_counter获取RTC计数值，这个时间值是秒数。
        第131行，调用rtc_time_to_tm函数将获取到的秒数转换为时间值，也就是rtc_time结构体类型，rtc_time结构体定义如下：
示例代码60.2.6 rtc_time结构体类型

1. 20struct rtc_time {
   
2. 21        int tm_sec;
   
3. 22        int tm_min;
   
4. 23        int tm_hour;
   
5. 24        int tm_mday;
   
6. 25        int tm_mon;
   
7. 26        int tm_year;
   
8. 27        int tm_wday;
   
9. 28        int tm_yday;
   
10. 29        int tm_isdst;
    
11. 30};

复制代码

        最后我们来看一下rtc_read_lp_counter函数，此函数用于读取RTC计数值，函数内容如下(有省略)：
示例代码60.2.7 rtc_read_lp_counter函数代码段

1. 50static u32 rtc_read_lp_counter(struct snvs_rtc_data *data)
   
2. 51{
   
3. 52        u64 read1, read2;
   
4. 53                u32 val;
   
5. 54
   
6. 55                do{
   
7. 56        regmap_read(data->regmap, data->offset + SNVS_LPSRTCMR,
   
8. &val);
   
9. 57        read1 = val;
   
10. 58        read1 <<=32;
    
11. 59        regmap_read(data->regmap, data->offset + SNVS_LPSRTCLR,
    
12. &val);
    
13. 60        read1 |= val;
    
14. 61
    
15. 62        regmap_read(data->regmap, data->offset + SNVS_LPSRTCMR,
    
16. &val);
    
17. 63        read2 = val;
    
18. 64        read2 <<=32;
    
19. 65        regmap_read(data->regmap, data->offset + SNVS_LPSRTCLR,
    
20. &val);
    
21. 66        read2 |= val;
    
22. 67        /*
    
23. 68        * when CPU/BUS are running at low speed, there is chance that
    
24. 69         * we never get same value during two consecutive read, so here
    
25. 70        * we only compare the second value.
    
26. 71        */
    
27. 72        }while((read1 >> CNTR_TO_SECS_SH)!=(read2 >>
    
28. CNTR_TO_SECS_SH));
    
29. 73
    
30. 74        /* Convert 47-bit counter to 32-bit raw second count */
    
31. 75                return(u32)(read1 >> CNTR_TO_SECS_SH);
    
32. 76}

复制代码

        第56~72行，读取RTC_LPSRTCMR和RTC_LPSRTCLR这两个寄存器，得到RTC的计数值，单位为秒，这个秒数就是当前时间。这里读取了两次RTC计数值，因为要读取两个寄存器，因此可能存在读取第二个寄存器的时候时间数据更新了，导致时间不匹配，因此这里连续读两次，如果两次的时间值相等那么就表示时间数据有效。
        第75行，返回时间值，注意这里将前面读取到的RTC计数值右移了15位。
        这个就是snvs_rtc_read_time函数读取RTC时间值的过程，至于其他的底层操作函数大家自行分析即可，都是大同小异的，这里就不再分析了。关于I.MX6U内部RTC驱动源码就讲解到这里。
60.3 RTC时间查看与设置
        1、时间RTC查看
        RTC是用来计时的，因此最基本的就是查看时间，Linux内核启动的时候可以看到系统时钟设置信息，如图60.3.1所示：

图60.3.1 Linux启动log信息

        从图60.3.1中可以看出，Linux内核在启动的时候将snvs_rtc设置为rtc0，大家的启动信息可能会和图60.3.1中的不同，但是内容基本上都是一样的。
        如果要查看时间的话输入“date”命令即可，结果如图60.3.2所示：

图60.3.2 当前时间值

        从图60.3.2可以看出，当前时间为1970年1月1日00:06:11，很明显是时间不对，我们需要重新设置RTC时间。
        2、设置RTC时间
        RTC时间设置也是使用的date命令，输入“date--help”命令即可查看date命令如何设置系统时间，结果如图60.3.3所示：

图60.3.3 date命令帮助信息

        现在我要设置当前时间为2019年8月31日18:13:00，因此输入如下命令：

1. date -s "2019-08-31 18:13:00"

复制代码

        设置完成以后再次使用date命令查看一下当前时间就会发现时间改过来了，如图60.3.4所示：

图60.3.4 当前时间

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

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

复制代码

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

armok.

打赏！

庆祝论坛“打赏”功能实施， 现在开始发技术主题，可以获得打赏
https://www.amobbs.com/thread-5735948-1-1.html