drivers/rtc/rtc-as3722.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * rtc-as3722.c - Real Time Clock driver for ams AS3722 PMICs
0004  *
0005  * Copyright (C) 2013 ams AG
0006  * Copyright (c) 2013, NVIDIA Corporation. All rights reserved.
0007  *
0008  * Author: Florian Lobmaier <florian.lobmaier@ams.com>
0009  * Author: Laxman Dewangan <ldewangan@nvidia.com>
0010  */
0011
0012 #include <linux/bcd.h>
0013 #include <linux/completion.h>
0014 #include <linux/delay.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/ioctl.h>
0017 #include <linux/kernel.h>
0018 #include <linux/module.h>
0019 #include <linux/mfd/as3722.h>
0020 #include <linux/platform_device.h>
0021 #include <linux/rtc.h>
0022 #include <linux/time.h>
0023
0024 #define AS3722_RTC_START_YEAR     2000
0025 struct as3722_rtc {
0026     struct rtc_device   *rtc;
0027     struct device       *dev;
0028     struct as3722       *as3722;
0029     int         alarm_irq;
0030     bool            irq_enable;
0031 };
0032
0033 static void as3722_time_to_reg(u8 *rbuff, struct rtc_time *tm)
0034 {
0035     rbuff[0] = bin2bcd(tm->tm_sec);
0036     rbuff[1] = bin2bcd(tm->tm_min);
0037     rbuff[2] = bin2bcd(tm->tm_hour);
0038     rbuff[3] = bin2bcd(tm->tm_mday);
0039     rbuff[4] = bin2bcd(tm->tm_mon + 1);
0040     rbuff[5] = bin2bcd(tm->tm_year - (AS3722_RTC_START_YEAR - 1900));
0041 }
0042
0043 static void as3722_reg_to_time(u8 *rbuff, struct rtc_time *tm)
0044 {
0045     tm->tm_sec = bcd2bin(rbuff[0] & 0x7F);
0046     tm->tm_min = bcd2bin(rbuff[1] & 0x7F);
0047     tm->tm_hour = bcd2bin(rbuff[2] & 0x3F);
0048     tm->tm_mday = bcd2bin(rbuff[3] & 0x3F);
0049     tm->tm_mon = bcd2bin(rbuff[4] & 0x1F) - 1;
0050     tm->tm_year = (AS3722_RTC_START_YEAR - 1900) + bcd2bin(rbuff[5] & 0x7F);
0051     return;
0052 }
0053
0054 static int as3722_rtc_read_time(struct device *dev, struct rtc_time *tm)
0055 {
0056     struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
0057     struct as3722 *as3722 = as3722_rtc->as3722;
0058     u8 as_time_array[6];
0059     int ret;
0060
0061     ret = as3722_block_read(as3722, AS3722_RTC_SECOND_REG,
0062             6, as_time_array);
0063     if (ret < 0) {
0064         dev_err(dev, "RTC_SECOND reg block read failed %d\n", ret);
0065         return ret;
0066     }
0067     as3722_reg_to_time(as_time_array, tm);
0068     return 0;
0069 }
0070
0071 static int as3722_rtc_set_time(struct device *dev, struct rtc_time *tm)
0072 {
0073     struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
0074     struct as3722 *as3722 = as3722_rtc->as3722;
0075     u8 as_time_array[6];
0076     int ret;
0077
0078     if (tm->tm_year < (AS3722_RTC_START_YEAR - 1900))
0079         return -EINVAL;
0080
0081     as3722_time_to_reg(as_time_array, tm);
0082     ret = as3722_block_write(as3722, AS3722_RTC_SECOND_REG, 6,
0083             as_time_array);
0084     if (ret < 0)
0085         dev_err(dev, "RTC_SECOND reg block write failed %d\n", ret);
0086     return ret;
0087 }
0088
0089 static int as3722_rtc_alarm_irq_enable(struct device *dev,
0090         unsigned int enabled)
0091 {
0092     struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
0093
0094     if (enabled && !as3722_rtc->irq_enable) {
0095         enable_irq(as3722_rtc->alarm_irq);
0096         as3722_rtc->irq_enable = true;
0097     } else if (!enabled && as3722_rtc->irq_enable)  {
0098         disable_irq(as3722_rtc->alarm_irq);
0099         as3722_rtc->irq_enable = false;
0100     }
0101     return 0;
0102 }
0103
0104 static int as3722_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0105 {
0106     struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
0107     struct as3722 *as3722 = as3722_rtc->as3722;
0108     u8 as_time_array[6];
0109     int ret;
0110
0111     ret = as3722_block_read(as3722, AS3722_RTC_ALARM_SECOND_REG, 6,
0112             as_time_array);
0113     if (ret < 0) {
0114         dev_err(dev, "RTC_ALARM_SECOND block read failed %d\n", ret);
0115         return ret;
0116     }
0117
0118     as3722_reg_to_time(as_time_array, &alrm->time);
0119     return 0;
0120 }
0121
0122 static int as3722_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0123 {
0124     struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
0125     struct as3722 *as3722 = as3722_rtc->as3722;
0126     u8 as_time_array[6];
0127     int ret;
0128
0129     if (alrm->time.tm_year < (AS3722_RTC_START_YEAR - 1900))
0130         return -EINVAL;
0131
0132     ret = as3722_rtc_alarm_irq_enable(dev, 0);
0133     if (ret < 0) {
0134         dev_err(dev, "Disable RTC alarm failed\n");
0135         return ret;
0136     }
0137
0138     as3722_time_to_reg(as_time_array, &alrm->time);
0139     ret = as3722_block_write(as3722, AS3722_RTC_ALARM_SECOND_REG, 6,
0140             as_time_array);
0141     if (ret < 0) {
0142         dev_err(dev, "RTC_ALARM_SECOND block write failed %d\n", ret);
0143         return ret;
0144     }
0145
0146     if (alrm->enabled)
0147         ret = as3722_rtc_alarm_irq_enable(dev, alrm->enabled);
0148     return ret;
0149 }
0150
0151 static irqreturn_t as3722_alarm_irq(int irq, void *data)
0152 {
0153     struct as3722_rtc *as3722_rtc = data;
0154
0155     rtc_update_irq(as3722_rtc->rtc, 1, RTC_IRQF | RTC_AF);
0156     return IRQ_HANDLED;
0157 }
0158
0159 static const struct rtc_class_ops as3722_rtc_ops = {
0160     .read_time = as3722_rtc_read_time,
0161     .set_time = as3722_rtc_set_time,
0162     .read_alarm = as3722_rtc_read_alarm,
0163     .set_alarm = as3722_rtc_set_alarm,
0164     .alarm_irq_enable = as3722_rtc_alarm_irq_enable,
0165 };
0166
0167 static int as3722_rtc_probe(struct platform_device *pdev)
0168 {
0169     struct as3722 *as3722 = dev_get_drvdata(pdev->dev.parent);
0170     struct as3722_rtc *as3722_rtc;
0171     int ret;
0172
0173     as3722_rtc = devm_kzalloc(&pdev->dev, sizeof(*as3722_rtc), GFP_KERNEL);
0174     if (!as3722_rtc)
0175         return -ENOMEM;
0176
0177     as3722_rtc->as3722 = as3722;
0178     as3722_rtc->dev = &pdev->dev;
0179     platform_set_drvdata(pdev, as3722_rtc);
0180
0181     /* Enable the RTC to make sure it is running. */
0182     ret = as3722_update_bits(as3722, AS3722_RTC_CONTROL_REG,
0183             AS3722_RTC_ON | AS3722_RTC_ALARM_WAKEUP_EN,
0184             AS3722_RTC_ON | AS3722_RTC_ALARM_WAKEUP_EN);
0185     if (ret < 0) {
0186         dev_err(&pdev->dev, "RTC_CONTROL reg write failed: %d\n", ret);
0187         return ret;
0188     }
0189
0190     device_init_wakeup(&pdev->dev, 1);
0191
0192     as3722_rtc->rtc = devm_rtc_device_register(&pdev->dev, "as3722-rtc",
0193                 &as3722_rtc_ops, THIS_MODULE);
0194     if (IS_ERR(as3722_rtc->rtc)) {
0195         ret = PTR_ERR(as3722_rtc->rtc);
0196         dev_err(&pdev->dev, "RTC register failed: %d\n", ret);
0197         return ret;
0198     }
0199
0200     as3722_rtc->alarm_irq = platform_get_irq(pdev, 0);
0201     dev_info(&pdev->dev, "RTC interrupt %d\n", as3722_rtc->alarm_irq);
0202
0203     ret = devm_request_threaded_irq(&pdev->dev, as3722_rtc->alarm_irq, NULL,
0204             as3722_alarm_irq, IRQF_ONESHOT,
0205             "rtc-alarm", as3722_rtc);
0206     if (ret < 0) {
0207         dev_err(&pdev->dev, "Failed to request alarm IRQ %d: %d\n",
0208                 as3722_rtc->alarm_irq, ret);
0209         return ret;
0210     }
0211     disable_irq(as3722_rtc->alarm_irq);
0212     return 0;
0213 }
0214
0215 #ifdef CONFIG_PM_SLEEP
0216 static int as3722_rtc_suspend(struct device *dev)
0217 {
0218     struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
0219
0220     if (device_may_wakeup(dev))
0221         enable_irq_wake(as3722_rtc->alarm_irq);
0222
0223     return 0;
0224 }
0225
0226 static int as3722_rtc_resume(struct device *dev)
0227 {
0228     struct as3722_rtc *as3722_rtc = dev_get_drvdata(dev);
0229
0230     if (device_may_wakeup(dev))
0231         disable_irq_wake(as3722_rtc->alarm_irq);
0232     return 0;
0233 }
0234 #endif
0235
0236 static SIMPLE_DEV_PM_OPS(as3722_rtc_pm_ops, as3722_rtc_suspend,
0237              as3722_rtc_resume);
0238
0239 static struct platform_driver as3722_rtc_driver = {
0240     .probe = as3722_rtc_probe,
0241     .driver = {
0242         .name = "as3722-rtc",
0243         .pm = &as3722_rtc_pm_ops,
0244     },
0245 };
0246 module_platform_driver(as3722_rtc_driver);
0247
0248 MODULE_DESCRIPTION("RTC driver for AS3722 PMICs");
0249 MODULE_ALIAS("platform:as3722-rtc");
0250 MODULE_AUTHOR("Florian Lobmaier <florian.lobmaier@ams.com>");
0251 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
0252 MODULE_LICENSE("GPL");