LXR linux/drivers/rtc/rtc-proc.c

   1/*
   2 * RTC subsystem, proc interface
   3 *
   4 * Copyright (C) 2005-06 Tower Technologies
   5 * Author: Alessandro Zummo <a.zummo@towertech.it>
   6 *
   7 * based on arch/arm/common/rtctime.c
   8 *
   9 * This program is free software; you can redistribute it and/or modify
  10 * it under the terms of the GNU General Public License version 2 as
  11 * published by the Free Software Foundation.
  12*/
  13
  14#include <linux/module.h>
  15#include <linux/rtc.h>
  16#include <linux/proc_fs.h>
  17#include <linux/seq_file.h>
  18
  19#include "rtc-core.h"
  20
  21
  22static int rtc_proc_show(struct seq_file *seq, void *offset)
  23{
  24        int err;
  25        struct rtc_device *rtc = seq->private;
  26        const struct rtc_class_ops *ops = rtc->ops;
  27        struct rtc_wkalrm alrm;
  28        struct rtc_time tm;
  29
  30        err = rtc_read_time(rtc, &tm);
  31        if (err == 0) {
  32                seq_printf(seq,
  33                        "rtc_time\t: %02d:%02d:%02d\n"
  34                        "rtc_date\t: %04d-%02d-%02d\n",
  35                        tm.tm_hour, tm.tm_min, tm.tm_sec,
  36                        tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
  37        }
  38
  39        err = rtc_read_alarm(rtc, &alrm);
  40        if (err == 0) {
  41                seq_printf(seq, "alrm_time\t: ");
  42                if ((unsigned int)alrm.time.tm_hour <= 24)
  43                        seq_printf(seq, "%02d:", alrm.time.tm_hour);
  44                else
  45                        seq_printf(seq, "**:");
  46                if ((unsigned int)alrm.time.tm_min <= 59)
  47                        seq_printf(seq, "%02d:", alrm.time.tm_min);
  48                else
  49                        seq_printf(seq, "**:");
  50                if ((unsigned int)alrm.time.tm_sec <= 59)
  51                        seq_printf(seq, "%02d\n", alrm.time.tm_sec);
  52                else
  53                        seq_printf(seq, "**\n");
  54
  55                seq_printf(seq, "alrm_date\t: ");
  56                if ((unsigned int)alrm.time.tm_year <= 200)
  57                        seq_printf(seq, "%04d-", alrm.time.tm_year + 1900);
  58                else
  59                        seq_printf(seq, "****-");
  60                if ((unsigned int)alrm.time.tm_mon <= 11)
  61                        seq_printf(seq, "%02d-", alrm.time.tm_mon + 1);
  62                else
  63                        seq_printf(seq, "**-");
  64                if (alrm.time.tm_mday && (unsigned int)alrm.time.tm_mday <= 31)
  65                        seq_printf(seq, "%02d\n", alrm.time.tm_mday);
  66                else
  67                        seq_printf(seq, "**\n");
  68                seq_printf(seq, "alarm_IRQ\t: %s\n",
  69                                alrm.enabled ? "yes" : "no");
  70                seq_printf(seq, "alrm_pending\t: %s\n",
  71                                alrm.pending ? "yes" : "no");
  72                seq_printf(seq, "update IRQ enabled\t: %s\n",
  73                        (rtc->uie_rtctimer.enabled) ? "yes" : "no");
  74                seq_printf(seq, "periodic IRQ enabled\t: %s\n",
  75                        (rtc->pie_enabled) ? "yes" : "no");
  76                seq_printf(seq, "periodic IRQ frequency\t: %d\n",
  77                        rtc->irq_freq);
  78                seq_printf(seq, "max user IRQ frequency\t: %d\n",
  79                        rtc->max_user_freq);
  80        }
  81
  82        seq_printf(seq, "24hr\t\t: yes\n");
  83
  84        if (ops->proc)
  85                ops->proc(rtc->dev.parent, seq);
  86
  87        return 0;
  88}
  89
  90static int rtc_proc_open(struct inode *inode, struct file *file)
  91{
  92        int ret;
  93        struct rtc_device *rtc = PDE(inode)->data;
  94
  95        if (!try_module_get(THIS_MODULE))
  96                return -ENODEV;
  97
  98        ret = single_open(file, rtc_proc_show, rtc);
  99        if (ret)
 100                module_put(THIS_MODULE);
 101        return ret;
 102}
 103
 104static int rtc_proc_release(struct inode *inode, struct file *file)
 105{
 106        int res = single_release(inode, file);
 107        module_put(THIS_MODULE);
 108        return res;
 109}
 110
 111static const struct file_operations rtc_proc_fops = {
 112        .open           = rtc_proc_open,
 113        .read           = seq_read,
 114        .llseek         = seq_lseek,
 115        .release        = rtc_proc_release,
 116};
 117
 118void rtc_proc_add_device(struct rtc_device *rtc)
 119{
 120        if (rtc->id == 0)
 121                proc_create_data("driver/rtc", 0, NULL, &rtc_proc_fops, rtc);
 122}
 123
 124void rtc_proc_del_device(struct rtc_device *rtc)
 125{
 126        if (rtc->id == 0)
 127                remove_proc_entry("driver/rtc", NULL);
 128}
 129