LCOV - code coverage report
Current view: top level - include/linux - rtc.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 10 10 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : /*
       2             :  * Generic RTC interface.
       3             :  * This version contains the part of the user interface to the Real Time Clock
       4             :  * service. It is used with both the legacy mc146818 and also  EFI
       5             :  * Struct rtc_time and first 12 ioctl by Paul Gortmaker, 1996 - separated out
       6             :  * from <linux/mc146818rtc.h> to this file for 2.4 kernels.
       7             :  *
       8             :  * Copyright (C) 1999 Hewlett-Packard Co.
       9             :  * Copyright (C) 1999 Stephane Eranian <eranian@hpl.hp.com>
      10             :  */
      11             : #ifndef _LINUX_RTC_H_
      12             : #define _LINUX_RTC_H_
      13             : 
      14             : /*
      15             :  * The struct used to pass data via the following ioctl. Similar to the
      16             :  * struct tm in <time.h>, but it needs to be here so that the kernel
      17             :  * source is self contained, allowing cross-compiles, etc. etc.
      18             :  */
      19             : 
      20             : struct rtc_time {
      21             :         int tm_sec;
      22             :         int tm_min;
      23             :         int tm_hour;
      24             :         int tm_mday;
      25             :         int tm_mon;
      26             :         int tm_year;
      27             :         int tm_wday;
      28             :         int tm_yday;
      29             :         int tm_isdst;
      30             : };
      31           1 : 
      32             : /*
      33             :  * This data structure is inspired by the EFI (v0.92) wakeup
      34             :  * alarm API.
      35             :  */
      36             : struct rtc_wkalrm {
      37             :         unsigned char enabled;  /* 0 = alarm disabled, 1 = alarm enabled */
      38             :         unsigned char pending;  /* 0 = alarm not pending, 1 = alarm pending */
      39             :         struct rtc_time time;   /* time the alarm is set to */
      40             : };
      41             : 
      42             : /*
      43             :  * Data structure to control PLL correction some better RTC feature
      44             :  * pll_value is used to get or set current value of correction,
      45             :  * the rest of the struct is used to query HW capabilities.
      46             :  * This is modeled after the RTC used in Q40/Q60 computers but
      47             :  * should be sufficiently flexible for other devices
      48             :  *
      49             :  * +ve pll_value means clock will run faster by
      50             :  *   pll_value*pll_posmult/pll_clock
      51             :  * -ve pll_value means clock will run slower by
      52             :  *   pll_value*pll_negmult/pll_clock
      53             :  */
      54             : 
      55             : struct rtc_pll_info {
      56             :         int pll_ctrl;       /* placeholder for fancier control */
      57             :         int pll_value;      /* get/set correction value */
      58             :         int pll_max;        /* max +ve (faster) adjustment value */
      59             :         int pll_min;        /* max -ve (slower) adjustment value */
      60             :         int pll_posmult;    /* factor for +ve correction */
      61             :         int pll_negmult;    /* factor for -ve correction */
      62             :         long pll_clock;     /* base PLL frequency */
      63             : };
      64           1 : 
      65             : /*
      66             :  * ioctl calls that are permitted to the /dev/rtc interface, if
      67             :  * any of the RTC drivers are enabled.
      68             :  */
      69             : 
      70             : #define RTC_AIE_ON      _IO('p', 0x01)  /* Alarm int. enable on         */
      71             : #define RTC_AIE_OFF     _IO('p', 0x02)  /* ... off                      */
      72             : #define RTC_UIE_ON      _IO('p', 0x03)  /* Update int. enable on        */
      73             : #define RTC_UIE_OFF     _IO('p', 0x04)  /* ... off                      */
      74             : #define RTC_PIE_ON      _IO('p', 0x05)  /* Periodic int. enable on      */
      75             : #define RTC_PIE_OFF     _IO('p', 0x06)  /* ... off                      */
      76             : #define RTC_WIE_ON      _IO('p', 0x0f)  /* Watchdog int. enable on      */
      77             : #define RTC_WIE_OFF     _IO('p', 0x10)  /* ... off                      */
      78             : 
      79             : #define RTC_ALM_SET     _IOW('p', 0x07, struct rtc_time) /* Set alarm time  */
      80             : #define RTC_ALM_READ    _IOR('p', 0x08, struct rtc_time) /* Read alarm time */
      81             : #define RTC_RD_TIME     _IOR('p', 0x09, struct rtc_time) /* Read RTC time   */
      82             : #define RTC_SET_TIME    _IOW('p', 0x0a, struct rtc_time) /* Set RTC time    */
      83             : #define RTC_IRQP_READ   _IOR('p', 0x0b, unsigned long)   /* Read IRQ rate   */
      84             : #define RTC_IRQP_SET    _IOW('p', 0x0c, unsigned long)   /* Set IRQ rate    */
      85             : #define RTC_EPOCH_READ  _IOR('p', 0x0d, unsigned long)   /* Read epoch      */
      86             : #define RTC_EPOCH_SET   _IOW('p', 0x0e, unsigned long)   /* Set epoch       */
      87             : 
      88             : #define RTC_WKALM_SET   _IOW('p', 0x0f, struct rtc_wkalrm)/* Set wakeup alarm*/
      89             : #define RTC_WKALM_RD    _IOR('p', 0x10, struct rtc_wkalrm)/* Get wakeup alarm*/
      90             : 
      91             : #define RTC_PLL_GET     _IOR('p', 0x11, struct rtc_pll_info)  /* Get PLL correction */
      92             : #define RTC_PLL_SET     _IOW('p', 0x12, struct rtc_pll_info)  /* Set PLL correction */
      93             : 
      94             : /* interrupt flags */
      95             : #define RTC_IRQF 0x80 /* any of the following is active */
      96             : #define RTC_PF 0x40
      97             : #define RTC_AF 0x20
      98             : #define RTC_UF 0x10
      99             : 
     100             : #ifdef __KERNEL__
     101             : 
     102             : #include <linux/types.h>
     103             : #include <linux/interrupt.h>
     104             : 
     105             : extern int rtc_month_days(unsigned int month, unsigned int year);
     106             : extern int rtc_year_days(unsigned int day, unsigned int month, unsigned int year);
     107             : extern int rtc_valid_tm(struct rtc_time *tm);
     108             : extern int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time);
     109             : extern void rtc_time_to_tm(unsigned long time, struct rtc_time *tm);
     110           1 : 
     111           1 : #include <linux/device.h>
     112           1 : #include <linux/seq_file.h>
     113           1 : #include <linux/cdev.h>
     114             : #include <linux/poll.h>
     115             : #include <linux/mutex.h>
     116             : 
     117             : extern struct class *rtc_class;
     118           1 : 
     119             : /*
     120             :  * For these RTC methods the device parameter is the physical device
     121             :  * on whatever bus holds the hardware (I2C, Platform, SPI, etc), which
     122             :  * was passed to rtc_device_register().  Its driver_data normally holds
     123             :  * device state, including the rtc_device pointer for the RTC.
     124             :  *
     125             :  * Most of these methods are called with rtc_device.ops_lock held,
     126             :  * through the rtc_*(struct rtc_device *, ...) calls.
     127             :  *
     128             :  * The (current) exceptions are mostly filesystem hooks:
     129             :  *   - the proc() hook for procfs
     130             :  *   - non-ioctl() chardev hooks:  open(), release(), read_callback()
     131             :  *   - periodic irq calls:  irq_set_state(), irq_set_freq()
     132             :  *
     133             :  * REVISIT those periodic irq calls *do* have ops_lock when they're
     134             :  * issued through ioctl() ...
     135             :  */
     136             : struct rtc_class_ops {
     137             :         int (*open)(struct device *);
     138             :         void (*release)(struct device *);
     139             :         int (*ioctl)(struct device *, unsigned int, unsigned long);
     140             :         int (*read_time)(struct device *, struct rtc_time *);
     141             :         int (*set_time)(struct device *, struct rtc_time *);
     142             :         int (*read_alarm)(struct device *, struct rtc_wkalrm *);
     143             :         int (*set_alarm)(struct device *, struct rtc_wkalrm *);
     144             :         int (*proc)(struct device *, struct seq_file *);
     145             :         int (*set_mmss)(struct device *, unsigned long secs);
     146             :         int (*irq_set_state)(struct device *, int enabled);
     147             :         int (*irq_set_freq)(struct device *, int freq);
     148             :         int (*read_callback)(struct device *, int data);
     149             :         int (*alarm_irq_enable)(struct device *, unsigned int enabled);
     150             :         int (*update_irq_enable)(struct device *, unsigned int enabled);
     151             : };
     152           1 : 
     153           1 : #define RTC_DEVICE_NAME_SIZE 20
     154             : struct rtc_task;
     155             : 
     156             : /* flags */
     157             : #define RTC_DEV_BUSY 0
     158             : 
     159             : struct rtc_device
     160             : {
     161             :         struct device dev;
     162             :         struct module *owner;
     163             : 
     164             :         int id;
     165             :         char name[RTC_DEVICE_NAME_SIZE];
     166             : 
     167             :         const struct rtc_class_ops *ops;
     168             :         struct mutex ops_lock;
     169             : 
     170             :         struct cdev char_dev;
     171             :         unsigned long flags;
     172             : 
     173             :         unsigned long irq_data;
     174             :         spinlock_t irq_lock;
     175             :         wait_queue_head_t irq_queue;
     176             :         struct fasync_struct *async_queue;
     177             : 
     178             :         struct rtc_task *irq_task;
     179             :         spinlock_t irq_task_lock;
     180             :         int irq_freq;
     181             :         int max_user_freq;
     182             : #ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
     183             :         struct work_struct uie_task;
     184             :         struct timer_list uie_timer;
     185             :         /* Those fields are protected by rtc->irq_lock */
     186             :         unsigned int oldsecs;
     187             :         unsigned int uie_irq_active:1;
     188             :         unsigned int stop_uie_polling:1;
     189             :         unsigned int uie_task_active:1;
     190             :         unsigned int uie_timer_active:1;
     191             : #endif
     192             : };
     193             : #define to_rtc_device(d) container_of(d, struct rtc_device, dev)
     194             : 
     195             : extern struct rtc_device *rtc_device_register(const char *name,
     196             :                                         struct device *dev,
     197             :                                         const struct rtc_class_ops *ops,
     198             :                                         struct module *owner);
     199             : extern void rtc_device_unregister(struct rtc_device *rtc);
     200             : 
     201             : extern int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm);
     202             : extern int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm);
     203             : extern int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs);
     204             : extern int rtc_read_alarm(struct rtc_device *rtc,
     205             :                         struct rtc_wkalrm *alrm);
     206             : extern int rtc_set_alarm(struct rtc_device *rtc,
     207             :                                 struct rtc_wkalrm *alrm);
     208             : extern void rtc_update_irq(struct rtc_device *rtc,
     209             :                         unsigned long num, unsigned long events);
     210             : 
     211             : extern struct rtc_device *rtc_class_open(char *name);
     212             : extern void rtc_class_close(struct rtc_device *rtc);
     213             : 
     214             : extern int rtc_irq_register(struct rtc_device *rtc,
     215             :                                 struct rtc_task *task);
     216             : extern void rtc_irq_unregister(struct rtc_device *rtc,
     217             :                                 struct rtc_task *task);
     218             : extern int rtc_irq_set_state(struct rtc_device *rtc,
     219             :                                 struct rtc_task *task, int enabled);
     220             : extern int rtc_irq_set_freq(struct rtc_device *rtc,
     221             :                                 struct rtc_task *task, int freq);
     222             : extern int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled);
     223             : extern int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled);
     224             : extern int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc,
     225           1 :                                                 unsigned int enabled);
     226             : 
     227             : typedef struct rtc_task {
     228             :         void (*func)(void *private_data);
     229             :         void *private_data;
     230             : } rtc_task_t;
     231             : 
     232             : int rtc_register(rtc_task_t *task);
     233             : int rtc_unregister(rtc_task_t *task);
     234             : int rtc_control(rtc_task_t *t, unsigned int cmd, unsigned long arg);
     235             : 
     236             : static inline bool is_leap_year(unsigned int year)
     237             : {
     238             :         return (!(year % 4) && (year % 100)) || !(year % 400);
     239             : }
     240             : 
     241             : #endif /* __KERNEL__ */
     242             : 
     243             : #endif /* _LINUX_RTC_H_ */

Generated by: LCOV version 1.10