drivers/rtc/pl031.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2008
   4  * Gururaja Hebbar gururajakr@sanyo.co.in
   5  *
   6  * reference linux-2.6.20.6/drivers/rtc/rtc-pl031.c
   7  */
   8
   9 #include <common.h>
  10 #include <command.h>
  11 #include <dm.h>
  12 #include <errno.h>
  13 #include <log.h>
  14 #include <rtc.h>
  15 #include <asm/io.h>
  16 #include <asm/types.h>
  17
  18 /*
  19  * Register definitions
  20  */
  21 #define RTC_DR          0x00    /* Data read register */
  22 #define RTC_MR          0x04    /* Match register */
  23 #define RTC_LR          0x08    /* Data load register */
  24 #define RTC_CR          0x0c    /* Control register */
  25 #define RTC_IMSC        0x10    /* Interrupt mask and set register */
  26 #define RTC_RIS         0x14    /* Raw interrupt status register */
  27 #define RTC_MIS         0x18    /* Masked interrupt status register */
  28 #define RTC_ICR         0x1c    /* Interrupt clear register */
  29
  30 #define RTC_CR_START    (1 << 0)
  31
  32 struct pl031_platdata {
  33         phys_addr_t base;
  34 };
  35
  36 static inline u32 pl031_read_reg(struct udevice *dev, int reg)
  37 {
  38         struct pl031_platdata *pdata = dev_get_platdata(dev);
  39
  40         return readl(pdata->base + reg);
  41 }
  42
  43 static inline u32 pl031_write_reg(struct udevice *dev, int reg, u32 value)
  44 {
  45         struct pl031_platdata *pdata = dev_get_platdata(dev);
  46
  47         return writel(value, pdata->base + reg);
  48 }
  49
  50 /*
  51  * Probe RTC device
  52  */
  53 static int pl031_probe(struct udevice *dev)
  54 {
  55         /* Enable RTC Start in Control register*/
  56         pl031_write_reg(dev, RTC_CR, RTC_CR_START);
  57
  58         return 0;
  59 }
  60
  61 /*
  62  * Get the current time from the RTC
  63  */
  64 static int pl031_get(struct udevice *dev, struct rtc_time *tm)
  65 {
  66         unsigned long tim;
  67
  68         if (!tm)
  69                 return -EINVAL;
  70
  71         tim = pl031_read_reg(dev, RTC_DR);
  72
  73         rtc_to_tm(tim, tm);
  74
  75         debug("Get DATE: %4d-%02d-%02d (wday=%d)  TIME: %2d:%02d:%02d\n",
  76               tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_wday,
  77               tm->tm_hour, tm->tm_min, tm->tm_sec);
  78
  79         return 0;
  80 }
  81
  82 /*
  83  * Set the RTC
  84  */
  85 static int pl031_set(struct udevice *dev, const struct rtc_time *tm)
  86 {
  87         unsigned long tim;
  88
  89         if (!tm)
  90                 return -EINVAL;
  91
  92         debug("Set DATE: %4d-%02d-%02d (wday=%d)  TIME: %2d:%02d:%02d\n",
  93               tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_wday,
  94               tm->tm_hour, tm->tm_min, tm->tm_sec);
  95
  96         /* Calculate number of seconds this incoming time represents */
  97         tim = rtc_mktime(tm);
  98
  99         pl031_write_reg(dev, RTC_LR, tim);
 100
 101         return 0;
 102 }
 103
 104 /*
 105  * Reset the RTC. We set the date back to 1970-01-01.
 106  */
 107 static int pl031_reset(struct udevice *dev)
 108 {
 109         pl031_write_reg(dev, RTC_LR, 0);
 110
 111         return 0;
 112 }
 113
 114 static const struct rtc_ops pl031_ops = {
 115         .get = pl031_get,
 116         .set = pl031_set,
 117         .reset = pl031_reset,
 118 };
 119
 120 static const struct udevice_id pl031_ids[] = {
 121         { .compatible = "arm,pl031" },
 122         { }
 123 };
 124
 125 static int pl031_ofdata_to_platdata(struct udevice *dev)
 126 {
 127         struct pl031_platdata *pdata = dev_get_platdata(dev);
 128
 129         pdata->base = dev_read_addr(dev);
 130
 131         return 0;
 132 }
 133
 134 U_BOOT_DRIVER(rtc_pl031) = {
 135         .name   = "rtc-pl031",
 136         .id     = UCLASS_RTC,
 137         .of_match = pl031_ids,
 138         .probe  = pl031_probe,
 139         .ofdata_to_platdata = pl031_ofdata_to_platdata,
 140         .platdata_auto_alloc_size = sizeof(struct pl031_platdata),
 141         .ops    = &pl031_ops,
 142 };