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实时时钟驱动

 

如图,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。。。。。。。。。。。。

有一种落差是,你配不上自己的野心,也辜负了所受的苦难
;