1 /* 2 * Regulators driver for Maxim max8649 3 * 4 * Copyright (C) 2009-2010 Marvell International Ltd. 5 * Haojian Zhuang <haojian.zhuang@marvell.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <linux/err.h> 14 #include <linux/i2c.h> 15 #include <linux/platform_device.h> 16 #include <linux/regulator/driver.h> 17 #include <linux/slab.h> 18 #include <linux/regulator/max8649.h> 19 #include <linux/regmap.h> 20 21 #define MAX8649_DCDC_VMIN 750000 /* uV */ 22 #define MAX8649_DCDC_VMAX 1380000 /* uV */ 23 #define MAX8649_DCDC_STEP 10000 /* uV */ 24 #define MAX8649_VOL_MASK 0x3f 25 26 /* Registers */ 27 #define MAX8649_MODE0 0x00 28 #define MAX8649_MODE1 0x01 29 #define MAX8649_MODE2 0x02 30 #define MAX8649_MODE3 0x03 31 #define MAX8649_CONTROL 0x04 32 #define MAX8649_SYNC 0x05 33 #define MAX8649_RAMP 0x06 34 #define MAX8649_CHIP_ID1 0x08 35 #define MAX8649_CHIP_ID2 0x09 36 37 /* Bits */ 38 #define MAX8649_EN_PD (1 << 7) 39 #define MAX8649_VID0_PD (1 << 6) 40 #define MAX8649_VID1_PD (1 << 5) 41 #define MAX8649_VID_MASK (3 << 5) 42 43 #define MAX8649_FORCE_PWM (1 << 7) 44 #define MAX8649_SYNC_EXTCLK (1 << 6) 45 46 #define MAX8649_EXT_MASK (3 << 6) 47 48 #define MAX8649_RAMP_MASK (7 << 5) 49 #define MAX8649_RAMP_DOWN (1 << 1) 50 51 struct max8649_regulator_info { 52 struct device *dev; 53 struct regmap *regmap; 54 55 unsigned mode:2; /* bit[1:0] = VID1, VID0 */ 56 unsigned extclk_freq:2; 57 unsigned extclk:1; 58 unsigned ramp_timing:3; 59 unsigned ramp_down:1; 60 }; 61 62 static int max8649_enable_time(struct regulator_dev *rdev) 63 { 64 struct max8649_regulator_info *info = rdev_get_drvdata(rdev); 65 int voltage, rate, ret; 66 unsigned int val; 67 68 /* get voltage */ 69 ret = regmap_read(info->regmap, rdev->desc->vsel_reg, &val); 70 if (ret != 0) 71 return ret; 72 val &= MAX8649_VOL_MASK; 73 voltage = regulator_list_voltage_linear(rdev, (unsigned char)val); 74 75 /* get rate */ 76 ret = regmap_read(info->regmap, MAX8649_RAMP, &val); 77 if (ret != 0) 78 return ret; 79 ret = (val & MAX8649_RAMP_MASK) >> 5; 80 rate = (32 * 1000) >> ret; /* uV/uS */ 81 82 return DIV_ROUND_UP(voltage, rate); 83 } 84 85 static int max8649_set_mode(struct regulator_dev *rdev, unsigned int mode) 86 { 87 struct max8649_regulator_info *info = rdev_get_drvdata(rdev); 88 89 switch (mode) { 90 case REGULATOR_MODE_FAST: 91 regmap_update_bits(info->regmap, rdev->desc->vsel_reg, 92 MAX8649_FORCE_PWM, MAX8649_FORCE_PWM); 93 break; 94 case REGULATOR_MODE_NORMAL: 95 regmap_update_bits(info->regmap, rdev->desc->vsel_reg, 96 MAX8649_FORCE_PWM, 0); 97 break; 98 default: 99 return -EINVAL; 100 } 101 return 0; 102 } 103 104 static unsigned int max8649_get_mode(struct regulator_dev *rdev) 105 { 106 struct max8649_regulator_info *info = rdev_get_drvdata(rdev); 107 unsigned int val; 108 int ret; 109 110 ret = regmap_read(info->regmap, rdev->desc->vsel_reg, &val); 111 if (ret != 0) 112 return ret; 113 if (val & MAX8649_FORCE_PWM) 114 return REGULATOR_MODE_FAST; 115 return REGULATOR_MODE_NORMAL; 116 } 117 118 static struct regulator_ops max8649_dcdc_ops = { 119 .set_voltage_sel = regulator_set_voltage_sel_regmap, 120 .get_voltage_sel = regulator_get_voltage_sel_regmap, 121 .list_voltage = regulator_list_voltage_linear, 122 .map_voltage = regulator_map_voltage_linear, 123 .enable = regulator_enable_regmap, 124 .disable = regulator_disable_regmap, 125 .is_enabled = regulator_is_enabled_regmap, 126 .enable_time = max8649_enable_time, 127 .set_mode = max8649_set_mode, 128 .get_mode = max8649_get_mode, 129 130 }; 131 132 static struct regulator_desc dcdc_desc = { 133 .name = "max8649", 134 .ops = &max8649_dcdc_ops, 135 .type = REGULATOR_VOLTAGE, 136 .n_voltages = 1 << 6, 137 .owner = THIS_MODULE, 138 .vsel_mask = MAX8649_VOL_MASK, 139 .min_uV = MAX8649_DCDC_VMIN, 140 .uV_step = MAX8649_DCDC_STEP, 141 .enable_reg = MAX8649_CONTROL, 142 .enable_mask = MAX8649_EN_PD, 143 .enable_is_inverted = true, 144 }; 145 146 static struct regmap_config max8649_regmap_config = { 147 .reg_bits = 8, 148 .val_bits = 8, 149 }; 150 151 static int max8649_regulator_probe(struct i2c_client *client, 152 const struct i2c_device_id *id) 153 { 154 struct max8649_platform_data *pdata = dev_get_platdata(&client->dev); 155 struct max8649_regulator_info *info = NULL; 156 struct regulator_dev *regulator; 157 struct regulator_config config = { }; 158 unsigned int val; 159 unsigned char data; 160 int ret; 161 162 info = devm_kzalloc(&client->dev, sizeof(struct max8649_regulator_info), 163 GFP_KERNEL); 164 if (!info) { 165 dev_err(&client->dev, "No enough memory\n"); 166 return -ENOMEM; 167 } 168 169 info->regmap = devm_regmap_init_i2c(client, &max8649_regmap_config); 170 if (IS_ERR(info->regmap)) { 171 ret = PTR_ERR(info->regmap); 172 dev_err(&client->dev, "Failed to allocate register map: %d\n", ret); 173 return ret; 174 } 175 176 info->dev = &client->dev; 177 i2c_set_clientdata(client, info); 178 179 info->mode = pdata->mode; 180 switch (info->mode) { 181 case 0: 182 dcdc_desc.vsel_reg = MAX8649_MODE0; 183 break; 184 case 1: 185 dcdc_desc.vsel_reg = MAX8649_MODE1; 186 break; 187 case 2: 188 dcdc_desc.vsel_reg = MAX8649_MODE2; 189 break; 190 case 3: 191 dcdc_desc.vsel_reg = MAX8649_MODE3; 192 break; 193 default: 194 break; 195 } 196 197 ret = regmap_read(info->regmap, MAX8649_CHIP_ID1, &val); 198 if (ret != 0) { 199 dev_err(info->dev, "Failed to detect ID of MAX8649:%d\n", 200 ret); 201 return ret; 202 } 203 dev_info(info->dev, "Detected MAX8649 (ID:%x)\n", val); 204 205 /* enable VID0 & VID1 */ 206 regmap_update_bits(info->regmap, MAX8649_CONTROL, MAX8649_VID_MASK, 0); 207 208 /* enable/disable external clock synchronization */ 209 info->extclk = pdata->extclk; 210 data = (info->extclk) ? MAX8649_SYNC_EXTCLK : 0; 211 regmap_update_bits(info->regmap, dcdc_desc.vsel_reg, 212 MAX8649_SYNC_EXTCLK, data); 213 if (info->extclk) { 214 /* set external clock frequency */ 215 info->extclk_freq = pdata->extclk_freq; 216 regmap_update_bits(info->regmap, MAX8649_SYNC, MAX8649_EXT_MASK, 217 info->extclk_freq << 6); 218 } 219 220 if (pdata->ramp_timing) { 221 info->ramp_timing = pdata->ramp_timing; 222 regmap_update_bits(info->regmap, MAX8649_RAMP, MAX8649_RAMP_MASK, 223 info->ramp_timing << 5); 224 } 225 226 info->ramp_down = pdata->ramp_down; 227 if (info->ramp_down) { 228 regmap_update_bits(info->regmap, MAX8649_RAMP, MAX8649_RAMP_DOWN, 229 MAX8649_RAMP_DOWN); 230 } 231 232 config.dev = &client->dev; 233 config.init_data = pdata->regulator; 234 config.driver_data = info; 235 config.regmap = info->regmap; 236 237 regulator = devm_regulator_register(&client->dev, &dcdc_desc, 238 &config); 239 if (IS_ERR(regulator)) { 240 dev_err(info->dev, "failed to register regulator %s\n", 241 dcdc_desc.name); 242 return PTR_ERR(regulator); 243 } 244 245 return 0; 246 } 247 248 static const struct i2c_device_id max8649_id[] = { 249 { "max8649", 0 }, 250 { } 251 }; 252 MODULE_DEVICE_TABLE(i2c, max8649_id); 253 254 static struct i2c_driver max8649_driver = { 255 .probe = max8649_regulator_probe, 256 .driver = { 257 .name = "max8649", 258 }, 259 .id_table = max8649_id, 260 }; 261 262 static int __init max8649_init(void) 263 { 264 return i2c_add_driver(&max8649_driver); 265 } 266 subsys_initcall(max8649_init); 267 268 static void __exit max8649_exit(void) 269 { 270 i2c_del_driver(&max8649_driver); 271 } 272 module_exit(max8649_exit); 273 274 /* Module information */ 275 MODULE_DESCRIPTION("MAXIM 8649 voltage regulator driver"); 276 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>"); 277 MODULE_LICENSE("GPL"); 278