// SPDX-License-Identifier: GPL-2.0+
/*
 * Real Time Clock driver for Conexant Digicolor
 *
 * Copyright (C) 2015 Paradox Innovation Ltd.
 *
 * Author: Baruch Siach <baruch@tkos.co.il>
 */

#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/rtc.h>
#include <linux/of.h>

#define DC_RTC_CONTROL          0x0
#define DC_RTC_TIME             0x8
#define DC_RTC_REFERENCE        0xc
#define DC_RTC_ALARM            0x10
#define DC_RTC_INTFLAG_CLEAR    0x14
#define DC_RTC_INTENABLE        0x16

#define DC_RTC_CMD_MASK         0xf
#define DC_RTC_GO_BUSY          BIT(7)

#define CMD_NOP                 0
#define CMD_RESET               1
#define CMD_WRITE               3
#define CMD_READ                4

#define CMD_DELAY_US            (10*1000)
#define CMD_TIMEOUT_US          (500*CMD_DELAY_US)

struct dc_rtc {
        struct rtc_device       *rtc_dev;
        void __iomem            *regs;
};

static int dc_rtc_cmds(struct dc_rtc *rtc, const u8 *cmds, int len)
{
        u8 val;
        int i, ret;

        for (i = 0; i < len; i++) {
                writeb_relaxed((cmds[i] & DC_RTC_CMD_MASK) | DC_RTC_GO_BUSY,
                               rtc->regs + DC_RTC_CONTROL);
                ret = readb_relaxed_poll_timeout(
                        rtc->regs + DC_RTC_CONTROL, val,
                        !(val & DC_RTC_GO_BUSY), CMD_DELAY_US, CMD_TIMEOUT_US);
                if (ret < 0)
                        return ret;
        }

        return 0;
}

static int dc_rtc_read(struct dc_rtc *rtc, unsigned long *val)
{
        static const u8 read_cmds[] = {CMD_READ, CMD_NOP};
        u32 reference, time1, time2;
        int ret;

        ret = dc_rtc_cmds(rtc, read_cmds, ARRAY_SIZE(read_cmds));
        if (ret < 0)
                return ret;

        reference = readl_relaxed(rtc->regs + DC_RTC_REFERENCE);
        time1 = readl_relaxed(rtc->regs + DC_RTC_TIME);
        /* Read twice to ensure consistency */
        while (1) {
                time2 = readl_relaxed(rtc->regs + DC_RTC_TIME);
                if (time1 == time2)
                        break;
                time1 = time2;
        }

        *val = reference + time1;
        return 0;
}

static int dc_rtc_write(struct dc_rtc *rtc, u32 val)
{
        static const u8 write_cmds[] = {CMD_WRITE, CMD_NOP, CMD_RESET, CMD_NOP};

        writel_relaxed(val, rtc->regs + DC_RTC_REFERENCE);
        return dc_rtc_cmds(rtc, write_cmds, ARRAY_SIZE(write_cmds));
}

static int dc_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
        struct dc_rtc *rtc = dev_get_drvdata(dev);
        unsigned long now;
        int ret;

        ret = dc_rtc_read(rtc, &now);
        if (ret < 0)
                return ret;
        rtc_time64_to_tm(now, tm);

        return 0;
}

static int dc_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
        struct dc_rtc *rtc = dev_get_drvdata(dev);

        return dc_rtc_write(rtc, rtc_tm_to_time64(tm));
}

static int dc_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
        struct dc_rtc *rtc = dev_get_drvdata(dev);
        u32 alarm_reg, reference;
        unsigned long now;
        int ret;

        alarm_reg = readl_relaxed(rtc->regs + DC_RTC_ALARM);
        reference = readl_relaxed(rtc->regs + DC_RTC_REFERENCE);
        rtc_time64_to_tm(reference + alarm_reg, &alarm->time);

        ret = dc_rtc_read(rtc, &now);
        if (ret < 0)
                return ret;

        alarm->pending = alarm_reg + reference > now;
        alarm->enabled = readl_relaxed(rtc->regs + DC_RTC_INTENABLE);

        return 0;
}

static int dc_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
        struct dc_rtc *rtc = dev_get_drvdata(dev);
        time64_t alarm_time;
        u32 reference;

        alarm_time = rtc_tm_to_time64(&alarm->time);

        reference = readl_relaxed(rtc->regs + DC_RTC_REFERENCE);
        writel_relaxed(alarm_time - reference, rtc->regs + DC_RTC_ALARM);

        writeb_relaxed(!!alarm->enabled, rtc->regs + DC_RTC_INTENABLE);

        return 0;
}

static int dc_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
        struct dc_rtc *rtc = dev_get_drvdata(dev);

        writeb_relaxed(!!enabled, rtc->regs + DC_RTC_INTENABLE);

        return 0;
}

static const struct rtc_class_ops dc_rtc_ops = {
        .read_time              = dc_rtc_read_time,
        .set_time               = dc_rtc_set_time,
        .read_alarm             = dc_rtc_read_alarm,
        .set_alarm              = dc_rtc_set_alarm,
        .alarm_irq_enable       = dc_rtc_alarm_irq_enable,
};

static irqreturn_t dc_rtc_irq(int irq, void *dev_id)
{
        struct dc_rtc *rtc = dev_id;

        writeb_relaxed(1, rtc->regs + DC_RTC_INTFLAG_CLEAR);
        rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF);

        return IRQ_HANDLED;
}

static int __init dc_rtc_probe(struct platform_device *pdev)
{
        struct dc_rtc *rtc;
        int irq, ret;

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

        rtc->regs = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(rtc->regs))
                return PTR_ERR(rtc->regs);

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

        irq = platform_get_irq(pdev, 0);
        if (irq < 0)
                return irq;
        ret = devm_request_irq(&pdev->dev, irq, dc_rtc_irq, 0, pdev->name, rtc);
        if (ret < 0)
                return ret;

        platform_set_drvdata(pdev, rtc);

        rtc->rtc_dev->ops = &dc_rtc_ops;
        rtc->rtc_dev->range_max = U32_MAX;

        return devm_rtc_register_device(rtc->rtc_dev);
}

static const __maybe_unused struct of_device_id dc_dt_ids[] = {
        { .compatible = "cnxt,cx92755-rtc" },
        { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, dc_dt_ids);

static struct platform_driver dc_rtc_driver = {
        .driver = {
                .name = "digicolor_rtc",
                .of_match_table = of_match_ptr(dc_dt_ids),
        },
};
module_platform_driver_probe(dc_rtc_driver, dc_rtc_probe);

MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
MODULE_DESCRIPTION("Conexant Digicolor Realtime Clock Driver (RTC)");
MODULE_LICENSE("GPL");