drivers/regulator/max8660.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * max8660.c  --  Voltage regulation for the Maxim 8660/8661
0004  *
0005  * based on max1586.c and wm8400-regulator.c
0006  *
0007  * Copyright (C) 2009 Wolfram Sang, Pengutronix e.K.
0008  *
0009  * Some info:
0010  *
0011  * Datasheet: http://datasheets.maxim-ic.com/en/ds/MAX8660-MAX8661.pdf
0012  *
0013  * This chip is a bit nasty because it is a write-only device. Thus, the driver
0014  * uses shadow registers to keep track of its values. The main problem appears
0015  * to be the initialization: When Linux boots up, we cannot know if the chip is
0016  * in the default state or not, so we would have to pass such information in
0017  * platform_data. As this adds a bit of complexity to the driver, this is left
0018  * out for now until it is really needed.
0019  *
0020  * [A|S|M]DTV1 registers are currently not used, but [A|S|M]DTV2.
0021  *
0022  * If the driver is feature complete, it might be worth to check if one set of
0023  * functions for V3-V7 is sufficient. For maximum flexibility during
0024  * development, they are separated for now.
0025  */
0026
0027 #include <linux/module.h>
0028 #include <linux/err.h>
0029 #include <linux/i2c.h>
0030 #include <linux/platform_device.h>
0031 #include <linux/regulator/driver.h>
0032 #include <linux/slab.h>
0033 #include <linux/regulator/max8660.h>
0034 #include <linux/of.h>
0035 #include <linux/of_device.h>
0036 #include <linux/regulator/of_regulator.h>
0037
0038 #define MAX8660_DCDC_MIN_UV  725000
0039 #define MAX8660_DCDC_MAX_UV 1800000
0040 #define MAX8660_DCDC_STEP     25000
0041 #define MAX8660_DCDC_MAX_SEL    0x2b
0042
0043 #define MAX8660_LDO5_MIN_UV 1700000
0044 #define MAX8660_LDO5_MAX_UV 2000000
0045 #define MAX8660_LDO5_STEP     25000
0046 #define MAX8660_LDO5_MAX_SEL    0x0c
0047
0048 #define MAX8660_LDO67_MIN_UV    1800000
0049 #define MAX8660_LDO67_MAX_UV    3300000
0050 #define MAX8660_LDO67_STEP   100000
0051 #define MAX8660_LDO67_MAX_SEL   0x0f
0052
0053 enum {
0054     MAX8660_OVER1,
0055     MAX8660_OVER2,
0056     MAX8660_VCC1,
0057     MAX8660_ADTV1,
0058     MAX8660_ADTV2,
0059     MAX8660_SDTV1,
0060     MAX8660_SDTV2,
0061     MAX8660_MDTV1,
0062     MAX8660_MDTV2,
0063     MAX8660_L12VCR,
0064     MAX8660_FPWM,
0065     MAX8660_N_REGS, /* not a real register */
0066 };
0067
0068 struct max8660 {
0069     struct i2c_client *client;
0070     u8 shadow_regs[MAX8660_N_REGS];     /* as chip is write only */
0071 };
0072
0073 static int max8660_write(struct max8660 *max8660, u8 reg, u8 mask, u8 val)
0074 {
0075     static const u8 max8660_addresses[MAX8660_N_REGS] = {
0076      0x10, 0x12, 0x20, 0x23, 0x24, 0x29, 0x2a, 0x32, 0x33, 0x39, 0x80
0077     };
0078
0079     int ret;
0080     u8 reg_val = (max8660->shadow_regs[reg] & mask) | val;
0081
0082     dev_vdbg(&max8660->client->dev, "Writing reg %02x with %02x\n",
0083             max8660_addresses[reg], reg_val);
0084
0085     ret = i2c_smbus_write_byte_data(max8660->client,
0086             max8660_addresses[reg], reg_val);
0087     if (ret == 0)
0088         max8660->shadow_regs[reg] = reg_val;
0089
0090     return ret;
0091 }
0092
0093
0094 /*
0095  * DCDC functions
0096  */
0097
0098 static int max8660_dcdc_is_enabled(struct regulator_dev *rdev)
0099 {
0100     struct max8660 *max8660 = rdev_get_drvdata(rdev);
0101     u8 val = max8660->shadow_regs[MAX8660_OVER1];
0102     u8 mask = (rdev_get_id(rdev) == MAX8660_V3) ? 1 : 4;
0103
0104     return !!(val & mask);
0105 }
0106
0107 static int max8660_dcdc_enable(struct regulator_dev *rdev)
0108 {
0109     struct max8660 *max8660 = rdev_get_drvdata(rdev);
0110     u8 bit = (rdev_get_id(rdev) == MAX8660_V3) ? 1 : 4;
0111
0112     return max8660_write(max8660, MAX8660_OVER1, 0xff, bit);
0113 }
0114
0115 static int max8660_dcdc_disable(struct regulator_dev *rdev)
0116 {
0117     struct max8660 *max8660 = rdev_get_drvdata(rdev);
0118     u8 mask = (rdev_get_id(rdev) == MAX8660_V3) ? ~1 : ~4;
0119
0120     return max8660_write(max8660, MAX8660_OVER1, mask, 0);
0121 }
0122
0123 static int max8660_dcdc_get_voltage_sel(struct regulator_dev *rdev)
0124 {
0125     struct max8660 *max8660 = rdev_get_drvdata(rdev);
0126     u8 reg = (rdev_get_id(rdev) == MAX8660_V3) ? MAX8660_ADTV2 : MAX8660_SDTV2;
0127     u8 selector = max8660->shadow_regs[reg];
0128
0129     return selector;
0130 }
0131
0132 static int max8660_dcdc_set_voltage_sel(struct regulator_dev *rdev,
0133                     unsigned int selector)
0134 {
0135     struct max8660 *max8660 = rdev_get_drvdata(rdev);
0136     u8 reg, bits;
0137     int ret;
0138
0139     reg = (rdev_get_id(rdev) == MAX8660_V3) ? MAX8660_ADTV2 : MAX8660_SDTV2;
0140     ret = max8660_write(max8660, reg, 0, selector);
0141     if (ret)
0142         return ret;
0143
0144     /* Select target voltage register and activate regulation */
0145     bits = (rdev_get_id(rdev) == MAX8660_V3) ? 0x03 : 0x30;
0146     return max8660_write(max8660, MAX8660_VCC1, 0xff, bits);
0147 }
0148
0149 static struct regulator_ops max8660_dcdc_ops = {
0150     .is_enabled = max8660_dcdc_is_enabled,
0151     .list_voltage = regulator_list_voltage_linear,
0152     .map_voltage = regulator_map_voltage_linear,
0153     .set_voltage_sel = max8660_dcdc_set_voltage_sel,
0154     .get_voltage_sel = max8660_dcdc_get_voltage_sel,
0155 };
0156
0157
0158 /*
0159  * LDO5 functions
0160  */
0161
0162 static int max8660_ldo5_get_voltage_sel(struct regulator_dev *rdev)
0163 {
0164     struct max8660 *max8660 = rdev_get_drvdata(rdev);
0165
0166     u8 selector = max8660->shadow_regs[MAX8660_MDTV2];
0167     return selector;
0168 }
0169
0170 static int max8660_ldo5_set_voltage_sel(struct regulator_dev *rdev,
0171                     unsigned int selector)
0172 {
0173     struct max8660 *max8660 = rdev_get_drvdata(rdev);
0174     int ret;
0175
0176     ret = max8660_write(max8660, MAX8660_MDTV2, 0, selector);
0177     if (ret)
0178         return ret;
0179
0180     /* Select target voltage register and activate regulation */
0181     return max8660_write(max8660, MAX8660_VCC1, 0xff, 0xc0);
0182 }
0183
0184 static const struct regulator_ops max8660_ldo5_ops = {
0185     .list_voltage = regulator_list_voltage_linear,
0186     .map_voltage = regulator_map_voltage_linear,
0187     .set_voltage_sel = max8660_ldo5_set_voltage_sel,
0188     .get_voltage_sel = max8660_ldo5_get_voltage_sel,
0189 };
0190
0191
0192 /*
0193  * LDO67 functions
0194  */
0195
0196 static int max8660_ldo67_is_enabled(struct regulator_dev *rdev)
0197 {
0198     struct max8660 *max8660 = rdev_get_drvdata(rdev);
0199     u8 val = max8660->shadow_regs[MAX8660_OVER2];
0200     u8 mask = (rdev_get_id(rdev) == MAX8660_V6) ? 2 : 4;
0201
0202     return !!(val & mask);
0203 }
0204
0205 static int max8660_ldo67_enable(struct regulator_dev *rdev)
0206 {
0207     struct max8660 *max8660 = rdev_get_drvdata(rdev);
0208     u8 bit = (rdev_get_id(rdev) == MAX8660_V6) ? 2 : 4;
0209
0210     return max8660_write(max8660, MAX8660_OVER2, 0xff, bit);
0211 }
0212
0213 static int max8660_ldo67_disable(struct regulator_dev *rdev)
0214 {
0215     struct max8660 *max8660 = rdev_get_drvdata(rdev);
0216     u8 mask = (rdev_get_id(rdev) == MAX8660_V6) ? ~2 : ~4;
0217
0218     return max8660_write(max8660, MAX8660_OVER2, mask, 0);
0219 }
0220
0221 static int max8660_ldo67_get_voltage_sel(struct regulator_dev *rdev)
0222 {
0223     struct max8660 *max8660 = rdev_get_drvdata(rdev);
0224     u8 shift = (rdev_get_id(rdev) == MAX8660_V6) ? 0 : 4;
0225     u8 selector = (max8660->shadow_regs[MAX8660_L12VCR] >> shift) & 0xf;
0226
0227     return selector;
0228 }
0229
0230 static int max8660_ldo67_set_voltage_sel(struct regulator_dev *rdev,
0231                      unsigned int selector)
0232 {
0233     struct max8660 *max8660 = rdev_get_drvdata(rdev);
0234
0235     if (rdev_get_id(rdev) == MAX8660_V6)
0236         return max8660_write(max8660, MAX8660_L12VCR, 0xf0, selector);
0237     else
0238         return max8660_write(max8660, MAX8660_L12VCR, 0x0f,
0239                      selector << 4);
0240 }
0241
0242 static const struct regulator_ops max8660_ldo67_ops = {
0243     .is_enabled = max8660_ldo67_is_enabled,
0244     .enable = max8660_ldo67_enable,
0245     .disable = max8660_ldo67_disable,
0246     .list_voltage = regulator_list_voltage_linear,
0247     .map_voltage = regulator_map_voltage_linear,
0248     .get_voltage_sel = max8660_ldo67_get_voltage_sel,
0249     .set_voltage_sel = max8660_ldo67_set_voltage_sel,
0250 };
0251
0252 static const struct regulator_desc max8660_reg[] = {
0253     {
0254         .name = "V3(DCDC)",
0255         .id = MAX8660_V3,
0256         .ops = &max8660_dcdc_ops,
0257         .type = REGULATOR_VOLTAGE,
0258         .n_voltages = MAX8660_DCDC_MAX_SEL + 1,
0259         .owner = THIS_MODULE,
0260         .min_uV = MAX8660_DCDC_MIN_UV,
0261         .uV_step = MAX8660_DCDC_STEP,
0262     },
0263     {
0264         .name = "V4(DCDC)",
0265         .id = MAX8660_V4,
0266         .ops = &max8660_dcdc_ops,
0267         .type = REGULATOR_VOLTAGE,
0268         .n_voltages = MAX8660_DCDC_MAX_SEL + 1,
0269         .owner = THIS_MODULE,
0270         .min_uV = MAX8660_DCDC_MIN_UV,
0271         .uV_step = MAX8660_DCDC_STEP,
0272     },
0273     {
0274         .name = "V5(LDO)",
0275         .id = MAX8660_V5,
0276         .ops = &max8660_ldo5_ops,
0277         .type = REGULATOR_VOLTAGE,
0278         .n_voltages = MAX8660_LDO5_MAX_SEL + 1,
0279         .owner = THIS_MODULE,
0280         .min_uV = MAX8660_LDO5_MIN_UV,
0281         .uV_step = MAX8660_LDO5_STEP,
0282     },
0283     {
0284         .name = "V6(LDO)",
0285         .id = MAX8660_V6,
0286         .ops = &max8660_ldo67_ops,
0287         .type = REGULATOR_VOLTAGE,
0288         .n_voltages = MAX8660_LDO67_MAX_SEL + 1,
0289         .owner = THIS_MODULE,
0290         .min_uV = MAX8660_LDO67_MIN_UV,
0291         .uV_step = MAX8660_LDO67_STEP,
0292     },
0293     {
0294         .name = "V7(LDO)",
0295         .id = MAX8660_V7,
0296         .ops = &max8660_ldo67_ops,
0297         .type = REGULATOR_VOLTAGE,
0298         .n_voltages = MAX8660_LDO67_MAX_SEL + 1,
0299         .owner = THIS_MODULE,
0300         .min_uV = MAX8660_LDO67_MIN_UV,
0301         .uV_step = MAX8660_LDO67_STEP,
0302     },
0303 };
0304
0305 enum {
0306     MAX8660 = 0,
0307     MAX8661 = 1,
0308 };
0309
0310 #ifdef CONFIG_OF
0311 static const struct of_device_id max8660_dt_ids[] = {
0312     { .compatible = "maxim,max8660", .data = (void *) MAX8660 },
0313     { .compatible = "maxim,max8661", .data = (void *) MAX8661 },
0314     { }
0315 };
0316 MODULE_DEVICE_TABLE(of, max8660_dt_ids);
0317
0318 static int max8660_pdata_from_dt(struct device *dev,
0319                  struct device_node **of_node,
0320                  struct max8660_platform_data *pdata)
0321 {
0322     int matched, i;
0323     struct device_node *np;
0324     struct max8660_subdev_data *sub;
0325     struct of_regulator_match rmatch[ARRAY_SIZE(max8660_reg)] = { };
0326
0327     np = of_get_child_by_name(dev->of_node, "regulators");
0328     if (!np) {
0329         dev_err(dev, "missing 'regulators' subnode in DT\n");
0330         return -EINVAL;
0331     }
0332
0333     for (i = 0; i < ARRAY_SIZE(rmatch); i++)
0334         rmatch[i].name = max8660_reg[i].name;
0335
0336     matched = of_regulator_match(dev, np, rmatch, ARRAY_SIZE(rmatch));
0337     of_node_put(np);
0338     if (matched <= 0)
0339         return matched;
0340
0341     pdata->subdevs = devm_kcalloc(dev,
0342                       matched,
0343                       sizeof(struct max8660_subdev_data),
0344                       GFP_KERNEL);
0345     if (!pdata->subdevs)
0346         return -ENOMEM;
0347
0348     pdata->num_subdevs = matched;
0349     sub = pdata->subdevs;
0350
0351     for (i = 0; i < matched; i++) {
0352         sub->id = i;
0353         sub->name = rmatch[i].name;
0354         sub->platform_data = rmatch[i].init_data;
0355         of_node[i] = rmatch[i].of_node;
0356         sub++;
0357     }
0358
0359     return 0;
0360 }
0361 #else
0362 static inline int max8660_pdata_from_dt(struct device *dev,
0363                     struct device_node **of_node,
0364                     struct max8660_platform_data *pdata)
0365 {
0366     return 0;
0367 }
0368 #endif
0369
0370 static int max8660_probe(struct i2c_client *client,
0371                    const struct i2c_device_id *i2c_id)
0372 {
0373     struct device *dev = &client->dev;
0374     struct max8660_platform_data pdata_of, *pdata = dev_get_platdata(dev);
0375     struct regulator_config config = { };
0376     struct max8660 *max8660;
0377     int boot_on, i, id, ret = -EINVAL;
0378     struct device_node *of_node[MAX8660_V_END];
0379     unsigned long type;
0380
0381     if (dev->of_node && !pdata) {
0382         const struct of_device_id *id;
0383
0384         id = of_match_device(of_match_ptr(max8660_dt_ids), dev);
0385         if (!id)
0386             return -ENODEV;
0387
0388         ret = max8660_pdata_from_dt(dev, of_node, &pdata_of);
0389         if (ret < 0)
0390             return ret;
0391
0392         pdata = &pdata_of;
0393         type = (unsigned long) id->data;
0394     } else {
0395         type = i2c_id->driver_data;
0396         memset(of_node, 0, sizeof(of_node));
0397     }
0398
0399     if (pdata->num_subdevs > MAX8660_V_END) {
0400         dev_err(dev, "Too many regulators found!\n");
0401         return -EINVAL;
0402     }
0403
0404     max8660 = devm_kzalloc(dev, sizeof(struct max8660), GFP_KERNEL);
0405     if (!max8660)
0406         return -ENOMEM;
0407
0408     max8660->client = client;
0409
0410     if (pdata->en34_is_high) {
0411         /* Simulate always on */
0412         max8660->shadow_regs[MAX8660_OVER1] = 5;
0413     } else {
0414         /* Otherwise devices can be toggled via software */
0415         max8660_dcdc_ops.enable = max8660_dcdc_enable;
0416         max8660_dcdc_ops.disable = max8660_dcdc_disable;
0417     }
0418
0419     /*
0420      * First, set up shadow registers to prevent glitches. As some
0421      * registers are shared between regulators, everything must be properly
0422      * set up for all regulators in advance.
0423      */
0424     max8660->shadow_regs[MAX8660_ADTV1] =
0425         max8660->shadow_regs[MAX8660_ADTV2] =
0426         max8660->shadow_regs[MAX8660_SDTV1] =
0427         max8660->shadow_regs[MAX8660_SDTV2] = 0x1b;
0428     max8660->shadow_regs[MAX8660_MDTV1] =
0429         max8660->shadow_regs[MAX8660_MDTV2] = 0x04;
0430
0431     for (i = 0; i < pdata->num_subdevs; i++) {
0432
0433         if (!pdata->subdevs[i].platform_data)
0434             boot_on = false;
0435         else
0436             boot_on = pdata->subdevs[i].platform_data->constraints.boot_on;
0437
0438         switch (pdata->subdevs[i].id) {
0439         case MAX8660_V3:
0440             if (boot_on)
0441                 max8660->shadow_regs[MAX8660_OVER1] |= 1;
0442             break;
0443
0444         case MAX8660_V4:
0445             if (boot_on)
0446                 max8660->shadow_regs[MAX8660_OVER1] |= 4;
0447             break;
0448
0449         case MAX8660_V5:
0450             break;
0451
0452         case MAX8660_V6:
0453             if (boot_on)
0454                 max8660->shadow_regs[MAX8660_OVER2] |= 2;
0455             break;
0456
0457         case MAX8660_V7:
0458             if (type == MAX8661) {
0459                 dev_err(dev, "Regulator not on this chip!\n");
0460                 return -EINVAL;
0461             }
0462
0463             if (boot_on)
0464                 max8660->shadow_regs[MAX8660_OVER2] |= 4;
0465             break;
0466
0467         default:
0468             dev_err(dev, "invalid regulator %s\n",
0469                  pdata->subdevs[i].name);
0470             return ret;
0471         }
0472     }
0473
0474     /* Finally register devices */
0475     for (i = 0; i < pdata->num_subdevs; i++) {
0476         struct regulator_dev *rdev;
0477
0478         id = pdata->subdevs[i].id;
0479
0480         config.dev = dev;
0481         config.init_data = pdata->subdevs[i].platform_data;
0482         config.of_node = of_node[i];
0483         config.driver_data = max8660;
0484
0485         rdev = devm_regulator_register(&client->dev,
0486                           &max8660_reg[id], &config);
0487         if (IS_ERR(rdev)) {
0488             dev_err(&client->dev, "failed to register %s\n",
0489                 max8660_reg[id].name);
0490             return PTR_ERR(rdev);
0491         }
0492     }
0493
0494     i2c_set_clientdata(client, max8660);
0495     return 0;
0496 }
0497
0498 static const struct i2c_device_id max8660_id[] = {
0499     { .name = "max8660", .driver_data = MAX8660 },
0500     { .name = "max8661", .driver_data = MAX8661 },
0501     { }
0502 };
0503 MODULE_DEVICE_TABLE(i2c, max8660_id);
0504
0505 static struct i2c_driver max8660_driver = {
0506     .probe = max8660_probe,
0507     .driver     = {
0508         .name   = "max8660",
0509     },
0510     .id_table   = max8660_id,
0511 };
0512
0513 static int __init max8660_init(void)
0514 {
0515     return i2c_add_driver(&max8660_driver);
0516 }
0517 subsys_initcall(max8660_init);
0518
0519 static void __exit max8660_exit(void)
0520 {
0521     i2c_del_driver(&max8660_driver);
0522 }
0523 module_exit(max8660_exit);
0524
0525 /* Module information */
0526 MODULE_DESCRIPTION("MAXIM 8660/8661 voltage regulator driver");
0527 MODULE_AUTHOR("Wolfram Sang");
0528 MODULE_LICENSE("GPL v2");