1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * max1586.c -- Voltage and current regulation for the Maxim 1586 4 * 5 * Copyright (C) 2008 Robert Jarzmik 6 */ 7 #include <linux/module.h> 8 #include <linux/err.h> 9 #include <linux/i2c.h> 10 #include <linux/platform_device.h> 11 #include <linux/regulator/driver.h> 12 #include <linux/slab.h> 13 #include <linux/regulator/max1586.h> 14 #include <linux/of.h> 15 #include <linux/regulator/of_regulator.h> 16 17 #define MAX1586_V3_MAX_VSEL 31 18 #define MAX1586_V6_MAX_VSEL 3 19 20 #define MAX1586_V3_MIN_UV 700000 21 #define MAX1586_V3_MAX_UV 1475000 22 23 #define MAX1586_V6_MIN_UV 0 24 #define MAX1586_V6_MAX_UV 3000000 25 26 #define I2C_V3_SELECT (0 << 5) 27 #define I2C_V6_SELECT (1 << 5) 28 29 struct max1586_data { 30 struct i2c_client *client; 31 32 /* min/max V3 voltage */ 33 unsigned int min_uV; 34 unsigned int max_uV; 35 36 unsigned int v3_curr_sel; 37 unsigned int v6_curr_sel; 38 }; 39 40 /* 41 * V6 voltage 42 * On I2C bus, sending a "x" byte to the max1586 means : 43 * set V6 to either 0V, 1.8V, 2.5V, 3V depending on (x & 0x3) 44 * As regulator framework doesn't accept voltages to be 0V, we use 1uV. 45 */ 46 static const unsigned int v6_voltages_uv[] = { 1, 1800000, 2500000, 3000000 }; 47 48 /* 49 * V3 voltage 50 * On I2C bus, sending a "x" byte to the max1586 means : 51 * set V3 to 0.700V + (x & 0x1f) * 0.025V 52 * This voltage can be increased by external resistors 53 * R24 and R25=100kOhm as described in the data sheet. 54 * The gain is approximately: 1 + R24/R25 + R24/185.5kOhm 55 */ 56 static int max1586_v3_get_voltage_sel(struct regulator_dev *rdev) 57 { 58 struct max1586_data *max1586 = rdev_get_drvdata(rdev); 59 60 return max1586->v3_curr_sel; 61 } 62 63 static int max1586_v3_set_voltage_sel(struct regulator_dev *rdev, 64 unsigned selector) 65 { 66 struct max1586_data *max1586 = rdev_get_drvdata(rdev); 67 struct i2c_client *client = max1586->client; 68 int ret; 69 u8 v3_prog; 70 71 dev_dbg(&client->dev, "changing voltage v3 to %dmv\n", 72 regulator_list_voltage_linear(rdev, selector) / 1000); 73 74 v3_prog = I2C_V3_SELECT | (u8) selector; 75 ret = i2c_smbus_write_byte(client, v3_prog); 76 if (ret) 77 return ret; 78 79 max1586->v3_curr_sel = selector; 80 81 return 0; 82 } 83 84 static int max1586_v6_get_voltage_sel(struct regulator_dev *rdev) 85 { 86 struct max1586_data *max1586 = rdev_get_drvdata(rdev); 87 88 return max1586->v6_curr_sel; 89 } 90 91 static int max1586_v6_set_voltage_sel(struct regulator_dev *rdev, 92 unsigned int selector) 93 { 94 struct max1586_data *max1586 = rdev_get_drvdata(rdev); 95 struct i2c_client *client = max1586->client; 96 u8 v6_prog; 97 int ret; 98 99 dev_dbg(&client->dev, "changing voltage v6 to %dmv\n", 100 rdev->desc->volt_table[selector] / 1000); 101 102 v6_prog = I2C_V6_SELECT | (u8) selector; 103 ret = i2c_smbus_write_byte(client, v6_prog); 104 if (ret) 105 return ret; 106 107 max1586->v6_curr_sel = selector; 108 109 return 0; 110 } 111 112 /* 113 * The Maxim 1586 controls V3 and V6 voltages, but offers no way of reading back 114 * the set up value. 115 */ 116 static const struct regulator_ops max1586_v3_ops = { 117 .get_voltage_sel = max1586_v3_get_voltage_sel, 118 .set_voltage_sel = max1586_v3_set_voltage_sel, 119 .list_voltage = regulator_list_voltage_linear, 120 .map_voltage = regulator_map_voltage_linear, 121 }; 122 123 static const struct regulator_ops max1586_v6_ops = { 124 .get_voltage_sel = max1586_v6_get_voltage_sel, 125 .set_voltage_sel = max1586_v6_set_voltage_sel, 126 .list_voltage = regulator_list_voltage_table, 127 }; 128 129 static struct regulator_desc max1586_reg[] = { 130 { 131 .name = "Output_V3", 132 .id = MAX1586_V3, 133 .ops = &max1586_v3_ops, 134 .type = REGULATOR_VOLTAGE, 135 .n_voltages = MAX1586_V3_MAX_VSEL + 1, 136 .owner = THIS_MODULE, 137 }, 138 { 139 .name = "Output_V6", 140 .id = MAX1586_V6, 141 .ops = &max1586_v6_ops, 142 .type = REGULATOR_VOLTAGE, 143 .n_voltages = MAX1586_V6_MAX_VSEL + 1, 144 .volt_table = v6_voltages_uv, 145 .owner = THIS_MODULE, 146 }, 147 }; 148 149 static int of_get_max1586_platform_data(struct device *dev, 150 struct max1586_platform_data *pdata) 151 { 152 struct max1586_subdev_data *sub; 153 struct of_regulator_match rmatch[ARRAY_SIZE(max1586_reg)] = { }; 154 struct device_node *np = dev->of_node; 155 int i, matched; 156 157 if (of_property_read_u32(np, "v3-gain", 158 &pdata->v3_gain) < 0) { 159 dev_err(dev, "%pOF has no 'v3-gain' property\n", np); 160 return -EINVAL; 161 } 162 163 np = of_get_child_by_name(np, "regulators"); 164 if (!np) { 165 dev_err(dev, "missing 'regulators' subnode in DT\n"); 166 return -EINVAL; 167 } 168 169 for (i = 0; i < ARRAY_SIZE(rmatch); i++) 170 rmatch[i].name = max1586_reg[i].name; 171 172 matched = of_regulator_match(dev, np, rmatch, ARRAY_SIZE(rmatch)); 173 of_node_put(np); 174 /* 175 * If matched is 0, ie. neither Output_V3 nor Output_V6 have been found, 176 * return 0, which signals the normal situation where no subregulator is 177 * available. This is normal because the max1586 doesn't provide any 178 * readback support, so the subregulators can't report any status 179 * anyway. If matched < 0, return the error. 180 */ 181 if (matched <= 0) 182 return matched; 183 184 pdata->subdevs = devm_kcalloc(dev, 185 matched, 186 sizeof(struct max1586_subdev_data), 187 GFP_KERNEL); 188 if (!pdata->subdevs) 189 return -ENOMEM; 190 191 pdata->num_subdevs = matched; 192 sub = pdata->subdevs; 193 194 for (i = 0; i < matched; i++) { 195 sub->id = i; 196 sub->name = rmatch[i].of_node->name; 197 sub->platform_data = rmatch[i].init_data; 198 sub++; 199 } 200 201 return 0; 202 } 203 204 static const struct of_device_id __maybe_unused max1586_of_match[] = { 205 { .compatible = "maxim,max1586", }, 206 {}, 207 }; 208 MODULE_DEVICE_TABLE(of, max1586_of_match); 209 210 static int max1586_pmic_probe(struct i2c_client *client) 211 { 212 struct max1586_platform_data *pdata, pdata_of; 213 struct regulator_config config = { }; 214 struct max1586_data *max1586; 215 int i, id, ret; 216 217 pdata = dev_get_platdata(&client->dev); 218 if (client->dev.of_node && !pdata) { 219 ret = of_get_max1586_platform_data(&client->dev, &pdata_of); 220 if (ret < 0) 221 return ret; 222 pdata = &pdata_of; 223 } 224 225 max1586 = devm_kzalloc(&client->dev, sizeof(struct max1586_data), 226 GFP_KERNEL); 227 if (!max1586) 228 return -ENOMEM; 229 230 max1586->client = client; 231 232 if (!pdata->v3_gain) 233 return -EINVAL; 234 235 max1586->min_uV = MAX1586_V3_MIN_UV / 1000 * pdata->v3_gain / 1000; 236 max1586->max_uV = MAX1586_V3_MAX_UV / 1000 * pdata->v3_gain / 1000; 237 238 /* Set curr_sel to default voltage on power-up */ 239 max1586->v3_curr_sel = 24; /* 1.3V */ 240 max1586->v6_curr_sel = 0; 241 242 for (i = 0; i < pdata->num_subdevs && i <= MAX1586_V6; i++) { 243 struct regulator_dev *rdev; 244 245 id = pdata->subdevs[i].id; 246 if (!pdata->subdevs[i].platform_data) 247 continue; 248 if (id < MAX1586_V3 || id > MAX1586_V6) { 249 dev_err(&client->dev, "invalid regulator id %d\n", id); 250 return -EINVAL; 251 } 252 253 if (id == MAX1586_V3) { 254 max1586_reg[id].min_uV = max1586->min_uV; 255 max1586_reg[id].uV_step = 256 (max1586->max_uV - max1586->min_uV) / 257 MAX1586_V3_MAX_VSEL; 258 } 259 260 config.dev = &client->dev; 261 config.init_data = pdata->subdevs[i].platform_data; 262 config.driver_data = max1586; 263 264 rdev = devm_regulator_register(&client->dev, 265 &max1586_reg[id], &config); 266 if (IS_ERR(rdev)) { 267 dev_err(&client->dev, "failed to register %s\n", 268 max1586_reg[id].name); 269 return PTR_ERR(rdev); 270 } 271 } 272 273 i2c_set_clientdata(client, max1586); 274 dev_info(&client->dev, "Maxim 1586 regulator driver loaded\n"); 275 return 0; 276 } 277 278 static const struct i2c_device_id max1586_id[] = { 279 { "max1586", 0 }, 280 { } 281 }; 282 MODULE_DEVICE_TABLE(i2c, max1586_id); 283 284 static struct i2c_driver max1586_pmic_driver = { 285 .probe = max1586_pmic_probe, 286 .driver = { 287 .name = "max1586", 288 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 289 .of_match_table = of_match_ptr(max1586_of_match), 290 }, 291 .id_table = max1586_id, 292 }; 293 294 static int __init max1586_pmic_init(void) 295 { 296 return i2c_add_driver(&max1586_pmic_driver); 297 } 298 subsys_initcall(max1586_pmic_init); 299 300 static void __exit max1586_pmic_exit(void) 301 { 302 i2c_del_driver(&max1586_pmic_driver); 303 } 304 module_exit(max1586_pmic_exit); 305 306 /* Module information */ 307 MODULE_DESCRIPTION("MAXIM 1586 voltage regulator driver"); 308 MODULE_AUTHOR("Robert Jarzmik"); 309 MODULE_LICENSE("GPL"); 310