您的位置 首页 芯闻

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

2020年9月18日 15:02 阅读(404)

硬件平台：FL2440（S3C2440）内核版本：Linux2.6.28主机平台：Ubuntu11.04内核版本：Linux2.6.39交叉编译器版本：arm-linux-gcc3.4…

硬件渠道：FL2440（S3C2440）

内核版别：Linux 2.6.28

主机渠道：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=%p\n”,__func__,pdev);
  9. /*findtheIRQs*/
  11. s3c_rtc_tickno=platform_get_irq(pdev,1);//在体系界说的渠道设备中获取中止号
  12. if(s3c_rtc_tickno<0){//反常处理
  13. dev_err(&pdev->dev,”noirqforrtctick\n”);
  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,”failedtogetmemoryregionresource\n”);
  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,”failedtoreservememoryregion\n”);
  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=%02x\n”,
  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,”cannotattachrtc\n”);
  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-enabling\n”);
  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_CNTSEL\n”);
  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_CLKRST\n”);
  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%d\n”,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=%d\n”,__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/%02x\n”,
  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/%02d\n”,
  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,”rtconlysupports100years\n”);
  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=%d\n”,__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=%d\n”,__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/%02x\n”,
  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/%02d\n”,
  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,”rtconlysupports100years\n”);
  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%d\n”,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-enabling\n”);
  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_CNTSEL\n”);
  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_CLKRST\n”);
  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=%p\n”,__func__,pdev);
  255. /*findtheIRQs*/
  257. s3c_rtc_tickno=platform_get_irq(pdev,1);
  258. if(s3c_rtc_tickno<0){
  259. dev_err(&pdev->dev,”noirqforrtctick\n”);
  260. return-ENOENT;
  261. }
  263. /*getthememoryregion*/
  265. res=platform_get_resource(pdev,IORESOURCE_MEM,0);
  266. if(res==NULL){
  267. dev_err(&pdev->dev,”failedtogetmemoryregionresource\n”);
  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,”failedtoreservememoryregion\n”);
  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=%02x\n”,
  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,”cannotattachrtc\n”);
  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,2006SimtecElectronics\n”;
  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_L%&&&&&%ENSE(“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。

声明：本文内容来自网络转载或用户投稿，文章版权归原作者和原出处所有。文中观点，不代表本站立场。若有侵权请联系本站删除（kf@86ic.com）https://www.86ic.net/news/xinwen/264385.html
8赞
标签:

为您推荐

河北小漫电子商务有限公司新增代理产品线——MST(迈尔斯通)

利用机电继电器解决现代接口问题

武汉电子展︱赋能中西部电子信息产业发展——2025 武汉国际半导体产业与电子技术博览会

用指针万用表检测双向触发二极管

单板机如何扩展工业自动化的覆盖范围

掌握几个技巧 降低运放电路中的功耗！

联系我们

联系我们

在线咨询: QQ交谈

邮箱: kf@86ic.com

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

返回顶部