mfd: regulator: clk: Split rohm-bd718x7.h (2a6a7aac) · Commits · 戴 / test

drivers/clk/clk-bd718x7.c

+3 −3

Original line number	Diff line number	Diff line
		@@ -17,7 +17,7 @@ struct bd718xx_clk {
		u8 reg;
		u8 mask;
		struct platform_device *pdev;
		struct bd718xx *mfd;
		struct rohm_regmap_dev *mfd;
		};

		static int bd71837_clk_set(struct clk_hw *hw, int status)
		@@ -68,7 +68,7 @@ static int bd71837_clk_probe(struct platform_device *pdev)
		int rval = -ENOMEM;
		const char *parent_clk;
		struct device *parent = pdev->dev.parent;
		struct bd718xx *mfd = dev_get_drvdata(parent);
		struct rohm_regmap_dev *mfd = dev_get_drvdata(parent);
		struct clk_init_data init = {
		.name = "bd718xx-32k-out",
		.ops = &bd71837_clk_ops,
		@@ -119,5 +119,5 @@ static struct platform_driver bd71837_clk = {
		module_platform_driver(bd71837_clk);

		MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
		MODULE_DESCRIPTION("BD71837 chip clk driver");
		MODULE_DESCRIPTION("BD71837/BD71847 chip clk driver");
		MODULE_LICENSE("GPL");

drivers/mfd/rohm-bd718x7.c

+12 −11

Original line number	Diff line number	Diff line
		@@ -98,18 +98,19 @@ static int bd718xx_i2c_probe(struct i2c_client *i2c,
		return -ENOMEM;

		bd718xx->chip_irq = i2c->irq;
		bd718xx->chip_type = (unsigned int)(uintptr_t)
		bd718xx->chip.chip_type = (unsigned int)(uintptr_t)
		of_device_get_match_data(&i2c->dev);
		bd718xx->dev = &i2c->dev;
		bd718xx->chip.dev = &i2c->dev;
		dev_set_drvdata(&i2c->dev, bd718xx);

		bd718xx->regmap = devm_regmap_init_i2c(i2c, &bd718xx_regmap_config);
		if (IS_ERR(bd718xx->regmap)) {
		bd718xx->chip.regmap = devm_regmap_init_i2c(i2c,
		&bd718xx_regmap_config);
		if (IS_ERR(bd718xx->chip.regmap)) {
		dev_err(&i2c->dev, "regmap initialization failed\n");
		return PTR_ERR(bd718xx->regmap);
		return PTR_ERR(bd718xx->chip.regmap);
		}

		ret = devm_regmap_add_irq_chip(&i2c->dev, bd718xx->regmap,
		ret = devm_regmap_add_irq_chip(&i2c->dev, bd718xx->chip.regmap,
		bd718xx->chip_irq, IRQF_ONESHOT, 0,
		&bd718xx_irq_chip, &bd718xx->irq_data);
		if (ret) {
		@@ -118,7 +119,7 @@ static int bd718xx_i2c_probe(struct i2c_client *i2c,
		}

		/* Configure short press to 10 milliseconds */
		ret = regmap_update_bits(bd718xx->regmap,
		ret = regmap_update_bits(bd718xx->chip.regmap,
		BD718XX_REG_PWRONCONFIG0,
		BD718XX_PWRBTN_PRESS_DURATION_MASK,
		BD718XX_PWRBTN_SHORT_PRESS_10MS);
		@@ -129,7 +130,7 @@ static int bd718xx_i2c_probe(struct i2c_client *i2c,
		}

		/* Configure long press to 10 seconds */
		ret = regmap_update_bits(bd718xx->regmap,
		ret = regmap_update_bits(bd718xx->chip.regmap,
		BD718XX_REG_PWRONCONFIG1,
		BD718XX_PWRBTN_PRESS_DURATION_MASK,
		BD718XX_PWRBTN_LONG_PRESS_10S);
		@@ -149,7 +150,7 @@ static int bd718xx_i2c_probe(struct i2c_client *i2c,

		button.irq = ret;

		ret = devm_mfd_add_devices(bd718xx->dev, PLATFORM_DEVID_AUTO,
		ret = devm_mfd_add_devices(bd718xx->chip.dev, PLATFORM_DEVID_AUTO,
		bd718xx_mfd_cells,
		ARRAY_SIZE(bd718xx_mfd_cells), NULL, 0,
		regmap_irq_get_domain(bd718xx->irq_data));
		@@ -162,11 +163,11 @@ static int bd718xx_i2c_probe(struct i2c_client *i2c,
		static const struct of_device_id bd718xx_of_match[] = {
		{
		.compatible = "rohm,bd71837",
		.data = (void *)BD718XX_TYPE_BD71837,
		.data = (void *)ROHM_CHIP_TYPE_BD71837,
		},
		{
		.compatible = "rohm,bd71847",
		.data = (void *)BD718XX_TYPE_BD71847,
		.data = (void *)ROHM_CHIP_TYPE_BD71847,
		},
		{ }
		};

drivers/regulator/bd718x7-regulator.c

+13 −12

Original line number	Diff line number	Diff line
		@@ -1152,12 +1152,12 @@ static int bd718xx_probe(struct platform_device *pdev)
		{
		struct bd718xx *mfd;
		struct regulator_config config = { 0 };
		struct bd718xx_pmic_inits pmic_regulators[] = {
		[BD718XX_TYPE_BD71837] = {
		struct bd718xx_pmic_inits pmic_regulators[ROHM_CHIP_TYPE_AMOUNT] = {
		[ROHM_CHIP_TYPE_BD71837] = {
		.r_datas = bd71837_regulators,
		.r_amount = ARRAY_SIZE(bd71837_regulators),
		},
		[BD718XX_TYPE_BD71847] = {
		[ROHM_CHIP_TYPE_BD71847] = {
		.r_datas = bd71847_regulators,
		.r_amount = ARRAY_SIZE(bd71847_regulators),
		},
		@@ -1173,15 +1173,15 @@ static int bd718xx_probe(struct platform_device *pdev)
		goto err;
		}

		if (mfd->chip_type >= BD718XX_TYPE_AMOUNT \|\|
		!pmic_regulators[mfd->chip_type].r_datas) {
		if (mfd->chip.chip_type >= ROHM_CHIP_TYPE_AMOUNT \|\|
		!pmic_regulators[mfd->chip.chip_type].r_datas) {
		dev_err(&pdev->dev, "Unsupported chip type\n");
		err = -EINVAL;
		goto err;
		}

		/* Register LOCK release */
		err = regmap_update_bits(mfd->regmap, BD718XX_REG_REGLOCK,
		err = regmap_update_bits(mfd->chip.regmap, BD718XX_REG_REGLOCK,
		(REGLOCK_PWRSEQ \| REGLOCK_VREG), 0);
		if (err) {
		dev_err(&pdev->dev, "Failed to unlock PMIC (%d)\n", err);
		@@ -1200,7 +1200,8 @@ static int bd718xx_probe(struct platform_device *pdev)
		* bit allowing HW defaults for power rails to be used
		*/
		if (!use_snvs) {
		err = regmap_update_bits(mfd->regmap, BD718XX_REG_TRANS_COND1,
		err = regmap_update_bits(mfd->chip.regmap,
		BD718XX_REG_TRANS_COND1,
		BD718XX_ON_REQ_POWEROFF_MASK \|
		BD718XX_SWRESET_POWEROFF_MASK \|
		BD718XX_WDOG_POWEROFF_MASK \|
		@@ -1215,17 +1216,17 @@ static int bd718xx_probe(struct platform_device *pdev)
		}
		}

		for (i = 0; i < pmic_regulators[mfd->chip_type].r_amount; i++) {
		for (i = 0; i < pmic_regulators[mfd->chip.chip_type].r_amount; i++) {

		const struct regulator_desc *desc;
		struct regulator_dev *rdev;
		const struct bd718xx_regulator_data *r;

		r = &pmic_regulators[mfd->chip_type].r_datas[i];
		r = &pmic_regulators[mfd->chip.chip_type].r_datas[i];
		desc = &r->desc;

		config.dev = pdev->dev.parent;
		config.regmap = mfd->regmap;
		config.regmap = mfd->chip.regmap;

		rdev = devm_regulator_register(&pdev->dev, desc, &config);
		if (IS_ERR(rdev)) {
		@@ -1254,7 +1255,7 @@ static int bd718xx_probe(struct platform_device *pdev)
		*/
		if (!use_snvs \|\| !rdev->constraints->always_on \|\|
		!rdev->constraints->boot_on) {
		err = regmap_update_bits(mfd->regmap, r->init.reg,
		err = regmap_update_bits(mfd->chip.regmap, r->init.reg,
		r->init.mask, r->init.val);
		if (err) {
		dev_err(&pdev->dev,
		@@ -1264,7 +1265,7 @@ static int bd718xx_probe(struct platform_device *pdev)
		}
		}
		for (j = 0; j < r->additional_init_amnt; j++) {
		err = regmap_update_bits(mfd->regmap,
		err = regmap_update_bits(mfd->chip.regmap,
		r->additional_inits[j].reg,
		r->additional_inits[j].mask,
		r->additional_inits[j].val);

include/linux/mfd/rohm-bd718x7.h

+8 −14

Original line number	Diff line number	Diff line
		@@ -4,14 +4,9 @@
		#ifndef __LINUX_MFD_BD718XX_H__
		#define __LINUX_MFD_BD718XX_H__

		#include <linux/mfd/rohm-generic.h>
		#include <linux/regmap.h>

		enum {
		BD718XX_TYPE_BD71837 = 0,
		BD718XX_TYPE_BD71847,
		BD718XX_TYPE_AMOUNT
		};

		enum {
		BD718XX_BUCK1 = 0,
		BD718XX_BUCK2,
		@@ -321,18 +316,17 @@ enum {
		BD718XX_PWRBTN_LONG_PRESS_15S
		};

		struct bd718xx_clk;

		struct bd718xx {
		unsigned int chip_type;
		struct device *dev;
		struct regmap *regmap;
		unsigned long int id;
		/*
		* Please keep this as the first member here as some
		* drivers (clk) supporting more than one chip may only know this
		* generic struct 'struct rohm_regmap_dev' and assume it is
		* the first chunk of parent device's private data.
		*/
		struct rohm_regmap_dev chip;

		int chip_irq;
		struct regmap_irq_chip_data *irq_data;

		struct bd718xx_clk *clk;
		};

		#endif /* __LINUX_MFD_BD718XX_H__ */

include/linux/mfd/rohm-generic.h

0 → 100644

+20 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0-or-later */
		/* Copyright (C) 2018 ROHM Semiconductors */

		#ifndef __LINUX_MFD_ROHM_H__
		#define __LINUX_MFD_ROHM_H__

		enum {
		ROHM_CHIP_TYPE_BD71837 = 0,
		ROHM_CHIP_TYPE_BD71847,
		ROHM_CHIP_TYPE_BD70528,
		ROHM_CHIP_TYPE_AMOUNT
		};

		struct rohm_regmap_dev {
		unsigned int chip_type;
		struct device *dev;
		struct regmap *regmap;
		};

		#endif

Admin message