RTC源代码分析

花了一个下午时间，把rtc代码的架构弄懂了，如下图所示：

下面附上各个包含详细注释的C文件源代码：

class.c源代码：

/*
 * RTC subsystem, base class
 *
 * Copyright (C) 2005 Tower Technologies
 * Author: Alessandro Zummo <a.zummo@towertech.it>
 *
 * class skeleton from drivers/hwmon/hwmon.c
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
本c文件工作总结:
1.在init函数中:
    (1):创建sysfs文件系统的/sys/class/rtc目录，并且初始化rtc类的相关成员
        作用:向用户空间提供设备的信息，驱动程序不需要直接处理类
    (2):动态分配rtc字符设备的设备号
    (3):初始化rtc的/sys/class/rtc目录中的属性文件
2.在exit函数中:
    (1):注销rtc设备号
    (2):注销sysfs文件系统的/sys/class/rtc目录。
3.在rtc_device_register中
    (1):申请一个idr整数ID管理机制结构体，并且初始化相关成员
    (2):将设备dev关联sysfs下的rtc类
    (3):初始化rtc结构体的信号量
    (4):初始化rtc结构体中的中断
    (5):设置rtc的名字
    (6):初始化rtc字符设备的设备号，然后注册rtc设备,自动创建/dev/rtc(n)设备节点文件
    (7):注册字符设备
    (8):在/sys/rtc/目录下创建一个闹钟属性文件
    (9):创建/proc/driver/rtc目录
4.在rtc_device_unregister中
    (1):删除sysfs中的rtc设备,即删除/sys/class/rtc目录
    (2):删除dev下的/dev/rtc(n)设备节点文件
    (3):删除虚拟文件系统接口,即删除/proc/driver/rtc目录
    (4):卸载字符设备
    (5):清空rtc的操作函数指针rtc->ops
    (6):释放rtc的device结构体
5.在rtc_device_release函数中
    (1):卸载idr数字管理机制结构体
    (2):释放rtc结构体的内存
*/

#include <linux/module.h>
#include <linux/rtc.h>
#include <linux/kdev_t.h>
#include <linux/idr.h>

#include "rtc-core.h"
static DEFINE_MUTEX

static DEFINE_IDR(rtc_idr);   //定义整数ID管理机制idr结构体
(idr_lock);
struct class *rtc_class;      //定义sysfs的类结构体

static void rtc_device_release(struct device *dev)
{
    struct rtc_device *rtc = to_rtc_device(dev);
    mutex_lock(&idr_lock);
    idr_remove(&rtc_idr, rtc->id);     //卸载idr数字管理机制结构体
    mutex_unlock(&idr_lock);
    kfree(rtc);                        //释放rtc结构体的内存
}

#if defined(CONFIG_PM) && defined(CONFIG_RTC_HCTOSYS_DEVICE)

/*
 * On suspend(), measure the delta between one RTC and the
 * system's wall clock; restore it on resume().
 */

static struct timespec    delta;
static time_t        oldtime;

static int rtc_suspend(struct device *dev, pm_message_t mesg)
{
    struct rtc_device    *rtc = to_rtc_device(dev);
    struct rtc_time        tm;
    struct timespec        ts = current_kernel_time();

    if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
        return 0;

    rtc_read_time(rtc, &tm);
    rtc_tm_to_time(&tm, &oldtime);

    /* RTC precision is 1 second; adjust delta for avg 1/2 sec err */
    set_normalized_timespec(&delta,
                ts.tv_sec - oldtime,
                ts.tv_nsec - (NSEC_PER_SEC >> 1));

    return 0;
}

static int rtc_resume(struct device *dev)
{
    struct rtc_device    *rtc = to_rtc_device(dev);
    struct rtc_time        tm;
    time_t            newtime;
    struct timespec        time;

    if (strcmp(dev_name(&rtc->dev), CONFIG_RTC_HCTOSYS_DEVICE) != 0)
        return 0;

    rtc_read_time(rtc, &tm);
    if (rtc_valid_tm(&tm) != 0) {
        pr_debug("%s:  bogus resume time
", dev_name(&rtc->dev));
        return 0;
    }
    rtc_tm_to_time(&tm, &newtime);
    if (newtime <= oldtime) {
        if (newtime < oldtime)
            pr_debug("%s:  time travel!
", dev_name(&rtc->dev));
        return 0;
    }

    /* restore wall clock using delta against this RTC;
     * adjust again for avg 1/2 second RTC sampling error
     */
    set_normalized_timespec(&time,
                newtime + delta.tv_sec,
                (NSEC_PER_SEC >> 1) + delta.tv_nsec);
    do_settimeofday(&time);

    return 0;
}

#else
#define rtc_suspend    NULL
#define rtc_resume    NULL
#endif


/**
 * rtc_device_register - register w/ RTC class
 * @dev: the device to register
 *
 * rtc_device_unregister() must be called when the class device is no
 * longer needed.
 *
 * Returns the pointer to the new struct class device.
 */
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;
    //整数ID管理机制
    if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) {   //检测IDR是否能正常获取
        err = -ENOMEM;
        goto exit;
    }


    mutex_lock(&idr_lock);                   //原子操作，上锁，防止被打断
    err = idr_get_new(&rtc_idr, NULL, &id);  //获取一个idr结构，并与id相关联
    mutex_unlock(&idr_lock);                 //解锁

    if (err < 0)
        goto exit;

    id = id & MAX_ID_MASK;          //将32为id的无效高位清零

    rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL);  //分配一个rtc_device结构体
    if (rtc == NULL) {
        err = -ENOMEM;
        goto exit_idr;
    }

    rtc->id = id;            //整数ID管理机制
    rtc->ops = ops;          //关联定义的操作函数结构体  open,release,ioctl等函数
    rtc->owner = owner;      //所属模块的相关信息
    rtc->max_user_freq = 64; //最大使用数量 64
    rtc->dev.parent = dev;   //父设备
    rtc->dev.class = rtc_class;  //包含的sysfs下面的类
    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);   //定义rtc中断

    strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE);  //设置rtc的名字
    dev_set_name(&rtc->dev, "rtc%d", id);   

    rtc_dev_prepare(rtc);              //初始化rtc字符设备的设备号  

    err = device_register(&rtc->dev);  //注册rtc设备，这样rtc会自动创建设备文件rtc(n)
    if (err)
        goto exit_kfree;

    rtc_dev_add_device(rtc);    //注册字符设备
    rtc_sysfs_add_device(rtc);  //为设备添加一个闹钟属性，在/sys/rtc下面创建闹钟属性文件
    rtc_proc_add_device(rtc);   //穿件proc文件结构体  在/proc目录下创建 driver/rtc

    dev_info(dev, "rtc core: registered %s as %s
",
            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
",
            name, err);
    return ERR_PTR(err);
}
EXPORT_SYMBOL_GPL(rtc_device_register);


/**
 * rtc_device_unregister - removes the previously registered RTC class device
 *
 * @rtc: the RTC class device to destroy
 */
void rtc_device_unregister(struct rtc_device *rtc)
{
    if (get_device(&rtc->dev) != NULL) {
        mutex_lock(&rtc->ops_lock);     //上锁
        /* remove innards of this RTC, then disable it, before
         * letting any rtc_class_open() users access it again
         */
        rtc_sysfs_del_device(rtc);     //删除sysfs下面的rtc设备
        rtc_dev_del_device(rtc);       //删除dev下的rtc
        rtc_proc_del_device(rtc);      //删除虚拟文件系统接口
        device_unregister(&rtc->dev);  //卸载字符设备
        rtc->ops = NULL;               //将rtc的操作函数指针清空
        mutex_unlock(&rtc->ops_lock);  //解锁
        put_device(&rtc->dev);         //释放rtc的device结构体
    }
}
EXPORT_SYMBOL_GPL(rtc_device_unregister);

static int __init rtc_init(void)
{
    rtc_class = class_create(THIS_MODULE, "rtc");//在/sys/class下面创建类目录,类名为rtc
    if (IS_ERR(rtc_class)) {
        printk(KERN_ERR "%s: couldn't create class
", __FILE__);
        return PTR_ERR(rtc_class);
    }
    //类的作用就是向用户空间提供设备的信息，驱动程序不需要直接处理类
    rtc_class->suspend = rtc_suspend;   //初始化类结构体的相关成员
    rtc_class->resume = rtc_resume;     //动态分配rtc的设备号
    rtc_dev_init();                     //动态分配
    rtc_sysfs_init(rtc_class);          //初始化rtc的属性文件
    return 0;
}

static void __exit rtc_exit(void)
{
    rtc_dev_exit();                     //注销rtc设备号
    class_destroy(rtc_class);           //注销/sys/class下的类目录
}

subsys_initcall(rtc_init);
module_exit(rtc_exit);

MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
MODULE_DESCRIPTION("RTC class support");
MODULE_LICENSE("GPL");

rtc-dev.c源代码：

/*
 * RTC subsystem, dev interface
 *
 * Copyright (C) 2005 Tower Technologies
 * Author: Alessandro Zummo <a.zummo@towertech.it>
 *
 * based on arch/arm/common/rtctime.c
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.

本程序大致内容
1.在init函数中动态的申请字符设备的设备号
2.实现struct file_operations rtc_dev_fops 结构体及其默认函数
3.在exit中注销字符设备设备号
*/

#include <linux/module.h>
#include <linux/rtc.h>
#include "rtc-core.h"

static dev_t rtc_devt;

#define RTC_DEV_MAX 16 /* 16 RTCs should be enough for everyone... */

static int rtc_dev_open(struct inode *inode, struct file *file)
{
    int err;
    struct rtc_device *rtc = container_of(inode->i_cdev,
                    struct rtc_device, char_dev);
    const struct rtc_class_ops *ops = rtc->ops;

    if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
        return -EBUSY;

    file->private_data = rtc;

    err = ops->open ? ops->open(rtc->dev.parent) : 0;
    if (err == 0) {
        spin_lock_irq(&rtc->irq_lock);
        rtc->irq_data = 0;
        spin_unlock_irq(&rtc->irq_lock);

        return 0;
    }

    /* something has gone wrong */
    clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
    return err;
}

#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
/*
 * Routine to poll RTC seconds field for change as often as possible,
 * after first RTC_UIE use timer to reduce polling
 */
static void rtc_uie_task(struct work_struct *work)
{
    struct rtc_device *rtc =
        container_of(work, struct rtc_device, uie_task);
    struct rtc_time tm;
    int num = 0;
    int err;

    err = rtc_read_time(rtc, &tm);

    spin_lock_irq(&rtc->irq_lock);
    if (rtc->stop_uie_polling || err) {
        rtc->uie_task_active = 0;
    } else if (rtc->oldsecs != tm.tm_sec) {
        num = (tm.tm_sec + 60 - rtc->oldsecs) % 60;
        rtc->oldsecs = tm.tm_sec;
        rtc->uie_timer.expires = jiffies + HZ - (HZ/10);
        rtc->uie_timer_active = 1;
        rtc->uie_task_active = 0;
        add_timer(&rtc->uie_timer);
    } else if (schedule_work(&rtc->uie_task) == 0) {
        rtc->uie_task_active = 0;
    }
    spin_unlock_irq(&rtc->irq_lock);
    if (num)
        rtc_update_irq(rtc, num, RTC_UF | RTC_IRQF);
}
static void rtc_uie_timer(unsigned long data)
{
    struct rtc_device *rtc = (struct rtc_device *)data;
    unsigned long flags;

    spin_lock_irqsave(&rtc->irq_lock, flags);
    rtc->uie_timer_active = 0;
    rtc->uie_task_active = 1;
    if ((schedule_work(&rtc->uie_task) == 0))
        rtc->uie_task_active = 0;
    spin_unlock_irqrestore(&rtc->irq_lock, flags);
}

static int clear_uie(struct rtc_device *rtc)
{
    spin_lock_irq(&rtc->irq_lock);
    if (rtc->uie_irq_active) {
        rtc->stop_uie_polling = 1;
        if (rtc->uie_timer_active) {
            spin_unlock_irq(&rtc->irq_lock);
            del_timer_sync(&rtc->uie_timer);
            spin_lock_irq(&rtc->irq_lock);
            rtc->uie_timer_active = 0;
        }
        if (rtc->uie_task_active) {
            spin_unlock_irq(&rtc->irq_lock);
            flush_scheduled_work();
            spin_lock_irq(&rtc->irq_lock);
        }
        rtc->uie_irq_active = 0;
    }
    spin_unlock_irq(&rtc->irq_lock);
    return 0;
}

static int set_uie(struct rtc_device *rtc)
{
    struct rtc_time tm;
    int err;

    err = rtc_read_time(rtc, &tm);
    if (err)
        return err;
    spin_lock_irq(&rtc->irq_lock);
    if (!rtc->uie_irq_active) {
        rtc->uie_irq_active = 1;
        rtc->stop_uie_polling = 0;
        rtc->oldsecs = tm.tm_sec;
        rtc->uie_task_active = 1;
        if (schedule_work(&rtc->uie_task) == 0)
            rtc->uie_task_active = 0;
    }
    rtc->irq_data = 0;
    spin_unlock_irq(&rtc->irq_lock);
    return 0;
}

int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc, unsigned int enabled)
{
    if (enabled)
        return set_uie(rtc);
    else
        return clear_uie(rtc);
}
EXPORT_SYMBOL(rtc_dev_update_irq_enable_emul);

#endif /* CONFIG_RTC_INTF_DEV_UIE_EMUL */

static ssize_t
rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
    struct rtc_device *rtc = file->private_data;

    DECLARE_WAITQUEUE(wait, current);    //声明一个等待队列入口
    unsigned long data;
    ssize_t ret;

    if (count != sizeof(unsigned int) && count < sizeof(unsigned long))
        return -EINVAL;

    add_wait_queue(&rtc->irq_queue, &wait);//将这个等待队列的入口加入到rtc的irq等待队列中
    do {
        __set_current_state(TASK_INTERRUPTIBLE);//把当前进程的状态修改为TASK_INTERRUPTIBLE

        spin_lock_irq(&rtc->irq_lock); //保护代码段不被抢占（禁止 IRQ 同时也就隐式地禁止了抢占），既禁止本地中断，又禁止内核抢占。
        data = rtc->irq_data;
        rtc->irq_data = 0;
        spin_unlock_irq(&rtc->irq_lock);

        if (data != 0) { //如果数据不是零的话说明发生过一次中断
            ret = 0;
            break;
        }
        if (file->f_flags & O_NONBLOCK) { //如果打开方式为不阻塞的话，直接返回
            ret = -EAGAIN;
            break;
        }
        if (signal_pending(current)) {  //检查当前进程是否有信号处理，返回不为0表示有信号需要处理。
            ret = -ERESTARTSYS;
            break;
        }
        schedule();  //如果没有发生过中断，并且也没有信号处理，则调度
    } while (1);
    set_current_state(TASK_RUNNING);//把当前进程的状态修改为TASK_RUNNING

    remove_wait_queue(&rtc->irq_queue, &wait); //移除等待队列
 
    if (ret == 0) {  //如果发生过中断
        /* Check for any data updates */
        if (rtc->ops->read_callback)
            data = rtc->ops->read_callback(rtc->dev.parent,
                               data);

        if (sizeof(int) != sizeof(long) &&
            count == sizeof(unsigned int))
            ret = put_user(data, (unsigned int __user *)buf) ?:
                sizeof(unsigned int);
        else
            ret = put_user(data, (unsigned long __user *)buf) ?:
                sizeof(unsigned long);
    }
    return ret;
}

static unsigned int rtc_dev_poll(struct file *file, poll_table *wait)
{
    struct rtc_device *rtc = file->private_data;
    unsigned long data;

    poll_wait(file, &rtc->irq_queue, wait);  //监控文件，加入等待队列

    data = rtc->irq_data;

    return (data != 0) ? (POLLIN | POLLRDNORM) : 0;
}

static long rtc_dev_ioctl(struct file *file,
        unsigned int cmd, unsigned long arg)
{
    int err = 0;
    struct rtc_device *rtc = file->private_data;
    const struct rtc_class_ops *ops = rtc->ops;
    struct rtc_time tm;
    struct rtc_wkalrm alarm;
    void __user *uarg = (void __user *) arg;

    err = mutex_lock_interruptible(&rtc->ops_lock);
    if (err)
        return err;

    /* check that the calling task has appropriate permissions
     * for certain ioctls. doing this check here is useful
     * to avoid duplicate code in each driver.
     */
    switch (cmd) {
    case RTC_EPOCH_SET:
    case RTC_SET_TIME:
        if (!capable(CAP_SYS_TIME))
            err = -EACCES;
        break;

    case RTC_IRQP_SET:
        if (arg > rtc->max_user_freq && !capable(CAP_SYS_RESOURCE))
            err = -EACCES;
        break;

    case RTC_PIE_ON:
        if (rtc->irq_freq > rtc->max_user_freq &&
                !capable(CAP_SYS_RESOURCE))
            err = -EACCES;
        break;
    }

    if (err)
        goto done;

    /* try the driver's ioctl interface */
    if (ops->ioctl) {
        err = ops->ioctl(rtc->dev.parent, cmd, arg);
        if (err != -ENOIOCTLCMD) {
            mutex_unlock(&rtc->ops_lock);
            return err;
        }
    }

    /* if the driver does not provide the ioctl interface
     * or if that particular ioctl was not implemented
     * (-ENOIOCTLCMD), we will try to emulate here.
     *
     * Drivers *SHOULD NOT* provide ioctl implementations
     * for these requests.  Instead, provide methods to
     * support the following code, so that the RTC's main
     * features are accessible without using ioctls.
     *
     * RTC and alarm times will be in UTC, by preference,
     * but dual-booting with MS-Windows implies RTCs must
     * use the local wall clock time.
     */

    switch (cmd) {
    case RTC_ALM_READ:
        mutex_unlock(&rtc->ops_lock);

        err = rtc_read_alarm(rtc, &alarm);
        if (err < 0)
            return err;

        if (copy_to_user(uarg, &alarm.time, sizeof(tm)))
            err = -EFAULT;
        return err;

    case RTC_ALM_SET:
        mutex_unlock(&rtc->ops_lock);

        if (copy_from_user(&alarm.time, uarg, sizeof(tm)))
            return -EFAULT;

        alarm.enabled = 0;
        alarm.pending = 0;
        alarm.time.tm_wday = -1;
        alarm.time.tm_yday = -1;
        alarm.time.tm_isdst = -1;

        /* RTC_ALM_SET alarms may be up to 24 hours in the future.
         * Rather than expecting every RTC to implement "don't care"
         * for day/month/year fields, just force the alarm to have
         * the right values for those fields.
         *
         * RTC_WKALM_SET should be used instead.  Not only does it
         * eliminate the need for a separate RTC_AIE_ON call, it
         * doesn't have the "alarm 23:59:59 in the future" race.
         *
         * NOTE:  some legacy code may have used invalid fields as
         * wildcards, exposing hardware "periodic alarm" capabilities.
         * Not supported here.
         */
        {
            unsigned long now, then;

            err = rtc_read_time(rtc, &tm);
            if (err < 0)
                return err;
            rtc_tm_to_time(&tm, &now);

            alarm.time.tm_mday = tm.tm_mday;
            alarm.time.tm_mon = tm.tm_mon;
            alarm.time.tm_year = tm.tm_year;
            err  = rtc_valid_tm(&alarm.time);
            if (err < 0)
                return err;
            rtc_tm_to_time(&alarm.time, &then);

            /* alarm may need to wrap into tomorrow */
            if (then < now) {
                rtc_time_to_tm(now + 24 * 60 * 60, &tm);
                alarm.time.tm_mday = tm.tm_mday;
                alarm.time.tm_mon = tm.tm_mon;
                alarm.time.tm_year = tm.tm_year;
            }
        }

        return rtc_set_alarm(rtc, &alarm);

    case RTC_RD_TIME:
        mutex_unlock(&rtc->ops_lock);

        err = rtc_read_time(rtc, &tm);
        if (err < 0)
            return err;

        if (copy_to_user(uarg, &tm, sizeof(tm)))
            err = -EFAULT;
        return err;

    case RTC_SET_TIME:
        mutex_unlock(&rtc->ops_lock);

        if (copy_from_user(&tm, uarg, sizeof(tm)))
            return -EFAULT;

        return rtc_set_time(rtc, &tm);

    case RTC_PIE_ON:
        err = rtc_irq_set_state(rtc, NULL, 1);
        break;

    case RTC_PIE_OFF:
        err = rtc_irq_set_state(rtc, NULL, 0);
        break;

    case RTC_AIE_ON:
        mutex_unlock(&rtc->ops_lock);
        return rtc_alarm_irq_enable(rtc, 1);

    case RTC_AIE_OFF:
        mutex_unlock(&rtc->ops_lock);
        return rtc_alarm_irq_enable(rtc, 0);

    case RTC_UIE_ON:
        mutex_unlock(&rtc->ops_lock);
        return rtc_update_irq_enable(rtc, 1);

    case RTC_UIE_OFF:
        mutex_unlock(&rtc->ops_lock);
        return rtc_update_irq_enable(rtc, 0);

    case RTC_IRQP_SET:
        err = rtc_irq_set_freq(rtc, NULL, arg);
        break;

    case RTC_IRQP_READ:
        err = put_user(rtc->irq_freq, (unsigned long __user *)uarg);
        break;

#if 0
    case RTC_EPOCH_SET:
#ifndef rtc_epoch
        /*
         * There were no RTC clocks before 1900.
         */
        if (arg < 1900) {
            err = -EINVAL;
            break;
        }
        rtc_epoch = arg;
        err = 0;
#endif
        break;

    case RTC_EPOCH_READ:
        err = put_user(rtc_epoch, (unsigned long __user *)uarg);
        break;
#endif
    case RTC_WKALM_SET:
        mutex_unlock(&rtc->ops_lock);
        if (copy_from_user(&alarm, uarg, sizeof(alarm)))
            return -EFAULT;

        return rtc_set_alarm(rtc, &alarm);

    case RTC_WKALM_RD:
        mutex_unlock(&rtc->ops_lock);
        err = rtc_read_alarm(rtc, &alarm);
        if (err < 0)
            return err;

        if (copy_to_user(uarg, &alarm, sizeof(alarm)))
            err = -EFAULT;
        return err;

    default:
        err = -ENOTTY;
        break;
    }

done:
    mutex_unlock(&rtc->ops_lock);
    return err;
}

static int rtc_dev_fasync(int fd, struct file *file, int on)
{
    struct rtc_device *rtc = file->private_data;
    return fasync_helper(fd, file, on, &rtc->async_queue);
}

static int rtc_dev_release(struct inode *inode, struct file *file)
{
    struct rtc_device *rtc = file->private_data;

    /* We shut down the repeating IRQs that userspace enabled,
     * since nothing is listening to them.
     *  - Update (UIE) ... currently only managed through ioctls
     *  - Periodic (PIE) ... also used through rtc_*() interface calls
     *
     * Leave the alarm alone; it may be set to trigger a system wakeup
     * later, or be used by kernel code, and is a one-shot event anyway.
     */

    /* Keep ioctl until all drivers are converted */
    rtc_dev_ioctl(file, RTC_UIE_OFF, 0);
    rtc_update_irq_enable(rtc, 0);
    rtc_irq_set_state(rtc, NULL, 0);

    if (rtc->ops->release)
        rtc->ops->release(rtc->dev.parent);

    clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);
    return 0;
}

static const struct file_operations rtc_dev_fops = {
    .owner        = THIS_MODULE,
    .llseek        = no_llseek,
    .read        = rtc_dev_read,
    .poll        = rtc_dev_poll,
    .unlocked_ioctl    = rtc_dev_ioctl,
    .open        = rtc_dev_open,
    .release    = rtc_dev_release,
    .fasync        = rtc_dev_fasync,
};

/* insertion/removal hooks */

void rtc_dev_prepare(struct rtc_device *rtc)
{
    if (!rtc_devt)
        return;

    if (rtc->id >= RTC_DEV_MAX) {
        pr_debug("%s: too many RTC devices
", rtc->name);
        return;
    }

    rtc->dev.devt = MKDEV(MAJOR(rtc_devt), rtc->id);    //获取rtc的设备号

#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
    INIT_WORK(&rtc->uie_task, rtc_uie_task);
    setup_timer(&rtc->uie_timer, rtc_uie_timer, (unsigned long)rtc);
#endif

    cdev_init(&rtc->char_dev, &rtc_dev_fops);
    rtc->char_dev.owner = rtc->owner;
}

void rtc_dev_add_device(struct rtc_device *rtc)
{
    if (cdev_add(&rtc->char_dev, rtc->dev.devt, 1))
        printk(KERN_WARNING "%s: failed to add char device %d:%d
",
            rtc->name, MAJOR(rtc_devt), rtc->id);
    else
        pr_debug("%s: dev (%d:%d)
", rtc->name,
            MAJOR(rtc_devt), rtc->id);
}

void rtc_dev_del_device(struct rtc_device *rtc)
{
    if (rtc->dev.devt)
        cdev_del(&rtc->char_dev);
}

void __init rtc_dev_init(void)
{
    int err;

    err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc");   //动态分配rtc的设备号
    if (err < 0)
        printk(KERN_ERR "%s: failed to allocate char dev region
",
            __FILE__);
}

void __exit rtc_dev_exit(void)
{
    if (rtc_devt)
        unregister_chrdev_region(rtc_devt, RTC_DEV_MAX);          //注销设备号
}

interface.c源代码：

/*
 * RTC subsystem, interface functions
 *
 * Copyright (C) 2005 Tower Technologies
 * Author: Alessandro Zummo <a.zummo@towertech.it>
 *
 * based on arch/arm/common/rtctime.c
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.

本函数中主要就是实现 前面我们rtc-dev.c中ioctl的各种命令函数
RTC_ALM_READ             rtc_read_alarm             读取闹钟时间
RTC_ALM_SET              rtc_set_alarm              设置闹钟时间
RTC_RD_TIME              rtc_read_time              读取时间与日期
RTC_SET_TIME             rtc_set_time               设置时间与日期
RTC_PIE_ON RTC_PIE_OFF   rtc_irq_set_state          开关RTC全局中断的函数
RTC_AIE_ON RTC_AIE_OFF   rtc_alarm_irq_enable       使能禁止RTC闹钟中断
RTC_UIE_OFF RTC_UIE_ON   rtc_update_irq_enable      使能禁止RTC更新中断
RTC_IRQP_SET             rtc_irq_set_freq           设置中断的频率

*/

#include <linux/rtc.h>
#include <linux/log2.h>

int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm)
{
    int err;

    err = mutex_lock_interruptible(&rtc->ops_lock); //上锁，用了一个信号来保证在同一时刻只有一个进程可以获取时间
    if (err)
        return err;

    if (!rtc->ops) //如果rtc的ops结构体为空，则直接返回
        err = -ENODEV;
    else if (!rtc->ops->read_time) //如果未定义ops的read_time函数，直接返回
        err = -EINVAL;
    else {
        memset(tm, 0, sizeof(struct rtc_time)); //将内存清零，清空tm结构体
        err = rtc->ops->read_time(rtc->dev.parent, tm);//读取时间
    }

    mutex_unlock(&rtc->ops_lock);//解锁
    return err;
}
EXPORT_SYMBOL_GPL(rtc_read_time);

int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm)
{
    int err;

    err = rtc_valid_tm(tm);
    if (err != 0)
        return err;

    err = mutex_lock_interruptible(&rtc->ops_lock);
    if (err)
        return err;

    if (!rtc->ops)
        err = -ENODEV;
    else if (rtc->ops->set_time)
        err = rtc->ops->set_time(rtc->dev.parent, tm);
    else if (rtc->ops->set_mmss) {
        unsigned long secs;
        err = rtc_tm_to_time(tm, &secs);
        if (err == 0)
            err = rtc->ops->set_mmss(rtc->dev.parent, secs);
    } else
        err = -EINVAL;

    mutex_unlock(&rtc->ops_lock);
    return err;
}
EXPORT_SYMBOL_GPL(rtc_set_time);

int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs)
{
    int err;

    err = mutex_lock_interruptible(&rtc->ops_lock);
    if (err)
        return err;

    if (!rtc->ops)
        err = -ENODEV;
    else if (rtc->ops->set_mmss)
        err = rtc->ops->set_mmss(rtc->dev.parent, secs);
    else if (rtc->ops->read_time && rtc->ops->set_time) {
        struct rtc_time new, old;

        err = rtc->ops->read_time(rtc->dev.parent, &old);
        if (err == 0) {
            rtc_time_to_tm(secs, &new);

            /*
             * avoid writing when we're going to change the day of
             * the month. We will retry in the next minute. This
             * basically means that if the RTC must not drift
             * by more than 1 minute in 11 minutes.
             */
            if (!((old.tm_hour == 23 && old.tm_min == 59) ||
                (new.tm_hour == 23 && new.tm_min == 59)))
                err = rtc->ops->set_time(rtc->dev.parent,
                        &new);
        }
    }
    else
        err = -EINVAL;

    mutex_unlock(&rtc->ops_lock);

    return err;
}
EXPORT_SYMBOL_GPL(rtc_set_mmss);

static int rtc_read_alarm_internal(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
{
    int err;

    err = mutex_lock_interruptible(&rtc->ops_lock);
    if (err)
        return err;

    if (rtc->ops == NULL)
        err = -ENODEV;
    else if (!rtc->ops->read_alarm)
        err = -EINVAL;
    else {
        memset(alarm, 0, sizeof(struct rtc_wkalrm));
        err = rtc->ops->read_alarm(rtc->dev.parent, alarm);
    }

    mutex_unlock(&rtc->ops_lock);
    return err;
}

int rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
{
    int err;
    struct rtc_time before, now;
    int first_time = 1;
    unsigned long t_now, t_alm;
    enum { none, day, month, year } missing = none;
    unsigned days;

    /* The lower level RTC driver may return -1 in some fields,
     * creating invalid alarm->time values, for reasons like:
     *
     *   - The hardware may not be capable of filling them in;
     *     many alarms match only on time-of-day fields, not
     *     day/month/year calendar data.
     *
     *   - Some hardware uses illegal values as "wildcard" match
     *     values, which non-Linux firmware (like a BIOS) may try
     *     to set up as e.g. "alarm 15 minutes after each hour".
     *     Linux uses only oneshot alarms.
     *
     * When we see that here, we deal with it by using values from
     * a current RTC timestamp for any missing (-1) values.  The
     * RTC driver prevents "periodic alarm" modes.
     *
     * But this can be racey, because some fields of the RTC timestamp
     * may have wrapped in the interval since we read the RTC alarm,
     * which would lead to us inserting inconsistent values in place
     * of the -1 fields.
     *
     * Reading the alarm and timestamp in the reverse sequence
     * would have the same race condition, and not solve the issue.
     *
     * So, we must first read the RTC timestamp,
     * then read the RTC alarm value,
     * and then read a second RTC timestamp.
     *
     * If any fields of the second timestamp have changed
     * when compared with the first timestamp, then we know
     * our timestamp may be inconsistent with that used by
     * the low-level rtc_read_alarm_internal() function.
     *
     * So, when the two timestamps disagree, we just loop and do
     * the process again to get a fully consistent set of values.
     *
     * This could all instead be done in the lower level driver,
     * but since more than one lower level RTC implementation needs it,
     * then it's probably best best to do it here instead of there..
     */

    /* Get the "before" timestamp */
    err = rtc_read_time(rtc, &before);
    if (err < 0)
        return err;
    do {
        if (!first_time)
            memcpy(&before, &now, sizeof(struct rtc_time));
        first_time = 0;

        /* get the RTC alarm values, which may be incomplete */
        err = rtc_read_alarm_internal(rtc, alarm);
        if (err)
            return err;
        if (!alarm->enabled)
            return 0;

        /* full-function RTCs won't have such missing fields */
        if (rtc_valid_tm(&alarm->time) == 0)
            return 0;

        /* get the "after" timestamp, to detect wrapped fields */
        err = rtc_read_time(rtc, &now);
        if (err < 0)
            return err;

        /* note that tm_sec is a "don't care" value here: */
    } while (   before.tm_min   != now.tm_min
         || before.tm_hour  != now.tm_hour
         || before.tm_mon   != now.tm_mon
         || before.tm_year  != now.tm_year);

    /* Fill in the missing alarm fields using the timestamp; we
     * know there's at least one since alarm->time is invalid.
     */
    if (alarm->time.tm_sec == -1)
        alarm->time.tm_sec = now.tm_sec;
    if (alarm->time.tm_min == -1)
        alarm->time.tm_min = now.tm_min;
    if (alarm->time.tm_hour == -1)
        alarm->time.tm_hour = now.tm_hour;

    /* For simplicity, only support date rollover for now */
    if (alarm->time.tm_mday == -1) {
        alarm->time.tm_mday = now.tm_mday;
        missing = day;
    }
    if (alarm->time.tm_mon == -1) {
        alarm->time.tm_mon = now.tm_mon;
        if (missing == none)
            missing = month;
    }
    if (alarm->time.tm_year == -1) {
        alarm->time.tm_year = now.tm_year;
        if (missing == none)
            missing = year;
    }

    /* with luck, no rollover is needed */
    rtc_tm_to_time(&now, &t_now);
    rtc_tm_to_time(&alarm->time, &t_alm);
    if (t_now < t_alm)
        goto done;

    switch (missing) {

    /* 24 hour rollover ... if it's now 10am Monday, an alarm that
     * that will trigger at 5am will do so at 5am Tuesday, which
     * could also be in the next month or year.  This is a common
     * case, especially for PCs.
     */
    case day:
        dev_dbg(&rtc->dev, "alarm rollover: %s
", "day");
        t_alm += 24 * 60 * 60;
        rtc_time_to_tm(t_alm, &alarm->time);
        break;

    /* Month rollover ... if it's the 31th, an alarm on the 3rd will
     * be next month.  An alarm matching on the 30th, 29th, or 28th
     * may end up in the month after that!  Many newer PCs support
     * this type of alarm.
     */
    case month:
        dev_dbg(&rtc->dev, "alarm rollover: %s
", "month");
        do {
            if (alarm->time.tm_mon < 11)
                alarm->time.tm_mon++;
            else {
                alarm->time.tm_mon = 0;
                alarm->time.tm_year++;
            }
            days = rtc_month_days(alarm->time.tm_mon,
                    alarm->time.tm_year);
        } while (days < alarm->time.tm_mday);
        break;

    /* Year rollover ... easy except for leap years! */
    case year:
        dev_dbg(&rtc->dev, "alarm rollover: %s
", "year");
        do {
            alarm->time.tm_year++;
        } while (rtc_valid_tm(&alarm->time) != 0);
        break;

    default:
        dev_warn(&rtc->dev, "alarm rollover not handled
");
    }

done:
    return 0;
}
EXPORT_SYMBOL_GPL(rtc_read_alarm);

int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
{
    int err;

    err = rtc_valid_tm(&alarm->time);
    if (err != 0)
        return err;

    err = mutex_lock_interruptible(&rtc->ops_lock);
    if (err)
        return err;

    if (!rtc->ops)
        err = -ENODEV;
    else if (!rtc->ops->set_alarm)
        err = -EINVAL;
    else
        err = rtc->ops->set_alarm(rtc->dev.parent, alarm);

    mutex_unlock(&rtc->ops_lock);
    return err;
}
EXPORT_SYMBOL_GPL(rtc_set_alarm);

int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
{
    int err = mutex_lock_interruptible(&rtc->ops_lock);
    if (err)
        return err;

    if (!rtc->ops)
        err = -ENODEV;
    else if (!rtc->ops->alarm_irq_enable)
        err = -EINVAL;
    else
        err = rtc->ops->alarm_irq_enable(rtc->dev.parent, enabled);

    mutex_unlock(&rtc->ops_lock);
    return err;
}
EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable);

int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
{
    int err = mutex_lock_interruptible(&rtc->ops_lock);
    if (err)
        return err;

#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
    if (enabled == 0 && rtc->uie_irq_active) {
        mutex_unlock(&rtc->ops_lock);
        return rtc_dev_update_irq_enable_emul(rtc, enabled);
    }
#endif

    if (!rtc->ops)
        err = -ENODEV;
    else if (!rtc->ops->update_irq_enable)
        err = -EINVAL;
    else
        err = rtc->ops->update_irq_enable(rtc->dev.parent, enabled);

    mutex_unlock(&rtc->ops_lock);

#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
    /*
     * Enable emulation if the driver did not provide
     * the update_irq_enable function pointer or if returned
     * -EINVAL to signal that it has been configured without
     * interrupts or that are not available at the moment.
     */
    if (err == -EINVAL)
        err = rtc_dev_update_irq_enable_emul(rtc, enabled);
#endif
    return err;
}
EXPORT_SYMBOL_GPL(rtc_update_irq_enable);

/**
 * rtc_update_irq - report RTC periodic, alarm, and/or update irqs
 * @rtc: the rtc device
 * @num: how many irqs are being reported (usually one)
 * @events: mask of RTC_IRQF with one or more of RTC_PF, RTC_AF, RTC_UF
 * Context: any
 */
void rtc_update_irq(struct rtc_device *rtc,
        unsigned long num, unsigned long events)
{
    unsigned long flags;

    spin_lock_irqsave(&rtc->irq_lock, flags);
    rtc->irq_data = (rtc->irq_data + (num << 8)) | events;
    spin_unlock_irqrestore(&rtc->irq_lock, flags);

    spin_lock_irqsave(&rtc->irq_task_lock, flags);
    if (rtc->irq_task)
        rtc->irq_task->func(rtc->irq_task->private_data);
    spin_unlock_irqrestore(&rtc->irq_task_lock, flags);

    wake_up_interruptible(&rtc->irq_queue);
    kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
}
EXPORT_SYMBOL_GPL(rtc_update_irq);

static int __rtc_match(struct device *dev, void *data)
{
    char *name = (char *)data;

    if (strcmp(dev_name(dev), name) == 0)
        return 1;
    return 0;
}

struct rtc_device *rtc_class_open(char *name)
{
    struct device *dev;
    struct rtc_device *rtc = NULL;

    dev = class_find_device(rtc_class, NULL, name, __rtc_match);
    if (dev)
        rtc = to_rtc_device(dev);

    if (rtc) {
        if (!try_module_get(rtc->owner)) {
            put_device(dev);
            rtc = NULL;
        }
    }

    return rtc;
}
EXPORT_SYMBOL_GPL(rtc_class_open);

void rtc_class_close(struct rtc_device *rtc)
{
    module_put(rtc->owner);
    put_device(&rtc->dev);
}
EXPORT_SYMBOL_GPL(rtc_class_close);

int rtc_irq_register(struct rtc_device *rtc, struct rtc_task *task)
{
    int retval = -EBUSY;

    if (task == NULL || task->func == NULL)
        return -EINVAL;

    /* Cannot register while the char dev is in use */
    if (test_and_set_bit_lock(RTC_DEV_BUSY, &rtc->flags))
        return -EBUSY;

    spin_lock_irq(&rtc->irq_task_lock);
    if (rtc->irq_task == NULL) {
        rtc->irq_task = task;
        retval = 0;
    }
    spin_unlock_irq(&rtc->irq_task_lock);

    clear_bit_unlock(RTC_DEV_BUSY, &rtc->flags);

    return retval;
}
EXPORT_SYMBOL_GPL(rtc_irq_register);

void rtc_irq_unregister(struct rtc_device *rtc, struct rtc_task *task)
{
    spin_lock_irq(&rtc->irq_task_lock);
    if (rtc->irq_task == task)
        rtc->irq_task = NULL;
    spin_unlock_irq(&rtc->irq_task_lock);
}
EXPORT_SYMBOL_GPL(rtc_irq_unregister);

/**
 * rtc_irq_set_state - enable/disable 2^N Hz periodic IRQs
 * @rtc: the rtc device
 * @task: currently registered with rtc_irq_register()
 * @enabled: true to enable periodic IRQs
 * Context: any
 *
 * Note that rtc_irq_set_freq() should previously have been used to
 * specify the desired frequency of periodic IRQ task->func() callbacks.
 */
int rtc_irq_set_state(struct rtc_device *rtc, struct rtc_task *task, int enabled)
{
    int err = 0;
    unsigned long flags;

    if (rtc->ops->irq_set_state == NULL)
        return -ENXIO;

    spin_lock_irqsave(&rtc->irq_task_lock, flags);
    if (rtc->irq_task != NULL && task == NULL)
        err = -EBUSY;
    if (rtc->irq_task != task)
        err = -EACCES;
    spin_unlock_irqrestore(&rtc->irq_task_lock, flags);

    if (err == 0)
        err = rtc->ops->irq_set_state(rtc->dev.parent, enabled);

    return err;
}
EXPORT_SYMBOL_GPL(rtc_irq_set_state);

/**
 * rtc_irq_set_freq - set 2^N Hz periodic IRQ frequency for IRQ
 * @rtc: the rtc device
 * @task: currently registered with rtc_irq_register()
 * @freq: positive frequency with which task->func() will be called
 * Context: any
 *
 * Note that rtc_irq_set_state() is used to enable or disable the
 * periodic IRQs.
 */
int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
{
    int err = 0;
    unsigned long flags;

    if (rtc->ops->irq_set_freq == NULL)
        return -ENXIO;

    spin_lock_irqsave(&rtc->irq_task_lock, flags);
    if (rtc->irq_task != NULL && task == NULL)
        err = -EBUSY;
    if (rtc->irq_task != task)
        err = -EACCES;
    spin_unlock_irqrestore(&rtc->irq_task_lock, flags);

    if (err == 0) {
        err = rtc->ops->irq_set_freq(rtc->dev.parent, freq);
        if (err == 0)
            rtc->irq_freq = freq;
    }
    return err;
}
EXPORT_SYMBOL_GPL(rtc_irq_set_freq);

rtc-sysfs.c源代码：

/*
 * RTC subsystem, sysfs interface
 *
 * Copyright (C) 2005 Tower Technologies
 * Author: Alessandro Zummo <a.zummo@towertech.it>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
本文主要工作:
1.在init给rtc时钟增加闹钟属性
2.初始化一个struct device_attribute rtc_attrs[]属性结构体数组
3.在函数rtc_sysfs_add_device中增加闹钟属性文件
4.在函数rtc_sysfs_del_device中删除闹钟属性文件
*/

#include <linux/module.h>
#include <linux/rtc.h>

#include "rtc-core.h"


/* device attributes */

/*
 * NOTE:  RTC times displayed in sysfs use the RTC's timezone.  That's
 * ideally UTC.  However, PCs that also boot to MS-Windows normally use
 * the local time and change to match daylight savings time.  That affects
 * attributes including date, time, since_epoch, and wakealarm.
 */

static ssize_t
rtc_sysfs_show_name(struct device *dev, struct device_attribute *attr,
        char *buf)
{
    return sprintf(buf, "%s
", to_rtc_device(dev)->name);
}

static ssize_t
rtc_sysfs_show_date(struct device *dev, struct device_attribute *attr,
        char *buf)
{
    ssize_t retval;
    struct rtc_time tm;

    retval = rtc_read_time(to_rtc_device(dev), &tm);
    if (retval == 0) {
        retval = sprintf(buf, "%04d-%02d-%02d
",
            tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
    }

    return retval;
}

static ssize_t
rtc_sysfs_show_time(struct device *dev, struct device_attribute *attr,
        char *buf)
{
    ssize_t retval;
    struct rtc_time tm;

    retval = rtc_read_time(to_rtc_device(dev), &tm);
    if (retval == 0) {
        retval = sprintf(buf, "%02d:%02d:%02d
",
            tm.tm_hour, tm.tm_min, tm.tm_sec);
    }

    return retval;
}

static ssize_t
rtc_sysfs_show_since_epoch(struct device *dev, struct device_attribute *attr,
        char *buf)
{
    ssize_t retval;
    struct rtc_time tm;

    retval = rtc_read_time(to_rtc_device(dev), &tm);
    if (retval == 0) {
        unsigned long time;
        rtc_tm_to_time(&tm, &time);
        retval = sprintf(buf, "%lu
", time);
    }

    return retval;
}

static ssize_t
rtc_sysfs_show_max_user_freq(struct device *dev, struct device_attribute *attr,
        char *buf)
{
    return sprintf(buf, "%d
", to_rtc_device(dev)->max_user_freq);
}

static ssize_t
rtc_sysfs_set_max_user_freq(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t n)
{
    struct rtc_device *rtc = to_rtc_device(dev);
    unsigned long val = simple_strtoul(buf, NULL, 0);

    if (val >= 4096 || val == 0)
        return -EINVAL;

    rtc->max_user_freq = (int)val;

    return n;
}

static struct device_attribute rtc_attrs[] = {
    __ATTR(name, S_IRUGO, rtc_sysfs_show_name, NULL),
    __ATTR(date, S_IRUGO, rtc_sysfs_show_date, NULL),
    __ATTR(time, S_IRUGO, rtc_sysfs_show_time, NULL),
    __ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL),
    __ATTR(max_user_freq, S_IRUGO | S_IWUSR, rtc_sysfs_show_max_user_freq,
            rtc_sysfs_set_max_user_freq),
    { },
};

static ssize_t
rtc_sysfs_show_wakealarm(struct device *dev, struct device_attribute *attr,
        char *buf)
{
    ssize_t retval;
    unsigned long alarm;
    struct rtc_wkalrm alm;

    /* Don't show disabled alarms.  For uniformity, RTC alarms are
     * conceptually one-shot, even though some common RTCs (on PCs)
     * don't actually work that way.
     *
     * NOTE: RTC implementations where the alarm doesn't match an
     * exact YYYY-MM-DD HH:MM[:SS] date *must* disable their RTC
     * alarms after they trigger, to ensure one-shot semantics.
     */
    retval = rtc_read_alarm(to_rtc_device(dev), &alm);
    if (retval == 0 && alm.enabled) {
        rtc_tm_to_time(&alm.time, &alarm);
        retval = sprintf(buf, "%lu
", alarm);
    }

    return retval;
}

static ssize_t
rtc_sysfs_set_wakealarm(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t n)
{
    ssize_t retval;
    unsigned long now, alarm;
    struct rtc_wkalrm alm;
    struct rtc_device *rtc = to_rtc_device(dev);
    char *buf_ptr;
    int adjust = 0;

    /* Only request alarms that trigger in the future.  Disable them
     * by writing another time, e.g. 0 meaning Jan 1 1970 UTC.
     */
    retval = rtc_read_time(rtc, &alm.time);
    if (retval < 0)
        return retval;
    rtc_tm_to_time(&alm.time, &now);

    buf_ptr = (char *)buf;
    if (*buf_ptr == '+') {
        buf_ptr++;
        adjust = 1;
    }
    alarm = simple_strtoul(buf_ptr, NULL, 0);
    if (adjust) {
        alarm += now;
    }
    if (alarm > now) {
        /* Avoid accidentally clobbering active alarms; we can't
         * entirely prevent that here, without even the minimal
         * locking from the /dev/rtcN api.
         */
        retval = rtc_read_alarm(rtc, &alm);
        if (retval < 0)
            return retval;
        if (alm.enabled)
            return -EBUSY;

        alm.enabled = 1;
    } else {
        alm.enabled = 0;

        /* Provide a valid future alarm time.  Linux isn't EFI,
         * this time won't be ignored when disabling the alarm.
         */
        alarm = now + 300;
    }
    rtc_time_to_tm(alarm, &alm.time);

    retval = rtc_set_alarm(rtc, &alm);
    return (retval < 0) ? retval : n;
}
static DEVICE_ATTR(wakealarm, S_IRUGO | S_IWUSR,
        rtc_sysfs_show_wakealarm, rtc_sysfs_set_wakealarm);


/* The reason to trigger an alarm with no process watching it (via sysfs)
 * is its side effect:  waking from a system state like suspend-to-RAM or
 * suspend-to-disk.  So: no attribute unless that side effect is possible.
 * (Userspace may disable that mechanism later.)
 */
static inline int rtc_does_wakealarm(struct rtc_device *rtc)
{
    if (!device_can_wakeup(rtc->dev.parent))
        return 0;
    return rtc->ops->set_alarm != NULL;
}


void rtc_sysfs_add_device(struct rtc_device *rtc)
{
    int err;

    /* not all RTCs support both alarms and wakeup */
    if (!rtc_does_wakealarm(rtc))
        return;

    err = device_create_file(&rtc->dev, &dev_attr_wakealarm);
    if (err)
        dev_err(rtc->dev.parent,
            "failed to create alarm attribute, %d
", err);
}

void rtc_sysfs_del_device(struct rtc_device *rtc)
{
    /* REVISIT did we add it successfully? */
    if (rtc_does_wakealarm(rtc))
        device_remove_file(&rtc->dev, &dev_attr_wakealarm);
}

void __init rtc_sysfs_init(struct class *rtc_class)
{
    rtc_class->dev_attrs = rtc_attrs; //给rtc的类dev_attrs赋值rtc_attrs这个属性指针
}

rtc-proc.c源代码：

/*
 * RTC subsystem, proc interface
 *
 * Copyright (C) 2005-06 Tower Technologies
 * Author: Alessandro Zummo <a.zummo@towertech.it>
 *
 * based on arch/arm/common/rtctime.c
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
*/

#include <linux/module.h>
#include <linux/rtc.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>

#include "rtc-core.h"


static int rtc_proc_show(struct seq_file *seq, void *offset)
{
    int err;
    struct rtc_device *rtc = seq->private;
    const struct rtc_class_ops *ops = rtc->ops;
    struct rtc_wkalrm alrm;
    struct rtc_time tm;

    err = rtc_read_time(rtc, &tm);
    if (err == 0) {
        seq_printf(seq,
            "rtc_time	: %02d:%02d:%02d
"
            "rtc_date	: %04d-%02d-%02d
",
            tm.tm_hour, tm.tm_min, tm.tm_sec,
            tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
    }

    err = rtc_read_alarm(rtc, &alrm);
    if (err == 0) {
        seq_printf(seq, "alrm_time	: ");
        if ((unsigned int)alrm.time.tm_hour <= 24)
            seq_printf(seq, "%02d:", alrm.time.tm_hour);
        else
            seq_printf(seq, "**:");
        if ((unsigned int)alrm.time.tm_min <= 59)
            seq_printf(seq, "%02d:", alrm.time.tm_min);
        else
            seq_printf(seq, "**:");
        if ((unsigned int)alrm.time.tm_sec <= 59)
            seq_printf(seq, "%02d
", alrm.time.tm_sec);
        else
            seq_printf(seq, "**
");

        seq_printf(seq, "alrm_date	: ");
        if ((unsigned int)alrm.time.tm_year <= 200)
            seq_printf(seq, "%04d-", alrm.time.tm_year + 1900);
        else
            seq_printf(seq, "****-");
        if ((unsigned int)alrm.time.tm_mon <= 11)
            seq_printf(seq, "%02d-", alrm.time.tm_mon + 1);
        else
            seq_printf(seq, "**-");
        if (alrm.time.tm_mday && (unsigned int)alrm.time.tm_mday <= 31)
            seq_printf(seq, "%02d
", alrm.time.tm_mday);
        else
            seq_printf(seq, "**
");
        seq_printf(seq, "alarm_IRQ	: %s
",
                alrm.enabled ? "yes" : "no");
        seq_printf(seq, "alrm_pending	: %s
",
                alrm.pending ? "yes" : "no");
    }

    seq_printf(seq, "24hr		: yes
");

    if (ops->proc)
        ops->proc(rtc->dev.parent, seq);

    return 0;
}

static int rtc_proc_open(struct inode *inode, struct file *file)
{
    struct rtc_device *rtc = PDE(inode)->data;

    if (!try_module_get(THIS_MODULE))
        return -ENODEV;

    return single_open(file, rtc_proc_show, rtc);
}

static int rtc_proc_release(struct inode *inode, struct file *file)
{
    int res = single_release(inode, file);
    module_put(THIS_MODULE);
    return res;
}

static const struct file_operations rtc_proc_fops = {
    .open        = rtc_proc_open,
    .read        = seq_read,
    .llseek        = seq_lseek,
    .release    = rtc_proc_release,
};

void rtc_proc_add_device(struct rtc_device *rtc)
{
    if (rtc->id == 0)
        proc_create_data("driver/rtc", 0, NULL, &rtc_proc_fops, rtc);
    //proc_create_data完成创建文件节点的作用，并将文件的操作函数与节点联系起来
}

void rtc_proc_del_device(struct rtc_device *rtc)
{
    if (rtc->id == 0)
        remove_proc_entry("driver/rtc", NULL);
}