drivers/rtc/rtc-max8907.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * RTC driver for Maxim MAX8907
0004  *
0005  * Copyright (c) 2011-2012, NVIDIA Corporation.
0006  *
0007  * Based on drivers/rtc/rtc-max8925.c,
0008  * Copyright (C) 2009-2010 Marvell International Ltd.
0009  */
0010
0011 #include <linux/bcd.h>
0012 #include <linux/i2c.h>
0013 #include <linux/mfd/max8907.h>
0014 #include <linux/module.h>
0015 #include <linux/platform_device.h>
0016 #include <linux/regmap.h>
0017 #include <linux/rtc.h>
0018 #include <linux/slab.h>
0019
0020 enum {
0021     RTC_SEC = 0,
0022     RTC_MIN,
0023     RTC_HOUR,
0024     RTC_WEEKDAY,
0025     RTC_DATE,
0026     RTC_MONTH,
0027     RTC_YEAR1,
0028     RTC_YEAR2,
0029 };
0030
0031 #define TIME_NUM            8
0032 #define ALARM_1SEC          (1 << 7)
0033 #define HOUR_12             (1 << 7)
0034 #define HOUR_AM_PM          (1 << 5)
0035 #define ALARM0_IRQ          (1 << 3)
0036 #define ALARM1_IRQ          (1 << 2)
0037 #define ALARM0_STATUS           (1 << 2)
0038 #define ALARM1_STATUS           (1 << 1)
0039
0040 struct max8907_rtc {
0041     struct max8907      *max8907;
0042     struct regmap       *regmap;
0043     struct rtc_device   *rtc_dev;
0044     int         irq;
0045 };
0046
0047 static irqreturn_t max8907_irq_handler(int irq, void *data)
0048 {
0049     struct max8907_rtc *rtc = data;
0050
0051     regmap_write(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0);
0052
0053     rtc_update_irq(rtc->rtc_dev, 1, RTC_IRQF | RTC_AF);
0054
0055     return IRQ_HANDLED;
0056 }
0057
0058 static void regs_to_tm(u8 *regs, struct rtc_time *tm)
0059 {
0060     tm->tm_year = bcd2bin(regs[RTC_YEAR2]) * 100 +
0061         bcd2bin(regs[RTC_YEAR1]) - 1900;
0062     tm->tm_mon = bcd2bin(regs[RTC_MONTH] & 0x1f) - 1;
0063     tm->tm_mday = bcd2bin(regs[RTC_DATE] & 0x3f);
0064     tm->tm_wday = (regs[RTC_WEEKDAY] & 0x07);
0065     if (regs[RTC_HOUR] & HOUR_12) {
0066         tm->tm_hour = bcd2bin(regs[RTC_HOUR] & 0x01f);
0067         if (tm->tm_hour == 12)
0068             tm->tm_hour = 0;
0069         if (regs[RTC_HOUR] & HOUR_AM_PM)
0070             tm->tm_hour += 12;
0071     } else {
0072         tm->tm_hour = bcd2bin(regs[RTC_HOUR] & 0x03f);
0073     }
0074     tm->tm_min = bcd2bin(regs[RTC_MIN] & 0x7f);
0075     tm->tm_sec = bcd2bin(regs[RTC_SEC] & 0x7f);
0076 }
0077
0078 static void tm_to_regs(struct rtc_time *tm, u8 *regs)
0079 {
0080     u8 high, low;
0081
0082     high = (tm->tm_year + 1900) / 100;
0083     low = tm->tm_year % 100;
0084     regs[RTC_YEAR2] = bin2bcd(high);
0085     regs[RTC_YEAR1] = bin2bcd(low);
0086     regs[RTC_MONTH] = bin2bcd(tm->tm_mon + 1);
0087     regs[RTC_DATE] = bin2bcd(tm->tm_mday);
0088     regs[RTC_WEEKDAY] = tm->tm_wday;
0089     regs[RTC_HOUR] = bin2bcd(tm->tm_hour);
0090     regs[RTC_MIN] = bin2bcd(tm->tm_min);
0091     regs[RTC_SEC] = bin2bcd(tm->tm_sec);
0092 }
0093
0094 static int max8907_rtc_read_time(struct device *dev, struct rtc_time *tm)
0095 {
0096     struct max8907_rtc *rtc = dev_get_drvdata(dev);
0097     u8 regs[TIME_NUM];
0098     int ret;
0099
0100     ret = regmap_bulk_read(rtc->regmap, MAX8907_REG_RTC_SEC, regs,
0101                    TIME_NUM);
0102     if (ret < 0)
0103         return ret;
0104
0105     regs_to_tm(regs, tm);
0106
0107     return 0;
0108 }
0109
0110 static int max8907_rtc_set_time(struct device *dev, struct rtc_time *tm)
0111 {
0112     struct max8907_rtc *rtc = dev_get_drvdata(dev);
0113     u8 regs[TIME_NUM];
0114
0115     tm_to_regs(tm, regs);
0116
0117     return regmap_bulk_write(rtc->regmap, MAX8907_REG_RTC_SEC, regs,
0118                  TIME_NUM);
0119 }
0120
0121 static int max8907_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0122 {
0123     struct max8907_rtc *rtc = dev_get_drvdata(dev);
0124     u8 regs[TIME_NUM];
0125     unsigned int val;
0126     int ret;
0127
0128     ret = regmap_bulk_read(rtc->regmap, MAX8907_REG_ALARM0_SEC, regs,
0129                    TIME_NUM);
0130     if (ret < 0)
0131         return ret;
0132
0133     regs_to_tm(regs, &alrm->time);
0134
0135     ret = regmap_read(rtc->regmap, MAX8907_REG_ALARM0_CNTL, &val);
0136     if (ret < 0)
0137         return ret;
0138
0139     alrm->enabled = !!(val & 0x7f);
0140
0141     return 0;
0142 }
0143
0144 static int max8907_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0145 {
0146     struct max8907_rtc *rtc = dev_get_drvdata(dev);
0147     u8 regs[TIME_NUM];
0148     int ret;
0149
0150     tm_to_regs(&alrm->time, regs);
0151
0152     /* Disable alarm while we update the target time */
0153     ret = regmap_write(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0);
0154     if (ret < 0)
0155         return ret;
0156
0157     ret = regmap_bulk_write(rtc->regmap, MAX8907_REG_ALARM0_SEC, regs,
0158                 TIME_NUM);
0159     if (ret < 0)
0160         return ret;
0161
0162     if (alrm->enabled)
0163         ret = regmap_write(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0x77);
0164
0165     return ret;
0166 }
0167
0168 static const struct rtc_class_ops max8907_rtc_ops = {
0169     .read_time  = max8907_rtc_read_time,
0170     .set_time   = max8907_rtc_set_time,
0171     .read_alarm = max8907_rtc_read_alarm,
0172     .set_alarm  = max8907_rtc_set_alarm,
0173 };
0174
0175 static int max8907_rtc_probe(struct platform_device *pdev)
0176 {
0177     struct max8907 *max8907 = dev_get_drvdata(pdev->dev.parent);
0178     struct max8907_rtc *rtc;
0179     int ret;
0180
0181     rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
0182     if (!rtc)
0183         return -ENOMEM;
0184     platform_set_drvdata(pdev, rtc);
0185
0186     rtc->max8907 = max8907;
0187     rtc->regmap = max8907->regmap_rtc;
0188
0189     rtc->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8907-rtc",
0190                     &max8907_rtc_ops, THIS_MODULE);
0191     if (IS_ERR(rtc->rtc_dev)) {
0192         ret = PTR_ERR(rtc->rtc_dev);
0193         dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
0194         return ret;
0195     }
0196
0197     rtc->irq = regmap_irq_get_virq(max8907->irqc_rtc,
0198                        MAX8907_IRQ_RTC_ALARM0);
0199     if (rtc->irq < 0)
0200         return rtc->irq;
0201
0202     ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL,
0203                 max8907_irq_handler,
0204                 IRQF_ONESHOT, "max8907-alarm0", rtc);
0205     if (ret < 0)
0206         dev_err(&pdev->dev, "Failed to request IRQ%d: %d\n",
0207             rtc->irq, ret);
0208
0209     return ret;
0210 }
0211
0212 static struct platform_driver max8907_rtc_driver = {
0213     .driver = {
0214         .name = "max8907-rtc",
0215     },
0216     .probe = max8907_rtc_probe,
0217 };
0218 module_platform_driver(max8907_rtc_driver);
0219
0220 MODULE_DESCRIPTION("Maxim MAX8907 RTC driver");
0221 MODULE_LICENSE("GPL v2");