新闻中心

EEPW首页 > 嵌入式系统 > 设计应用 > ARM-Linux驱动--RTC(实时时钟)驱动分析

ARM-Linux驱动--RTC(实时时钟)驱动分析

作者： 时间：2016-11-20 来源：网络
收藏
硬件平台：FL2440（S3C2440）

内核版本：Linux 2.6.28

本文引用地址：https://www.eepw.com.cn/article/201611/318867.htm

主机平台：Ubuntu 11.04

内核版本：Linux 2.6.39

交叉编译器版本：arm-linux-gcc 3.4.1

原创作品，转载请标明出处http://blog.csdn.net/yming0221/article/details/6584285

1、实时时钟概述

实时时钟（RTC）单元可以在断电的情况下使用纽扣电池继续计时工作。RTC使用STRB/LDRB ARM操作传输二进制码十进制数的8位数据给CPU。其中的数据包括秒、分、时、日期、天、月、年的时间信息。可以执行报警功能。

2、实时时钟操作

下面是RTC模块的电路图

3、RTC寄存器介绍

实时时钟控制寄存器（RTCCON）－REAL TIME CLOCK CONTROL REGISTER

节拍时间计数寄存器（TICNT）－TICK TIME COUNT REGISTER

RTC报警控制寄存器（RTCALM）－RTC ALARM CONTROL REGISTER

报警秒数寄存器（ALMSEC）－ALARM SECOND DATA REGISTER

报警分钟计数寄存器（ALMMIN）－ALARM MIN DATA REGISTER

报警小时数据寄存器（ALMHOUR）－ALARM HOUR DATA REGISTER

报警日期数据寄存器（ALMDATE）－ALARM DATE DATA REGISTER

报警月数数据寄存器（ALMMON）－ALARM MON DATA REGISTER

报警年数数据寄存器（ALMYEAR）－ALARM YEAR DATA REGISTER

BCD数据寄存器的格式和报警寄存器结构相同，只是对应的地址不同。

BCD秒寄存器（BCDSEC）－BCD SECOND REGISTER 地址：0x57000070(L)0x57000073(B)

BCD分寄存器（BCDMIN）－BCD MINUTE REGISTER 地址：0x57000074(L)0x57000077(B)

BCD小时寄存器（BCDHOUR）－BCD HOUR REGISTER 地址：0x57000078(L)0x5700007B(B)

BCD日期寄存器（BCDDATE）－BCD DATE REGISTER 地址：0x5700007C(L)0x5700007F(B)

BCD日寄存器（BCDDAY）－BCD DAY REGISTER 地址：0x57000080(L)0x57000083(B)

BCD月寄存器（BCDMON）－BCD MONTH REGISTER 地址：0x57000084(L)0x57000087(B)

BCD年寄存器（BCDYEAR）－BCD YEAR REGISTER 地址：0x57000088(L)0x5700008B(B)

4、驱动实例分析

为了使驱动更容易理解，现在这个RTC驱动只完成了计时功能，没有添加相应的报警功能，也没有添加电源管理的功能，缺少的功能今后完善。

下面先总体了解驱动：

首先是RTC驱动的结构体，在/include/linux/platform_device.h中，如下

[cpp]view plaincopy
  1. structplatform_driver{
  2. int(*probe)(structplatform_device*);
  3. int(*remove)(structplatform_device*);
  4. void(*shutdown)(structplatform_device*);
  5. int(*suspend)(structplatform_device*,pm_message_tstate);
  6. int(*suspend_late)(structplatform_device*,pm_message_tstate);
  7. int(*resume_early)(structplatform_device*);
  8. int(*resume)(structplatform_device*);
  9. structpm_ext_ops*pm;
  10. structdevice_driverdriver;
  11. };
驱动中定义对应的结构体

[cpp]view plaincopy
  1. staticstructplatform_drivers3c2410_rtc_driver={
  2. .probe=s3c_rtc_probe,//RTC探测函数
  3. .remove=__devexit_p(s3c_rtc_remove),//RTC移除函数
  4. .driver={
  5. .name="s3c2410-rtc",
  6. .owner=THIS_MODULE,
  7. },
  8. };
下面是驱动中驱动的初始化和退出函数

[cpp]view plaincopy
  1. staticint__inits3c_rtc_init(void)
  2. {
  3. printk(banner);
  4. returnplatform_driver_register(&s3c2410_rtc_driver);
  5. }
  7. staticvoid__exits3c_rtc_exit(void)
  8. {
  9. platform_driver_unregister(&s3c2410_rtc_driver);
  10. }

platform_driver_register()和platform_driver_unregister()函数在/drivers/base/platform.c中实现的。

可以看出，platform_driver_register()函数的作用就是为platform_driver中的driver中的probe、remove等提供接口函数

[cpp]view plaincopy
  1. intplatform_driver_register(structplatform_driver*drv)
  2. {
  3. drv->driver.bus=&platform_bus_type;
  4. if(drv->probe)
  5. drv->driver.probe=platform_drv_probe;
  6. if(drv->remove)
  7. drv->driver.remove=platform_drv_remove;
  8. if(drv->shutdown)
  9. drv->driver.shutdown=platform_drv_shutdown;
  10. if(drv->suspend)
  11. drv->driver.suspend=platform_drv_suspend;
  12. if(drv->resume)
  13. drv->driver.resume=platform_drv_resume;
  14. if(drv->pm)
  15. drv->driver.pm=&drv->pm->base;
  16. returndriver_register(&drv->driver);//注册老的驱动
  17. }
[cpp]view plaincopy
  1. voidplatform_driver_unregister(structplatform_driver*drv)
  2. {
  3. driver_unregister(&drv->driver);
  4. }

接下来是RTC平台驱动探测函数s3c_rtc_probe,下面函数定义的时候使用了__devinit的作用是使编译器优化代码，将其放在和是的内存位置，减少内存占用和提高内核效率。

probe函数接收到plarform_device这个参数后，就需要从中提取出需要的信息。它一般会通过调用内核提供的platform_get_resource和platform_get_irq等函数来获得相关信息。如通过platform_get_resource获得设备的起始地址后，可以对其进行request_mem_region和ioremap等操作，以便应用程序对其进行操作。通过platform_get_irq得到设备的中断号以后，就可以调用request_irq函数来向系统申请中断。这些操作在设备驱动程序中一般都要完成。

[cpp]view plaincopy
  1. staticint__devinits3c_rtc_probe(structplatform_device*pdev)
  2. {
  3. structrtc_device*rtc;//定义rtc_device结构体，定义在/include/linux/rtc.h
  4. structresource*res;//定义资源结构体，定义在/include/linux/ioport.h
  5. intret;
  7. pr_debug("%s:probe=%pn",__func__,pdev);
  9. /*findtheIRQs*/
  11. s3c_rtc_tickno=platform_get_irq(pdev,1);//在系统定义的平台设备中获取中断号
  12. if(s3c_rtc_tickno<0){//异常处理
  13. dev_err(&pdev->dev,"noirqforrtctickn");
  14. return-ENOENT;
  15. }
  17. /*getthememoryregion*/
  19. res=platform_get_resource(pdev,IORESOURCE_MEM,0);//获取RTC平台使用的IO资源
  20. if(res==NULL){
  21. dev_err(&pdev->dev,"failedtogetmemoryregionresourcen");
  22. return-ENOENT;
  23. }
  24. //申请内存区域，res是structresource类型，见本函数后面
  25. s3c_rtc_mem=request_mem_region(res->start,
  26. res->end-res->start+1,
  27. pdev->name);
  29. if(s3c_rtc_mem==NULL){//申请内存出错
  30. dev_err(&pdev->dev,"failedtoreservememoryregionn");
  31. ret=-ENOENT;
  32. gotoerr_nores;
  33. }
  34. //将寄存器地址映射成虚拟地址，以便访问
  35. s3c_rtc_base=ioremap(res->start,res->end-res->start+1);
  36. if(s3c_rtc_base==NULL){
  37. dev_err(&pdev->dev,"failedioremap()n");
  38. ret=-EINVAL;
  39. gotoerr_nomap;
  40. }
  42. /*checktoseeifeverythingissetupcorrectly*/
  44. s3c_rtc_enable(pdev,1);//对RTCCON寄存器设置，详情见下面的函数实现
  46. pr_debug("s3c2410_rtc:RTCCON=%02xn",
  47. readb(s3c_rtc_base+S3C2410_RTCCON));
  49. s3c_rtc_setfreq(&pdev->dev,1);//详情见下面的函数实现
  51. /*registerRTCandexit*/
  53. rtc=rtc_device_register("s3c",&pdev->dev,&s3c_rtcops,
  54. THIS_MODULE);//注册RTC为RTC设备，其中s3c_rtcops定义见下
  56. if(IS_ERR(rtc)){
  57. dev_err(&pdev->dev,"cannotattachrtcn");
  58. ret=PTR_ERR(rtc);
  59. gotoerr_nortc;
  60. }
  62. rtc->max_user_freq=128;//设置RTC节拍时间计数寄存器TICNT的节拍时间计数值的用户最大相对值
  63. //将RTC类的设备数据传递给系统设备，在/include/linux/platform_device.h中
[cpp]view plaincopy
  1. //#defineplatform_set_drvdata(_dev,data)dev_set_drvdata(&(_dev)->dev,(data))，该函数在/include/linux/device.h中定义，见本函数下面
[cpp]view plaincopy
  1. platform_set_drvdata(pdev,rtc);
[cpp]view plaincopy
  1. return0;
[cpp]view plaincopy
  1. //异常处理
  2. err_nortc:
  3. s3c_rtc_enable(pdev,0);
  4. iounmap(s3c_rtc_base);
  6. err_nomap:
  7. release_resource(s3c_rtc_mem);
  8. err_nores:
  9. returnret;
  10. }
下面是/include/linux/ioport.h中struct resource结构体定义
[cpp]view plaincopy
  1. structresource{
  2. resource_size_tstart;
  3. resource_size_tend;
  4. constchar*name;
  5. unsignedlongflags;
  6. structresource*parent,*sibling,*child;
  7. };
这是dev_set_drvdata()的函数定义：

[cpp]view plaincopy
  1. staticinlinevoiddev_set_drvdata(structdevice*dev,void*data)
  2. {
  3. dev->driver_data=data;
  4. }
接下来是在s3c_rtc_probe()函数用到的两个函数s3c_rtc_enable()和s3c_rtc_setfreq()

  1. staticvoids3c_rtc_enable(structplatform_device*pdev,inten)
  2. {
  1. void__iomem*base=s3c_rtc_base;//__iomem的作用就是为了使编译器更好的优化编译
  2. unsignedinttmp;
  4. if(s3c_rtc_base==NULL)
  5. return;
  6. //en作为参数传递过来如果en==0,关闭电源前的情况
  7. if(!en){
  8. tmp=readb(base+S3C2410_RTCCON);
  1. writeb(tmp&~S3C2410_RTCCON_RTCEN,base+S3C2410_RTCCON);//设置RTCCON寄存器，屏蔽RTC使能，可以参考数据手册中寄存器的相关定义
  3. tmp=readb(base+S3C2410_TICNT);
  4. writeb(tmp&~S3C2410_TICNT_ENABLE,base+S3C2410_TICNT);//设置TICNT寄存器，屏蔽节拍时间中断使能
  5. }else{
  6. /*re-enablethedevice,andcheckitisok*/
  7. //en!=0的情况，表示系统复位，重新使能RTC驱动
  8. if((readb(base+S3C2410_RTCCON)&S3C2410_RTCCON_RTCEN)==0){//RTCCON第0位为0，将其设置为1，重新使能
  9. dev_info(&pdev->dev,"rtcdisabled,re-enablingn");
  11. tmp=readb(base+S3C2410_RTCCON);
  12. writeb(tmp|S3C2410_RTCCON_RTCEN,base+S3C2410_RTCCON);
  13. }
  15. if((readb(base+S3C2410_RTCCON)&S3C2410_RTCCON_CNTSEL)){
  16. dev_info(&pdev->dev,"removingRTCCON_CNTSELn");
  18. tmp=readb(base+S3C2410_RTCCON);
  19. writeb(tmp&~S3C2410_RTCCON_CNTSEL,base+S3C2410_RTCCON);//设置RTCCON第2位为0，设置BCD计数为混合BCD计数
  20. }
  22. if((readb(base+S3C2410_RTCCON)&S3C2410_RTCCON_CLKRST)){
  23. dev_info(&pdev->dev,"removingRTCCON_CLKRSTn");
  25. tmp=readb(base+S3C2410_RTCCON);
  26. writeb(tmp&~S3C2410_RTCCON_CLKRST,base+S3C2410_RTCCON);//RTC时钟计数器复位
  27. }
  28. }
  29. }
[cpp]view plaincopy
  1. staticints3c_rtc_setfreq(structdevice*dev,intfreq)//设定节拍时间计数值
  2. {
  3. unsignedinttmp;
  5. spin_lock_irq(&s3c_rtc_pie_lock);//获取自旋锁，对资源互斥访问
  7. tmp=readb(s3c_rtc_base+S3C2410_TICNT)&S3C2410_TICNT_ENABLE;//节拍时间使能有效
  8. tmp|=(128/freq)-1;
  10. writeb(tmp,s3c_rtc_base+S3C2410_TICNT);
  11. spin_unlock_irq(&s3c_rtc_pie_lock);//解锁
  13. return0;
  14. }
接下来是RTC设备类的操作。

下面是rtc_class_ops是RTC设备类在RTC驱动核心部分中定义的对RTC设备类进行操作的结构体，类似字符设备在驱动中的file_operations对字符设备进行操作的意思。该结构体被定义在rtc.h中，对RTC的操作主要有打开、关闭、设置或获取时间、设置或获取报警、设置节拍时间计数值等等，该结构体内接口函数的实现都在下面

  1. staticconststructrtc_class_opss3c_rtcops={
  2. .open=s3c_rtc_open,
  3. .release=s3c_rtc_release,
  4. .read_time=s3c_rtc_gettime,
  5. .set_time=s3c_rtc_settime,
  6. .irq_set_freq=s3c_rtc_setfreq,
  7. .irq_set_state=s3c_rtc_setpie,
  8. };
RTC打开设备函数s3c_rtc_open()
  1. staticints3c_rtc_open(structdevice*dev)
  2. {
  3. structplatform_device*pdev=to_platform_device(dev);//从平台设备中获取RTC设备类的数据
  4. structrtc_device*rtc_dev=platform_get_drvdata(pdev);
  5. intret;
  7. ret=request_irq(s3c_rtc_tickno,s3c_rtc_tickirq,
  8. IRQF_DISABLED,"s3c2410-rtctick",rtc_dev);//申请中断
  10. if(ret){
  11. dev_err(dev,"IRQ%derror%dn",s3c_rtc_tickno,ret);
  12. gototick_err;
  13. }
  15. tick_err:
  16. returnret;
  17. }
RTC TICK节拍时间中断服务程序
  1. staticirqreturn_ts3c_rtc_tickirq(intirq,void*id)
  2. {
  3. structrtc_device*rdev=id;
  5. rtc_update_irq(rdev,1,RTC_PF|RTC_IRQF);
  6. returnIRQ_HANDLED;
  7. }
RTC关闭设备函数s3c_rtc_release()

  1. staticvoids3c_rtc_release(structdevice*dev)
  2. {
  3. structplatform_device*pdev=to_platform_device(dev);//从平台设备中获取RTC设备类的数据
  5. structrtc_device*rtc_dev=platform_get_drvdata(pdev);
  7. /*donotclearAIEhere,itmaybeneededforwake*/
  9. s3c_rtc_setpie(dev,0);//函数定义见下面
  10. free_irq(s3c_rtc_tickno,rtc_dev);
  11. }
s3c_rtc_setpie()函数，该函数主要作用就是根据参数设置TICNT寄存器的最高位，参数为0，禁止使能，参数为1，使能
  1. staticints3c_rtc_setpie(structdevice*dev,intenabled)
  2. {
  3. unsignedinttmp;
  5. pr_debug("%s:pie=%dn",__func__,enabled);
  7. spin_lock_irq(&s3c_rtc_pie_lock);
  8. tmp=readb(s3c_rtc_base+S3C2410_TICNT)&~S3C2410_TICNT_ENABLE;//读取TICNT的值并将最高位清0
  10. if(enabled)
  11. tmp|=S3C2410_TICNT_ENABLE;
  13. writeb(tmp,s3c_rtc_base+S3C2410_TICNT);//写入计算后新的值
  14. spin_unlock_irq(&s3c_rtc_pie_lock);
  16. return0;
  17. }
下面两个函数是设置和读取BCD寄存器的时间，逻辑很简单，只是读取和设置相应寄存器的值

  1. staticints3c_rtc_gettime(structdevice*dev,structrtc_time*rtc_tm)
  2. {
  3. unsignedinthave_retried=0;
  4. void__iomem*base=s3c_rtc_base;
  6. retry_get_time:
  7. rtc_tm->tm_min=readb(base+S3C2410_RTCMIN);
  8. rtc_tm->tm_hour=readb(base+S3C2410_RTCHOUR);
  9. rtc_tm->tm_mday=readb(base+S3C2410_RTCDATE);
  10. rtc_tm->tm_mon=readb(base+S3C2410_RTCMON);
  11. rtc_tm->tm_year=readb(base+S3C2410_RTCYEAR);
  12. rtc_tm->tm_sec=readb(base+S3C2410_RTCSEC);
  14. /*theonlywaytoworkoutwetherthesystemwasmid-update
  15. *whenwereaditistocheckthesecondcounter,andifit
  16. *iszero,thenwere-trytheentireread
  17. */
  19. if(rtc_tm->tm_sec==0&&!have_retried){
  20. have_retried=1;
  21. gotoretry_get_time;
  22. }
  24. pr_debug("readtime%02x.%02x.%02x%02x/%02x/%02xn",
  25. rtc_tm->tm_year,rtc_tm->tm_mon,rtc_tm->tm_mday,
  26. rtc_tm->tm_hour,rtc_tm->tm_min,rtc_tm->tm_sec);
  28. rtc_tm->tm_sec=bcd2bin(rtc_tm->tm_sec);
  29. rtc_tm->tm_min=bcd2bin(rtc_tm->tm_min);
  30. rtc_tm->tm_hour=bcd2bin(rtc_tm->tm_hour);
  31. rtc_tm->tm_mday=bcd2bin(rtc_tm->tm_mday);
  32. rtc_tm->tm_mon=bcd2bin(rtc_tm->tm_mon);
  33. rtc_tm->tm_year=bcd2bin(rtc_tm->tm_year);
  35. rtc_tm->tm_year+=100;
  36. rtc_tm->tm_mon-=1;
  38. return0;
  39. }
  41. staticints3c_rtc_settime(structdevice*dev,structrtc_time*tm)
  42. {
  43. void__iomem*base=s3c_rtc_base;
  44. intyear=tm->tm_year-100;
  46. pr_debug("settime%02d.%02d.%02d%02d/%02d/%02dn",
  47. tm->tm_year,tm->tm_mon,tm->tm_mday,
  48. tm->tm_hour,tm->tm_min,tm->tm_sec);
  50. /*wegetaroundy2kbysimplynotsupportingit*/
  52. if(year<0||year>=100){
  53. dev_err(dev,"rtconlysupports100yearsn");
  54. return-EINVAL;
  55. }
  57. writeb(bin2bcd(tm->tm_sec),base+S3C2410_RTCSEC);
  58. writeb(bin2bcd(tm->tm_min),base+S3C2410_RTCMIN);
  59. writeb(bin2bcd(tm->tm_hour),base+S3C2410_RTCHOUR);
  60. writeb(bin2bcd(tm->tm_mday),base+S3C2410_RTCDATE);
  61. writeb(bin2bcd(tm->tm_mon+1),base+S3C2410_RTCMON);
  62. writeb(bin2bcd(year),base+S3C2410_RTCYEAR);
  64. return0;
  65. }
到这里RTC驱动的计时功能实现，报警功能还没有完成。下面是这个驱动源代码

  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #includeinterrupt.h>
  7. #include
  8. #include
  9. #include
  10. #include
  12. #include
  13. #include
  14. #include
  15. #include
  16. #include
  19. staticstructresource*s3c_rtc_mem;
  21. staticvoid__iomem*s3c_rtc_base;
  23. staticints3c_rtc_tickno=NO_IRQ;
  25. staticDEFINE_SPINLOCK(s3c_rtc_pie_lock);
  28. staticirqreturn_ts3c_rtc_tickirq(intirq,void*id)
  29. {
  30. structrtc_device*rdev=id;
  32. rtc_update_irq(rdev,1,RTC_PF|RTC_IRQF);
  33. returnIRQ_HANDLED;
  34. }
  36. /*Updatecontrolregisters*/
  37. staticvoids3c_rtc_setaie(intto)
  38. {
  39. unsignedinttmp;
  41. pr_debug("%s:aie=%dn",__func__,to);
  43. tmp=readb(s3c_rtc_base+S3C2410_RTCALM)&~S3C2410_RTCALM_ALMEN;
  45. if(to)
  46. tmp|=S3C2410_RTCALM_ALMEN;
  48. writeb(tmp,s3c_rtc_base+S3C2410_RTCALM);
  49. }
  51. staticints3c_rtc_setpie(structdevice*dev,intenabled)
  52. {
  53. unsignedinttmp;
  55. pr_debug("%s:pie=%dn",__func__,enabled);
  57. spin_lock_irq(&s3c_rtc_pie_lock);
  58. tmp=readb(s3c_rtc_base+S3C2410_TICNT)&~S3C2410_TICNT_ENABLE;
  60. if(enabled)
  61. tmp|=S3C2410_TICNT_ENABLE;
  63. writeb(tmp,s3c_rtc_base+S3C2410_TICNT);
  64. spin_unlock_irq(&s3c_rtc_pie_lock);
  66. return0;
  67. }
  69. staticints3c_rtc_setfreq(structdevice*dev,intfreq)
  70. {
  71. unsignedinttmp;
  73. spin_lock_irq(&s3c_rtc_pie_lock);
  75. tmp=readb(s3c_rtc_base+S3C2410_TICNT)&S3C2410_TICNT_ENABLE;
  76. tmp|=(128/freq)-1;
  78. writeb(tmp,s3c_rtc_base+S3C2410_TICNT);
  79. spin_unlock_irq(&s3c_rtc_pie_lock);
  81. return0;
  82. }
  84. /*Timeread/write*/
  86. staticints3c_rtc_gettime(structdevice*dev,structrtc_time*rtc_tm)
  87. {
  88. unsignedinthave_retried=0;
  89. void__iomem*base=s3c_rtc_base;
  91. retry_get_time:
  92. rtc_tm->tm_min=readb(base+S3C2410_RTCMIN);
  93. rtc_tm->tm_hour=readb(base+S3C2410_RTCHOUR);
  94. rtc_tm->tm_mday=readb(base+S3C2410_RTCDATE);
  95. rtc_tm->tm_mon=readb(base+S3C2410_RTCMON);
  96. rtc_tm->tm_year=readb(base+S3C2410_RTCYEAR);
  97. rtc_tm->tm_sec=readb(base+S3C2410_RTCSEC);
  99. /*theonlywaytoworkoutwetherthesystemwasmid-update
  100. *whenwereaditistocheckthesecondcounter,andifit
  101. *iszero,thenwere-trytheentireread
  102. */
  104. if(rtc_tm->tm_sec==0&&!have_retried){
  105. have_retried=1;
  106. gotoretry_get_time;
  107. }
  109. pr_debug("readtime%02x.%02x.%02x%02x/%02x/%02xn",
  110. rtc_tm->tm_year,rtc_tm->tm_mon,rtc_tm->tm_mday,
  111. rtc_tm->tm_hour,rtc_tm->tm_min,rtc_tm->tm_sec);
  113. rtc_tm->tm_sec=bcd2bin(rtc_tm->tm_sec);
  114. rtc_tm->tm_min=bcd2bin(rtc_tm->tm_min);
  115. rtc_tm->tm_hour=bcd2bin(rtc_tm->tm_hour);
  116. rtc_tm->tm_mday=bcd2bin(rtc_tm->tm_mday);
  117. rtc_tm->tm_mon=bcd2bin(rtc_tm->tm_mon);
  118. rtc_tm->tm_year=bcd2bin(rtc_tm->tm_year);
  120. rtc_tm->tm_year+=100;
  121. rtc_tm->tm_mon-=1;
  123. return0;
  124. }
  126. staticints3c_rtc_settime(structdevice*dev,structrtc_time*tm)
  127. {
  128. void__iomem*base=s3c_rtc_base;
  129. intyear=tm->tm_year-100;
  131. pr_debug("settime%02d.%02d.%02d%02d/%02d/%02dn",
  132. tm->tm_year,tm->tm_mon,tm->tm_mday,
  133. tm->tm_hour,tm->tm_min,tm->tm_sec);
  135. /*wegetaroundy2kbysimplynotsupportingit*/
  137. if(year<0||year>=100){
  138. dev_err(dev,"rtconlysupports100yearsn");
  139. return-EINVAL;
  140. }
  142. writeb(bin2bcd(tm->tm_sec),base+S3C2410_RTCSEC);
  143. writeb(bin2bcd(tm->tm_min),base+S3C2410_RTCMIN);
  144. writeb(bin2bcd(tm->tm_hour),base+S3C2410_RTCHOUR);
  145. writeb(bin2bcd(tm->tm_mday),base+S3C2410_RTCDATE);
  146. writeb(bin2bcd(tm->tm_mon+1),base+S3C2410_RTCMON);
  147. writeb(bin2bcd(year),base+S3C2410_RTCYEAR);
  149. return0;
  150. }
  152. staticints3c_rtc_open(structdevice*dev)
  153. {
  154. structplatform_device*pdev=to_platform_device(dev);
  155. structrtc_device*rtc_dev=platform_get_drvdata(pdev);
  156. intret;
  158. ret=request_irq(s3c_rtc_tickno,s3c_rtc_tickirq,
  159. IRQF_DISABLED,"s3c2410-rtctick",rtc_dev);
  161. if(ret){
  162. dev_err(dev,"IRQ%derror%dn",s3c_rtc_tickno,ret);
  163. gototick_err;
  164. }
  166. tick_err:
  167. returnret;
  168. }
  170. staticvoids3c_rtc_release(structdevice*dev)
  171. {
  172. structplatform_device*pdev=to_platform_device(dev);
  173. structrtc_device*rtc_dev=platform_get_drvdata(pdev);
  175. /*donotclearAIEhere,itmaybeneededforwake*/
  177. s3c_rtc_setpie(dev,0);
  178. free_irq(s3c_rtc_tickno,rtc_dev);
  179. }
  181. staticconststructrtc_class_opss3c_rtcops={
  182. .open=s3c_rtc_open,
  183. .release=s3c_rtc_release,
  184. .read_time=s3c_rtc_gettime,
  185. .set_time=s3c_rtc_settime,
  186. .irq_set_freq=s3c_rtc_setfreq,
  187. .irq_set_state=s3c_rtc_setpie,
  188. };
  190. staticvoids3c_rtc_enable(structplatform_device*pdev,inten)
  191. {
  192. void__iomem*base=s3c_rtc_base;
  193. unsignedinttmp;
  195. if(s3c_rtc_base==NULL)
  196. return;
  198. if(!en){
  199. tmp=readb(base+S3C2410_RTCCON);
  200. writeb(tmp&~S3C2410_RTCCON_RTCEN,base+S3C2410_RTCCON);
  202. tmp=readb(base+S3C2410_TICNT);
  203. writeb(tmp&~S3C2410_TICNT_ENABLE,base+S3C2410_TICNT);
  204. }else{
  205. /*re-enablethedevice,andcheckitisok*/
  207. if((readb(base+S3C2410_RTCCON)&S3C2410_RTCCON_RTCEN)==0){
  208. dev_info(&pdev->dev,"rtcdisabled,re-enablingn");
  210. tmp=readb(base+S3C2410_RTCCON);
  211. writeb(tmp|S3C2410_RTCCON_RTCEN,base+S3C2410_RTCCON);
  212. }
  214. if((readb(base+S3C2410_RTCCON)&S3C2410_RTCCON_CNTSEL)){
  215. dev_info(&pdev->dev,"removingRTCCON_CNTSELn");
  217. tmp=readb(base+S3C2410_RTCCON);
  218. writeb(tmp&~S3C2410_RTCCON_CNTSEL,base+S3C2410_RTCCON);
  219. }
  221. if((readb(base+S3C2410_RTCCON)&S3C2410_RTCCON_CLKRST)){
  222. dev_info(&pdev->dev,"removingRTCCON_CLKRSTn");
  224. tmp=readb(base+S3C2410_RTCCON);
  225. writeb(tmp&~S3C2410_RTCCON_CLKRST,base+S3C2410_RTCCON);
  226. }
  227. }
  228. }
  230. staticint__devexits3c_rtc_remove(structplatform_device*dev)
  231. {
  232. structrtc_device*rtc=platform_get_drvdata(dev);
  234. platform_set_drvdata(dev,NULL);
  235. rtc_device_unregister(rtc);
  237. s3c_rtc_setpie(&dev->dev,0);
  238. s3c_rtc_setaie(0);
  240. iounmap(s3c_rtc_base);
  241. release_resource(s3c_rtc_mem);
  242. kfree(s3c_rtc_mem);
  244. return0;
  245. }
  247. staticint__devinits3c_rtc_probe(structplatform_device*pdev)
  248. {
  249. structrtc_device*rtc;
  250. structresource*res;
  251. intret;
  253. pr_debug("%s:probe=%pn",__func__,pdev);
  255. /*findtheIRQs*/
  257. s3c_rtc_tickno=platform_get_irq(pdev,1);
  258. if(s3c_rtc_tickno<0){
  259. dev_err(&pdev->dev,"noirqforrtctickn");
  260. return-ENOENT;
  261. }
  263. /*getthememoryregion*/
  265. res=platform_get_resource(pdev,IORESOURCE_MEM,0);
  266. if(res==NULL){
  267. dev_err(&pdev->dev,"failedtogetmemoryregionresourcen");
  268. return-ENOENT;
  269. }
  271. s3c_rtc_mem=request_mem_region(res->start,
  272. res->end-res->start+1,
  273. pdev->name);
  275. if(s3c_rtc_mem==NULL){
  276. dev_err(&pdev->dev,"failedtoreservememoryregionn");
  277. ret=-ENOENT;
  278. gotoerr_nores;
  279. }
  281. s3c_rtc_base=ioremap(res->start,res->end-res->start+1);
  282. if(s3c_rtc_base==NULL){
  283. dev_err(&pdev->dev,"failedioremap()n");
  284. ret=-EINVAL;
  285. gotoerr_nomap;
  286. }
  288. /*checktoseeifeverythingissetupcorrectly*/
  290. s3c_rtc_enable(pdev,1);
  292. pr_debug("s3c2410_rtc:RTCCON=%02xn",
  293. readb(s3c_rtc_base+S3C2410_RTCCON));
  295. s3c_rtc_setfreq(&pdev->dev,1);
  297. /*registerRTCandexit*/
  299. rtc=rtc_device_register("s3c",&pdev->dev,&s3c_rtcops,
  300. THIS_MODULE);
  302. if(IS_ERR(rtc)){
  303. dev_err(&pdev->dev,"cannotattachrtcn");
  304. ret=PTR_ERR(rtc);
  305. gotoerr_nortc;
  306. }
  308. rtc->max_user_freq=128;
  310. platform_set_drvdata(pdev,rtc);
  311. return0;
  313. err_nortc:
  314. s3c_rtc_enable(pdev,0);
  315. iounmap(s3c_rtc_base);
  317. err_nomap:
  318. release_resource(s3c_rtc_mem);
  319. err_nores:
  320. returnret;
  321. }
  323. staticstructplatform_drivers3c2410_rtc_driver={
  324. .probe=s3c_rtc_probe,
  325. .remove=__devexit_p(s3c_rtc_remove),
  326. .driver={
  327. .name="s3c2410-rtc",
  328. .owner=THIS_MODULE,
  329. },
  330. };
  332. staticchar__initdatabanner[]="S3C24XXRTC,(c)2004,2006SimtecElectronicsn";
  334. staticint__inits3c_rtc_init(void)
  335. {
  336. printk(banner);
  337. returnplatform_driver_register(&s3c2410_rtc_driver);
  338. }
  340. staticvoid__exits3c_rtc_exit(void)
  341. {
  342. platform_driver_unregister(&s3c2410_rtc_driver);
  343. }
  345. module_init(s3c_rtc_init);
  346. module_exit(s3c_rtc_exit);
  348. MODULE_DESCRIPTION("Mys3c2440RTCDriver");
  349. MODULE_AUTHOR("YanMing-yming0221@gmail.com");
  350. MODULE_LICENSE("GPL");
  351. MODULE_ALIAS("platform:s3c2410-rtc");

Makefile文件

  1. obj-m:=rtc.o
  2. KERNELDIR?=/arm/linux-2.6.28.7-2440
  3. PWD:=$(shellpwd)
  4. default:
  5. $(MAKE)-C$(KERNELDIR)M=$(PWD)modules
  6. clean:
  7. rm-f*.o*.ko*.order*.symvers

make后在目录下生成rtc.ko驱动，利用NFS挂在到目标板，insmod rtc.ko驱动就可以加载，执行hwclock命令，查看是否可以读取硬件的RTC。

关键词： ARMLinux驱动RTC实时时钟驱动分

评论


相关推荐

技术专区

关闭