1 /* 2 * FAN53555 Fairchild Digitally Programmable TinyBuck Regulator Driver. 3 * 4 * Supported Part Numbers: 5 * FAN53555UC00X/01X/03X/04X/05X 6 * 7 * Copyright (c) 2012 Marvell Technology Ltd. 8 * Yunfan Zhang <yfzhang@marvell.com> 9 * 10 * This package is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 * 14 */ 15 #include <linux/module.h> 16 #include <linux/param.h> 17 #include <linux/err.h> 18 #include <linux/platform_device.h> 19 #include <linux/regulator/driver.h> 20 #include <linux/regulator/machine.h> 21 #include <linux/i2c.h> 22 #include <linux/slab.h> 23 #include <linux/regmap.h> 24 #include <linux/regulator/fan53555.h> 25 26 /* Voltage setting */ 27 #define FAN53555_VSEL0 0x00 28 #define FAN53555_VSEL1 0x01 29 /* Control register */ 30 #define FAN53555_CONTROL 0x02 31 /* IC Type */ 32 #define FAN53555_ID1 0x03 33 /* IC mask version */ 34 #define FAN53555_ID2 0x04 35 /* Monitor register */ 36 #define FAN53555_MONITOR 0x05 37 38 /* VSEL bit definitions */ 39 #define VSEL_BUCK_EN (1 << 7) 40 #define VSEL_MODE (1 << 6) 41 #define VSEL_NSEL_MASK 0x3F 42 /* Chip ID and Verison */ 43 #define DIE_ID 0x0F /* ID1 */ 44 #define DIE_REV 0x0F /* ID2 */ 45 /* Control bit definitions */ 46 #define CTL_OUTPUT_DISCHG (1 << 7) 47 #define CTL_SLEW_MASK (0x7 << 4) 48 #define CTL_SLEW_SHIFT 4 49 #define CTL_RESET (1 << 2) 50 51 #define FAN53555_NVOLTAGES 64 /* Numbers of voltages */ 52 53 /* IC Type */ 54 enum { 55 FAN53555_CHIP_ID_00 = 0, 56 FAN53555_CHIP_ID_01, 57 FAN53555_CHIP_ID_02, 58 FAN53555_CHIP_ID_03, 59 FAN53555_CHIP_ID_04, 60 FAN53555_CHIP_ID_05, 61 }; 62 63 struct fan53555_device_info { 64 struct regmap *regmap; 65 struct device *dev; 66 struct regulator_desc desc; 67 struct regulator_dev *rdev; 68 struct regulator_init_data *regulator; 69 /* IC Type and Rev */ 70 int chip_id; 71 int chip_rev; 72 /* Voltage setting register */ 73 unsigned int vol_reg; 74 unsigned int sleep_reg; 75 /* Voltage range and step(linear) */ 76 unsigned int vsel_min; 77 unsigned int vsel_step; 78 /* Voltage slew rate limiting */ 79 unsigned int slew_rate; 80 /* Sleep voltage cache */ 81 unsigned int sleep_vol_cache; 82 }; 83 84 static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV) 85 { 86 struct fan53555_device_info *di = rdev_get_drvdata(rdev); 87 int ret; 88 89 if (di->sleep_vol_cache == uV) 90 return 0; 91 ret = regulator_map_voltage_linear(rdev, uV, uV); 92 if (ret < 0) 93 return -EINVAL; 94 ret = regmap_update_bits(di->regmap, di->sleep_reg, 95 VSEL_NSEL_MASK, ret); 96 if (ret < 0) 97 return -EINVAL; 98 /* Cache the sleep voltage setting. 99 * Might not be the real voltage which is rounded */ 100 di->sleep_vol_cache = uV; 101 102 return 0; 103 } 104 105 static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode) 106 { 107 struct fan53555_device_info *di = rdev_get_drvdata(rdev); 108 109 switch (mode) { 110 case REGULATOR_MODE_FAST: 111 regmap_update_bits(di->regmap, di->vol_reg, 112 VSEL_MODE, VSEL_MODE); 113 break; 114 case REGULATOR_MODE_NORMAL: 115 regmap_update_bits(di->regmap, di->vol_reg, VSEL_MODE, 0); 116 break; 117 default: 118 return -EINVAL; 119 } 120 return 0; 121 } 122 123 static unsigned int fan53555_get_mode(struct regulator_dev *rdev) 124 { 125 struct fan53555_device_info *di = rdev_get_drvdata(rdev); 126 unsigned int val; 127 int ret = 0; 128 129 ret = regmap_read(di->regmap, di->vol_reg, &val); 130 if (ret < 0) 131 return ret; 132 if (val & VSEL_MODE) 133 return REGULATOR_MODE_FAST; 134 else 135 return REGULATOR_MODE_NORMAL; 136 } 137 138 static struct regulator_ops fan53555_regulator_ops = { 139 .set_voltage_sel = regulator_set_voltage_sel_regmap, 140 .get_voltage_sel = regulator_get_voltage_sel_regmap, 141 .map_voltage = regulator_map_voltage_linear, 142 .list_voltage = regulator_list_voltage_linear, 143 .set_suspend_voltage = fan53555_set_suspend_voltage, 144 .enable = regulator_enable_regmap, 145 .disable = regulator_disable_regmap, 146 .is_enabled = regulator_is_enabled_regmap, 147 .set_mode = fan53555_set_mode, 148 .get_mode = fan53555_get_mode, 149 }; 150 151 /* For 00,01,03,05 options: 152 * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V. 153 * For 04 option: 154 * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V. 155 * */ 156 static int fan53555_device_setup(struct fan53555_device_info *di, 157 struct fan53555_platform_data *pdata) 158 { 159 unsigned int reg, data, mask; 160 161 /* Setup voltage control register */ 162 switch (pdata->sleep_vsel_id) { 163 case FAN53555_VSEL_ID_0: 164 di->sleep_reg = FAN53555_VSEL0; 165 di->vol_reg = FAN53555_VSEL1; 166 break; 167 case FAN53555_VSEL_ID_1: 168 di->sleep_reg = FAN53555_VSEL1; 169 di->vol_reg = FAN53555_VSEL0; 170 break; 171 default: 172 dev_err(di->dev, "Invalid VSEL ID!\n"); 173 return -EINVAL; 174 } 175 /* Init voltage range and step */ 176 switch (di->chip_id) { 177 case FAN53555_CHIP_ID_00: 178 case FAN53555_CHIP_ID_01: 179 case FAN53555_CHIP_ID_03: 180 case FAN53555_CHIP_ID_05: 181 di->vsel_min = 600000; 182 di->vsel_step = 10000; 183 break; 184 case FAN53555_CHIP_ID_04: 185 di->vsel_min = 603000; 186 di->vsel_step = 12826; 187 break; 188 default: 189 dev_err(di->dev, 190 "Chip ID[%d]\n not supported!\n", di->chip_id); 191 return -EINVAL; 192 } 193 /* Init slew rate */ 194 if (pdata->slew_rate & 0x7) 195 di->slew_rate = pdata->slew_rate; 196 else 197 di->slew_rate = FAN53555_SLEW_RATE_64MV; 198 reg = FAN53555_CONTROL; 199 data = di->slew_rate << CTL_SLEW_SHIFT; 200 mask = CTL_SLEW_MASK; 201 return regmap_update_bits(di->regmap, reg, mask, data); 202 } 203 204 static int fan53555_regulator_register(struct fan53555_device_info *di, 205 struct regulator_config *config) 206 { 207 struct regulator_desc *rdesc = &di->desc; 208 209 rdesc->name = "fan53555-reg"; 210 rdesc->ops = &fan53555_regulator_ops; 211 rdesc->type = REGULATOR_VOLTAGE; 212 rdesc->n_voltages = FAN53555_NVOLTAGES; 213 rdesc->enable_reg = di->vol_reg; 214 rdesc->enable_mask = VSEL_BUCK_EN; 215 rdesc->min_uV = di->vsel_min; 216 rdesc->uV_step = di->vsel_step; 217 rdesc->vsel_reg = di->vol_reg; 218 rdesc->vsel_mask = VSEL_NSEL_MASK; 219 rdesc->owner = THIS_MODULE; 220 221 di->rdev = regulator_register(&di->desc, config); 222 return PTR_ERR_OR_ZERO(di->rdev); 223 224 } 225 226 static struct regmap_config fan53555_regmap_config = { 227 .reg_bits = 8, 228 .val_bits = 8, 229 }; 230 231 static int fan53555_regulator_probe(struct i2c_client *client, 232 const struct i2c_device_id *id) 233 { 234 struct fan53555_device_info *di; 235 struct fan53555_platform_data *pdata; 236 struct regulator_config config = { }; 237 unsigned int val; 238 int ret; 239 240 pdata = dev_get_platdata(&client->dev); 241 if (!pdata || !pdata->regulator) { 242 dev_err(&client->dev, "Platform data not found!\n"); 243 return -ENODEV; 244 } 245 246 di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info), 247 GFP_KERNEL); 248 if (!di) { 249 dev_err(&client->dev, "Failed to allocate device info data!\n"); 250 return -ENOMEM; 251 } 252 di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config); 253 if (IS_ERR(di->regmap)) { 254 dev_err(&client->dev, "Failed to allocate regmap!\n"); 255 return PTR_ERR(di->regmap); 256 } 257 di->dev = &client->dev; 258 di->regulator = pdata->regulator; 259 i2c_set_clientdata(client, di); 260 /* Get chip ID */ 261 ret = regmap_read(di->regmap, FAN53555_ID1, &val); 262 if (ret < 0) { 263 dev_err(&client->dev, "Failed to get chip ID!\n"); 264 return -ENODEV; 265 } 266 di->chip_id = val & DIE_ID; 267 /* Get chip revision */ 268 ret = regmap_read(di->regmap, FAN53555_ID2, &val); 269 if (ret < 0) { 270 dev_err(&client->dev, "Failed to get chip Rev!\n"); 271 return -ENODEV; 272 } 273 di->chip_rev = val & DIE_REV; 274 dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n", 275 di->chip_id, di->chip_rev); 276 /* Device init */ 277 ret = fan53555_device_setup(di, pdata); 278 if (ret < 0) { 279 dev_err(&client->dev, "Failed to setup device!\n"); 280 return ret; 281 } 282 /* Register regulator */ 283 config.dev = di->dev; 284 config.init_data = di->regulator; 285 config.regmap = di->regmap; 286 config.driver_data = di; 287 ret = fan53555_regulator_register(di, &config); 288 if (ret < 0) 289 dev_err(&client->dev, "Failed to register regulator!\n"); 290 return ret; 291 292 } 293 294 static int fan53555_regulator_remove(struct i2c_client *client) 295 { 296 struct fan53555_device_info *di = i2c_get_clientdata(client); 297 298 regulator_unregister(di->rdev); 299 return 0; 300 } 301 302 static const struct i2c_device_id fan53555_id[] = { 303 {"fan53555", -1}, 304 { }, 305 }; 306 307 static struct i2c_driver fan53555_regulator_driver = { 308 .driver = { 309 .name = "fan53555-regulator", 310 }, 311 .probe = fan53555_regulator_probe, 312 .remove = fan53555_regulator_remove, 313 .id_table = fan53555_id, 314 }; 315 316 module_i2c_driver(fan53555_regulator_driver); 317 318 MODULE_AUTHOR("Yunfan Zhang <yfzhang@marvell.com>"); 319 MODULE_DESCRIPTION("FAN53555 regulator driver"); 320 MODULE_LICENSE("GPL v2"); 321