首页 > 代码库 > RTC实时时钟驱动
RTC实时时钟驱动
RTC（Real-Time Clock)实时时钟为操作系统提供了一个可靠的时间，并且在断电的情况下，RTC实时时钟也可以通过电池供电，一直运行下去。
RTC通过STRB/LDRB这两个ARM指令向CPU传送8位数据（BCD码）。数据包括秒，分，小时，日期，天，月和年。RTC实时时钟依靠一个外部的32.768Khz的石英晶体，产生周期性的脉冲信号。每一个信号到来时，计数器就加1，通过这种方式，完成计时功能。
RTC实时时钟有如下一些特性：
1，BCD数据：这些数据包括秒、分、小时、日期、、星期几、月和年。
2，闰年产生器
3，报警功能：报警中断或者从掉电模式唤醒
4，解决了千年虫问题 （详见http://baike.baidu.com/view/9349.htm）
5，独立电源引脚RTCVDD
6，支持ms中断作为RTOS内核时钟
7，循环复位（round reset)功能
如图，RTC实时时钟的框架图，XTIrtc和XTOrtc产生脉冲信号，即外部晶振。传给2^15的一个时钟分频器，得到一个128Hz的频率，这个频率用来产生滴答计数。当时钟计数为0时，产生一个TIME TICK中断信号。时钟控制器用来控制RTC实时时钟的功能。复位寄存器用来重置SEC和MIN寄存器。闰年发生器用来产生闰年逻辑。报警发生器用来控制是否产生报警信号。
1，闰年产生器：
闰年产生器可以基于BCDDATE，BCDMON，BCDYEAR决定每月最后一天的日期是28、29、30、31.一个8位计数器只能表示两位BCD码，每一位BCD码由4位表示。因此不能支持。因此不能决定00年是否为闰年，例如不能区别1900和2000年。RTC模块通过硬件逻辑支持2000年为闰年。因此这两位00指的是2000，而不是1900
2，后备电池：
即使系统电源关闭，RTC模块可以由后备电池通过RTCVDD引脚供电。当系统电源关闭时，CPU和RTC的接口应该被阻塞，后备电池应该只驱动晶振电路和BCD计数器，以消耗最少的电池。
3，报警功能：
在正常模式和掉电模式下，RTC在指定的时刻会产生一个报警信号。正常模式下，报警中断ALMINT有效，对应INT_RTC引脚。掉电模式下，报警中断ALMINT有效外还产生一个唤醒信号PMWKUP，对应PMWKUP引脚。RTC报警寄存器RTCALM决定是否使能报警状态和设置报警条件
RTC工作原理上网查一下，很多。而且不同板子的RTC寄存器也不同，这里以S3C2440为例
下面是RTC实时时钟构架：
与RTC核心有关的文件有：
/drivers/rtc/class.c 这个文件向linux设备模型核心注册了一个类RTC，然后向驱动程序提供了注册/注销接口
/drivers/rtc/rtc-dev.c 这个文件定义了基本的设备文件操作函数，如：open,read等
/drivers/rtc/interface.c 顾名思义，这个文件主要提供了用户程序与RTC驱动的接口函数，用户程序一般通过ioctl与RTC驱动交互，这里定义了每个ioctl命令需要调用的函数
/drivers/rtc/rtc-sysfs.c 与sysfs有关
/drivers/rtc/rtc-proc.c 与proc文件系统有关
/include/linux/rtc.h 定义了与RTC有关的数据结构
static char __initdata banner[] = "S3C24XX RTC, (c) 2004,2006 Simtec Electronics\n"; //标志语
static int __init s3c_rtc_init(void) //初始化模块
{
printk(banner);
return platform_driver_register(&s3c2410_rtc_driver);
}
static void __exit s3c_rtc_exit(void) //卸载模块
{
platform_driver_unregister(&s3c2410_rtc_driver);
}
module_init(s3c_rtc_init);
module_exit(s3c_rtc_exit);
void platform_driver_unregister(struct platfort_driver *drv)
{
driver_unregister(&drv->driver);
}
RTC实时时钟的平台驱动设备定义：
static struct platform_driver s3c2410_rtc_driver = {
.probe = s3c_rtc_probe, //RTC探测函数
.remove = __devexit_p(s3c_rtc_remove), //RTC移除函数
.suspend = s3c_rtc_suspend, //RTC挂起函数
.resume = s3c_rtc_resume, //RTC恢复函数
.driver = {
.name = "s3c2410-rtc", //驱动名字
.owner = THIS_MODULE, //驱动模块
},
};
当调用plat_driver_register()函数注册驱动以后，会触发平台设备和驱动的匹配函数platform_match()。匹配成功，则会调用平台驱动中的probe（）函数，RTC实时时钟驱动中对应的函数就是s3c_rtc_probe()。主要任务有以下：（请参考下面源代码）
1，读取平台设备的资源结构体s3c_rtc_resource中的第二个中断号，即滴答中断号
2，读取平台设备的资源结构体s3c_rtc_resource中的第一个中断号，即报警中断号
3，将RTC实时时钟的寄存器映射为虚拟地址，返回虚拟基地址
4，重新打开RTC实时时钟，通过调用s3c_rtc_enable()函数
5，设置RTC滴答中断间隔，并打开RTC滴答中断
6，调用rtc_device_register()函数注册RTC并退出，返回struct rtc_device 结构体
7，设置平台设备驱动的驱动数据dev->driver_dat为struct rtc_device指针
static int __devinit s3c_rtc_probe(struct platform_device *pdev)
{
struct rtc_device *rtc;
struct resource *res;
int ret;
pr_debug("%s: probe=%p\n", __func__, pdev);
/* find the IRQs */
s3c_rtc_tickno = platform_get_irq(pdev, 1); //1代表第二个中断 这里被赋值46
if (s3c_rtc_tickno < 0) {
dev_err(&pdev->dev, "no irq for rtc tick\n");
return -ENOENT;
}
s3c_rtc_alarmno = platform_get_irq(pdev, 0); //0代表第一个中断，这里被赋值24
if (s3c_rtc_alarmno < 0) {
dev_err(&pdev->dev, "no irq for alarm\n");
return -ENOENT;
}
pr_debug("s3c2410_rtc: tick irq %d, alarm irq %d\n",
s3c_rtc_tickno, s3c_rtc_alarmno);
/* get the memory region */
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(&pdev->dev, "failed to get memory region resource\n");
return -ENOENT;
}
s3c_rtc_mem = request_mem_region(res->start,
res->end-res->start+1,
pdev->name);
if (s3c_rtc_mem == NULL) {
dev_err(&pdev->dev, "failed to reserve memory region\n");
ret = -ENOENT;
goto err_nores;
}
s3c_rtc_base = ioremap(res->start, res->end - res->start + 1);
if (s3c_rtc_base == NULL) {
dev_err(&pdev->dev, "failed ioremap()\n");
ret = -EINVAL;
goto err_nomap;
}
/* check to see if everything is setup correctly */
s3c_rtc_enable(pdev, 1);
pr_debug("s3c2410_rtc: RTCCON=%02x\n",
readb(s3c_rtc_base + S3C2410_RTCCON));
s3c_rtc_setfreq(&pdev->dev, 1);
device_init_wakeup(&pdev->dev, 1);
/* register RTC and exit */
rtc = rtc_device_register("s3c", &pdev->dev, &s3c_rtcops,
THIS_MODULE);
if (IS_ERR(rtc)) {
dev_err(&pdev->dev, "cannot attach rtc\n");
ret = PTR_ERR(rtc);
goto err_nortc;
}
rtc->max_user_freq = 128;
platform_set_drvdata(pdev, rtc);
return 0;
err_nortc:
s3c_rtc_enable(pdev, 0);
iounmap(s3c_rtc_base);
err_nomap:
release_resource(s3c_rtc_mem);
err_nores:
return ret;
}
RTC实时时钟设备由结构体struct rtc_device 表示
struct rtc_device
{
struct device dev; //内嵌设备结构体
struct module *owner; //指向自身所在的模块
int id; //设备的ID号
char name[RTC_DEVICE_NAME_SIZE]; //RTC名字
const struct rtc_class_ops *ops; //类操作函数集
struct mutex ops_lock; //互斥锁
struct cdev char_dev; //内嵌一个字符设备
unsigned long flags; //RTC状态标志
unsigned long irq_data; //中断数据
spinlock_t irq_lock; //中断自旋锁
wait_queue_head_t irq_queue; //中断等待队列头
struct fasync_struct *async_queue; //异步队列
struct rtc_task *irq_task; //RTC的任务结构体
spinlock_t irq_task_lock; //自旋锁
int irq_freq; //中断频率
int max_user_freq; 最大的用户频率
#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
struct work_struct uie_task;
struct timer_list uie_timer;
/* Those fields are protected by rtc->irq_lock */
unsigned int oldsecs;
unsigned int uie_irq_active:1;
unsigned int stop_uie_polling:1;
unsigned int uie_task_active:1;
unsigned int uie_timer_active:1;T
#endif
};
RTC平台设备结构体：
struct platform_device s3c_device_rtc = {
.name = "s3c2410-rtc",
.id = -1,
.num_resources = ARRAY_SIZE(s3c_rtc_resource),
.resource = s3c_rtc_resource,
};
s3c2440处理器的RTC资源如下代码：
static struct resource s3c_rtc_resource[] = {
[0] = {
.start = S3C24XX_PA_RTC,
.end = S3C24XX_PA_RTC + 0xff,
.flags = IORESOURCE_MEM,
},
[1] = {
.start = IRQ_RTC,
.end = IRQ_RTC,
.flags = IORESOURCE_IRQ,
},
[2] = {
.start = IRQ_TICK,
.end = IRQ_TICK,
.flags = IORESOURCE_IRQ
}
};
RTC实时时钟的使能函数s3c_rtc_enable()
RTC实时时钟可以设置相应的寄存器来控制实时时钟的状态。这些状态包括使实时时钟开始工作，也包括使实时时钟停止工作。s3c_rtc_enable()函数用来设置实时时钟的工作状态。第一个参数是RTC的平台设备指针，第二个参数是使能标志en，en等于0时，表示实时时钟停止工作，en不等于0时，表示实时时钟开始工作。
static void s3c_rtc_enable(struct platform_device *pdev, int en)
{
void __iomem *base = s3c_rtc_base; //将虚拟地址s3c_rtc_base赋给base指针
unsigned int tmp;
if (s3c_rtc_base == NULL) //如果为空，则返回。这表示没有成功申请到内存，设备驱动退出
return;
if (!en)
{
//如果en等于0，表示不允许RTC实时时钟工作，这时，需要RTCCON寄存器的最低位置0，表示不允许实时时钟计数。同时，需
要将TICNT寄存器的最高位置为0，表示不允许实时时钟产生报警中断
tmp = readb(base + S3C2410_RTCCON);
writeb(tmp & ~S3C2410_RTCCON_RTCEN, base + S3C2410_RTCCON); //不允许实时时钟计数
tmp = readb(base + S3C2410_TICNT);
writeb(tmp & ~S3C2410_TICNT_ENABLE, base + S3C2410_TICNT); //不允许实时时钟产生报警中断
} else {
/* re-enable the device, and check it is ok */
if ((readb(base+S3C2410_RTCCON) & S3C2410_RTCCON_RTCEN) == 0){ //将RTCCON的最低位置为0，使实时时钟工作起来
dev_info(&pdev->dev, "rtc disabled, re-enabling\n");
tmp = readb(base + S3C2410_RTCCON);
writeb(tmp|S3C2410_RTCCON_RTCEN, base+S3C2410_RTCCON);
}
if ((readb(base + S3C2410_RTCCON) & S3C2410_RTCCON_CNTSEL)){ //将RTCCON第2位置为0，不使用BCD计数选择器
dev_info(&pdev->dev, "removing RTCCON_CNTSEL\n");
tmp = readb(base + S3C2410_RTCCON);
writeb(tmp& ~S3C2410_RTCCON_CNTSEL, base+S3C2410_RTCCON);
}
if ((readb(base + S3C2410_RTCCON) & S3C2410_RTCCON_CLKRST)){ //将RTCCON的第3位置为0，不重新设置计数器
dev_info(&pdev->dev, "removing RTCCON_CLKRST\n");
tmp = readb(base + S3C2410_RTCCON);
writeb(tmp & ~S3C2410_RTCCON_CLKRST, base+S3C2410_RTCCON);
}
}
}
set_rtc_setfreq()函数用来设置时钟脉冲中断的频率，即多少时间产生一次中断。第一个参数表示RTC的设备结构体，第二个参数表示频率，即多久产生一次中断。如果freq等于1，则表示1秒钟产生一次中断；等于2，表示每秒产生2次中断
static int s3c_rtc_setfreq(struct device *dev, int freq)
{
unsigned int tmp;
if (!is_power_of_2(freq)) //判断是不是2的倍数，不是返回
return -EINVAL;
spin_lock_irq(&s3c_rtc_pie_lock);
tmp = readb(s3c_rtc_base + S3C2410_TICNT) & S3C2410_TICNT_ENABLE;
tmp |= (128 / freq)-1;
//时钟脉冲1秒中产生128次时钟滴答。Period = (n+1) / 128 second => freq = 128 /
(n+1) => n = 128 / freq - 1
writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
spin_unlock_irq(&s3c_rtc_pie_lock);
return 0;
}
RTC设备注册函数rtc_device_register()
rtc实时时钟设备必须注册到内核中才能可以使用。在注册设备的过程中，将设备提供的应用程序的接口ops也指定到设备上。这样，当应用程序读取设备的数据时，就可以调用这些底层的驱动函数
struct rtc_device *rtc_device_register(const char *name, struct device *dev,
const struct rtc_class_ops *ops,
struct module *owner)
{
struct rtc_device *rtc;
int id, err;
if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) { //分配一个ID号，用来把一个数字与一个指针联系起来
err = -ENOMEM;
goto exit;
}
mutex_lock(&idr_lock); //加锁
err = idr_get_new(&rtc_idr, NULL, &id); //得到一个ID号
mutex_unlock(&idr_lock); //释放自旋锁
if (err < 0)
goto exit;
id = id & MAX_ID_MASK;
rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL);
if (rtc == NULL) {
err = -ENOMEM;
goto exit_idr;
}
//初始化RTC设备结构体的相关成员。将ops操作函数赋值给ret->ops结构体指针。将用户可以设置的最大频率设为64
rtc->id = id;
rtc->ops = ops;
rtc->owner = owner;
rtc->max_user_freq = 64;
rtc->dev.parent = dev;
rtc->dev.class = rtc_class;
rtc->dev.release = rtc_device_release;
//初始化锁和设置设备的名字
mutex_init(&rtc->ops_lock);
spin_lock_init(&rtc->irq_lock);
spin_lock_init(&rtc->irq_task_lock);
init_waitqueue_head(&rtc->irq_queue);
strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE);
dev_set_name(&rtc->dev, "rtc%d", id);
rtc_dev_prepare(rtc); //设置RTC设备的设备号
err = device_register(&rtc->dev); //向内核注册实时时钟设备
if (err)
goto exit_kfree;
//下面是向文件系统注册设备，这样就可以通过文件系统访问相应的设备
rtc_dev_add_device(rtc);
rtc_sysfs_add_device(rtc);
rtc_proc_add_device(rtc);
dev_info(dev, "rtc core: registered %s as %s\n",
rtc->name, dev_name(&rtc->dev));
return rtc;
exit_kfree:
kfree(rtc);
exit_idr:
mutex_lock(&idr_lock);
idr_remove(&rtc_idr, id);
mutex_unlock(&idr_lock);
exit:
dev_err(dev, "rtc core: unable to register %s, err = %d\n",
name, err);
return ERR_PTR(err);
}
rtc_class_ops是一个对设备进行操作的抽象结构体。内核允许为设备建立一个设备文件，对设备文件的所有操作，就相当于对设备的操作。这样的好处是，用户程序可以使用访问普通文件的方法，来访问设备文件，进而访问设备。这样的方法，极大的减轻了程序员的编程负担，程序员不必熟悉新的驱动接口，就能够访问设备
struct rtc_class_ops {
int (*open)(struct device *); //打开一个设备，在该函数中可以对设备进行初始化。如果这个函数被赋值NULL，那么设备打开永远成功，并不会对设备产生影响
void (*release)(struct device *);
//释放open()函数中申请的资源。其将在文件引用计数为0时，被系统调用。对应的应用程序的close（）方法，但并不是每一次调用close（）都会触发release（）函数。其会在对设备文件的所有打开都释放后，才会被调用
int (*ioctl)(struct device *, unsigned int, unsigned long);
//提供了一种执行设备特定命令的方法。例如，使设备复位，既不是读操作也不是写操作，不适合用read（）和write（）方法来实现。如果在应用程序中给ioctl传入没有定义的命令，那么将返回-ENOTTY的错误，表示设备不支持这个命令
int (*read_time)(struct device *, struct rtc_time *); //读取RTC设备的当前时间
int (*set_time)(struct device *, struct rtc_time *); //设置RTC设备的当前时间
int (*read_alarm)(struct device *, struct rtc_wkalrm *); //读取RTC设备的报警时间
int (*set_alarm)(struct device *, struct rtc_wkalrm *); //设置RTC设备的报警时间，当时间到达时，会产生中断信号
int (*proc)(struct device *, struct seq_file *); //用来读取proc文件系统的数据
int (*set_mmss)(struct device *, unsigned long secs);
int (*irq_set_state)(struct device *, int enabled); //设置中断状态
int (*irq_set_freq)(struct device *, int freq); //设置中断频率，最大不能超过64
int (*read_callback)(struct device *, int data);
int (*alarm_irq_enable)(struct device *, unsigned int enabled); //用来设置中断使能状态
int (*update_irq_enable)(struct device *, unsigned int enabled); //更新中断使能状态
};
实时时钟RTC的rtc_class_ops结构体定义如下:
static const struct rtc_class_ops s3c_rtcops = {
.open = s3c_rtc_open,
.release = s3c_rtc_release,
.read_time = s3c_rtc_gettime,
.set_time = s3c_rtc_settime,
.read_alarm = s3c_rtc_getalarm,
.set_alarm = s3c_rtc_setalarm,
.irq_set_freq = s3c_rtc_setfreq,
.irq_set_state = s3c_rtc_setpie,
.proc = s3c_rtc_proc,
};
RTC设备打开函数由s3c_rtc_open()来实现，用户空间调用open时，最终会调用s3c_rtc_open()函数。该函数只要申请了两个中断，一个报警中断，一个计时中断。
static int s3c_rtc_open(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev); //从device结构体转到platform_device
struct rtc_device *rtc_dev = platform_get_drvdata(pdev); //从pdev->dev的私有数据中得到rtc_device
int ret;
ret = request_irq(s3c_rtc_alarmno, s3c_rtc_alarmirq,
IRQF_DISABLED, "s3c2410-rtc alarm",
rtc_dev);
//申请一个报警中断，将中断函数设为s3c_rtc_alarmirq()，并传递rtc_dev作为参数
if (ret) {
dev_err(dev, "IRQ%d error %d\n", s3c_rtc_alarmno, ret);
return ret;
}
ret = request_irq(s3c_rtc_tickno, s3c_rtc_tickirq,
IRQF_DISABLED, "s3c2410-rtc tick",
rtc_dev);
//申请一个计数中断，将中断函数设为s3c_rtc_tickirq(),并传递rtc_dev作为参数
if (ret) {
dev_err(dev, "IRQ%d error %d\n", s3c_rtc_tickno, ret);
goto tick_err;
}
return ret;
tick_err:
free_irq(s3c_rtc_alarmno, rtc_dev);
return ret;
}
RTC设备释放函数由s3c_rtc_release()来实现。用户空间调用close（）时，最终会调用s3c_rtc_release()函数。该函数主要释放s3c_rtc_open（）函数申请的两个中断
static void s3c_rtc_release(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev); //从device结构体转到platform_device
struct rtc_device *rtc_dev = platform_get_drvdata(pdev); //从pdev->dev的私有数据中得到rtc_device
/* do not clear AIE here, it may be needed for wake */
s3c_rtc_setpie(dev, 0);
free_irq(s3c_rtc_alarmno, rtc_dev);
free_irq(s3c_rtc_tickno, rtc_dev);
}
RTC实时时钟获得时间安函数
当调用read()函数时会间接的调用s3c_rtc_gettime()函数来获得实时时钟的时间。时间值分别保存在RTC实时时钟的各个寄存器中。这些寄存器是秒寄存器、日期寄存器、分钟寄存器、和小时寄存器。s3c_rtc_gettime()函数会使用一个struct rtc_time 的机构体来表示一个时间值
struct rtc_time {
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday; //这三个RTC实时时钟未用
int tm_yday;
int tm_isdst;
};
存储在RTC实时时钟寄存器中的值都是以BCD码保存的。但是Linux驱动程序中使用二进制码形式。通过bcd2bin（）
unsigned bcd2bin(unsigned char val)
{
return (val & 0x0f) + (val >> 4) * 10;
}
unsigned char bin2bcd(unsigned val)
{
return ((val / 10) << 4) + val % 10;
}
从RTC实时时钟得到时间的函数是s3c_rtc_gettime()。第一个参数是RTC设备结构体指针，第二个参数是前面提到的struct rtc_time。
static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
{
unsigned int have_retried = 0;
void __iomem *base = s3c_rtc_base;
retry_get_time:
rtc_tm->tm_min = readb(base + S3C2410_RTCMIN);
rtc_tm->tm_hour = readb(base + S3C2410_RTCHOUR);
rtc_tm->tm_mday = readb(base + S3C2410_RTCDATE);
rtc_tm->tm_mon = readb(base + S3C2410_RTCMON);
rtc_tm->tm_year = readb(base + S3C2410_RTCYEAR);
rtc_tm->tm_sec = readb(base + S3C2410_RTCSEC);
/* the only way to work out wether the system was mid-update
* when we read it is to check the second counter, and if it
* is zero, then we re-try the entire read
*/
if (rtc_tm->tm_sec == 0 && !have_retried) { //如果秒寄存器中是0，则表示过去了一分钟，那么小时，天，月，等寄存器中的值都可能已经变化，则重新读取这些寄存器的值
have_retried = 1;
goto retry_get_time;
}
pr_debug("read time %02x.%02x.%02x %02x/%02x/%02x\n",
rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
// 转化为二进制存储
rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday);
rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon);
rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
rtc_tm->tm_year += 100; //因为存储器中存放的是从1900年开始的时间，所有加上100（这是2000年开始，自己改变这个值）
rtc_tm->tm_mon -= 1;
return 0;
}
同理，下面看设置时钟函数
static int s3c_rtc_settime(struct device *dev, struct rtc_time *tm)
{
void __iomem *base = s3c_rtc_base;
int year = tm->tm_year - 100; //理由如上
pr_debug("set time %02d.%02d.%02d %02d/%02d/%02d\n",
tm->tm_year, tm->tm_mon, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec);
/* we get around y2k by simply not supporting it */
if (year < 0 || year >= 100) { //由于寄存器的限制，RTC实时时钟只支持100年时间
dev_err(dev, "rtc only supports 100 years\n");
return -EINVAL;
}
//转化为BCD码写到相应的寄存器
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);
return 0;
}
在正常模式和掉电模式下，RTC在指定的时刻会产生一个报警信号。正常模式下，报警中断ALMINT有效，对应INT_RTC引脚。掉电模式下，报警 中断ALMINT有效外还产生一个唤醒信号PMWKUP，对应PMWKUP引脚。RTC报警寄存器RTCALM决定是否使能报警状态和设置报警条件
这个指定的时刻由年、月、日、分、秒等组成，在Linux中由struct rtc_time结构体表示。这里struct rtc_time结构体被包含在struct rtc_wkalrm结构体中。
s3c_rtc_getalarm()函数用来获得这个时刻。该函数第一个参数是RTC设备结构体，第二个参数是包含报警时刻的rtc_wkalarm结构体。
static int s3c_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
struct rtc_time *alm_tm = &alrm->time;
void __iomem *base = s3c_rtc_base;
unsigned int alm_en;
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_mon = readb(base + S3C2410_ALMMON);
alm_tm->tm_mday = readb(base + S3C2410_ALMDATE);
alm_tm->tm_year = readb(base + S3C2410_ALMYEAR);
alm_en = readb(base + S3C2410_RTCALM);
alrm->enabled = (alm_en & S3C2410_RTCALM_ALMEN) ? 1 : 0;
pr_debug("read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n",
alm_en,
alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,
alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec);
/* decode the alarm enable field */
if (alm_en & S3C2410_RTCALM_SECEN)
alm_tm->tm_sec = bcd2bin(alm_tm->tm_sec);
else
alm_tm->tm_sec = 0xff;
if (alm_en & S3C2410_RTCALM_MINEN)
alm_tm->tm_min = bcd2bin(alm_tm->tm_min);
else
alm_tm->tm_min = 0xff;
if (alm_en & S3C2410_RTCALM_HOUREN)
alm_tm->tm_hour = bcd2bin(alm_tm->tm_hour);
else
alm_tm->tm_hour = 0xff;
if (alm_en & S3C2410_RTCALM_DAYEN)
alm_tm->tm_mday = bcd2bin(alm_tm->tm_mday);
else
alm_tm->tm_mday = 0xff;
if (alm_en & S3C2410_RTCALM_MONEN) {
alm_tm->tm_mon = bcd2bin(alm_tm->tm_mon);
alm_tm->tm_mon -= 1;
} else {
alm_tm->tm_mon = 0xff;
}
if (alm_en & S3C2410_RTCALM_YEAREN)
alm_tm->tm_year = bcd2bin(alm_tm->tm_year);
else
alm_tm->tm_year = 0xffff;
return 0;
}
同理，报警时间设置函数如下：
static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
struct rtc_time *tm = &alrm->time; //得到RTC报警时间
void __iomem *base = s3c_rtc_base; //得到寄存器的虚拟内存地址的基地址
unsigned int alrm_en; //是否使能报警
pr_debug("s3c_rtc_setalarm: %d, %02x/%02x/%02x %02x.%02x.%02x\n",
alrm->enabled,
tm->tm_mday & 0xff, tm->tm_mon & 0xff, tm->tm_year & 0xff,
tm->tm_hour & 0xff, tm->tm_min & 0xff, tm->tm_sec); //打印一些调试信息
alrm_en = readb(base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN; //读出RTCALM的第6位，表示所有报警功能都打开
writeb(0x00, base + S3C2410_RTCALM); //将00写入RTCALM，使所有的功能都不可以用
if (tm->tm_sec < 60 && tm->tm_sec >= 0)
{
//大于0小于60，则设置报警秒寄存器ALMSEC的值，并设置RTCALM寄存器的第0位为1，表示打开秒报警功能
alrm_en |= S3C2410_RTCALM_SECEN;
writeb(bin2bcd(tm->tm_sec), base + S3C2410_ALMSEC);
}
if (tm->tm_min < 60 && tm->tm_min >= 0) {
alrm_en |= S3C2410_RTCALM_MINEN;
writeb(bin2bcd(tm->tm_min), base + S3C2410_ALMMIN);
}
if (tm->tm_hour < 24 && tm->tm_hour >= 0) {
alrm_en |= S3C2410_RTCALM_HOUREN;
writeb(bin2bcd(tm->tm_hour), base + S3C2410_ALMHOUR);
}
pr_debug("setting S3C2410_RTCALM to %08x\n", alrm_en); //打印报警使能状态
writeb(alrm_en, base + S3C2410_RTCALM);
s3c_rtc_setaie(alrm->enabled);
if (alrm->enabled) //使能中断唤醒功能
enable_irq_wake(s3c_rtc_alarmno);
else
disable_irq_wake(s3c_rtc_alarmno);
return 0;
}
RTC设置脉冲中断使能函数s3c_rtc_setpie()
该函数用来设置是否允许脉冲中断。
第一个参数是RTC设备结构体，第二个参数表示是否允许脉冲中断。enabled等于1表示允许，等于0表示不允许
static int s3c_rtc_setpie(struct device *dev, int enabled)
{
unsigned int tmp;
pr_debug("%s: pie=%d\n", __func__, enabled);
spin_lock_irq(&s3c_rtc_pie_lock);
tmp = readb(s3c_rtc_base + S3C2410_TICNT) & ~S3C2410_TICNT_ENABLE; //读出TICNT的值，清除最高位
if (enabled) //如果enabled不等于0，则设置tmp变量最高位为允许脉冲中断
tmp |= S3C2410_TICNT_ENABLE;
writeb(tmp, s3c_rtc_base + S3C2410_TICNT);
spin_unlock_irq(&s3c_rtc_pie_lock);
return 0;
}
在proc文件系统中，可以读取proc文件系统来判断RTC实时时钟是否支持脉冲中断。脉冲中断由TICNT寄存器的最高位决定，最高位为1则表示使能脉冲中断，为0则表示不允许脉冲中断。proc文件系统中的读取命令，一般为cat命令，会调用内核中的s3c_rtc_proc（）函数
static int s3c_rtc_proc(struct device *dev, struct seq_file *seq)
{
unsigned int ticnt = readb(s3c_rtc_base + S3C2410_TICNT);
seq_printf(seq, "periodic_IRQ\t: %s\n",
(ticnt & S3C2410_TICNT_ENABLE) ? "yes" : "no" );
return 0;
}
over。。。。。。。。。。。。
RTC实时时钟驱动