Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * DS1286 Real Time Clock interface for Linux
0004  *
0005  * Copyright (C) 1998, 1999, 2000 Ralf Baechle
0006  * Copyright (C) 2008 Thomas Bogendoerfer
0007  *
0008  * Based on code written by Paul Gortmaker.
0009  */
0010 
0011 #include <linux/module.h>
0012 #include <linux/rtc.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/bcd.h>
0015 #include <linux/rtc/ds1286.h>
0016 #include <linux/io.h>
0017 #include <linux/slab.h>
0018 
0019 struct ds1286_priv {
0020     struct rtc_device *rtc;
0021     u32 __iomem *rtcregs;
0022     spinlock_t lock;
0023 };
0024 
0025 static inline u8 ds1286_rtc_read(struct ds1286_priv *priv, int reg)
0026 {
0027     return __raw_readl(&priv->rtcregs[reg]) & 0xff;
0028 }
0029 
0030 static inline void ds1286_rtc_write(struct ds1286_priv *priv, u8 data, int reg)
0031 {
0032     __raw_writel(data, &priv->rtcregs[reg]);
0033 }
0034 
0035 
0036 static int ds1286_alarm_irq_enable(struct device *dev, unsigned int enabled)
0037 {
0038     struct ds1286_priv *priv = dev_get_drvdata(dev);
0039     unsigned long flags;
0040     unsigned char val;
0041 
0042     /* Allow or mask alarm interrupts */
0043     spin_lock_irqsave(&priv->lock, flags);
0044     val = ds1286_rtc_read(priv, RTC_CMD);
0045     if (enabled)
0046         val &=  ~RTC_TDM;
0047     else
0048         val |=  RTC_TDM;
0049     ds1286_rtc_write(priv, val, RTC_CMD);
0050     spin_unlock_irqrestore(&priv->lock, flags);
0051 
0052     return 0;
0053 }
0054 
0055 #ifdef CONFIG_RTC_INTF_DEV
0056 
0057 static int ds1286_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
0058 {
0059     struct ds1286_priv *priv = dev_get_drvdata(dev);
0060     unsigned long flags;
0061     unsigned char val;
0062 
0063     switch (cmd) {
0064     case RTC_WIE_OFF:
0065         /* Mask watchdog int. enab. bit */
0066         spin_lock_irqsave(&priv->lock, flags);
0067         val = ds1286_rtc_read(priv, RTC_CMD);
0068         val |= RTC_WAM;
0069         ds1286_rtc_write(priv, val, RTC_CMD);
0070         spin_unlock_irqrestore(&priv->lock, flags);
0071         break;
0072     case RTC_WIE_ON:
0073         /* Allow watchdog interrupts.   */
0074         spin_lock_irqsave(&priv->lock, flags);
0075         val = ds1286_rtc_read(priv, RTC_CMD);
0076         val &= ~RTC_WAM;
0077         ds1286_rtc_write(priv, val, RTC_CMD);
0078         spin_unlock_irqrestore(&priv->lock, flags);
0079         break;
0080     default:
0081         return -ENOIOCTLCMD;
0082     }
0083     return 0;
0084 }
0085 
0086 #else
0087 #define ds1286_ioctl    NULL
0088 #endif
0089 
0090 #ifdef CONFIG_PROC_FS
0091 
0092 static int ds1286_proc(struct device *dev, struct seq_file *seq)
0093 {
0094     struct ds1286_priv *priv = dev_get_drvdata(dev);
0095     unsigned char month, cmd, amode;
0096     const char *s;
0097 
0098     month = ds1286_rtc_read(priv, RTC_MONTH);
0099     seq_printf(seq,
0100            "oscillator\t: %s\n"
0101            "square_wave\t: %s\n",
0102            (month & RTC_EOSC) ? "disabled" : "enabled",
0103            (month & RTC_ESQW) ? "disabled" : "enabled");
0104 
0105     amode = ((ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x80) >> 5) |
0106         ((ds1286_rtc_read(priv, RTC_HOURS_ALARM) & 0x80) >> 6) |
0107         ((ds1286_rtc_read(priv, RTC_DAY_ALARM) & 0x80) >> 7);
0108     switch (amode) {
0109     case 7:
0110         s = "each minute";
0111         break;
0112     case 3:
0113         s = "minutes match";
0114         break;
0115     case 1:
0116         s = "hours and minutes match";
0117         break;
0118     case 0:
0119         s = "days, hours and minutes match";
0120         break;
0121     default:
0122         s = "invalid";
0123         break;
0124     }
0125     seq_printf(seq, "alarm_mode\t: %s\n", s);
0126 
0127     cmd = ds1286_rtc_read(priv, RTC_CMD);
0128     seq_printf(seq,
0129            "alarm_enable\t: %s\n"
0130            "wdog_alarm\t: %s\n"
0131            "alarm_mask\t: %s\n"
0132            "wdog_alarm_mask\t: %s\n"
0133            "interrupt_mode\t: %s\n"
0134            "INTB_mode\t: %s_active\n"
0135            "interrupt_pins\t: %s\n",
0136            (cmd & RTC_TDF) ? "yes" : "no",
0137            (cmd & RTC_WAF) ? "yes" : "no",
0138            (cmd & RTC_TDM) ? "disabled" : "enabled",
0139            (cmd & RTC_WAM) ? "disabled" : "enabled",
0140            (cmd & RTC_PU_LVL) ? "pulse" : "level",
0141            (cmd & RTC_IBH_LO) ? "low" : "high",
0142            (cmd & RTC_IPSW) ? "unswapped" : "swapped");
0143     return 0;
0144 }
0145 
0146 #else
0147 #define ds1286_proc     NULL
0148 #endif
0149 
0150 static int ds1286_read_time(struct device *dev, struct rtc_time *tm)
0151 {
0152     struct ds1286_priv *priv = dev_get_drvdata(dev);
0153     unsigned char save_control;
0154     unsigned long flags;
0155     unsigned long uip_watchdog = jiffies;
0156 
0157     /*
0158      * read RTC once any update in progress is done. The update
0159      * can take just over 2ms. We wait 10 to 20ms. There is no need to
0160      * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
0161      * If you need to know *exactly* when a second has started, enable
0162      * periodic update complete interrupts, (via ioctl) and then
0163      * immediately read /dev/rtc which will block until you get the IRQ.
0164      * Once the read clears, read the RTC time (again via ioctl). Easy.
0165      */
0166 
0167     if (ds1286_rtc_read(priv, RTC_CMD) & RTC_TE)
0168         while (time_before(jiffies, uip_watchdog + 2*HZ/100))
0169             barrier();
0170 
0171     /*
0172      * Only the values that we read from the RTC are set. We leave
0173      * tm_wday, tm_yday and tm_isdst untouched. Even though the
0174      * RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated
0175      * by the RTC when initially set to a non-zero value.
0176      */
0177     spin_lock_irqsave(&priv->lock, flags);
0178     save_control = ds1286_rtc_read(priv, RTC_CMD);
0179     ds1286_rtc_write(priv, (save_control|RTC_TE), RTC_CMD);
0180 
0181     tm->tm_sec = ds1286_rtc_read(priv, RTC_SECONDS);
0182     tm->tm_min = ds1286_rtc_read(priv, RTC_MINUTES);
0183     tm->tm_hour = ds1286_rtc_read(priv, RTC_HOURS) & 0x3f;
0184     tm->tm_mday = ds1286_rtc_read(priv, RTC_DATE);
0185     tm->tm_mon = ds1286_rtc_read(priv, RTC_MONTH) & 0x1f;
0186     tm->tm_year = ds1286_rtc_read(priv, RTC_YEAR);
0187 
0188     ds1286_rtc_write(priv, save_control, RTC_CMD);
0189     spin_unlock_irqrestore(&priv->lock, flags);
0190 
0191     tm->tm_sec = bcd2bin(tm->tm_sec);
0192     tm->tm_min = bcd2bin(tm->tm_min);
0193     tm->tm_hour = bcd2bin(tm->tm_hour);
0194     tm->tm_mday = bcd2bin(tm->tm_mday);
0195     tm->tm_mon = bcd2bin(tm->tm_mon);
0196     tm->tm_year = bcd2bin(tm->tm_year);
0197 
0198     /*
0199      * Account for differences between how the RTC uses the values
0200      * and how they are defined in a struct rtc_time;
0201      */
0202     if (tm->tm_year < 45)
0203         tm->tm_year += 30;
0204     tm->tm_year += 40;
0205     if (tm->tm_year < 70)
0206         tm->tm_year += 100;
0207 
0208     tm->tm_mon--;
0209 
0210     return 0;
0211 }
0212 
0213 static int ds1286_set_time(struct device *dev, struct rtc_time *tm)
0214 {
0215     struct ds1286_priv *priv = dev_get_drvdata(dev);
0216     unsigned char mon, day, hrs, min, sec;
0217     unsigned char save_control;
0218     unsigned int yrs;
0219     unsigned long flags;
0220 
0221     yrs = tm->tm_year + 1900;
0222     mon = tm->tm_mon + 1;   /* tm_mon starts at zero */
0223     day = tm->tm_mday;
0224     hrs = tm->tm_hour;
0225     min = tm->tm_min;
0226     sec = tm->tm_sec;
0227 
0228     if (yrs < 1970)
0229         return -EINVAL;
0230 
0231     yrs -= 1940;
0232     if (yrs > 255)    /* They are unsigned */
0233         return -EINVAL;
0234 
0235     if (yrs >= 100)
0236         yrs -= 100;
0237 
0238     sec = bin2bcd(sec);
0239     min = bin2bcd(min);
0240     hrs = bin2bcd(hrs);
0241     day = bin2bcd(day);
0242     mon = bin2bcd(mon);
0243     yrs = bin2bcd(yrs);
0244 
0245     spin_lock_irqsave(&priv->lock, flags);
0246     save_control = ds1286_rtc_read(priv, RTC_CMD);
0247     ds1286_rtc_write(priv, (save_control|RTC_TE), RTC_CMD);
0248 
0249     ds1286_rtc_write(priv, yrs, RTC_YEAR);
0250     ds1286_rtc_write(priv, mon, RTC_MONTH);
0251     ds1286_rtc_write(priv, day, RTC_DATE);
0252     ds1286_rtc_write(priv, hrs, RTC_HOURS);
0253     ds1286_rtc_write(priv, min, RTC_MINUTES);
0254     ds1286_rtc_write(priv, sec, RTC_SECONDS);
0255     ds1286_rtc_write(priv, 0, RTC_HUNDREDTH_SECOND);
0256 
0257     ds1286_rtc_write(priv, save_control, RTC_CMD);
0258     spin_unlock_irqrestore(&priv->lock, flags);
0259     return 0;
0260 }
0261 
0262 static int ds1286_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
0263 {
0264     struct ds1286_priv *priv = dev_get_drvdata(dev);
0265     unsigned long flags;
0266 
0267     /*
0268      * Only the values that we read from the RTC are set. That
0269      * means only tm_wday, tm_hour, tm_min.
0270      */
0271     spin_lock_irqsave(&priv->lock, flags);
0272     alm->time.tm_min = ds1286_rtc_read(priv, RTC_MINUTES_ALARM) & 0x7f;
0273     alm->time.tm_hour = ds1286_rtc_read(priv, RTC_HOURS_ALARM)  & 0x1f;
0274     alm->time.tm_wday = ds1286_rtc_read(priv, RTC_DAY_ALARM)    & 0x07;
0275     ds1286_rtc_read(priv, RTC_CMD);
0276     spin_unlock_irqrestore(&priv->lock, flags);
0277 
0278     alm->time.tm_min = bcd2bin(alm->time.tm_min);
0279     alm->time.tm_hour = bcd2bin(alm->time.tm_hour);
0280     alm->time.tm_sec = 0;
0281     return 0;
0282 }
0283 
0284 static int ds1286_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
0285 {
0286     struct ds1286_priv *priv = dev_get_drvdata(dev);
0287     unsigned char hrs, min, sec;
0288 
0289     hrs = alm->time.tm_hour;
0290     min = alm->time.tm_min;
0291     sec = alm->time.tm_sec;
0292 
0293     if (hrs >= 24)
0294         hrs = 0xff;
0295 
0296     if (min >= 60)
0297         min = 0xff;
0298 
0299     if (sec != 0)
0300         return -EINVAL;
0301 
0302     min = bin2bcd(min);
0303     hrs = bin2bcd(hrs);
0304 
0305     spin_lock(&priv->lock);
0306     ds1286_rtc_write(priv, hrs, RTC_HOURS_ALARM);
0307     ds1286_rtc_write(priv, min, RTC_MINUTES_ALARM);
0308     spin_unlock(&priv->lock);
0309 
0310     return 0;
0311 }
0312 
0313 static const struct rtc_class_ops ds1286_ops = {
0314     .ioctl      = ds1286_ioctl,
0315     .proc       = ds1286_proc,
0316     .read_time  = ds1286_read_time,
0317     .set_time   = ds1286_set_time,
0318     .read_alarm = ds1286_read_alarm,
0319     .set_alarm  = ds1286_set_alarm,
0320     .alarm_irq_enable = ds1286_alarm_irq_enable,
0321 };
0322 
0323 static int ds1286_probe(struct platform_device *pdev)
0324 {
0325     struct rtc_device *rtc;
0326     struct ds1286_priv *priv;
0327 
0328     priv = devm_kzalloc(&pdev->dev, sizeof(struct ds1286_priv), GFP_KERNEL);
0329     if (!priv)
0330         return -ENOMEM;
0331 
0332     priv->rtcregs = devm_platform_ioremap_resource(pdev, 0);
0333     if (IS_ERR(priv->rtcregs))
0334         return PTR_ERR(priv->rtcregs);
0335 
0336     spin_lock_init(&priv->lock);
0337     platform_set_drvdata(pdev, priv);
0338     rtc = devm_rtc_device_register(&pdev->dev, "ds1286", &ds1286_ops,
0339                     THIS_MODULE);
0340     if (IS_ERR(rtc))
0341         return PTR_ERR(rtc);
0342     priv->rtc = rtc;
0343     return 0;
0344 }
0345 
0346 static struct platform_driver ds1286_platform_driver = {
0347     .driver     = {
0348         .name   = "rtc-ds1286",
0349     },
0350     .probe      = ds1286_probe,
0351 };
0352 
0353 module_platform_driver(ds1286_platform_driver);
0354 
0355 MODULE_AUTHOR("Thomas Bogendoerfer <tsbogend@alpha.franken.de>");
0356 MODULE_DESCRIPTION("DS1286 RTC driver");
0357 MODULE_LICENSE("GPL");
0358 MODULE_ALIAS("platform:rtc-ds1286");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!