本次来说一下Linux的RTC子系统. (Real Time Clock).
在说之前,先说一下STM32上的一些事儿,在移植UCOS的时候,总是想着用timer为系统提供定时中断服务,然后这次搞RTC驱动,忽然,就想到了实际上还可以使用RTC来为UCOS提供系统时钟中断服务,STM32上是有集成RTC的,其实UCOS的创始人出的书上就有说,能提供定时中断的对象有很对,甚至可以用交流电来提供,这样一判断,发现STM32上能提供类似定时中断的器件还是不少呢,比如timer, watchdog, RTC等等都可以.
好了回到主题,本次说一下Linux上的RTC子系统驱动程序如何编写,并在这之前,先来认识一下RTC这个器件.
RTC实时时钟
RTC一般成为RTC实时时钟. 实时时钟(RTC)单元可以在系统电源关闭的情况下依靠备用电池工作,一般主板上都有一个纽扣电池作为实时时钟的电源.RTC可以通过使用STRB/LDDRB这两个ARM指令向CPU传递8为数据(BCD码).数据包括秒, 分, 小时, 日期, 天, 月, 年.RTC实时时钟依靠一个外部的32.768kHz的石英晶体,产生周期性的脉冲信号.每一个脉冲信号到来时,计数器就加1,通过这种方式,完成计时功能.
RTC实时时钟有如下特性:
1).BCD数据:这些数据包括秒,分,小时,日期,星期几,月和年.
2).闰年产生器.
3).闹钟功能:闹钟中断或者从掉电模式唤醒.
4).滴答功能:支持滴答中断或者滴答唤醒.
5).独立电源引脚RTCVDD.
6).支持ms中断作为RTOS内核时钟.
RTC实时时钟的功能
如下图所示,是RTC实时时钟的框架图.XrtcXTI和XercXTO产生脉冲信号.XRTCCLKO则是把这个产生的信号输出外部,这个可以通过配置RTCCON寄存器使能或者关闭,传给2^15 的之时钟分频器,得到一个128Hz的频率,这个频率用来产生滴答计数.当TICNT计数为0时,产生一个TIME TICK中断信号.RTCCON寄存器用来控制RTC实时时钟的功能.RTCRST是重置寄存器,用来重置SEC和MIN寄存器.Leap Year Generator是一个闰年发生器,用来产生闰年逻辑.RTCALM用来控制是否产生报警信号.下面对这些功能分别介绍:
1,闰年发生器(Leap Year Generator)
闰年发生器可以基于BCDDATE, BCDMON, BCDYEAR决定每月最后一天的日期是28,29,30 还是31.一个8位计数器只能表示两位BCD码,每一位BCD码由4位表示.因此不能决定00年是否是闰年,例如它不能区别1900年还是2000年.RTC模块通过硬件逻辑支持2000年为闰年(注意1900年不是闰年,2000年才是闰年).因此这两位"00"指的是2000年,而不是1900年.
2,读写寄存器
要写BCD寄存器时必须要将RTCCON寄存器的0位置1;要显示秒,分,小时,日期,星期几,月和年等时间,必须单独读取BCDSEC,BCDMIN,BCDHOUR,BCDDAY,BCDDATE,BCDMON,BCDYEAR寄存器的值.但是这中间可能存在1秒钟的偏差,因为要读多个寄存器.例如,用户读取到的结果是2017年12月31日23点59分,如果读取BCDSEC寄存器的值是1~59是没有问题的,但是如果是0,由于存在1秒的偏差,时间将变成2018年1月1日0时0分.这种情况下,应该重新读取BCDYEAR~BCDSEC寄存器的值,否则读出的时间仍然是2017年12月31日23点59分.
3,后备电池
即使系统电源关闭,RTC模块可以由后备电池通过RTCVDD引脚供电.当系统电源关闭时,CPU和RTC的接口应该被阻塞,后备电池应该只驱动晶振电路和BCD计数器,以消耗最少的电量.
4,报警功能
在正常模式和掉电模式下,RTC在指定的时刻会产生一个报警信号.正常模式下,报警中断ALMINT有效,对应INT_RTC引脚.掉电模式下,报警中断ALMINT有效外还产生一个唤醒信号PMWKUP,对用PMWKUP引脚.RTC报警寄存器RTCALM决定是否使能报警状态和设置报警条件.
5,时钟脉冲中断与时钟唤醒
RTC时钟脉冲用于中断请求,如上图中的TICNT寄存器有一个中断/唤醒使能位和一个相关的计数器值.最高位是中断/唤醒使能位,低7位是计数位,每产生一个时钟脉冲,计数值减1.如果当时钟脉冲发生时,计数器值到达0,那么会发生一个TIME TICK中断.上图方框Time Tick Generator下有一个128Hz的时钟频率,表示1秒钟产生128次时钟滴答.可以给TICNT的低7位赋值,取值范围为0~127,用n表示.则产生中断请求的周期为如下公式所示:Period = (n + 1) / 128 second
其中,n表示产生中断前需要滴答的次数(1~127).
6,后循环测试功能
注意:在Exynos 4412的datasheet上处理上面那个图里边有写RTCRST之外,我没有找到这个寄存器,可能是没有了,但是还是写出来,万一有呢,哈哈, 后循环测试功能由RTCRST寄存器执行.秒执行发生器的循环边界可以选择为30秒,40秒或50秒,第二个值变为0.例如,如果当前时间是23:37:45,循环测试时间为40秒,则循环测试将当前时间设为23:38:00.注意,所有RTC寄存器都必须使用STRB和LDRB指令或者字符型指针操作.
RTC实时时钟的工作原理
RTC实时时钟的工作由多个寄存器来控制.Exynos 4412都有如下寄存器:
从上面的表格看,好像是没有RTCRST寄存器,下面对其中一些寄存器进行一个大概地讲解,详细的请直接参考datasheet.
1.INTP寄存器
INTP寄存器主要控制ALARM和TICK是否产生中断,从上面的表格来看,只有到了低两位.
2,RTCCON寄存器
配置寄存器则是一个整体功能的控制,从0位开始包括RTC使能,时钟选择,计数器选择,时钟复位滴答频率选择,滴答使能,以及是否向外部提供RTC时钟.
3,RTC报警控制寄存器RTCALM
RTCALM控制报警使能和报警时间,注意,注意,RTCALM在掉电模式下产生ALMINT和PMWKUP报警信号,而在正常模式下,只产生ALMINT信号.RTCALM寄存器的各位表示的内容如下:
4,RTC报警秒数据寄存器ALMSEC
5,RTC报警分钟数据寄存器ALMMIN
6,RTC报警小时数据寄存器ALMHOUR
7,RTC报警日期数据寄存器ALMDATE
8,RTC报警月数据寄存器ALMMON
9,RTC报警年数据寄存器ALMYEAR
10,RTC秒数据寄存器BCDSEC
11,RTC分数据寄存器BCDMIN
12,RTC小时数据寄存器BCDHOUR
由于代码里把关键的地方都进行了注释,所以,代码就直接贴出来了:
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/fs.h>
#include <linux/rtc.h>
#include <linux/platform_device.h>
#include <linux/bcd.h>
#include <linux/clk.h>
#include <linux/of.h>
#include <mach/hardware.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <plat/regs-rtc.h>
enum exynos4_cpu_type {
TYPE_S3C2410,
TYPE_S3C64XX,
};
struct exynos4_rtc_drv_data {
int cpu_type;
};
struct exynos4_rtc_object {
struct resource *exynos4_rtc_mem;
void __iomem *exynos4_rtc_base;
struct clk *rtc_clk;
int exynos4_rtc_alarmno;
int exynos4_rtc_tickno;
bool wake_en;
enum exynos4_cpu_type exynos4_rtc_cpu_type;
};
struct exynos4_rtc_object *rtc_obj = NULL;
static DEFINE_SPINLOCK(exynos4_rtc_pie_lock);
static void exynos4_rtc_alarm_clk_enable(bool enable)
{
static DEFINE_SPINLOCK(exynos4_rtc_alarm_clk_lock);
static bool alarm_clk_enabled;
unsigned long irq_flags;
spin_lock_irqsave(&exynos4_rtc_alarm_clk_lock, irq_flags);
if(enable){
if(!alarm_clk_enabled){
clk_enable(rtc_obj->rtc_clk);
alarm_clk_enabled = true;
}
}
else{
if(alarm_clk_enabled){
clk_disable(rtc_obj->rtc_clk);
alarm_clk_enabled = false;
}
}
spin_unlock_irqrestore(&exynos4_rtc_alarm_clk_lock, irq_flags);
}
irqreturn_t
alarm_irq_handler(int irqno, void *devid)
{
struct rtc_device *rdev = devid;
clk_enable(rtc_obj->rtc_clk);
rtc_update_irq(rdev, 1, RTC_AF | RTC_IRQF);
if(TYPE_S3C2410 == rtc_obj->exynos4_rtc_cpu_type)
writeb(S3C2410_INTP_ALM, rtc_obj->exynos4_rtc_base + S3C2410_INTP);
clk_disable(rtc_obj->rtc_clk);
exynos4_rtc_alarm_clk_enable(false);
return IRQ_HANDLED;
}
irqreturn_t
tick_irq_handler(int irqno, void *devid)
{
struct rtc_device *rdev = devid;
clk_enable(rtc_obj->rtc_clk);
rtc_update_irq(rdev, 1, RTC_PF | RTC_IRQF);
if(TYPE_S3C64XX == rtc_obj->exynos4_rtc_cpu_type)
writeb(S3C2410_INTP_TIC, rtc_obj->exynos4_rtc_base + S3C2410_INTP);
clk_disable(rtc_obj->rtc_clk);
return IRQ_HANDLED;
}
static int exynos4_rtc_setfreq(struct device *dev, int freq)
{
struct paltform_device *pdev = to_platform_device(dev);
struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
unsigned int temp = 0;
int val;
if(!is_power_of_2(freq))
return -EINVAL;
clk_enable(rtc_obj->rtc_clk);
spin_lock_irq(&exynos4_rtc_pie_lock);
if(TYPE_S3C64XX != rtc_obj->exynos4_rtc_cpu_type){
temp = readb(rtc_obj->exynos4_rtc_base + S3C2410_TICNT);
temp &= S3C2410_TICNT_ENABLE;
}
val = (rtc_dev->max_user_freq / freq) - 1;
temp |= val;
writel(temp, rtc_obj->exynos4_rtc_base + S3C2410_TICNT);
spin_unlock_irq(&exynos4_rtc_pie_lock);
clk_disable(rtc_obj->rtc_clk);
return 0;
}
int
exynos4_rtc_open(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct rtc_device *rtc = platform_get_drvdata(pdev);
int ret = -1;
// IRQF_DISABLED代表快速中断,使用datasheet上默认的中断触发方式
ret = request_irq(rtc_obj->exynos4_rtc_alarmno, alarm_irq_handler, IRQF_DISABLED, "exynos4 alarm_irq", rtc);
if(ret){
printk("request alarm irq failed !\n");
return ret;
}
ret = request_irq(rtc_obj->exynos4_rtc_tickno, tick_irq_handler, IRQF_DISABLED, "exynos4 tick_irq", rtc);
if(ret){
printk("request tick irq failed !\n");
free_irq(rtc_obj->exynos4_rtc_alarmno, rtc);
return ret;
}
return 0;
}
int
exynos4_rtc_setaie(struct device *dev, unsigned int enabled)
{
unsigned int temp;
clk_enable(rtc_obj->rtc_clk);
temp = readb(rtc_obj->exynos4_rtc_base + S3C2410_RTCALM) & ~S3C2410_RTCALM_ALMEN;
if(enabled)
temp |= S3C2410_RTCALM_ALMEN;
writeb(temp, rtc_obj->exynos4_rtc_base + S3C2410_RTCALM);
clk_disable(rtc_obj->rtc_clk);
exynos4_rtc_alarm_clk_enable(enabled);
return 0;
}
int
exynos4_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
unsigned int have_retried = 0;
void __iomem *base = rtc_obj->exynos4_rtc_base;
printk("-----%s-----\n", __func__); // 用户测试程序里会调用这个函数,但时候会打印这个函数名
clk_enable(rtc_obj->rtc_clk);
retry_read_time:
tm->tm_min = readb(base + S3C2410_RTCMIN);
tm->tm_hour = readb(base + S3C2410_RTCHOUR);
tm->tm_mday = readb(base + S3C2410_RTCDATE);
tm->tm_mon = readb(base + S3C2410_RTCMON);
tm->tm_year = readb(base + S3C2410_RTCYEAR);
tm->tm_sec = readb(base + S3C2410_RTCSEC);
// 判断读到的秒数是不是0,如果是0的话,说明已经更新了分钟寄存器了,重读
if((0 == tm->tm_sec) && !have_retried){
have_retried = 1;
goto retry_read_time;
}
tm->tm_sec = bcd2bin(tm->tm_sec);
tm->tm_min = bcd2bin(tm->tm_min);
tm->tm_hour = bcd2bin(tm->tm_hour);
tm->tm_mday = bcd2bin(tm->tm_mday);
tm->tm_mon = bcd2bin(tm->tm_mon);
tm->tm_year = bcd2bin(tm->tm_year);
tm->tm_year += 100;
tm->tm_mon -= 1;
clk_disable(rtc_obj->rtc_clk);
return rtc_valid_tm(tm);;
}
int
exynos4_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
void __iomem *base = rtc_obj->exynos4_rtc_base;
int year = tm->tm_year - 100;
if(year < 0 || year >= 100){
printk("set time year more than 100 !\n");
return -EINVAL;
}
clk_enable(rtc_obj->rtc_clk);
writeb(bin2bcd(tm->tm_sec), base + S3C2410_RTCSEC);
writeb(bin2bcd(tm->tm_min), base + S3C2410_RTCMIN);
writeb(bin2bcd(tm->tm_hour), base + S3C2410_RTCHOUR);
writeb(bin2bcd(tm->tm_mday), base + S3C2410_RTCDATE);
writeb(bin2bcd(tm->tm_mon + 1), base + S3C2410_RTCMON);
writeb(bin2bcd(year), base + S3C2410_RTCYEAR);
clk_disable(rtc_obj->rtc_clk);
return 0;
}
int
exynos4_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
struct rtc_time *alm_tm = &alm->time;
void __iomem *base = rtc_obj->exynos4_rtc_base;
unsigned int alm_en;
clk_enable(rtc_obj->rtc_clk);
alm_tm->tm_sec = readb(base + S3C2410_ALMSEC);
alm_tm->tm_min = readb(base + S3C2410_ALMMIN);
alm_tm->tm_hour = readb(base + S3C2410_ALMHOUR);
alm_tm->tm_mday = readb(base + S3C2410_ALMDATE);
alm_tm->tm_mon = readb(base + S3C2410_ALMMON);
alm_tm->tm_year = readb(base + S3C2410_ALMYEAR);
alm_en = readb(base + S3C2410_RTCALM);
alm->enabled = (alm_en & S3C2410_RTCALM_ALMEN) ? 1 : 0;
if(alm_en & S3C2410_RTCALM_SECEN)
alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
else
alm_tm->tm_sec = -1;
if(alm_en & S3C2410_RTCALM_MINEN)
alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
else
alm_tm->tm_min = -1;
if(alm_en & S3C2410_RTCALM_HOUREN)
alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
else
alm_tm->tm_hour = -1;
if(alm_en & S3C2410_RTCALM_DAYEN)
alm_tm->tm_mday = bcd2bin(alm_tm->tm_mday);
else
alm_tm->tm_mday = -1;
if(alm_en & S3C2410_RTCALM_MONEN)
alm_tm->tm_mon = bcd2bin(alm_tm->tm_mon);
else
alm_tm->tm_mon = -1;
if(alm_en & S3C2410_RTCALM_YEAREN)
alm_tm->tm_year = bcd2bin(alm_tm->tm_year);
else
alm_tm->tm_year = -1;
clk_disable(rtc_obj->rtc_clk);
return 0;
}
int
exynos4_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
struct rtc_time *tm = &alm->time;
void __iomem *base = rtc_obj->exynos4_rtc_base;
unsigned int alm_en;
clk_enable(rtc_obj->rtc_clk);
alm_en = readb(base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN;
writeb(0x00, base + S3C2410_RTCALM);
if(tm->tm_sec < 60 && tm->tm_sec >= 0){
alm_en |= S3C2410_RTCALM_SECEN;
writeb(bin2bcd(tm->tm_sec), base + S3C2410_ALMSEC);
}
if(tm->tm_min < 60 && tm->tm_min >= 0){
alm_en |= S3C2410_RTCALM_MINEN;
writeb(bin2bcd(tm->tm_min), base + S3C2410_ALMMIN);
}
if(tm->tm_hour < 24 && tm->tm_hour >= 0){
alm_en |= S3C2410_RTCALM_HOUREN;
writeb(bin2bcd(tm->tm_hour), base + S3C2410_ALMHOUR);
}
writeb(alm_en, base + S3C2410_RTCALM);
exynos4_rtc_setaie(dev, alm->enabled);
clk_disable(rtc_obj->rtc_clk);
return 0;
}
int
exynos4_rtc_proc(struct device *dev, struct seq_file *seq)
{
unsigned int ticnt;
clk_enable(rtc_obj->rtc_clk);
if(TYPE_S3C64XX == rtc_obj->exynos4_rtc_cpu_type){
ticnt = readw(rtc_obj->exynos4_rtc_base + S3C2410_RTCCON);
ticnt &= S3C64XX_RTCCON_TICEN;
}
else{
ticnt = readb(rtc_obj->exynos4_rtc_base + S3C2410_TICNT);
ticnt &= S3C2410_TICNT_ENABLE;
}
seq_printf(seq, "periodic_IRQ\t: %s\n", ticnt ? "yes" : "no");
clk_disable(rtc_obj->rtc_clk);
return 0;
}
void
exynos4_rtc_release(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct rtc_device *rtc = platform_get_drvdata(pdev);
exynos4_rtc_setaie(dev, 0);
free_irq(rtc_obj->exynos4_rtc_tickno, rtc);
free_irq(rtc_obj->exynos4_rtc_alarmno, rtc);
}
static const struct rtc_class_ops exynos4_rtcops = {
.open = exynos4_rtc_open,
.release = exynos4_rtc_release,
.read_time = exynos4_rtc_read_time,
.set_time = exynos4_rtc_set_time,
.read_alarm = exynos4_rtc_read_alarm,
.set_alarm = exynos4_rtc_set_alarm,
.proc = exynos4_rtc_proc,
.alarm_irq_enable = exynos4_rtc_setaie,
};
static void exynos4_rtc_enable(struct platform_device *pdev, int en)
{
void __iomem *base = rtc_obj->exynos4_rtc_base;
unsigned int temp;
if(NULL == rtc_obj->exynos4_rtc_base)
return;
clk_enable(rtc_obj->rtc_clk);
if(!en){
temp = readw(base + S3C2410_RTCCON);
if(TYPE_S3C64XX == rtc_obj->exynos4_rtc_cpu_type)
temp &= ~S3C64XX_RTCCON_TICEN;
temp &= ~S3C2410_RTCCON_RTCEN;
writew(temp, base + S3C2410_RTCCON);
if(TYPE_S3C64XX != rtc_obj->exynos4_rtc_cpu_type){
temp = readb(base + S3C2410_TICNT);
temp &= ~S3C2410_TICNT_ENABLE;
writeb(temp, base + S3C2410_TICNT);
}
}
else{
if(0 == (readw(base + S3C2410_RTCCON) & S3C2410_RTCCON_RTCEN)){
temp = readw(base + S3C2410_RTCCON);
writew(temp | S3C2410_RTCCON_RTCEN, base + S3C2410_RTCCON);
}
if((readw(base + S3C2410_RTCCON) & S3C2410_RTCCON_CNTSEL)){
temp = readw(base + S3C2410_RTCCON);
writew(temp & ~S3C2410_RTCCON_CNTSEL, base + S3C2410_RTCCON);
}
if(readw(base + S3C2410_RTCCON) & S3C2410_RTCCON_CLKRST){
temp = readw(base + S3C2410_RTCCON);
writew(temp & ~S3C2410_RTCCON_CLKRST, base + S3C2410_RTCCON);
}
}
clk_disable(rtc_obj->rtc_clk);
}
static const struct of_device_id exynos4_rtc_dt_match[];
static inline int exynos4_rtc_get_driver_data(struct platform_device *pdev)
{
#ifdef CONFIG_OF
struct exynos4_rtc_drv_data *data;
if(pdev->dev.of_node){
const struct of_device_id *match;
match = of_match_node(exynos4_rtc_dt_match, pdev->dev.of_node);
data = (struct exynos4_rtc_drv_data *)mach->data;
return data->cpu_type;
}
#endif
return platform_get_device_id(pdev)->driver_data;
}
int
exynos4_rtc_probe(struct platform_device *pdev)
{
struct rtc_device *rtc;
struct rtc_time rtc_tm;
struct resource *res;
int ret = -1;
printk("Exynos RTC start (c) 2018...\n");
// 1,申请设备对象
rtc_obj = kzalloc(sizeof(struct exynos4_rtc_object), GFP_KERNEL);
if(NULL == rtc_obj){
printk("kzalloc failed !\n");
return -ENOMEM;
}
// 2,获取平台自定义数据
// 2.1,获取tick中断
rtc_obj->exynos4_rtc_tickno = platform_get_irq(pdev, 1);
if(rtc_obj->exynos4_rtc_tickno < 0){
printk("platform get tick irq failed !\n");
goto err1;
}
// 2.2,获取alarm寄存器中断
rtc_obj->exynos4_rtc_alarmno = platform_get_irq(pdev, 0);
if(rtc_obj->exynos4_rtc_alarmno < 0){
printk("paltform get alarm irq failed !\n");
goto err2;
}
// 2.3,获取内存资源
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if(NULL == res){
printk("platform get io resource failed !\n");
goto err3;
}
// 3,申请内存资源空间
rtc_obj->exynos4_rtc_mem = request_mem_region(res->start, resource_size(res), pdev->name);
if(NULL == rtc_obj->exynos4_rtc_mem){
printk("request mem failed !\n");
goto err3;
}
// 4,映射内存到虚拟空间
rtc_obj->exynos4_rtc_base = ioremap(res->start, resource_size(res));
if(NULL == rtc_obj->exynos4_rtc_base){
printk("ioremap failed !\n");
goto err4;
}
// 5,获取RTC时钟频率
rtc_obj->rtc_clk = clk_get(&pdev->dev, "rtc");
if(IS_ERR(rtc_obj->rtc_clk)){
printk("clk get failed !\n");
goto err5;
}
// 6,使能RTC时钟
clk_enable(rtc_obj->rtc_clk);
// 7,配置RTC寄存器,使能
exynos4_rtc_enable(pdev, 1);
// 8,设置设备是否可以唤醒
device_init_wakeup(&pdev->dev, 1);
// 9,注册RTC驱动程序
rtc = rtc_device_register("s3c", &pdev->dev, &exynos4_rtcops, THIS_MODULE);
if(IS_ERR(rtc)){
printk("rtc device register failed !\n");
goto err6;
}
// 10,获取driver的数据
rtc_obj->exynos4_rtc_cpu_type = exynos4_rtc_get_driver_data(pdev);
// 11,检查RTC是否正常工作
exynos4_rtc_read_time(NULL, &rtc_tm);
if(rtc_valid_tm(&rtc_tm)){ // 如果数据无效,则设置默认数据
rtc_tm.tm_year = 118;
rtc_tm.tm_mon = 0;
rtc_tm.tm_mday = 1;
rtc_tm.tm_hour = 12;
rtc_tm.tm_min = 0;
rtc_tm.tm_sec = 0;
exynos4_rtc_set_time(NULL, &rtc_tm);
}
// 12,设置用户自定义的最大频率值
if(TYPE_S3C2410 == rtc_obj->exynos4_rtc_cpu_type)
rtc->max_user_freq = 128;
else
rtc->max_user_freq = 32768;
// 13,把RTC的数据赋给pdev
platform_set_drvdata(pdev, rtc);
// 14,设置时钟中断频率
exynos4_rtc_setfreq(&pdev->dev, 1);
// 15,关闭rtc时钟
clk_disable(rtc_obj->rtc_clk);
return 0;
err6:
exynos4_rtc_enable(pdev, 0);
clk_disable(rtc_obj->rtc_clk);
clk_put(rtc_obj->rtc_clk);
err5:
iounmap(rtc_obj->exynos4_rtc_base);
err4:
release_resource(rtc_obj->exynos4_rtc_mem);
err3:
rtc_obj->exynos4_rtc_alarmno = -1;
err2:
rtc_obj->exynos4_rtc_tickno = -1;
err1:
kfree(rtc_obj);
return ret;
}
int
exynos4_rtc_remove(struct platform_device *pdev)
{
struct rtc_device *rtc = platform_get_drvdata(pdev);
platform_set_drvdata(pdev, NULL);
rtc_device_unregister(rtc);
exynos4_rtc_setaie(&pdev->dev, 0);
exynos4_rtc_enable(pdev, 0);
clk_disable(rtc_obj->rtc_clk);
clk_put(rtc_obj->rtc_clk);
rtc_obj->rtc_clk = NULL;
iounmap(rtc_obj->exynos4_rtc_base);
release_resource(rtc_obj->exynos4_rtc_mem);
rtc_obj->exynos4_rtc_alarmno = -1;
rtc_obj->exynos4_rtc_tickno = -1;
kfree(rtc_obj);
return 0;
}
#if defined CONFIG_PM
static int ticnt_save, ticnt_en_save;
int
exynos4_rtc_suspend(struct platform_device *pdev, pm_message_t state)
{
clk_enable(rtc_obj->rtc_clk);
ticnt_save = readb(rtc_obj->exynos4_rtc_base + S3C2410_TICNT);
if(TYPE_S3C64XX == rtc_obj->exynos4_rtc_cpu_type){
ticnt_en_save = readw(rtc_obj->exynos4_rtc_base + S3C2410_RTCCON);
ticnt_en_save &= S3C64XX_RTCCON_TICEN;
}
exynos4_rtc_enable(pdev, 0);
if(device_may_wakeup(&pdev->dev) && !rtc_obj->wake_en){
if(0 == enable_irq_wake(rtc_obj->exynos4_rtc_alarmno))
rtc_obj->wake_en = true;
else
printk("enable_irq_wake failed !\n");
}
clk_disable(rtc_obj->rtc_clk);
return 0;
}
int
exynos4_rtc_resume(struct platform_device *pdev)
{
unsigned int temp;
clk_enable(rtc_obj->rtc_clk);
exynos4_rtc_enable(pdev, 1);
writeb(ticnt_save, rtc_obj->exynos4_rtc_base + S3C2410_TICNT);
if(TYPE_S3C64XX == rtc_obj->exynos4_rtc_cpu_type && ticnt_en_save){
temp = readw(rtc_obj->exynos4_rtc_base + S3C2410_RTCCON);
writew(temp | ticnt_en_save, rtc_obj->exynos4_rtc_base + S3C2410_RTCCON);
}
if(device_may_wakeup(&pdev->dev) && rtc_obj->wake_en){
disable_irq_wake(rtc_obj->exynos4_rtc_alarmno);
rtc_obj->wake_en = false;
}
clk_disable(rtc_obj->rtc_clk);
return 0;
}
#else
#define exynos4_rtc_suspend NULL
#define exynos4_rtc_resume NULL
#endif
#ifdef CONFIG_OF
static struct exynos4_rtc_drv_data exynos4_rtc_drv_data_array[] = {
[TYPE_S3C2410] = { TYPE_S3C2410 },
[TYPE_S3C64XX] = { TYPE_S3C64XX },
};
static const struct of_device_id exynos4_rtc_dt_match[] = {
{
.compatible = "samsung,s3c2410-rtc",
.data = &exynos4_rtc_drv_data_array[TYPE_S3C2410],
},
{
.compatible = "samsung,s3c64xx-rtc",
.data = &exynos4_rtc_drv_data_array[TYPE_S3C64XX],
},
};
MODULE_DEVICE_TABLE(of, exynos4_rtc_dt_match);
#else
#define exynos4_rtc_dt_match NULL
#endif
const struct platform_device_id exynos4_rtc_id_table[] = {
{
.name = "s3c2410-rtc",
.driver_data= TYPE_S3C2410,
},
{
.name = "s3c64xx-rtc",
.driver_data= TYPE_S3C64XX,
},
};
static struct platform_driver exynos4_rtc_driver = {
.driver = {
.name = "s3c-rtc",
.owner = THIS_MODULE,
.of_match_table = exynos4_rtc_dt_match,
},
.probe = exynos4_rtc_probe,
.remove = __devexit_p(exynos4_rtc_remove),
.suspend= exynos4_rtc_suspend,
.resume = exynos4_rtc_resume,
.id_table = exynos4_rtc_id_table,
};
module_platform_driver(exynos4_rtc_driver);
MODULE_LICENSE("GPL");
由于Linux开机的时候,需要读取RTC时间,所以,这个加载要开机即加载,所以,我们把它加入到Linux开机启动的行列中,位置是:\drivers\rtc目录下面,我们这个驱动的名字叫rtc-exynos4.c,我们来修改一下\drivers\rtc目录下的Kconfig和Makefile文件,修改如下:
然后在menuconfig里配置如下:
接下来是测试代码:
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <fcntl.h>
#include <linux/rtc.h>
int main(void)
{
int fd = -1,
ret= -1;
struct rtc_time rtc_tm;
fd = open("/dev/rtc0", O_RDWR);
if(fd < 0){
perror("open failed");
exit(1);
}
ret = ioctl(fd, RTC_RD_TIME, &rtc_tm);
if(ret < 0){
perror("ioctl failed");
exit(1);
}
printf("%d-%d-%d, %d:%d:%d\n", rtc_tm.tm_year + 1900, rtc_tm.tm_mon + 1, rtc_tm.tm_mday,
rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
if(close(fd) < 0){
perror("close");
exit(1);
}
return 0;
}
然后是测试效果:
