Linux RTC驱动实验
+ P  m9 V# W8 r1 X4 L8 z& @RTC也就是实时时钟，用于记录当前系统时间，对于Linux系统而言时间是非常重要的，就和我们使用Windows电脑或手机查看时间一样，我们在使用Linux设备的时候也需要查看时间。本章我们就来学习一下如何编写Linux下的RTC驱动程序。
3 `% h; @* l( c3 d" H% H
42.1 Linux内核RTC驱动简介
RTC设备驱动是一个标准的字符设备驱动，应用程序通过open、release、read、write和ioctl等函数完成对RTC设备的操作，本章我们主要学习如何使用STM32MP1内部自带的RTC外设。
* m: K& v0 ^5 b4 Y0 Z9 iLinux内核将RTC设备抽象为rtc_device结构体，因此RTC设备驱动就是申请并初始化rtc_device，最后将rtc_device注册到Linux内核里面，这样Linux内核就有一个RTC设备的。至于RTC设备的操作肯定是用一个操作集合(结构体)来表示的，我们先来看一下rtc_device构体，此结构体定义在include/linux/rtc.h文件中，结构体内容如下(删除条件编译)：
1 `& f0 }! C( B% a5 L! H! T. a

1. 示例代码42.1.1 rtc_device结构体
   
2. 100 struct rtc_device {
   6 E+ q: J+ _/ F" g8 p, F
3. 101     struct device dev;                          /*  设备                  */
   7 G, k. D7 B$ `7 b3 g4 w! M- G
4. 102     struct module *owner;
   ) X7 d# L4 N4 g' t. p
5. 103
   ! @* D, x/ ?# h4 i3 g5 c3 [
6. 104     int id;                                             /* ID                     */
   ) G. y. F# e7 `2 U/ y6 Q
7. 105
   
8. 106     const struct rtc_class_ops *ops;          /* RTC设备底层操作函数 */
   ) w6 [3 w" v+ M5 C, \% U. o7 C
9. 107     struct mutex ops_lock;
   
10. 108
    ! X' e8 l7 ^! [- k+ s4 G' G5 L  k, J
11. 109     struct cdev char_dev;                       /* 字符设备                */
    
12. 110     unsigned long flags;
    
13. 111
    
14. 112     unsigned long irq_data;
    + V* N+ F7 f/ q; W" O
15. 113     spinlock_t irq_lock;
    
16. 114     wait_queue_head_t irq_queue;
    
17. 115     struct fasync_struct *async_queue;
    
18. 116
    ' m$ y( R- `/ A+ S/ Y  b2 M- `5 S' F
19. 117     int irq_freq;
    9 t2 R/ R$ ]1 L$ R8 @" I4 z
20. 118     int max_user_freq;
    1 N& l) l+ N. `0 p
21. 119
    
22. 120     struct timerqueue_head timerqueue;
    
23. 121     struct rtc_timer aie_timer;
    
24. 122     struct rtc_timer uie_rtctimer;
    
25. 123     struct hrtimer pie_timer; /* sub second exp, so needs hrtimer */
    
26. 124     int pie_enabled;
    
27. 125     struct work_struct irqwork;
    / t4 h& x3 g, a! j! ]9 t1 O
28. 126     /* Some hardware can't support UIE mode */
    
29. 127     int uie_unsupported;
    
30. ......
    
31. 159 };

复制代码

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

1. 示例代码42.1.2 rtc_class_ops 结构体
   
2. 75  struct rtc_class_ops {
   
3. 76      int (*ioctl)(struct device *, unsigned int, unsigned long);
   
4. 77      int (*read_time)(struct device *, struct rtc_time *);
   $ ^7 y6 t( h( C0 u
5. 78      int (*set_time)(struct device *, struct rtc_time *);
   
6. 79      int (*read_alarm)(struct device *, struct rtc_wkalrm *);
   
7. 80      int (*set_alarm)(struct device *, struct rtc_wkalrm *);
   : P- @- H! V: u; m5 b
8. 81      int (*proc)(struct device *, struct seq_file *);
   3 `5 n7 p; s6 a/ s$ \+ A; A
9. 82      int (*alarm_irq_enable)(struct device *, unsigned int enabled);
   
10. 83      int (*read_offset)(struct device *, long *offset);
    
11. 84      int (*set_offset)(struct device *, long offset);
    
12. 85  };

复制代码

看名字就知道rtc_class_ops操作集合中的这些函数是做什么的了，但是我们要注意，rtc_class_ops中的这些函数只是最底层的RTC设备操作函数，并不是提供给应用层的file_operations函数操作集。RTC是个字符设备，那么肯定有字符设备的file_operations函数操作集，Linux内核提供了一个RTC通用字符设备驱动文件，文件名为drivers/rtc/dev.c，dev.c文件提供了所有RTC设备共用的file_operations函数操作集，如下所示：

+ x( P& L' M' g( i% L- Z  x

1. 示例代码42.1.3 RTC通用 file_operations操作集
   
2. 431 static const struct file_operations rtc_dev_fops = {
   
3. 432     .owner           = THIS_MODULE,
   
4. 433     .llseek          = no_llseek,
   
5. 434     .read             = rtc_dev_read,
   5 |4 z0 }8 y( f7 E- c5 g1 k
6. 435     .poll             = rtc_dev_poll,
   
7. 436     .unlocked_ioctl = rtc_dev_ioctl,
   5 E5 J3 F& f7 t& U* l
8. 437     .open             = rtc_dev_open,
   
9. 438     .release         = rtc_dev_release,
   - V6 @1 q- [4 N# J& E! C; n
10. 439     .fasync           = rtc_dev_fasync,
    
11. 440 };

复制代码

看到示例代码42.1.3是不是很熟悉了，标准的字符设备操作集。应用程序可以通过ioctl函数来设置/读取时间、设置/读取闹钟的操作，对应的rtc_dev_ioctl函数就会执行。 rtc_dev_ioctl最终会通过操作rtc_class_ops中的read_time、set_time等函数来对具体RTC设备的读写操作。我们简单来看一下rtc_dev_ioctl函数，函数内容如下(有省略)：
, [" I4 `; u6 t+ B
  P7 r: k! G- W" p' E

1. 示例代码42.1.4 rtc_dev_ioctl函数代码段
   + d% B6 t5 P0 `* [& t6 B' C5 p0 r1 {: L& ~
2. 202 static long rtc_dev_ioctl(struct file *file,
   
3. 203               unsigned int cmd, unsigned long arg)
   + ~$ b- R7 {9 E+ E/ W* X
4. 204 {
   
5. 205     int err = 0;
   ! {$ Y9 o- F# S  |
6. 206     struct rtc_device *rtc = file->private_data;
   
7. 207     const struct rtc_class_ops *ops = rtc->ops;
   
8. 208     struct rtc_time tm;
   
9. 209     struct rtc_wkalrm alarm;
   % q. `. @- i/ L) N, e+ @
10. 210     void __user *uarg = (void __user *)arg;
    8 @6 `. f$ X6 b
11. 211
      }/ ~: ]5 a: G0 g- h7 v3 q
12. 212     err = mutex_lock_interruptible(&rtc->ops_lock);
    
13. 213     if (err)
    
14. 214         return err;
    
15. ......
    0 E6 ^) H) t0 a7 N
16. 253     switch (cmd) {
    ) X! j# G/ p( c$ d' @/ o6 X7 e
17. ......
    
18. 317     case RTC_RD_TIME:       /* 读取时间 */
    ! _; W7 \& k; G' B3 T
19. 318         mutex_unlock(&rtc->ops_lock);
    * k# C3 {2 M0 Q; o
20. 319
    
21. 320         err = rtc_read_time(rtc, &tm);
    
22. 321         if (err < 0)
    1 j" A1 a0 w6 G, F) t" f
23. 322             return err;
    
24. 323
    
25. 324         if (copy_to_user(uarg, &tm, sizeof(tm)))
    
26. 325             err = -EFAULT;
    ! k3 b$ c; b: @- U6 ~7 S' l
27. 326         return err;
    
28. 327
    , G* n" U/ b* x( f$ E1 Y
29. 328     case RTC_SET_TIME:      /* 设置时间 */
    : H3 n* j) y6 \" ^9 C5 q1 @" u
30. 329         mutex_unlock(&rtc->ops_lock);
    - y; w7 M+ h7 a* m; Y+ s3 c
31. 330
    
32. 331         if (copy_from_user(&tm, uarg, sizeof(tm)))
    . o" S3 M, }7 ~. x& V' C( n
33. 332             return -EFAULT;
    & _2 V) q- _! b2 y1 X8 ?* h( k) _
34. 333
    & V1 M1 v1 w& x+ y
35. 334         return rtc_set_time(rtc, &tm);
    1 ?$ {, m! v' N' w5 W, s. L7 ~! H
36. .....
    
37. 385     default:
    ( @" K. k  b2 x5 Q( [  U
38. 386         /* Finally try the driver's ioctl interface */
    
39. 387         if (ops->ioctl) {
      k- |- u* g% P6 I0 [
40. 388             err = ops->ioctl(rtc->dev.parent, cmd, arg);
    2 \* w% H' M; k; D7 ~9 m; i2 y
41. 389             if (err == -ENOIOCTLCMD)
    
42. 390                 err = -ENOTTY;
    
43. 391         } else {
    2 t0 D1 k0 W3 m  z' g
44. 392             err = -ENOTTY;
    
45. 393         }
    
46. 394         break;
    
47. 395     }
    8 Y. g) |$ F% H8 \/ h  W
48. 396
    
49. 397 done:
    & f, E# q9 \: e1 ^4 f
50. 398     mutex_unlock(&rtc->ops_lock);
    
51. 399     return err;
    
52. 400 }

复制代码

- a. r' ]  w% C5 C2 G- P第317行，RTC_RD_TIME为时间读取命令。
第320行，如果是读取时间命令的话就调用rtc_read_time函数获取当前RTC时钟， rtc_read_time会调用__rtc_read_time函数，__rtc_read_time函数内容如下：

) g, e7 X5 D# ?

1. 示例代码42.1.5 __rtc_read_time函数代码段
   
2. 84 static int __rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
   
3. 85 {
   
4. 86     int err;
   9 D% i0 _  ?# B" X- W
5. 87
   ! z6 b2 o3 U+ c& P# P% V% o& i
6. 88     if (!rtc->ops) {
   
7. 89         err = -ENODEV;
   
8. 90     } else if (!rtc->ops->read_time) {
   % g1 o3 o5 d- H4 S: x' T
9. 91         err = -EINVAL;
   . G* r, g% n1 N1 v# q
10. 92     } else {
    ' N% e8 y+ {! Q. H" C5 t! H
11. 93         memset(tm, 0, sizeof(struct rtc_time));
    
12. 94         err = rtc->ops->read_time(rtc->dev.parent, tm);
    
13. 95         if (err < 0) {
    
14. 96             dev_dbg(&rtc->dev, "read_time: fail to read: %d\n",
    $ M- F' o+ C( u) c+ N+ ^+ W1 e
15. 97                 err);
    7 Y4 C3 O' P- w/ k; C7 c
16. 98             return err;
    3 |  z; h9 r( Y9 |9 H# A/ c
17. 99         }
    
18. 100
    
19. 101         rtc_add_offset(rtc, tm);
    
20. 102
    ' m. K: c0 n9 C4 k% Q% E
21. 103         err = rtc_valid_tm(tm);
    % Q  d8 H2 m2 ]
22. 104         if (err < 0)
    
23. 105             dev_dbg(&rtc->dev, "read_time: rtc_time isn't valid\n");
    4 ?" s1 e1 W% \
24. 106     }
    
25. 107     return err;
    . Y2 _- O0 U) s( r
26. 108 }
    " k! W% j. r% s5 O; d

复制代码

7 R! ?7 u% f7 F$ R从第94行可以看出，__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函数来获取闹钟值。
9 x9 z0 Q) K( d& i: L6 @  m至此，Linux内核中RTC驱动调用流程就很清晰了，如图42.1.1所示：
! n" n  K1 H' D$ |, L
* S& V6 b. G/ _6 q( K6 a$ \
$ m0 ^3 M* Q/ ?/ S% X+ t5 `
8 q( `. q4 e) c$ K9 R* G1 Y/ a+ H9 E图42.1.1 Linux RTC驱动调用流程
  e  b/ m# q6 u7 v2 t! c) Z3 s9 \5 E当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,
   + D' U5 `, T$ L$ h9 t
3.                                                           const struct rtc_class_ops         *ops,
   
4.                                                           struct module                         *owner)

复制代码

+ i4 ^# y4 l: G0 Q函数参数和返回值含义如下：
; a) _* G2 [+ n; H' J# \  U/ ~- Hname：设备名字。
$ R: ^+ C8 X2 A7 d. E% l3 ~; Y. Vdev：设备。
ops：RTC底层驱动函数集。
8 h" M0 _( [3 Powner：驱动模块拥有者。
返回值：注册成功的话就返回rtc_device，错误的话会返回一个负值。
9 D% Z$ z# V9 q2 j: h当卸载RTC驱动的时候需要调用rtc_device_unregister函数来注销注册的rtc_device，函数原型如下：
1 r4 a! Z7 h+ M: D" W' L* r6 fvoid rtc_device_unregister(struct rtc_device *rtc)
函数参数和返回值含义如下：
rtc：要删除的rtc_device。
2 _  W9 H9 Q# i, c% w3 p! q返回值：无。
还有另外一对rtc_device注册函数devm_rtc_device_register和devm_rtc_device_unregister，分别为注册和注销rtc_device。
* d! `7 @, |& e' N  L42.2 STM32MP1内部RTC驱动分析
先直接告诉大家，STM32MP1的RTC驱动我们不用自己编写，因为ST已经写好了。其实对于大多数的SOC来讲，内部RTC驱动都不需要我们去编写，半导体厂商会编写好。但是这不代表我们就偷懒了，虽然不用编写RTC驱动，但是我们得看一下这些原厂是怎么编写RTC驱动的。
分析驱动，先从设备树入手，打开stm32mp151.dtsi，在里面找到如下rtc设备节点，节点内容如下所示：
, z! Y% x# R0 W2 E( I

1. 示例代码42.2.1 stm32mp151.dtsi文件rtc节点
   
2. 1746        rtc: rtc@5c004000 {
   $ d  ?% O7 I9 I
3. 1747                   compatible = "st,stm32mp1-rtc";
   9 N  c0 t3 d; S2 I
4. 1748              reg = <0x5c004000 0x400>;
   ' J  l: y/ |1 K1 U$ L3 q* C
5. 1749               clocks = <&scmi0_clk CK_SCMI0_RTCAPB>,
   
6. 1750                  <&scmi0_clk CK_SCMI0_RTC>;
   2 ?" A) ]& @# i4 k7 p4 L6 H; P) z: a
7. 1751              clock-names = "pclk", "rtc_ck";
   - v3 B. |8 V0 S/ h7 i  y* n; L5 ^
8. 1752               interrupts-extended = <&exti 19 IRQ_TYPE_LEVEL_HIGH>;
   # t5 K) O8 F) y5 K
9. 1753               status = "disabled";
   3 C* A* I+ i. I2 D! @' B
10. 1754          };

复制代码

5 ~# E1 B: S" w( [5 V. N第1747行设置兼容属性compatible的值为“st,stm32mp1-rtc”，因此在Linux内核源码中搜索此字符串即可找到对应的驱动文件，此文件为drivers/rtc/rtc-stm32.c，在rtc-stm32.c文件中找到如下所示内容：

9 I) O" H: C9 v$ \2 x

1. 示例代码42.2.2 设备 platform驱动框架
   
2. 719     static const struct of_device_id stm32_rtc_of_match[] = {
   3 s! n5 R$ T' n( }4 A
3. 720         { .compatible = "st,stm32-rtc", .data = &stm32_rtc_data },
   
4. 721         { .compatible = "st,stm32h7-rtc", .data = &stm32h7_rtc_data },
   , ?9 d( X5 ~! p6 |6 g
5. 722         { .compatible = "st,stm32mp1-rtc", .data = &stm32mp1_data },
   
6. 723         {}
   . O4 f' h: i* J/ ]
7. 724     };
   / L, t7 ?3 \9 M  v# D% a
8. 725     MODULE_DEVICE_TABLE(of, stm32_rtc_of_match);
   7 V$ Q: _- O, d: D7 F/ p
9. 726
   6 o+ O1 c! E: V( x- n) e
10. ......
    
11. 1020    static struct platform_driver stm32_rtc_driver = {
    9 _' D& ^& A- H8 X. Q( I! v8 V
12. 1021        .probe      = stm32_rtc_probe,
    
13. 1022        .remove     = stm32_rtc_remove,
    
14. 1023        .driver     = {
    
15. 1024            .name   = DRIVER_NAME,
    0 R0 H0 H8 U" {; n$ f
16. 1025            .pm = &stm32_rtc_pm_ops,
    
17. 1026            .of_match_table = stm32_rtc_of_match,
    0 `. R7 J2 a" K. ]# L
18. 1027        },
    
19. 1028    };
    * ^! `+ D3 D  t" [% D0 i9 m7 R
20. 1029
    
21. 1030    module_platform_driver(stm32_rtc_driver);

复制代码

/ e: @  R  \8 d" W- I, L2 w第719~723行，设备树ID表。第722行，刚好有一个compatible属性和设备树的rtc的compatible属性值一样，所以rtc设备节点会和此驱动匹配。
第1020~1028行，标准的platform驱动框架，当设备和驱动匹配成功以后stm32_rtc_probe函数就会执行，我们来看一下stm32_rtc_probe函数，函数内容如下(有省略)：

9 Y* y/ [! W9 R- y" B

1. 示例代码42.2.3 stm32_rtc_probe函数代码段
   
2. 789 static int stm32_rtc_probe(struct platform_device *pdev)
   0 ^$ g6 ~& [8 p; V
3. 790 {
   
4. 791     struct stm32_rtc *rtc;
   
5. 792     const struct stm32_rtc_registers *regs;
   
6. 793     struct resource *res;
   * e9 b: h) S0 G# c6 Z$ }/ Q
7. 794     int ret;
   
8. 795
   
9. 796     rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
   3 S; q: l7 F! _8 H" j
10. 797     if (!rtc)
    
11. 798         return -ENOMEM;
    
12. 799
    + s/ Q+ s8 u; b+ i
13. 800     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    
14. 801     rtc->base = devm_ioremap_resource(&pdev->dev, res);
    . c9 A; w6 I& U7 P  [7 q
15. ......
    
16. 856     ret = clk_prepare_enable(rtc->rtc_ck);
    
17. 857     if (ret)
    8 `& w& c' {( o- N( ?  y$ {
18. 858         goto err;
    1 }) k9 Z( S( n4 U; q, j
19. ......
    5 B9 Z' `1 ?1 j/ {' {
20. 872     ret = stm32_rtc_init(pdev, rtc);
    
21. 873     if (ret)
    7 V7 Z$ Q$ W! h& S  a
22. 874         goto err;
    ( ~3 L6 ]6 R8 v3 ~
23. 875
    
24. 876     rtc->irq_alarm = platform_get_irq(pdev, 0);
    
25. 877     if (rtc->irq_alarm <= 0) {
    
26. 878         ret = rtc->irq_alarm;
    
27. 879         goto err;
    ' i2 @8 l2 \4 t, v4 O. l3 ?! {/ B
28. 880     }
    ! J5 B, ~0 k5 l( P
29. ......
    1 \* H. Y5 V6 l1 Y+ _
30. 892     rtc->rtc_dev = devm_rtc_device_register(&pdev->dev, pdev->name,
    
31. 893                         &stm32_rtc_ops, THIS_MODULE);
    7 V" Y2 R/ G8 b% u
32. 894     if (IS_ERR(rtc->rtc_dev)) {
    
33. 895         ret = PTR_ERR(rtc->rtc_dev);
    
34. 896         dev_err(&pdev->dev, "rtc device registration failed, err=%d\n",
    
35. 897             ret);
    
36. 898         goto err;
    2 D) U* j; y& G3 b, b7 a
37. 899     }
    
38. 900
    
39. 901     /* Handle RTC alarm interrupts */
    
40. 902     ret = devm_request_threaded_irq(&pdev->dev, rtc->irq_alarm, NULL,
    
41. 903                     stm32_rtc_alarm_irq, IRQF_ONESHOT,
    ; @* _9 N, t; L/ N
42. 904                     pdev->name, rtc);
      ]/ X# R4 l5 {& {& G
43. 905     if (ret) {
    3 l' q2 {  W. o% m, V$ R% h+ @
44. 906         dev_err(&pdev->dev, "IRQ%d (alarm interrupt) already claimed\n",
    ! F$ h' t4 w( R5 S
45. 907             rtc->irq_alarm);
    - b3 c4 f; }# S9 v4 @/ Z; w  ^
46. 908         goto err;
    - O( R, M$ y5 I7 T/ |) J8 Z
47. 909     }
    , l' O# n* [1 F1 N6 k
48. ......
    ! c2 h, M2 q8 d; C8 F
49. 940
    
50. 941     return 0;
    7 T' T8 p4 u. t8 X9 L
51. ......
    
52. 954 }

复制代码

; r& P4 f7 f# S) g3 C1 b第796行，调用devm_kzalloc申请rtc大小的空间，返回申请空间的首地址。
第800行，调用 platform_get_resource 函数从设备树中获取到 RTC 外设寄存器基地址。
第801行，调用函数 devm_ioremap_resource 完成内存映射，得到 RTC 外设寄存器物理基地址对应的虚拟地址。
第856行，调用clk_prepare_enable函数使能时钟。
3 u7 Y- u: Y6 k. v第872行，初始化STM32MP1 rtc的寄存器。
第876行，获取设备树的中断号。
第892行，调用 devm_rtc_device_register 函数向系统注册 rtc_devcie，RTC 底层驱动集为stm32_rtc_ops。stm32_rtc_ops操作集包含了读取/设置RTC时间，读取/设置闹钟等函数。
' S* {) A( h, i+ P5 W! i# G! C  o第902行，调用devm_request_threaded_irq函数请求RTC中断，中断服务函数为stm32_rtc_alarm_irq，用于RTC闹钟中断。
stm32_rtc_ops内容如下所示：

1. 示例代码42.2.4 rtc_class_ops操作集
   4 \; L* x- r; e. h% J* R  J! k
2. 623 static const struct rtc_class_ops stm32_rtc_ops = {
   
3. 624     .read_time         = stm32_rtc_read_time,
   
4. 625     .set_time           = stm32_rtc_set_time,
   $ E- ~( x8 k. g. J
5. 626     .read_alarm         = stm32_rtc_read_alarm,
   ; }' l0 y7 m- m2 V! ~
6. 627     .set_alarm          = stm32_rtc_set_alarm,
   / i! H" z/ d0 p! T2 C' K
7. 628     .alarm_irq_enable = stm32_rtc_alarm_irq_enable,
   0 X2 i% F+ j: X& r
8. 629 };

复制代码

我们就以第624行的stm32_rtc_read_time函数为例讲解一下rtc_class_ops的各个RTC底层操作函数该如何去编写。stm32_rtc_read_time函数用于读取RTC时间值，此函数内容如下所示：
# h9 S' @0 z% M" p
, e, j- G/ W, F0 H8 O- w. l

1. 示例代码42.2.5 stm32_rtc_read_time代码段
   2 q3 s3 Q, Q  T% ~" n. o
2. 364 static int stm32_rtc_read_time(struct device *dev,
   
3. struct rtc_time *tm)
   ! o5 ^+ B: k* C0 |4 {- m- H/ c
4. 365 {
   - w6 |# {! z  v! u8 l; H
5. 366     struct stm32_rtc *rtc = dev_get_drvdata(dev);
   
6. 367     const struct stm32_rtc_registers *regs = &rtc->data->regs;
   
7. 368     unsigned int tr, dr;
   
8. 369
   
9. 370     /* Time and Date in BCD format */
   9 B9 @8 K# g, v$ G
10. 371     tr = readl_relaxed(rtc->base + regs->tr);
    6 W( |( n* N) @# j3 f. H: k
11. 372     dr = readl_relaxed(rtc->base + regs->dr);
    
12. 373
    3 J8 G' B% Z: d3 U9 p# N
13. 374     tm->tm_sec = (tr & STM32_RTC_TR_SEC) >> STM32_RTC_TR_SEC_SHIFT;
    # l, d- g7 g: T8 s5 ?1 Z* {
14. 375     tm->tm_min = (tr & STM32_RTC_TR_MIN) >> STM32_RTC_TR_MIN_SHIFT;
    - A$ D9 ~" J1 U% q  @' w
15. 376     tm->tm_hour = (tr & STM32_RTC_TR_HOUR) >> STM32_RTC_TR_HOUR_SHIFT;
    
16. 377
    # t! v/ p/ I* g  X
17. 378     tm->tm_mday = (dr & STM32_RTC_DR_DATE) >> STM32_RTC_DR_DATE_SHIFT;
    
18. 379     tm->tm_mon = (dr & STM32_RTC_DR_MONTH) >> STM32_RTC_DR_MONTH_SHIFT;
    
19. 380     tm->tm_year = (dr & STM32_RTC_DR_YEAR) >> STM32_RTC_DR_YEAR_SHIFT;
    
20. 381     tm->tm_wday = (dr & STM32_RTC_DR_WDAY) >> STM32_RTC_DR_WDAY_SHIFT;
    & _5 p6 C( S" w/ `
21. 382
    
22. 383     /* We don't report tm_yday and tm_isdst */
    9 d& H9 p, w* c+ Z% k" M
23. 384
    
24. 385     bcd2tm(tm);
    
25. 386
    
26. 387     return 0;
    $ T3 @$ a2 U2 C. |/ Q
27. 388 }
    

复制代码

" h6 C9 L+ y+ P7 L% y1 B第371~372行，调用readl_relaxed读取STM32MP1的RTC_TR和RTC_DR这两个寄存器的值，其中TR寄存器为RTC时间寄存器，保存着时、分、秒信息；DR为RTC的日期寄存器，保存着年、月、日信息。通过这两个寄存器我们就可以得到RTC时间
第374~381行，前两行获取到了TR和DR这两个寄存器的值，这里需要从这两个寄存器值中提取出具体的年、月、日和时、分、秒信息。
第385行，上面得到的时间信息为BCD格式的，这里通过bcd2tm函数将BCD格式转换为rtc_time格式， rtc_time结构体定义如下：
" R: R* B' `3 @& Q/ A
1 E6 N, Q5 _' _. r( O% ^

1. 示例代码42.2.6 rtc_time结构体类型
   
2. 20 sruct rtc_time {
   1 {) X4 V. e7 D4 q% t. t
3. 21          int tm_sec;
   
4. 22          int tm_min;
   3 @7 H$ K( q' P$ `
5. 23          int tm_hour;
   . q" h: ]: {- `, w2 r( |
6. 24          int tm_mday;
   
7. 25          int tm_mon;
   3 Q% Q5 e0 |1 G) T  l5 G/ L
8. 26          int tm_year;
   ' P! c% b7 _6 C
9. 27          int tm_wday;
   
10. 28          int tm_yday;
    / X, X# c( o/ S. a! m
11. 29          int tm_isdst;
      K5 y, k& x/ z: G; [; ~1 m
12. 30 };

复制代码

42.3 RTC时间查看与设置
+ e' N* r0 I, V* Z0 x1 ?% w/ B42.3.1 使能内部RTC
8 j# O$ E3 g7 {% j: ?# t6 d' u在Linux内核移植的时候，设备树是经过精简的，就没有启动RTC功能。打开stm32mp157d-atk.dts文件，添加如下代码所示：
示例代码42.3.1.1 rtc节点信息
% {7 D0 f2 c  b

1. 1 &rtc {
   , M. q; ]2 L* j8 r
2. 2 status = “okay”;
   
3. 3 };

复制代码

追加的RTC节点内容很简单，就是把status属性改为“okay”。接着我们重新编译设备树，然后使用新编译的stm32mp157d-atk.dtb文件启动开发板。
7 O; G2 V: g$ k42.3.2 查看时间
+ X! H0 ^2 |& a7 j8 pRTC是用来记时的，因此最基本的就是查看时间，Linux内核启动的时候可以看到系统时钟设置信息，如图42.3.2.1所示：
  w- I! U- F# G  l  B1 ^8 @


图42.3.2.1 Linux启动log信息
1 C6 ~/ C8 W6 y9 |5 P/ _+ c+ D9 X从图42.3.2.1中可以看出，Linux内核在启动的时候将rtc设置为rtc0，大家的启动信息可能会和图42.3.2.1中不同，但是基本上都是一样的。
; C7 n0 h. w2 b2 v( j2 {5 e& H如果要查看时间的话输入“date”命令即可，结果如图42.3.2.2所示：

8 R* i8 s, x6 b- t! z

% K) [! R* B. A图42.3.2.2 当前时间值
从图42.3.2.2可以看出，当前时间为2000年1月1日 03:30:29，很明显时间不对，我们需要重新设置RTC时间。
) ~* e7 [* Z, V% O+ K6 ^4 WRTC时间设置也是使用的date命令，输入“date --help”命令即可查看date命令如何设置系统时间，结果如图42.3.2.3所示：
% @2 r9 c1 T. x) B9 R+ F
2 x: q3 m( Q+ x* b) V

' s" [% h6 o# W+ e/ R图42.3.2.3 date命令帮助信息
比如现在设置当前时间为2021年5月2日 18:53:00，因此输入如下命令：
date -s “2021-05-02 18:53:00”
设置完成以后再次使用date命令查看一下当前时间就会发现时间改过来了，如图42.3.2.4所示：



图42.3.2.4 当前时间
3 e9 j3 ?3 w8 K; V/ l& t" B大家注意我们使用“date -s”命令仅仅是修改了当前时间，此时间还没有写入到STM32MP1内部RTC里面或其他的RTC芯片里面，因此系统重启以后时间又会丢失。我们需要将当前的时间写入到RTC里面，这里要用到hwclock命令，输入如下命令将系统时间写入到RTC里面：
hwclock -w //将当前系统时间写入到RTC里面
% a; ?9 i7 k% _% f5 x, U$ M: C8 H3 e0 l时间写入到RTC里面以后就不怕系统重启以后时间丢失了，如果STM32MP1开发板底板接了纽扣电池，那么开发板即使断电了时间也不会丢失。大家可以尝试一下不断电重启和断电重启这两种情况下开发板时间会不会丢失。
————————————————
* U8 P# |( Z' ~3 L. k版权声明：正点原子