// SPDX-License-Identifier: GPL-2.0
/*
 * simple driver for PWM (Pulse Width Modulator) controller
 *
 * Derived from pxa PWM driver by eric miao <eric.miao@marvell.com>
 */

#include <linux/bitfield.h>
#include <linux/bitops.h>
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/pwm.h>
#include <linux/slab.h>

#define MX1_PWMC                        0x00   /* PWM Control Register */
#define MX1_PWMS                        0x04   /* PWM Sample Register */
#define MX1_PWMP                        0x08   /* PWM Period Register */

#define MX1_PWMC_EN                     BIT(4)

struct pwm_imx1_chip {
        struct clk *clk_ipg;
        struct clk *clk_per;
        void __iomem *mmio_base;
};

static inline struct pwm_imx1_chip *to_pwm_imx1_chip(struct pwm_chip *chip)
{
        return pwmchip_get_drvdata(chip);
}

static int pwm_imx1_clk_prepare_enable(struct pwm_chip *chip)
{
        struct pwm_imx1_chip *imx = to_pwm_imx1_chip(chip);
        int ret;

        ret = clk_prepare_enable(imx->clk_ipg);
        if (ret)
                return ret;

        ret = clk_prepare_enable(imx->clk_per);
        if (ret) {
                clk_disable_unprepare(imx->clk_ipg);
                return ret;
        }

        return 0;
}

static void pwm_imx1_clk_disable_unprepare(struct pwm_chip *chip)
{
        struct pwm_imx1_chip *imx = to_pwm_imx1_chip(chip);

        clk_disable_unprepare(imx->clk_per);
        clk_disable_unprepare(imx->clk_ipg);
}

static int pwm_imx1_config(struct pwm_chip *chip,
                           struct pwm_device *pwm, u64 duty_ns, u64 period_ns)
{
        struct pwm_imx1_chip *imx = to_pwm_imx1_chip(chip);
        u32 max, p;

        /*
         * The PWM subsystem allows for exact frequencies. However,
         * I cannot connect a scope on my device to the PWM line and
         * thus cannot provide the program the PWM controller
         * exactly. Instead, I'm relying on the fact that the
         * Bootloader (u-boot or WinCE+haret) has programmed the PWM
         * function group already. So I'll just modify the PWM sample
         * register to follow the ratio of duty_ns vs. period_ns
         * accordingly.
         *
         * This is good enough for programming the brightness of
         * the LCD backlight.
         *
         * The real implementation would divide PERCLK[0] first by
         * both the prescaler (/1 .. /128) and then by CLKSEL
         * (/2 .. /16).
         */
        max = readl(imx->mmio_base + MX1_PWMP);
        p = mul_u64_u64_div_u64(max, duty_ns, period_ns);

        writel(max - p, imx->mmio_base + MX1_PWMS);

        return 0;
}

static int pwm_imx1_enable(struct pwm_chip *chip, struct pwm_device *pwm)
{
        struct pwm_imx1_chip *imx = to_pwm_imx1_chip(chip);
        u32 value;
        int ret;

        ret = pwm_imx1_clk_prepare_enable(chip);
        if (ret < 0)
                return ret;

        value = readl(imx->mmio_base + MX1_PWMC);
        value |= MX1_PWMC_EN;
        writel(value, imx->mmio_base + MX1_PWMC);

        return 0;
}

static void pwm_imx1_disable(struct pwm_chip *chip, struct pwm_device *pwm)
{
        struct pwm_imx1_chip *imx = to_pwm_imx1_chip(chip);
        u32 value;

        value = readl(imx->mmio_base + MX1_PWMC);
        value &= ~MX1_PWMC_EN;
        writel(value, imx->mmio_base + MX1_PWMC);

        pwm_imx1_clk_disable_unprepare(chip);
}

static int pwm_imx1_apply(struct pwm_chip *chip, struct pwm_device *pwm,
                          const struct pwm_state *state)
{
        int err;

        if (state->polarity != PWM_POLARITY_NORMAL)
                return -EINVAL;

        if (!state->enabled) {
                if (pwm->state.enabled)
                        pwm_imx1_disable(chip, pwm);

                return 0;
        }

        err = pwm_imx1_config(chip, pwm, state->duty_cycle, state->period);
        if (err)
                return err;

        if (!pwm->state.enabled)
                return pwm_imx1_enable(chip, pwm);

        return 0;
}

static const struct pwm_ops pwm_imx1_ops = {
        .apply = pwm_imx1_apply,
};

static const struct of_device_id pwm_imx1_dt_ids[] = {
        { .compatible = "fsl,imx1-pwm", },
        { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, pwm_imx1_dt_ids);

static int pwm_imx1_probe(struct platform_device *pdev)
{
        struct pwm_chip *chip;
        struct pwm_imx1_chip *imx;

        chip = devm_pwmchip_alloc(&pdev->dev, 1, sizeof(*imx));
        if (IS_ERR(chip))
                return PTR_ERR(chip);
        imx = to_pwm_imx1_chip(chip);

        imx->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
        if (IS_ERR(imx->clk_ipg))
                return dev_err_probe(&pdev->dev, PTR_ERR(imx->clk_ipg),
                                     "getting ipg clock failed\n");

        imx->clk_per = devm_clk_get(&pdev->dev, "per");
        if (IS_ERR(imx->clk_per))
                return dev_err_probe(&pdev->dev, PTR_ERR(imx->clk_per),
                                     "failed to get peripheral clock\n");

        chip->ops = &pwm_imx1_ops;

        imx->mmio_base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(imx->mmio_base))
                return PTR_ERR(imx->mmio_base);

        return devm_pwmchip_add(&pdev->dev, chip);
}

static struct platform_driver pwm_imx1_driver = {
        .driver = {
                .name = "pwm-imx1",
                .of_match_table = pwm_imx1_dt_ids,
        },
        .probe = pwm_imx1_probe,
};
module_platform_driver(pwm_imx1_driver);

MODULE_DESCRIPTION("i.MX1 and i.MX21 Pulse Width Modulator driver");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");