linux-imx

// SPDX-License-Identifier: GPL-2.0

//

// Regulator controller driver for UniPhier SoC

// Copyright 2018 Socionext Inc.

// Author: Kunihiko Hayashi <hayashi.kunihiko@socionext.com>

​

#include <linux/clk.h>

#include <linux/io.h>

#include <linux/module.h>

#include <linux/of_device.h>

#include <linux/platform_device.h>

#include <linux/regmap.h>

#include <linux/regulator/driver.h>

#include <linux/regulator/of_regulator.h>

#include <linux/reset.h>

​

#define MAX_CLKS    2

#define MAX_RSTS    2

​

struct uniphier_regulator_soc_data {

    int nclks;

    const char * const *clock_names;

    int nrsts;

    const char * const *reset_names;

    const struct regulator_desc *desc;

    const struct regmap_config *regconf;

};

​

struct uniphier_regulator_priv {

    struct clk_bulk_data clk[MAX_CLKS];

    struct reset_control *rst[MAX_RSTS];

    const struct uniphier_regulator_soc_data *data;

};

​

static const struct regulator_ops uniphier_regulator_ops = {

    .enable     = regulator_enable_regmap,

    .disable    = regulator_disable_regmap,

    .is_enabled = regulator_is_enabled_regmap,

};

​

static int uniphier_regulator_probe(struct platform_device *pdev)

{

    struct device *dev = &pdev->dev;

    struct uniphier_regulator_priv *priv;

    struct regulator_config config = { };

    struct regulator_dev *rdev;

    struct regmap *regmap;

    struct resource *res;

    void __iomem *base;

    const char *name;

    int i, ret, nr;

​

    priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);

    if (!priv)

        return -ENOMEM;

​

    priv->data = of_device_get_match_data(dev);

    if (WARN_ON(!priv->data))

        return -EINVAL;

​

    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

    base = devm_ioremap_resource(dev, res);

    if (IS_ERR(base))

        return PTR_ERR(base);

​

    for (i = 0; i < priv->data->nclks; i++)

        priv->clk[i].id = priv->data->clock_names[i];

    ret = devm_clk_bulk_get(dev, priv->data->nclks, priv->clk);

    if (ret)

        return ret;

​

    for (i = 0; i < priv->data->nrsts; i++) {

        name = priv->data->reset_names[i];

        priv->rst[i] = devm_reset_control_get_shared(dev, name);

        if (IS_ERR(priv->rst[i]))

            return PTR_ERR(priv->rst[i]);

    }

​

    ret = clk_bulk_prepare_enable(priv->data->nclks, priv->clk);

    if (ret)

        return ret;

​

    for (nr = 0; nr < priv->data->nrsts; nr++) {

        ret = reset_control_deassert(priv->rst[nr]);

        if (ret)

            goto out_rst_assert;

    }

​

    regmap = devm_regmap_init_mmio(dev, base, priv->data->regconf);

    if (IS_ERR(regmap)) {

        ret = PTR_ERR(regmap);

        goto out_rst_assert;