drivers/rtc/rtc-pcap.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *  pcap rtc code for Motorola EZX phones
0004  *
0005  *  Copyright (c) 2008 guiming zhuo <gmzhuo@gmail.com>
0006  *  Copyright (c) 2009 Daniel Ribeiro <drwyrm@gmail.com>
0007  *
0008  *  Based on Motorola's rtc.c Copyright (c) 2003-2005 Motorola
0009  */
0010
0011 #include <linux/kernel.h>
0012 #include <linux/module.h>
0013 #include <linux/init.h>
0014 #include <linux/mfd/ezx-pcap.h>
0015 #include <linux/rtc.h>
0016 #include <linux/slab.h>
0017 #include <linux/platform_device.h>
0018
0019 struct pcap_rtc {
0020     struct pcap_chip *pcap;
0021     struct rtc_device *rtc;
0022 };
0023
0024 static irqreturn_t pcap_rtc_irq(int irq, void *_pcap_rtc)
0025 {
0026     struct pcap_rtc *pcap_rtc = _pcap_rtc;
0027     unsigned long rtc_events;
0028
0029     if (irq == pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ))
0030         rtc_events = RTC_IRQF | RTC_UF;
0031     else if (irq == pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA))
0032         rtc_events = RTC_IRQF | RTC_AF;
0033     else
0034         rtc_events = 0;
0035
0036     rtc_update_irq(pcap_rtc->rtc, 1, rtc_events);
0037     return IRQ_HANDLED;
0038 }
0039
0040 static int pcap_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0041 {
0042     struct pcap_rtc *pcap_rtc = dev_get_drvdata(dev);
0043     struct rtc_time *tm = &alrm->time;
0044     unsigned long secs;
0045     u32 tod;    /* time of day, seconds since midnight */
0046     u32 days;   /* days since 1/1/1970 */
0047
0048     ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_TODA, &tod);
0049     secs = tod & PCAP_RTC_TOD_MASK;
0050
0051     ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_DAYA, &days);
0052     secs += (days & PCAP_RTC_DAY_MASK) * SEC_PER_DAY;
0053
0054     rtc_time64_to_tm(secs, tm);
0055
0056     return 0;
0057 }
0058
0059 static int pcap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0060 {
0061     struct pcap_rtc *pcap_rtc = dev_get_drvdata(dev);
0062     unsigned long secs = rtc_tm_to_time64(&alrm->time);
0063     u32 tod, days;
0064
0065     tod = secs % SEC_PER_DAY;
0066     ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_TODA, tod);
0067
0068     days = secs / SEC_PER_DAY;
0069     ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_DAYA, days);
0070
0071     return 0;
0072 }
0073
0074 static int pcap_rtc_read_time(struct device *dev, struct rtc_time *tm)
0075 {
0076     struct pcap_rtc *pcap_rtc = dev_get_drvdata(dev);
0077     unsigned long secs;
0078     u32 tod, days;
0079
0080     ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_TOD, &tod);
0081     secs = tod & PCAP_RTC_TOD_MASK;
0082
0083     ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_DAY, &days);
0084     secs += (days & PCAP_RTC_DAY_MASK) * SEC_PER_DAY;
0085
0086     rtc_time64_to_tm(secs, tm);
0087
0088     return 0;
0089 }
0090
0091 static int pcap_rtc_set_time(struct device *dev, struct rtc_time *tm)
0092 {
0093     struct pcap_rtc *pcap_rtc = dev_get_drvdata(dev);
0094     unsigned long secs = rtc_tm_to_time64(tm);
0095     u32 tod, days;
0096
0097     tod = secs % SEC_PER_DAY;
0098     ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_TOD, tod);
0099
0100     days = secs / SEC_PER_DAY;
0101     ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_DAY, days);
0102
0103     return 0;
0104 }
0105
0106 static int pcap_rtc_irq_enable(struct device *dev, int pirq, unsigned int en)
0107 {
0108     struct pcap_rtc *pcap_rtc = dev_get_drvdata(dev);
0109
0110     if (en)
0111         enable_irq(pcap_to_irq(pcap_rtc->pcap, pirq));
0112     else
0113         disable_irq(pcap_to_irq(pcap_rtc->pcap, pirq));
0114
0115     return 0;
0116 }
0117
0118 static int pcap_rtc_alarm_irq_enable(struct device *dev, unsigned int en)
0119 {
0120     return pcap_rtc_irq_enable(dev, PCAP_IRQ_TODA, en);
0121 }
0122
0123 static const struct rtc_class_ops pcap_rtc_ops = {
0124     .read_time = pcap_rtc_read_time,
0125     .set_time = pcap_rtc_set_time,
0126     .read_alarm = pcap_rtc_read_alarm,
0127     .set_alarm = pcap_rtc_set_alarm,
0128     .alarm_irq_enable = pcap_rtc_alarm_irq_enable,
0129 };
0130
0131 static int __init pcap_rtc_probe(struct platform_device *pdev)
0132 {
0133     struct pcap_rtc *pcap_rtc;
0134     int timer_irq, alarm_irq;
0135     int err = -ENOMEM;
0136
0137     pcap_rtc = devm_kzalloc(&pdev->dev, sizeof(struct pcap_rtc),
0138                 GFP_KERNEL);
0139     if (!pcap_rtc)
0140         return err;
0141
0142     pcap_rtc->pcap = dev_get_drvdata(pdev->dev.parent);
0143
0144     platform_set_drvdata(pdev, pcap_rtc);
0145
0146     pcap_rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
0147     if (IS_ERR(pcap_rtc->rtc))
0148         return PTR_ERR(pcap_rtc->rtc);
0149
0150     pcap_rtc->rtc->ops = &pcap_rtc_ops;
0151     pcap_rtc->rtc->range_max = (1 << 14) * 86400ULL - 1;
0152
0153     timer_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ);
0154     alarm_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA);
0155
0156     err = devm_request_irq(&pdev->dev, timer_irq, pcap_rtc_irq, 0,
0157                 "RTC Timer", pcap_rtc);
0158     if (err)
0159         return err;
0160
0161     err = devm_request_irq(&pdev->dev, alarm_irq, pcap_rtc_irq, 0,
0162                 "RTC Alarm", pcap_rtc);
0163     if (err)
0164         return err;
0165
0166     return devm_rtc_register_device(pcap_rtc->rtc);
0167 }
0168
0169 static int __exit pcap_rtc_remove(struct platform_device *pdev)
0170 {
0171     return 0;
0172 }
0173
0174 static struct platform_driver pcap_rtc_driver = {
0175     .remove = __exit_p(pcap_rtc_remove),
0176     .driver = {
0177         .name  = "pcap-rtc",
0178     },
0179 };
0180
0181 module_platform_driver_probe(pcap_rtc_driver, pcap_rtc_probe);
0182
0183 MODULE_DESCRIPTION("Motorola pcap rtc driver");
0184 MODULE_AUTHOR("guiming zhuo <gmzhuo@gmail.com>");
0185 MODULE_LICENSE("GPL");