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

最新推荐文章于 2024-10-14 00:30:56 发布
最新推荐文章于 2024-10-14 00:30:56 发布
阅读量75 收藏
点赞数
原文链接：http://www.cnblogs.com/sky-heaven/p/5294484.html
版权

转自：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设备：

 

C-sharp代码 
  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：

 

C-sharp代码 
  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. };  

 

描述报警状态的结构：

 

C-sharp代码 
  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. };  

 

 

C-sharp代码 
  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子系统是怎么注册上的：

 

C-sharp代码 
  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也是一个字符设备:

 

C-sharp代码 
  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源码：
首先看模块的注册和撤销：

 

C-sharp代码 
  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上。

 

C-sharp代码 
  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:

 

C-sharp代码 
  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函数，下面来看他的实现：

 

C-sharp代码 
  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中实现:

 

C-sharp代码 
  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函数的实现：

 

C-sharp代码 
  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.       
  19.             tmp = readb(base + S3C2410_RTCCON);  
  20.             writeb(tmp|S3C2410_RTCCON_RTCEN, base+S3C2410_RTCCON);  
  21.         }  
  22.         /*如果BCD的计数选择位为1，则置位0，即Merge BCD counts*/  
  23.         if ((readb(base + S3C2410_RTCCON) & S3C2410_RTCCON_CNTSEL)){  
  24.             dev_info(&pdev->dev, "removing RTCCON_CNTSEL\n");  
  25.             tmp = readb(base + S3C2410_RTCCON);  
  26.             writeb(tmp& ~S3C2410_RTCCON_CNTSEL, base+S3C2410_RTCCON);  
  27.         }  
  28.         /*如果BCD的时钟选择为1，则置位0，即XTAL 1/215 divided clock*/  
  29.         if ((readb(base + S3C2410_RTCCON) & S3C2410_RTCCON_CLKRST)){  
  30.             dev_info(&pdev->dev, "removing RTCCON_CLKRST\n");  
  31.             tmp = readb(base + S3C2410_RTCCON);  
  32.             writeb(tmp & ~S3C2410_RTCCON_CLKRST, base+S3C2410_RTCCON);  
  33.         }  
  34.     }  
  35. }  
  36. static int __devexit s3c_rtc_remove(struct platform_device *dev)  
  37. {  
  38.     /*从系统平台设备中获取RTC设备类的数据*/  
  39.     struct rtc_device *rtc = platform_get_drvdata(dev);  
  40.      /*清空平台设备中RTC驱动数据*/  
  41.     platform_set_drvdata(dev, NULL);  
  42.     /*注销RTC设备类*/  
  43.     rtc_device_unregister(rtc);  
  44.     /*禁止RTC节拍时间计数寄存器TICNT的使能功能*/  
  45.     s3c_rtc_setpie(&dev->dev, 0);  
  46.     /*禁止RTC报警控制寄存器RTCALM的全局报警使能功能*/  
  47.     s3c_rtc_setaie(0);  
  48.     /*释放RTC虚拟地址映射空间*/  
  49.     iounmap(s3c_rtc_base);  
  50.     /*释放获取的RTC平台设备的资源*/  
  51.     release_resource(s3c_rtc_mem);  
  52.     /*销毁保存RTC平台设备的资源内存空间*/  
  53.     kfree(s3c_rtc_mem);  
  54.     return 0;  
  55. }  

 

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

 

C-sharp代码 
  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对字符设备进行操作的意思。

 

C-sharp代码 
  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)才返回给用户一个时间。

 

C-sharp代码 
  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. }  

 

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

 

C-sharp代码 
  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设备类关闭接口函数：

 

C-sharp代码 
  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寄存器的状态，是否使能：

 

C-sharp代码 
  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寄存器的状态，是否使能：

 

C-sharp代码 
  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节拍时间计数的值：

 

C-sharp代码 
  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. }  

 

获取报警时间的值：

 

C-sharp代码 
  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.       
  14.     alm_en = readb(base + S3C2410_RTCALM);  
  15.     /*根据RTCALM寄存器的报警全局使能位来设置报警状态结构rtc_wkalrm*/  
  16.     alrm->enabled = (alm_en & S3C2410_RTCALM_ALMEN) ? 1 : 0;  
  17.     pr_debug("read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n",  
  18.          alm_en,  
  19.          alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,  
  20.          alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec);  
  21.   
  22.     /* decode the alarm enable field */  
  23.     /*如果RTCALM寄存器的秒使能，则将rtc_wkalrm中存放的秒数据由BCD格式转换为BIN格式，否则设置为0xff*/  
  24.     if (alm_en & S3C2410_RTCALM_SECEN)  
  25.         alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);  
  26.     else  
  27.         alm_tm->tm_sec = 0xff;  
  28.     /*如果RTCALM寄存器的分钟使能，则将rtc_wkalrm中存放的分钟数据由BCD格式转换为BIN格式，否则设置为0xff*/  
  29.     if (alm_en & S3C2410_RTCALM_MINEN)  
  30.         alm_tm->tm_min = bcd2bin(alm_tm->tm_min);  
  31.     else  
  32.         alm_tm->tm_min = 0xff;  
  33.     /*如果RTCALM寄存器的小时使能，则将rtc_wkalrm中存放的小时数据由BCD格式转换为BIN格式，否则设置为0xff*/  
  34.     if (alm_en & S3C2410_RTCALM_HOUREN)  
  35.         alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);  
  36.     else  
  37.         alm_tm->tm_hour = 0xff;  
  38.     /*如果RTCALM寄存器的日使能，则将rtc_wkalrm中存放的日数据由BCD格式转换为BIN格式，否则设置为0xff*/  
  39.     if (alm_en & S3C2410_RTCALM_DAYEN)  
  40.         alm_tm->tm_mday = bcd2bin(alm_tm->tm_mday);  
  41.     else  
  42.         alm_tm->tm_mday = 0xff;  
  43.     /*如果RTCALM寄存器的月使能，则将rtc_wkalrm中存放的月数据由BCD格式转换为BIN格式，否则设置为0xff*/  
  44.     if (alm_en & S3C2410_RTCALM_MONEN) {  
  45.         alm_tm->tm_mon = bcd2bin(alm_tm->tm_mon);  
  46.         alm_tm->tm_mon -= 1;  
  47.     } else {  
  48.         alm_tm->tm_mon = 0xff;  
  49.     }  
  50.     /*如果RTCALM寄存器的年使能，则将rtc_wkalrm中存放的年数据由BCD格式转换为BIN格式，否则设置为0xff*/  
  51.     if (alm_en & S3C2410_RTCALM_YEAREN)  
  52.         alm_tm->tm_year = bcd2bin(alm_tm->tm_year);  
  53.     else  
  54.         alm_tm->tm_year = 0xffff;  
  55.     return 0;  
  56. }  

 

设置报警时间的值：

 

C-sharp代码 
  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，其中获取和设置时间如下：

 

C-sharp代码 
  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中实现：

 

C-sharp代码 
  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定义了可供其它模块访问的接口。

转载于:https://www.cnblogs.com/sky-heaven/p/5294484.html

weixin_34179762
关注
Linux下的RTC子系统
weiqing的专栏
01-09 4717
版权所有，转载必须说明转自 http://my.csdn.net/weiqing1981127    实时时钟的作用主要是为操作系统提供一个可靠的时间，并在断电下，RTC时钟也可以通过电池供电一直运行下去。实时时钟驱动也有一个子系统，叫做RTC子系统，其源代码目录是/driver/rtc/，在这个目录下有一个rtc核心代码区，主要是Rtc-dev.c、Rtc-sysfs.c和Rtc-proc.
Linux驱动修炼之道-RTC子系统框架与源码分析
helloyesyes
05-21 198
努力成为linux kernel hacker的人李万鹏原创作品，为梦而战。转载请标明出处 http://blog.csdn.net/woshixingaaa/archive/2011/05/21/6436215.aspx RTC(实时时钟)是一种典型的字符设备，作为一种字符设备驱动，RTC需要有file_operations中接口函数的实现，如open(),release(),read(),...
Linux内核4.14版本——RTC子系统框架
yangguoyu8023的博客
01-07 1613
RTC子系统简单分析
Linux驱动: rtc子系统
JiMoKuangXiangQu的专栏
11-30 378
linux,rtc子系统
Linux常见驱动源码分析(kernel hacker修炼之道全集)--李万鹏
07-03
Linux驱动修炼之道-RTC子系统框架与源码分析.pdf Linux驱动修炼之道-platform.pdf Linux驱动修炼之道-LCD背光与gpio控制.pdf Linux驱动修炼之道-INPUT子系统(下).pdf Linux驱动修炼之道-INPUT子系统(上...
linux系统驱动-RTC驱动-rv-8263-c7
12-26
linux系统驱动-RTC驱动-rv-8263-c7,自己写的rtc驱动源码，参考内核rtc-pcf85063源码移植
Linux-RTC-function-test.zip_Linux rtc测试_linux rtc_rtc test_完好性
09-24
2. **RTC API**：Linux内核提供了一套RTC相关的系统调用和用户空间API，如`rtc-time-to-seconds()`和`rtc(seconds_to_tm)`，用于将时间转换为用户友好的格式。测试需确保这些API在各种场景下都能正确工作。 3. **...
rtc-rx8025t.rar_PNH_RX8025T_RX8025T linux_RX8025T例程_rx8025t驱动
07-14
RTC（Real-Time Clock）是计算机系统...通过分析和理解"rtc-rx8025t.c"源代码，开发者可以深入学习Linux驱动开发，尤其是RTC驱动的实现细节，这对于在Linux系统中开发或移植其他RTC芯片的驱动程序具有重要的参考价值。
嵌入式系统/ARM技术中的Linux下基于I2C协议的RTC驱动开发
10-21
首先研究了Linux环境下字符设备驱动程序框架，然后介绍I2C协议，在此基础上开发基于I2C协议的RTC字符设备驱动程序。对于驱动程序，这里详细介绍其整体架构和各模块实现细节。最终成功实现了基于I2C协议的RTC驱动程序...
【Linux 驱动开发】rtc子系统
weixin_43589750的博客
08-15 446
Linux RTC 子系统
嵌入式Linux——RTC驱动（1）：RTC框架分析
静祥阁
04-15 4913
简介：         本文通过分层的方式介绍RTC驱动，通过分析RTC在不同层次中所做的不同工作，以及各个层次之间的关系来了解RTC驱动框架。本文分为两部分，第一部分总的介绍RTC框架，而第二部分将结合详细的代码来分析各个层次的关系以及在本层中他们所做的事情。     Linux内核：linux-2.6.22.6     所用开发板：JZ2440 V3（S3C2440A） 声明 ：  ...
RTC驱动框架
哈呼呼屠露
05-18 904
第一部分：框架 从上面的图中我们可以看出RTC框架大致可以分为三部分：rtc-s3c.c ，class.c 以及 rtc-dev.c 。他们依次向上抽象注册。同时又对下面底层的函数进行回调，从而构成了整个完整的RTC框架。我们现在先分开介绍。 rtc-s3c.c 层： 该层是RTC框架的底层，与硬件打交道。用时又由于这是RTC框架的底层，所以各个芯片对应的这一层可能会不一样，所以该层是与具体芯片相关的。同时又由于内核面向对象的思想，所以在该层一定要有一个结构体...
linux rtc管理,linux RTC子系统学习笔记
weixin_39863918的博客
05-14 450
虽然目前的工作是在linux应用开发上，偏重于业务逻辑，但我还是希望自己能够更加明白操作系统本身的实现，计划之后在周末和闲暇时间抽出一定的时间来继续学习linux设备驱动，同时学习学习多媒体的知识。今天来学习linux设备驱动中的RTC(Real-Time Clock)子系统，RTC设备就是一些提供系统时间的设备，它们一般自备电池，系统断电后还能计算时间，以便设备开机运行时提供给系统。此外，它们还...
STM32MP157驱动开发——Linux RTC驱动
weixin_45682654的博客
12-25 894
Linux RTC驱动开发，由于ST已经开发好，所以仅做一些简述和使用介绍。
linux驱动基础系列--linux rtc子系统
yuzeze的专栏
04-19 2196
前言 　　linux驱动子系统太多了，连时钟也搞了个子系统，这导致一般的时钟芯片的驱动也会涉及到至少2个子系统，一个是时钟芯片接口子系统（比如I2c接口的时钟芯片），一个是内核给所有时钟芯片提供的rtc子系统。当然也可以自己写一个字符设备直接操作芯片然后给上层用户空间提供接口，但这种方法实在是太糟糕了，内核既然提供了，为什么不用呢！（真要这样做，请参考内核的drivers/char/rtc.c的
LINUX驱动分析之RTC（一）
lmm670的专栏
08-09 1422
/ *****************************************************************************************************/   声明：本博内容均由http://blog.csdn.net/lmm670原创，转载请注明出处，谢谢！ /***************************************
Linux RTC 子系统
m0_60259116的博客
01-24 544
Linux RTC 子系统
Linux驱动编程 - RTC子系统
最新发布
hinewcc的博客
10-14 936
Linux中RTC子系统
Linux RTC驱动开发：MicroCrystal RV-8263-C7移植指南
该资源是关于Linux系统中的RTC（实时时钟）驱动程序，特别是针对MicroCrystal RV-8263-C7芯片的驱动。这个驱动程序由作者Gregory Hermant根据内核现有的RTC类驱动程序进行移植和改编，遵循GNU General Public ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值