// SPDX-License-Identifier: GPL-2.0
/* drivers/rtc/rtc-goldfish.c
 *
 * Copyright (C) 2007 Google, Inc.
 * Copyright (C) 2017 Imagination Technologies Ltd.
 */

#include <linux/io.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/rtc.h>
#include <linux/goldfish.h>
#include <clocksource/timer-goldfish.h>

struct goldfish_rtc {
        void __iomem *base;
        int irq;
        struct rtc_device *rtc;
};

static int goldfish_rtc_read_alarm(struct device *dev,
                                   struct rtc_wkalrm *alrm)
{
        u64 rtc_alarm;
        u64 rtc_alarm_low;
        u64 rtc_alarm_high;
        void __iomem *base;
        struct goldfish_rtc *rtcdrv;

        rtcdrv = dev_get_drvdata(dev);
        base = rtcdrv->base;

        rtc_alarm_low = gf_ioread32(base + TIMER_ALARM_LOW);
        rtc_alarm_high = gf_ioread32(base + TIMER_ALARM_HIGH);
        rtc_alarm = (rtc_alarm_high << 32) | rtc_alarm_low;

        do_div(rtc_alarm, NSEC_PER_SEC);
        memset(alrm, 0, sizeof(struct rtc_wkalrm));

        rtc_time64_to_tm(rtc_alarm, &alrm->time);

        if (gf_ioread32(base + TIMER_ALARM_STATUS))
                alrm->enabled = 1;
        else
                alrm->enabled = 0;

        return 0;
}

static int goldfish_rtc_set_alarm(struct device *dev,
                                  struct rtc_wkalrm *alrm)
{
        struct goldfish_rtc *rtcdrv;
        u64 rtc_alarm64;
        u64 rtc_status_reg;
        void __iomem *base;

        rtcdrv = dev_get_drvdata(dev);
        base = rtcdrv->base;

        if (alrm->enabled) {
                rtc_alarm64 = rtc_tm_to_time64(&alrm->time) * NSEC_PER_SEC;
                gf_iowrite32((rtc_alarm64 >> 32), base + TIMER_ALARM_HIGH);
                gf_iowrite32(rtc_alarm64, base + TIMER_ALARM_LOW);
                gf_iowrite32(1, base + TIMER_IRQ_ENABLED);
        } else {
                /*
                 * if this function was called with enabled=0
                 * then it could mean that the application is
                 * trying to cancel an ongoing alarm
                 */
                rtc_status_reg = gf_ioread32(base + TIMER_ALARM_STATUS);
                if (rtc_status_reg)
                        gf_iowrite32(1, base + TIMER_CLEAR_ALARM);
        }

        return 0;
}

static int goldfish_rtc_alarm_irq_enable(struct device *dev,
                                         unsigned int enabled)
{
        void __iomem *base;
        struct goldfish_rtc *rtcdrv;

        rtcdrv = dev_get_drvdata(dev);
        base = rtcdrv->base;

        if (enabled)
                gf_iowrite32(1, base + TIMER_IRQ_ENABLED);
        else
                gf_iowrite32(0, base + TIMER_IRQ_ENABLED);

        return 0;
}

static irqreturn_t goldfish_rtc_interrupt(int irq, void *dev_id)
{
        struct goldfish_rtc *rtcdrv = dev_id;
        void __iomem *base = rtcdrv->base;

        gf_iowrite32(1, base + TIMER_CLEAR_INTERRUPT);

        rtc_update_irq(rtcdrv->rtc, 1, RTC_IRQF | RTC_AF);

        return IRQ_HANDLED;
}

static int goldfish_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
        struct goldfish_rtc *rtcdrv;
        void __iomem *base;
        u64 time_high;
        u64 time_low;
        u64 time;

        rtcdrv = dev_get_drvdata(dev);
        base = rtcdrv->base;

        time_low = gf_ioread32(base + TIMER_TIME_LOW);
        time_high = gf_ioread32(base + TIMER_TIME_HIGH);
        time = (time_high << 32) | time_low;

        do_div(time, NSEC_PER_SEC);

        rtc_time64_to_tm(time, tm);

        return 0;
}

static int goldfish_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
        struct goldfish_rtc *rtcdrv;
        void __iomem *base;
        u64 now64;

        rtcdrv = dev_get_drvdata(dev);
        base = rtcdrv->base;

        now64 = rtc_tm_to_time64(tm) * NSEC_PER_SEC;
        gf_iowrite32((now64 >> 32), base + TIMER_TIME_HIGH);
        gf_iowrite32(now64, base + TIMER_TIME_LOW);

        return 0;
}

static const struct rtc_class_ops goldfish_rtc_ops = {
        .read_time      = goldfish_rtc_read_time,
        .set_time       = goldfish_rtc_set_time,
        .read_alarm     = goldfish_rtc_read_alarm,
        .set_alarm      = goldfish_rtc_set_alarm,
        .alarm_irq_enable = goldfish_rtc_alarm_irq_enable
};

static int goldfish_rtc_probe(struct platform_device *pdev)
{
        struct goldfish_rtc *rtcdrv;
        int err;

        rtcdrv = devm_kzalloc(&pdev->dev, sizeof(*rtcdrv), GFP_KERNEL);
        if (!rtcdrv)
                return -ENOMEM;

        platform_set_drvdata(pdev, rtcdrv);
        rtcdrv->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(rtcdrv->base))
                return PTR_ERR(rtcdrv->base);

        rtcdrv->irq = platform_get_irq(pdev, 0);
        if (rtcdrv->irq < 0)
                return -ENODEV;

        rtcdrv->rtc = devm_rtc_allocate_device(&pdev->dev);
        if (IS_ERR(rtcdrv->rtc))
                return PTR_ERR(rtcdrv->rtc);

        rtcdrv->rtc->ops = &goldfish_rtc_ops;
        rtcdrv->rtc->range_max = U64_MAX / NSEC_PER_SEC;

        err = devm_request_irq(&pdev->dev, rtcdrv->irq,
                               goldfish_rtc_interrupt,
                               0, pdev->name, rtcdrv);
        if (err)
                return err;

        return devm_rtc_register_device(rtcdrv->rtc);
}

static const struct of_device_id goldfish_rtc_of_match[] = {
        { .compatible = "google,goldfish-rtc", },
        {},
};
MODULE_DEVICE_TABLE(of, goldfish_rtc_of_match);

static struct platform_driver goldfish_rtc = {
        .probe = goldfish_rtc_probe,
        .driver = {
                .name = "goldfish_rtc",
                .of_match_table = goldfish_rtc_of_match,
        }
};

module_platform_driver(goldfish_rtc);

MODULE_DESCRIPTION("Android Goldfish Real Time Clock driver");
MODULE_LICENSE("GPL v2");