Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Regulators driver for Maxim max8649
0004  *
0005  * Copyright (C) 2009-2010 Marvell International Ltd.
0006  *      Haojian Zhuang <haojian.zhuang@marvell.com>
0007  */
0008 #include <linux/kernel.h>
0009 #include <linux/module.h>
0010 #include <linux/err.h>
0011 #include <linux/i2c.h>
0012 #include <linux/platform_device.h>
0013 #include <linux/regulator/driver.h>
0014 #include <linux/slab.h>
0015 #include <linux/regulator/max8649.h>
0016 #include <linux/regmap.h>
0017 
0018 #define MAX8649_DCDC_VMIN   750000      /* uV */
0019 #define MAX8649_DCDC_VMAX   1380000     /* uV */
0020 #define MAX8649_DCDC_STEP   10000       /* uV */
0021 #define MAX8649_VOL_MASK    0x3f
0022 
0023 /* Registers */
0024 #define MAX8649_MODE0       0x00
0025 #define MAX8649_MODE1       0x01
0026 #define MAX8649_MODE2       0x02
0027 #define MAX8649_MODE3       0x03
0028 #define MAX8649_CONTROL     0x04
0029 #define MAX8649_SYNC        0x05
0030 #define MAX8649_RAMP        0x06
0031 #define MAX8649_CHIP_ID1    0x08
0032 #define MAX8649_CHIP_ID2    0x09
0033 
0034 /* Bits */
0035 #define MAX8649_EN_PD       (1 << 7)
0036 #define MAX8649_VID0_PD     (1 << 6)
0037 #define MAX8649_VID1_PD     (1 << 5)
0038 #define MAX8649_VID_MASK    (3 << 5)
0039 
0040 #define MAX8649_FORCE_PWM   (1 << 7)
0041 #define MAX8649_SYNC_EXTCLK (1 << 6)
0042 
0043 #define MAX8649_EXT_MASK    (3 << 6)
0044 
0045 #define MAX8649_RAMP_MASK   (7 << 5)
0046 #define MAX8649_RAMP_DOWN   (1 << 1)
0047 
0048 struct max8649_regulator_info {
0049     struct device       *dev;
0050     struct regmap       *regmap;
0051 
0052     unsigned    mode:2; /* bit[1:0] = VID1, VID0 */
0053     unsigned    extclk_freq:2;
0054     unsigned    extclk:1;
0055     unsigned    ramp_timing:3;
0056     unsigned    ramp_down:1;
0057 };
0058 
0059 static int max8649_enable_time(struct regulator_dev *rdev)
0060 {
0061     struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
0062     int voltage, rate, ret;
0063     unsigned int val;
0064 
0065     /* get voltage */
0066     ret = regmap_read(info->regmap, rdev->desc->vsel_reg, &val);
0067     if (ret != 0)
0068         return ret;
0069     val &= MAX8649_VOL_MASK;
0070     voltage = regulator_list_voltage_linear(rdev, (unsigned char)val);
0071 
0072     /* get rate */
0073     ret = regmap_read(info->regmap, MAX8649_RAMP, &val);
0074     if (ret != 0)
0075         return ret;
0076     ret = (val & MAX8649_RAMP_MASK) >> 5;
0077     rate = (32 * 1000) >> ret;  /* uV/uS */
0078 
0079     return DIV_ROUND_UP(voltage, rate);
0080 }
0081 
0082 static int max8649_set_mode(struct regulator_dev *rdev, unsigned int mode)
0083 {
0084     struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
0085 
0086     switch (mode) {
0087     case REGULATOR_MODE_FAST:
0088         regmap_update_bits(info->regmap, rdev->desc->vsel_reg,
0089                    MAX8649_FORCE_PWM, MAX8649_FORCE_PWM);
0090         break;
0091     case REGULATOR_MODE_NORMAL:
0092         regmap_update_bits(info->regmap, rdev->desc->vsel_reg,
0093                    MAX8649_FORCE_PWM, 0);
0094         break;
0095     default:
0096         return -EINVAL;
0097     }
0098     return 0;
0099 }
0100 
0101 static unsigned int max8649_get_mode(struct regulator_dev *rdev)
0102 {
0103     struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
0104     unsigned int val;
0105     int ret;
0106 
0107     ret = regmap_read(info->regmap, rdev->desc->vsel_reg, &val);
0108     if (ret != 0)
0109         return ret;
0110     if (val & MAX8649_FORCE_PWM)
0111         return REGULATOR_MODE_FAST;
0112     return REGULATOR_MODE_NORMAL;
0113 }
0114 
0115 static const struct regulator_ops max8649_dcdc_ops = {
0116     .set_voltage_sel = regulator_set_voltage_sel_regmap,
0117     .get_voltage_sel = regulator_get_voltage_sel_regmap,
0118     .list_voltage   = regulator_list_voltage_linear,
0119     .map_voltage    = regulator_map_voltage_linear,
0120     .enable     = regulator_enable_regmap,
0121     .disable    = regulator_disable_regmap,
0122     .is_enabled = regulator_is_enabled_regmap,
0123     .enable_time    = max8649_enable_time,
0124     .set_mode   = max8649_set_mode,
0125     .get_mode   = max8649_get_mode,
0126 
0127 };
0128 
0129 static struct regulator_desc dcdc_desc = {
0130     .name       = "max8649",
0131     .ops        = &max8649_dcdc_ops,
0132     .type       = REGULATOR_VOLTAGE,
0133     .n_voltages = 1 << 6,
0134     .owner      = THIS_MODULE,
0135     .vsel_mask  = MAX8649_VOL_MASK,
0136     .min_uV     = MAX8649_DCDC_VMIN,
0137     .uV_step    = MAX8649_DCDC_STEP,
0138     .enable_reg = MAX8649_CONTROL,
0139     .enable_mask    = MAX8649_EN_PD,
0140     .enable_is_inverted = true,
0141 };
0142 
0143 static const struct regmap_config max8649_regmap_config = {
0144     .reg_bits = 8,
0145     .val_bits = 8,
0146 };
0147 
0148 static int max8649_regulator_probe(struct i2c_client *client,
0149                          const struct i2c_device_id *id)
0150 {
0151     struct max8649_platform_data *pdata = dev_get_platdata(&client->dev);
0152     struct max8649_regulator_info *info = NULL;
0153     struct regulator_dev *regulator;
0154     struct regulator_config config = { };
0155     unsigned int val;
0156     unsigned char data;
0157     int ret;
0158 
0159     info = devm_kzalloc(&client->dev, sizeof(struct max8649_regulator_info),
0160                 GFP_KERNEL);
0161     if (!info)
0162         return -ENOMEM;
0163 
0164     info->regmap = devm_regmap_init_i2c(client, &max8649_regmap_config);
0165     if (IS_ERR(info->regmap)) {
0166         ret = PTR_ERR(info->regmap);
0167         dev_err(&client->dev, "Failed to allocate register map: %d\n", ret);
0168         return ret;
0169     }
0170 
0171     info->dev = &client->dev;
0172     i2c_set_clientdata(client, info);
0173 
0174     info->mode = pdata->mode;
0175     switch (info->mode) {
0176     case 0:
0177         dcdc_desc.vsel_reg = MAX8649_MODE0;
0178         break;
0179     case 1:
0180         dcdc_desc.vsel_reg = MAX8649_MODE1;
0181         break;
0182     case 2:
0183         dcdc_desc.vsel_reg = MAX8649_MODE2;
0184         break;
0185     case 3:
0186         dcdc_desc.vsel_reg = MAX8649_MODE3;
0187         break;
0188     default:
0189         break;
0190     }
0191 
0192     ret = regmap_read(info->regmap, MAX8649_CHIP_ID1, &val);
0193     if (ret != 0) {
0194         dev_err(info->dev, "Failed to detect ID of MAX8649:%d\n",
0195             ret);
0196         return ret;
0197     }
0198     dev_info(info->dev, "Detected MAX8649 (ID:%x)\n", val);
0199 
0200     /* enable VID0 & VID1 */
0201     regmap_update_bits(info->regmap, MAX8649_CONTROL, MAX8649_VID_MASK, 0);
0202 
0203     /* enable/disable external clock synchronization */
0204     info->extclk = pdata->extclk;
0205     data = (info->extclk) ? MAX8649_SYNC_EXTCLK : 0;
0206     regmap_update_bits(info->regmap, dcdc_desc.vsel_reg,
0207                MAX8649_SYNC_EXTCLK, data);
0208     if (info->extclk) {
0209         /* set external clock frequency */
0210         info->extclk_freq = pdata->extclk_freq;
0211         regmap_update_bits(info->regmap, MAX8649_SYNC, MAX8649_EXT_MASK,
0212                    info->extclk_freq << 6);
0213     }
0214 
0215     if (pdata->ramp_timing) {
0216         info->ramp_timing = pdata->ramp_timing;
0217         regmap_update_bits(info->regmap, MAX8649_RAMP, MAX8649_RAMP_MASK,
0218                    info->ramp_timing << 5);
0219     }
0220 
0221     info->ramp_down = pdata->ramp_down;
0222     if (info->ramp_down) {
0223         regmap_update_bits(info->regmap, MAX8649_RAMP, MAX8649_RAMP_DOWN,
0224                    MAX8649_RAMP_DOWN);
0225     }
0226 
0227     config.dev = &client->dev;
0228     config.init_data = pdata->regulator;
0229     config.driver_data = info;
0230     config.regmap = info->regmap;
0231 
0232     regulator = devm_regulator_register(&client->dev, &dcdc_desc,
0233                           &config);
0234     if (IS_ERR(regulator)) {
0235         dev_err(info->dev, "failed to register regulator %s\n",
0236             dcdc_desc.name);
0237         return PTR_ERR(regulator);
0238     }
0239 
0240     return 0;
0241 }
0242 
0243 static const struct i2c_device_id max8649_id[] = {
0244     { "max8649", 0 },
0245     { }
0246 };
0247 MODULE_DEVICE_TABLE(i2c, max8649_id);
0248 
0249 static struct i2c_driver max8649_driver = {
0250     .probe      = max8649_regulator_probe,
0251     .driver     = {
0252         .name   = "max8649",
0253     },
0254     .id_table   = max8649_id,
0255 };
0256 
0257 static int __init max8649_init(void)
0258 {
0259     return i2c_add_driver(&max8649_driver);
0260 }
0261 subsys_initcall(max8649_init);
0262 
0263 static void __exit max8649_exit(void)
0264 {
0265     i2c_del_driver(&max8649_driver);
0266 }
0267 module_exit(max8649_exit);
0268 
0269 /* Module information */
0270 MODULE_DESCRIPTION("MAXIM 8649 voltage regulator driver");
0271 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
0272 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!