Linux驱动修炼之道-RTC子系统框架与源码分析【转】

转自：http://helloyesyes.iteye.com/blog/1072433

努力成为linux kernel hacker的人李万鹏原创作品，为梦而战。转载请标明出处

http://blog.csdn.net/woshixingaaa/archive/2011/05/21/6436215.aspx

RTC(实时时钟)是一种典型的字符设备，作为一种字符设备驱动，RTC需要有file_operations中接口函数的实现，如open(),release(),read(),poll(),ioctl()等,而典型的ioctl包括RTC_SET_TIME,RTC_ALM_READ,RTC_ALM_SET,RTC_IRQP_SET,RTC_IRQP_READ等，这些对于所有的RTC是通用的，只有底层的具体实现是设备相关的。如下图可以清楚看出RTC子系统的框架。

下面介绍几个重要的数据结构：

rtc_device用来描述rtc设备：

1. struct rtc_device
2. {
3. struct device dev;
4. struct module *owner;
5. int id;                                   //RTC设备的次设备号
6. char name[RTC_DEVICE_NAME_SIZE];
7. const struct rtc_class_ops *ops;
8. struct mutex ops_lock;
9. struct cdev char_dev;
10. unsigned long flags;
11. unsigned long irq_data;
12. spinlock_t irq_lock;
13. wait_queue_head_t irq_queue;
14. struct fasync_struct *async_queue;
15. struct rtc_task *irq_task;
16. spinlock_t irq_task_lock;
17. int irq_freq;
18. int max_user_freq;
19. #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
20. struct work_struct uie_task;
21. struct timer_list uie_timer;
22. /* Those fields are protected by rtc->irq_lock */
23. unsigned int oldsecs;
24. unsigned int uie_irq_active:1;
25. unsigned int stop_uie_polling:1;
26. unsigned int uie_task_active:1;
27. unsigned int uie_timer_active:1;
28. #endif
29. };

rtc_time用于get time/set time：

1. struct rtc_time {
2. int tm_sec;
3. int tm_min;
4. int tm_hour;
5. int tm_mday;
6. int tm_mon;
7. int tm_year;
8. int tm_wday;
9. int tm_yday;
10. int tm_isdst;
11. };

描述报警状态的结构：

1. struct rtc_wkalrm {
2. unsigned char enabled;  /* 0 = alarm disabled, 1 = alarm enabled */
3. unsigned char pending;  /* 0 = alarm not pending, 1 = alarm pending */
4. struct rtc_time time;   /* time the alarm is set to */
5. };

1. struct rtc_class_ops {
2. int (*open)(struct device *);     //打开设备时的回调函数，这个函数应该初始化硬件并申请资源
3. void (*release)(struct device *); //这个函数是设备关闭时被调用的，应该注销申请的资源
4. int (*ioctl)(struct device *, unsigned int, unsigned long); //ioctl函数，对想让RTC自己实现的命令应返回ENOIOCTLCMD
5. int (*read_time)(struct device *, struct rtc_time *);       //读取时间
6. int (*set_time)(struct device *, struct rtc_time *);        //设置时间
7. int (*read_alarm)(struct device *, struct rtc_wkalrm *);    //读取下一次定时中断的时间
8. int (*set_alarm)(struct device *, struct rtc_wkalrm *);     //设置下一次定时中断的时间
9. int (*proc)(struct device *, struct seq_file *);            //procfs接口
10. int (*set_mmss)(struct device *, unsigned long secs);       //将传入的参数secs转换为struct rtc_time然后调用set_time函数。程序员可以不实现这个函数，但
11. 前提是定义好了read_time/set_time，因为RTC框架需要用这两个函数来实现这个功能。
12. int (*irq_set_state)(struct device *, int enabled);         //周期采样中断的开关，根据enabled的值来设置
13. int (*irq_set_freq)(struct device *, int freq);             //设置周期中断的频率
14. int (*read_callback)(struct device *, int data);            ///用户空间获得数据后会传入读取的数据，并用这个函数返回的数据更新数据。
15. int (*alarm_irq_enable)(struct device *, unsigned int enabled);  //alarm中断使能开关，根据enabled的值来设置
16. int (*update_irq_enable)(struct device *, unsigned int enabled); //更新中断使能开关，根据enabled的值来设置
17. };

现在来看看rtc子系统是怎么注册上的：

1. static int __init rtc_init(void)
2. {
3. rtc_class = class_create(THIS_MODULE, "rtc");
4. if (IS_ERR(rtc_class)) {
5. printk(KERN_ERR "%s: couldn't create class\n", __FILE__);
6. return PTR_ERR(rtc_class);
7. }
8. rtc_class->suspend = rtc_suspend;
9. rtc_class->resume = rtc_resume;
10. rtc_dev_init();
11. rtc_sysfs_init(rtc_class);
12. return 0;
13. }
14. void __init rtc_dev_init(void)
15. {
16. int err;
17. err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc");
18. if (err < 0)
19. printk(KERN_ERR "%s: failed to allocate char dev region\n",
20. __FILE__);
21. }

在class.c文件函数rtc_init中生成rtc类，然后调用rtc-dev.c文件中的rtc_dev_init分配设备号。
在rtc-dev.c中声明了file_operations,因为rtc也是一个字符设备:

1. static const struct file_operations rtc_dev_fops = {
2. .owner      = THIS_MODULE,
3. .llseek     = no_llseek,
4. .read       = rtc_dev_read,
5. .poll       = rtc_dev_poll,
6. .unlocked_ioctl = rtc_dev_ioctl,
7. .open       = rtc_dev_open,
8. .release    = rtc_dev_release,
9. .fasync     = rtc_dev_fasync,
10. };

下面来分析rtc-s3c.c源码：
首先看模块的注册和撤销：

1. static int __init s3c_rtc_init(void)
2. {
3. printk(banner);
4. return platform_driver_register(&s3c2410_rtc_driver);
5. }
6. static void __exit s3c_rtc_exit(void)
7. {
8. platform_driver_unregister(&s3c2410_rtc_driver);
9. }

从上边的代码可以看出rtc driver作为platform_driver注册进内核，挂在platform_bus上。

1. static struct platform_driver s3c2410_rtc_driver = {
2. .probe      = s3c_rtc_probe,                //rtc探测函数
3. .remove     = __devexit_p(s3c_rtc_remove),  //rtc移除函数
4. .suspend    = s3c_rtc_suspend,              //rtc挂起函数
5. .resume     = s3c_rtc_resume,               //rtc恢复函数
6. .driver     = {
7. .name   = "s3c2410-rtc",                //注意这里的名字一定要和系统中定义平台设备的地方一致，这样才能把平台设备和平台驱动关联起来
8. .owner  = THIS_MODULE,
9. },
10. };

在arch/arm/plat-s3c24xx/devs.c中定义了rtc的platform_device:

1. /* RTC */
2. static struct resource s3c_rtc_resource[] = {            //定义了rtc平台设备会使用的资源
3. [0] = {                                          //IO端口资源范围
4. .start = S3C24XX_PA_RTC,
5. .end   = S3C24XX_PA_RTC + 0xff,
6. .flags = IORESOURCE_MEM,
7. },
8. [1] = {                                          //RTC报警中断资源
9. .start = IRQ_RTC,
10. .end   = IRQ_RTC,
11. .flags = IORESOURCE_IRQ,
12. },
13. [2] = {                                          //TICK节拍时间中断资源
14. .start = IRQ_TICK,
15. .end   = IRQ_TICK,
16. .flags = IORESOURCE_IRQ
17. }
18. };
19. struct platform_device s3c_device_rtc = {                //定义了平台设备
20. .name         = "s3c2410-rtc",               //设备名
21. .id       = -1,
22. .num_resources    = ARRAY_SIZE(s3c_rtc_resource),   //资源数量
23. .resource     = s3c_rtc_resource,               //引用上面定义的资源
24. };

平台驱动中定义了probe函数，下面来看他的实现：

1. static int __devinit s3c_rtc_probe(struct platform_device *pdev)
2. {
3. struct rtc_device *rtc;
4. struct resource *res;
5. int ret;
6. pr_debug("%s: probe=%p\n", __func__, pdev);
7. /* find the IRQs */
8. /*获得IRQ资源中的第二个，即TICK节拍时间中断号*/
9. s3c_rtc_tickno = platform_get_irq(pdev, 1);
10. if (s3c_rtc_tickno < 0) {
11. dev_err(&pdev->dev, "no irq for rtc tick\n");
12. return -ENOENT;
13. }
14. /*获取IRQ资源中的第一个，即RTC报警中断*/
15. s3c_rtc_alarmno = platform_get_irq(pdev, 0);
16. if (s3c_rtc_alarmno < 0) {
17. dev_err(&pdev->dev, "no irq for alarm\n");
18. return -ENOENT;
19. }
20. pr_debug("s3c2410_rtc: tick irq %d, alarm irq %d\n",
21. s3c_rtc_tickno, s3c_rtc_alarmno);
22. /* get the memory region */
23. /*获取RTC平台设备所使用的IO端口资源*/
24. res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
25. if (res == NULL) {
26. dev_err(&pdev->dev, "failed to get memory region resource\n");
27. return -ENOENT;
28. }
29. /*申请IO端口资源所占用的IO空间*/
30. s3c_rtc_mem = request_mem_region(res->start,
31. res->end-res->start+1,
32. pdev->name);
33. if (s3c_rtc_mem == NULL) {
34. dev_err(&pdev->dev, "failed to reserve memory region\n");
35. ret = -ENOENT;
36. goto err_nores;
37. }
38. /*将IO端口占用的IO空间映射到虚拟地址，s3c_rtc_base是这段虚拟地址的起始地址*/
39. s3c_rtc_base = ioremap(res->start, res->end - res->start + 1);
40. if (s3c_rtc_base == NULL) {
41. dev_err(&pdev->dev, "failed ioremap()\n");
42. ret = -EINVAL;
43. goto err_nomap;
44. }
45. /* check to see if everything is setup correctly */
46. /*对RTCCON第0位进行操作，使能RTC*/
47. s3c_rtc_enable(pdev, 1);
48. pr_debug("s3c2410_rtc: RTCCON=%02x\n",
49. readb(s3c_rtc_base + S3C2410_RTCCON));
50. /*对TICNT第7位进行操作，使能节拍时间计数寄存器*/
51. s3c_rtc_setfreq(&pdev->dev, 1);
52. /*让电源管理支持唤醒功能*/
53. device_init_wakeup(&pdev->dev, 1);
54. /* register RTC and exit */
55. /*注册rtc设备，名为"s3c",与s3c_rtcops这个rtc_class_ops进行关联*/
56. rtc = rtc_device_register("s3c", &pdev->dev, &s3c_rtcops,
57. THIS_MODULE);
58. if (IS_ERR(rtc)) {
59. dev_err(&pdev->dev, "cannot attach rtc\n");
60. ret = PTR_ERR(rtc);
61. goto err_nortc;
62. }
63. /**/
64. rtc->max_user_freq = 128;
65. /*将rtc这个rtc_device存放在&pdev->dev->driver_data*/
66. platform_set_drvdata(pdev, rtc);
67. return 0;
68. err_nortc:
69. s3c_rtc_enable(pdev, 0);
70. iounmap(s3c_rtc_base);
71. err_nomap:
72. release_resource(s3c_rtc_mem);
73. err_nores:
74. return ret;
75. }

函数rtc_device_register在文件class.c中实现:

1. struct rtc_device *rtc_device_register(const char *name, struct device *dev,
2. const struct rtc_class_ops *ops,
3. struct module *owner)
4. {
5. struct rtc_device *rtc;
6. int id, err;
7. /*为idr(rtc_idr)分配内存*/
8. if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) {
9. err = -ENOMEM;
10. goto exit;
11. }
12. mutex_lock(&idr_lock);
13. /*分配ID号存于id中，该ID号最终将作为该RTC设备的次设备号*/
14. err = idr_get_new(&rtc_idr, NULL, &id);
15. mutex_unlock(&idr_lock);
16. if (err < 0)
17. goto exit;
18. id = id & MAX_ID_MASK;
19. /*为RTC结构分配内存*/
20. rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL);
21. if (rtc == NULL) {
22. err = -ENOMEM;
23. goto exit_idr;
24. }
25. rtc->id = id;
26. /*指向原始操作函数集*/
27. rtc->ops = ops;
28. rtc->owner = owner;
29. rtc->max_user_freq = 64;
30. rtc->dev.parent = dev;
31. rtc->dev.class = rtc_class;
32. rtc->dev.release = rtc_device_release;
33. mutex_init(&rtc->ops_lock);
34. spin_lock_init(&rtc->irq_lock);
35. spin_lock_init(&rtc->irq_task_lock);
36. init_waitqueue_head(&rtc->irq_queue);
37. strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE);
38. dev_set_name(&rtc->dev, "rtc%d", id);
39. /*rtc->dev.devt = MKDEV(MAJOR(rtc_devt),rtc->id); cdev_init(&rtc->char_dev,&rtc_dev_fops);其中rtc_devt是从调用alloc_chrdev_region时获得的*/
40. rtc_dev_prepare(rtc);
41. /*注册该RTC设备rtc->dev*/
42. err = device_register(&rtc->dev);
43. if (err)
44. goto exit_kfree;
45. /*cdev_add(&rtc->chr_dev,rtc->dev.devt,1);将rtc->chrdev注册到系统中*/
46. rtc_dev_add_device(rtc);
47. /*在/sys下添加属性文件*/
48. rtc_sysfs_add_device(rtc);
49. /*在/proc中创建入口项"driver/rtc"*/
50. rtc_proc_add_device(rtc);
51. dev_info(dev, "rtc core: registered %s as %s\n",
52. rtc->name, dev_name(&rtc->dev));
53. return rtc;
54. exit_kfree:
55. kfree(rtc);
56. exit_idr:
57. mutex_lock(&idr_lock);
58. idr_remove(&rtc_idr, id);
59. mutex_unlock(&idr_lock);
60. exit:
61. dev_err(dev, "rtc core: unable to register %s, err = %d\n",
62. name, err);
63. return ERR_PTR(err);
64. }

下边是s3c_rtc_enable函数的实现：

1. static void s3c_rtc_enable(struct platform_device *pdev, int en)
2. {
3. void __iomem *base = s3c_rtc_base;
4. unsigned int tmp;
5. if (s3c_rtc_base == NULL)
6. return;
7. /*如果禁止，就disable RTCCON与TICNT*/
8. if (!en) {
9. tmp = readb(base + S3C2410_RTCCON);
10. writeb(tmp & ~S3C2410_RTCCON_RTCEN, base + S3C2410_RTCCON);
11. tmp = readb(base + S3C2410_TICNT);
12. writeb(tmp & ~S3C2410_TICNT_ENABLE, base + S3C2410_TICNT);
13. } else {
14. /* re-enable the device, and check it is ok */
15. /*如果RTCCON没有使能，则使能之*/
16. if ((readb(base+S3C2410_RTCCON) & S3C2410_RTCCON_RTCEN) == 0){
17. dev_info(&pdev->dev, "rtc disabled, re-enabling\n");
18. tmp = readb(base + S3C2410_RTCCON);
19. writeb(tmp|S3C2410_RTCCON_RTCEN, base+S3C2410_RTCCON);
20. }
21. /*如果BCD的计数选择位为1，则置位0，即Merge BCD counts*/
22. if ((readb(base + S3C2410_RTCCON) & S3C2410_RTCCON_CNTSEL)){
23. dev_info(&pdev->dev, "removing RTCCON_CNTSEL\n");
24. tmp = readb(base + S3C2410_RTCCON);
25. writeb(tmp& ~S3C2410_RTCCON_CNTSEL, base+S3C2410_RTCCON);
26. }
27. /*如果BCD的时钟选择为1，则置位0，即XTAL 1/215 divided clock*/
28. if ((readb(base + S3C2410_RTCCON) & S3C2410_RTCCON_CLKRST)){
29. dev_info(&pdev->dev, "removing RTCCON_CLKRST\n");
30. tmp = readb(base + S3C2410_RTCCON);
31. writeb(tmp & ~S3C2410_RTCCON_CLKRST, base+S3C2410_RTCCON);
32. }
33. }
34. }
35. static int __devexit s3c_rtc_remove(struct platform_device *dev)
36. {
37. /*从系统平台设备中获取RTC设备类的数据*/
38. struct rtc_device *rtc = platform_get_drvdata(dev);
39. /*清空平台设备中RTC驱动数据*/
40. platform_set_drvdata(dev, NULL);
41. /*注销RTC设备类*/
42. rtc_device_unregister(rtc);
43. /*禁止RTC节拍时间计数寄存器TICNT的使能功能*/
44. s3c_rtc_setpie(&dev->dev, 0);
45. /*禁止RTC报警控制寄存器RTCALM的全局报警使能功能*/
46. s3c_rtc_setaie(0);
47. /*释放RTC虚拟地址映射空间*/
48. iounmap(s3c_rtc_base);
49. /*释放获取的RTC平台设备的资源*/
50. release_resource(s3c_rtc_mem);
51. /*销毁保存RTC平台设备的资源内存空间*/
52. kfree(s3c_rtc_mem);
53. return 0;
54. }

这里是电源管理部分，在挂起时保存TICNT的值，并禁止RTCCON，TICNT；在休眠的时候开启RTCCON，并恢复TICNT的值。

1. #ifdef CONFIG_PM
2. /* RTC Power management control */
3. static int ticnt_save;
4. static int s3c_rtc_suspend(struct platform_device *pdev, pm_message_t state)
5. {
6. /* save TICNT for anyone using periodic interrupts */
7. ticnt_save = readb(s3c_rtc_base + S3C2410_TICNT);
8. s3c_rtc_enable(pdev, 0);
9. return 0;
10. }
11. static int s3c_rtc_resume(struct platform_device *pdev)
12. {
13. s3c_rtc_enable(pdev, 1);
14. writeb(ticnt_save, s3c_rtc_base + S3C2410_TICNT);
15. return 0;
16. }
17. #else
18. #define s3c_rtc_suspend NULL
19. #define s3c_rtc_resume  NULL
20. #endif

s3c_rtcops是RTC设备在RTC核心部分注册的对RTC设备进行操作的结构体，类似字符设备在驱动中的file_operations对字符设备进行操作的意思。

1. static const struct rtc_class_ops s3c_rtcops = {
2. .open       = s3c_rtc_open,
3. .release    = s3c_rtc_release,
4. .read_time  = s3c_rtc_gettime,
5. .set_time   = s3c_rtc_settime,
6. .read_alarm = s3c_rtc_getalarm,
7. .set_alarm  = s3c_rtc_setalarm,
8. .irq_set_freq   = s3c_rtc_setfreq,
9. .irq_set_state  = s3c_rtc_setpie,
10. .proc           = s3c_rtc_proc,
11. };

这两个是下边会用到的中断处理函数，产生一个时钟中断的时候就更新一下rtc_irq_data的值，也就是说只有当产生一个时钟中断(也就是一个滴答tick)才返回给用户一个时间。

1. static irqreturn_t s3c_rtc_alarmirq(int irq, void *id)
2. {
3. struct rtc_device *rdev = id;
4. rtc_update_irq(rdev, 1, RTC_AF | RTC_IRQF);
5. return IRQ_HANDLED;
6. }
7. static irqreturn_t s3c_rtc_tickirq(int irq, void *id)
8. {
9. struct rtc_device *rdev = id;
10. rtc_update_irq(rdev, 1, RTC_PF | RTC_IRQF);
11. return IRQ_HANDLED;
12. }

首先来看打开和关闭函数：

1. static int s3c_rtc_open(struct device *dev)
2. {
3. /*获得平台设备，从平台设备pdev->dev->driver_data获取rtc_device*/
4. struct platform_device *pdev = to_platform_device(dev);
5. struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
6. int ret;
7. /*注册RTC报警中断的中断处理函数*/
8. ret = request_irq(s3c_rtc_alarmno, s3c_rtc_alarmirq,
9. IRQF_DISABLED,  "s3c2410-rtc alarm", rtc_dev);
10. if (ret) {
11. dev_err(dev, "IRQ%d error %d\n", s3c_rtc_alarmno, ret);
12. return ret;
13. }
14. /*注册TICK节拍时间中断的中断处理函数*/
15. ret = request_irq(s3c_rtc_tickno, s3c_rtc_tickirq,
16. IRQF_DISABLED,  "s3c2410-rtc tick", rtc_dev);
17. if (ret) {
18. dev_err(dev, "IRQ%d error %d\n", s3c_rtc_tickno, ret);
19. goto tick_err;
20. }
21. return ret;
22. tick_err:
23. free_irq(s3c_rtc_alarmno, rtc_dev);
24. return ret;
25. }

RTC设备类关闭接口函数：

1. static void s3c_rtc_release(struct device *dev)
2. {
3. struct platform_device *pdev = to_platform_device(dev);
4. struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
5. /* do not clear AIE here, it may be needed for wake */
6. s3c_rtc_setpie(dev, 0);
7. free_irq(s3c_rtc_alarmno, rtc_dev);
8. free_irq(s3c_rtc_tickno, rtc_dev);
9. }

更新RTCALM寄存器的状态，是否使能：

1. static void s3c_rtc_setaie(int to)
2. {
3. unsigned int tmp;
4. pr_debug("%s: aie=%d\n", __func__, to);
5. tmp = readb(s3c_rtc_base + S3C2410_RTCALM) & ~S3C2410_RTCALM_ALMEN;
6. if (to)
7. tmp |= S3C2410_RTCALM_ALMEN;
8. writeb(tmp, s3c_rtc_base + S3C2410_RTCALM);
9. }

更新TICNT寄存器的状态，是否使能：

1. static int s3c_rtc_setpie(struct device *dev, int enabled)
2. {
3. unsigned int tmp;
4. pr_debug("%s: pie=%d\n", __func__, enabled);
5. spin_lock_irq(&s3c_rtc_pie_lock);
6. tmp = readb(s3c_rtc_base + S3C2410_TICNT) & ~S3C2410_TICNT_ENABLE;
7. if (enabled)
8. tmp |= S3C2410_TICNT_ENABLE;
9. writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
10. spin_unlock_irq(&s3c_rtc_pie_lock);
11. return 0;
12. }

更新TICNT节拍时间计数的值：

1. static int s3c_rtc_setfreq(struct device *dev, int freq)
2. {
3. unsigned int tmp;
4. if (!is_power_of_2(freq))
5. return -EINVAL;
6. spin_lock_irq(&s3c_rtc_pie_lock);
7. tmp = readb(s3c_rtc_base + S3C2410_TICNT) & S3C2410_TICNT_ENABLE;
8. tmp |= (128 / freq)-1;
9. writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
10. spin_unlock_irq(&s3c_rtc_pie_lock);
11. return 0;
12. }
13. /* Time read/write */
14. static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
15. {
16. unsigned int have_retried = 0;
17. /*获得rtc IO端口寄存器的虚拟地址的起始地址*/
18. void __iomem *base = s3c_rtc_base;
19. retry_get_time:
20. /*读取RTC中BCD数中的：分、时、日期、月、年、秒，放到rtc_time rtc_tm中*/
21. rtc_tm->tm_min  = readb(base + S3C2410_RTCMIN);
22. rtc_tm->tm_hour = readb(base + S3C2410_RTCHOUR);
23. rtc_tm->tm_mday = readb(base + S3C2410_RTCDATE);
24. rtc_tm->tm_mon  = readb(base + S3C2410_RTCMON);
25. rtc_tm->tm_year = readb(base + S3C2410_RTCYEAR);
26. rtc_tm->tm_sec  = readb(base + S3C2410_RTCSEC);
27. /* the only way to work out wether the system was mid-update
28. * when we read it is to check the second counter, and if it
29. * is zero, then we re-try the entire read
30. */
31. /*如果到达0秒就检查一下，因为年月日时分可能会有加1操作，比如此时是一年的最后天的最后一分一秒，则年月日时分秒都会改变*/
32. if (rtc_tm->tm_sec == 0 && !have_retried) {
33. have_retried = 1;
34. goto retry_get_time;
35. }
36. pr_debug("read time %02x.%02x.%02x %02x/%02x/%02x\n",
37. rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
38. rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
39. /*使用readb读取寄存器的值得到的是bcd格式，必须转换成bin格式再保存*/
40. rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
41. rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
42. rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
43. rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
44. rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
45. rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
46. rtc_tm->tm_year += 100;
47. rtc_tm->tm_mon -= 1;
48. return 0;
49. }
50. static int s3c_rtc_settime(struct device *dev, struct rtc_time *tm)
51. {
52. void __iomem *base = s3c_rtc_base;
53. int year = tm->tm_year - 100;
54. pr_debug("set time %02d.%02d.%02d %02d/%02d/%02d\n",
55. tm->tm_year, tm->tm_mon, tm->tm_mday,
56. tm->tm_hour, tm->tm_min, tm->tm_sec);
57. /* we get around y2k by simply not supporting it */
58. /*RTC时钟的范围是00~99，由BCDYEAR寄存器的0～7位存储*/
59. if (year < 0 || year >= 100) {
60. dev_err(dev, "rtc only supports 100 years\n");
61. return -EINVAL;
62. }
63. /*将上面保存到RTC核心定义的时间结构体中的时间日期值写入对应的寄存器中*/
64. writeb(bin2bcd(tm->tm_sec),  base + S3C2410_RTCSEC);
65. writeb(bin2bcd(tm->tm_min),  base + S3C2410_RTCMIN);
66. writeb(bin2bcd(tm->tm_hour), base + S3C2410_RTCHOUR);
67. writeb(bin2bcd(tm->tm_mday), base + S3C2410_RTCDATE);
68. writeb(bin2bcd(tm->tm_mon + 1), base + S3C2410_RTCMON);
69. writeb(bin2bcd(year), base + S3C2410_RTCYEAR);
70. return 0;
71. }

获取报警时间的值：

1. static int s3c_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
2. {
3. struct rtc_time *alm_tm = &alrm->time;
4. void __iomem *base = s3c_rtc_base;
5. unsigned int alm_en;
6. /*从RTC的报警寄存器中读取*/
7. alm_tm->tm_sec  = readb(base + S3C2410_ALMSEC);
8. alm_tm->tm_min  = readb(base + S3C2410_ALMMIN);
9. alm_tm->tm_hour = readb(base + S3C2410_ALMHOUR);
10. alm_tm->tm_mon  = readb(base + S3C2410_ALMMON);
11. alm_tm->tm_mday = readb(base + S3C2410_ALMDATE);
12. alm_tm->tm_year = readb(base + S3C2410_ALMYEAR);
13. alm_en = readb(base + S3C2410_RTCALM);
14. /*根据RTCALM寄存器的报警全局使能位来设置报警状态结构rtc_wkalrm*/
15. alrm->enabled = (alm_en & S3C2410_RTCALM_ALMEN) ? 1 : 0;
16. pr_debug("read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n",
17. alm_en,
18. alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,
19. alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec);
20. /* decode the alarm enable field */
21. /*如果RTCALM寄存器的秒使能，则将rtc_wkalrm中存放的秒数据由BCD格式转换为BIN格式，否则设置为0xff*/
22. if (alm_en & S3C2410_RTCALM_SECEN)
23. alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
24. else
25. alm_tm->tm_sec = 0xff;
26. /*如果RTCALM寄存器的分钟使能，则将rtc_wkalrm中存放的分钟数据由BCD格式转换为BIN格式，否则设置为0xff*/
27. if (alm_en & S3C2410_RTCALM_MINEN)
28. alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
29. else
30. alm_tm->tm_min = 0xff;
31. /*如果RTCALM寄存器的小时使能，则将rtc_wkalrm中存放的小时数据由BCD格式转换为BIN格式，否则设置为0xff*/
32. if (alm_en & S3C2410_RTCALM_HOUREN)
33. alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
34. else
35. alm_tm->tm_hour = 0xff;
36. /*如果RTCALM寄存器的日使能，则将rtc_wkalrm中存放的日数据由BCD格式转换为BIN格式，否则设置为0xff*/
37. if (alm_en & S3C2410_RTCALM_DAYEN)
38. alm_tm->tm_mday = bcd2bin(alm_tm->tm_mday);
39. else
40. alm_tm->tm_mday = 0xff;
41. /*如果RTCALM寄存器的月使能，则将rtc_wkalrm中存放的月数据由BCD格式转换为BIN格式，否则设置为0xff*/
42. if (alm_en & S3C2410_RTCALM_MONEN) {
43. alm_tm->tm_mon = bcd2bin(alm_tm->tm_mon);
44. alm_tm->tm_mon -= 1;
45. } else {
46. alm_tm->tm_mon = 0xff;
47. }
48. /*如果RTCALM寄存器的年使能，则将rtc_wkalrm中存放的年数据由BCD格式转换为BIN格式，否则设置为0xff*/
49. if (alm_en & S3C2410_RTCALM_YEAREN)
50. alm_tm->tm_year = bcd2bin(alm_tm->tm_year);
51. else
52. alm_tm->tm_year = 0xffff;
53. return 0;
54. }

设置报警时间的值：

1. static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
2. {
3. struct rtc_time *tm = &alrm->time;
4. void __iomem *base = s3c_rtc_base;
5. unsigned int alrm_en;
6. pr_debug("s3c_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n",
7. alrm->enabled,
8. tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff,
9. tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec);
10. /*读取RTCALM寄存器的全局使能位，关闭所有报警使能*/
11. alrm_en = readb(base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN;
12. writeb(0x00, base + S3C2410_RTCALM);
13. /*如果秒时间在合理范围内，则使能秒报警位，将报警状态寄存器中封装的time的秒位由BIN格式转换为BCD，写入秒报警寄存器中*/
14. if (tm->tm_sec < 60 && tm->tm_sec >= 0) {
15. alrm_en |= S3C2410_RTCALM_SECEN;
16. writeb(bin2bcd(tm->tm_sec), base + S3C2410_ALMSEC);
17. }
18. /*如果分钟时间在合理范围内，则使能分钟报警位，将报警状态寄存器中封装的time的分钟位由BIN格式转换为BCD，写入分钟报警寄存器中*/
19. if (tm->tm_min < 60 && tm->tm_min >= 0) {
20. alrm_en |= S3C2410_RTCALM_MINEN;
21. writeb(bin2bcd(tm->tm_min), base + S3C2410_ALMMIN);
22. }
23. /*如果小时时间在合理范围内，则使能小时报警位，将报警状态寄存器中封装的time的小时位由BIN格式转换为BCD，写入小时报警寄存器中*/
24. if (tm->tm_hour < 24 && tm->tm_hour >= 0) {
25. alrm_en |= S3C2410_RTCALM_HOUREN;
26. writeb(bin2bcd(tm->tm_hour), base + S3C2410_ALMHOUR);
27. }
28. pr_debug("setting S3C2410_RTCALM to %08x\n", alrm_en);
29. /*使能RTCALM寄存器全局报警位*/
30. writeb(alrm_en, base + S3C2410_RTCALM);
31. /**/
32. s3c_rtc_setaie(alrm->enabled);
33. /*根据全局报警使能的状态来决定是唤醒RTC报警中断还是睡眠RTC报警中断*/
34. if (alrm->enabled)
35. enable_irq_wake(s3c_rtc_alarmno);
36. else
37. disable_irq_wake(s3c_rtc_alarmno);
38. return 0;
39. }

下面来分析一下是怎样获取和设置时间的：
通过用户空间的ioctl，在rtc-dev.c中实现了rtc_dev_ioctl，其中获取和设置时间如下：

1. case RTC_RD_TIME:
2. mutex_unlock(&rtc->ops_lock);
3. err = rtc_read_time(rtc, &tm);
4. if (err < 0)
5. return err;
6. if (copy_to_user(uarg, &tm, sizeof(tm)))
7. err = -EFAULT;
8. return err;
9. case RTC_SET_TIME:
10. mutex_unlock(&rtc->ops_lock);
11. if (copy_from_user(&tm, uarg, sizeof(tm)))
12. return -EFAULT;
13. return rtc_set_time(rtc, &tm);

通过copy_to_user和copy_from_user实现时间在内核空间与用户空间的传递。这里调用到的rtc_read_time和rtc_set_time在interface.c中实现：

1. int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
2. {
3. int err;
4. err = mutex_lock_interruptible(&rtc->ops_lock);
5. if (err)
6. return err;
7. if (!rtc->ops)
8. err = -ENODEV;
9. else if (!rtc->ops->read_time)
10. err = -EINVAL;
11. else {
12. memset(tm, 0, sizeof(struct rtc_time));
13. err = rtc->ops->read_time(rtc->dev.parent, tm);
14. }
15. mutex_unlock(&rtc->ops_lock);
16. return err;
17. }
18. int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
19. {
20. int err;
21. err = rtc_valid_tm(tm);
22. if (err != 0)
23. return err;
24. err = mutex_lock_interruptible(&rtc->ops_lock);
25. if (err)
26. return err;
27. if (!rtc->ops)
28. err = -ENODEV;
29. else if (rtc->ops->set_time)
30. err = rtc->ops->set_time(rtc->dev.parent, tm);
31. else if (rtc->ops->set_mmss) {
32. unsigned long secs;
33. err = rtc_tm_to_time(tm, &secs);
34. if (err == 0)
35. err = rtc->ops->set_mmss(rtc->dev.parent, secs);
36. } else
37. err = -EINVAL;
38. mutex_unlock(&rtc->ops_lock);
39. return err;
40. }

可以看出他们调用了具体RTC设备驱动中的read_time和set_time函数，对应了s3c2410中的s3c_rtc_gettime和s3c_rtc_settime,这里使用的rtc_tm_to_time函数实现在rtclib.c中，/drivers/rtc/interface.c定义了可供其它模块访问的接口。