|  | 
| 1 |  | -// max77675.c | 
|  | 1 | +// SPDX-License-Identifier: GPL-2.0-or-later | 
|  | 2 | +/* | 
|  | 3 | + * Copyright (c) 2025 Analog Devices, Inc. | 
|  | 4 | + * ADI regulator driver for MAX77675. | 
|  | 5 | + */ | 
|  | 6 | + | 
| 2 | 7 | #include <linux/module.h> | 
| 3 | 8 | #include <linux/i2c.h> | 
| 4 | 9 | #include <linux/regulator/driver.h> | 
|  | 
| 8 | 13 | #define MAX77675_NUM_REGULATORS 4 | 
| 9 | 14 | 
 | 
| 10 | 15 | struct max77675_regulator { | 
| 11 |  | -    struct device *dev; | 
| 12 |  | -    struct regulator_dev *rdev[MAX77675_NUM_REGULATORS]; | 
| 13 |  | -    struct regmap *regmap; | 
|  | 16 | +	struct device *dev; | 
|  | 17 | +	struct regulator_dev *rdev[MAX77675_NUM_REGULATORS]; | 
|  | 18 | +	struct regmap *regmap; | 
| 14 | 19 | }; | 
| 15 | 20 | 
 | 
| 16 | 21 | static const struct regulator_ops max77675_regulator_ops = { | 
| 17 |  | -    .enable     = regulator_enable_regmap, | 
| 18 |  | -    .disable    = regulator_disable_regmap, | 
| 19 |  | -    .is_enabled = regulator_is_enabled_regmap, | 
| 20 |  | -    .set_voltage_sel = regulator_set_voltage_sel_regmap, | 
| 21 |  | -    .get_voltage_sel = regulator_get_voltage_sel_regmap, | 
|  | 22 | +	.enable     = regulator_enable_regmap, | 
|  | 23 | +	.disable    = regulator_disable_regmap, | 
|  | 24 | +	.is_enabled = regulator_is_enabled_regmap, | 
|  | 25 | +	.set_voltage_sel = regulator_set_voltage_sel_regmap, | 
|  | 26 | +	.get_voltage_sel = regulator_get_voltage_sel_regmap, | 
| 22 | 27 | }; | 
| 23 | 28 | 
 | 
| 24 | 29 | static const struct regulator_desc max77675_regulators[] = { | 
| 25 |  | -    { | 
| 26 |  | -        .name = "simo0", | 
| 27 |  | -        .id = 0, | 
| 28 |  | -        .ops = &max77675_regulator_ops, | 
| 29 |  | -        .type = REGULATOR_VOLTAGE, | 
| 30 |  | -        .owner = THIS_MODULE, | 
| 31 |  | -        .n_voltages = 64, | 
| 32 |  | -        .min_uV = 500000, | 
| 33 |  | -        .uV_step = 50000, | 
| 34 |  | -        .vsel_reg = 0x10,   // example value : SIMO0 VOUT | 
| 35 |  | -        .vsel_mask = 0x3F, | 
| 36 |  | -        .enable_reg = 0x20, // example value :  SIMO0 ENABLE | 
| 37 |  | -        .enable_mask = 0x01, | 
| 38 |  | -    }, | 
| 39 |  | -    // simo1, simo2, simo3  | 
|  | 30 | +	{ | 
|  | 31 | +		.name = "simo0", | 
|  | 32 | +		.id = 0, | 
|  | 33 | +		.ops = &max77675_regulator_ops, | 
|  | 34 | +		.type = REGULATOR_VOLTAGE, | 
|  | 35 | +		.owner = THIS_MODULE, | 
|  | 36 | +		.n_voltages = 64, | 
|  | 37 | +		.min_uV = 500000, | 
|  | 38 | +		.uV_step = 50000, | 
|  | 39 | +		.vsel_reg = 0x10,   // example value : SIMO0 VOUT | 
|  | 40 | +		.vsel_mask = 0x3F, | 
|  | 41 | +		.enable_reg = 0x20, // example value :  SIMO0 ENABLE | 
|  | 42 | +		.enable_mask = 0x01, | 
|  | 43 | +	}, | 
| 40 | 44 | }; | 
| 41 | 45 | 
 | 
| 42 | 46 | static int max77675_probe(struct i2c_client *client, const struct i2c_device_id *id) | 
| 43 | 47 | { | 
| 44 |  | -    struct max77675_regulator *priv; | 
| 45 |  | -    int i, ret; | 
| 46 |  | - | 
| 47 |  | -    priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL); | 
| 48 |  | -    if (!priv) | 
| 49 |  | -        return -ENOMEM; | 
| 50 |  | - | 
| 51 |  | -    i2c_set_clientdata(client, priv); | 
| 52 |  | - | 
| 53 |  | -    priv->regmap = devm_regmap_init_i2c(client, &some_regmap_config); | 
| 54 |  | -    if (IS_ERR(priv->regmap)) | 
| 55 |  | -        return dev_err_probe(&client->dev, PTR_ERR(priv->regmap), "regmap init failed"); | 
| 56 |  | - | 
| 57 |  | -    for (i = 0; i < MAX77675_NUM_REGULATORS; i++) { | 
| 58 |  | -        struct regulator_config config = {}; | 
| 59 |  | -        config.dev = &client->dev; | 
| 60 |  | -        config.regmap = priv->regmap; | 
| 61 |  | - | 
| 62 |  | -        priv->rdev[i] = devm_regulator_register(&client->dev, | 
| 63 |  | -                                                &max77675_regulators[i], &config); | 
| 64 |  | -        if (IS_ERR(priv->rdev[i])) { | 
| 65 |  | -            dev_err(&client->dev, "Failed to register regulator %d\n", i); | 
| 66 |  | -            return PTR_ERR(priv->rdev[i]); | 
| 67 |  | -        } | 
| 68 |  | -    } | 
| 69 |  | - | 
| 70 |  | -    dev_info(&client->dev, "MAX77675 regulator driver loaded\n"); | 
| 71 |  | -    return 0; | 
|  | 48 | +	struct max77675_regulator *priv; | 
|  | 49 | +	int i, ret; | 
|  | 50 | + | 
|  | 51 | +	priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL); | 
|  | 52 | +	if (!priv) | 
|  | 53 | +		return -ENOMEM; | 
|  | 54 | + | 
|  | 55 | +	i2c_set_clientdata(client, priv); | 
|  | 56 | + | 
|  | 57 | +	priv->regmap = devm_regmap_init_i2c(client, &some_regmap_config); | 
|  | 58 | +	if (IS_ERR(priv->regmap)) | 
|  | 59 | +		return dev_err_probe(&client->dev, PTR_ERR(priv->regmap), "regmap init failed"); | 
|  | 60 | + | 
|  | 61 | +	for (i = 0; i < MAX77675_NUM_REGULATORS; i++) { | 
|  | 62 | +		struct regulator_config config = {}; | 
|  | 63 | +		config.dev = &client->dev; | 
|  | 64 | +		config.regmap = priv->regmap; | 
|  | 65 | + | 
|  | 66 | +		priv->rdev[i] = devm_regulator_register(&client->dev, | 
|  | 67 | +				&max77675_regulators[i], &config); | 
|  | 68 | +		if (IS_ERR(priv->rdev[i])) { | 
|  | 69 | +			dev_err(&client->dev, "Failed to register regulator %d\n", i); | 
|  | 70 | +			return PTR_ERR(priv->rdev[i]); | 
|  | 71 | +		} | 
|  | 72 | +	} | 
|  | 73 | + | 
|  | 74 | +	dev_info(&client->dev, "MAX77675 regulator driver loaded\n"); | 
|  | 75 | +	return 0; | 
| 72 | 76 | } | 
| 73 | 77 | 
 | 
| 74 | 78 | static const struct of_device_id max77675_of_match[] = { | 
| 75 |  | -    { .compatible = "maxim,max77675", }, | 
| 76 |  | -    { /* sentinel */ } | 
|  | 79 | +	{ .compatible = "maxim,max77675", }, | 
|  | 80 | +	{ /* sentinel */ } | 
| 77 | 81 | }; | 
| 78 | 82 | MODULE_DEVICE_TABLE(of, max77675_of_match); | 
| 79 | 83 | 
 | 
| 80 | 84 | static const struct i2c_device_id max77675_id[] = { | 
| 81 |  | -    { "max77675", 0 }, | 
| 82 |  | -    { } | 
|  | 85 | +	{ "max77675", 0 }, | 
|  | 86 | +	{ } | 
| 83 | 87 | }; | 
| 84 | 88 | MODULE_DEVICE_TABLE(i2c, max77675_id); | 
| 85 | 89 | 
 | 
| 86 | 90 | static struct i2c_driver max77675_driver = { | 
| 87 |  | -    .driver = { | 
| 88 |  | -        .name = "max77675", | 
| 89 |  | -        .of_match_table = max77675_of_match, | 
| 90 |  | -    }, | 
| 91 |  | -    .probe = max77675_probe, | 
| 92 |  | -    .id_table = max77675_id, | 
|  | 91 | +	.driver = { | 
|  | 92 | +		.name = "max77675", | 
|  | 93 | +		.of_match_table = max77675_of_match, | 
|  | 94 | +	}, | 
|  | 95 | +	.probe = max77675_probe, | 
|  | 96 | +	.id_table = max77675_id, | 
| 93 | 97 | }; | 
| 94 | 98 | 
 | 
| 95 | 99 | module_i2c_driver(max77675_driver); | 
|  | 
0 commit comments