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_device.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 const struct of_device_id *match; 217 218 pdata = dev_get_platdata(&client->dev); 219 if (client->dev.of_node && !pdata) { 220 match = of_match_device(of_match_ptr(max1586_of_match), 221 &client->dev); 222 if (!match) { 223 dev_err(&client->dev, "Error: No device match found\n"); 224 return -ENODEV; 225 } 226 ret = of_get_max1586_platform_data(&client->dev, &pdata_of); 227 if (ret < 0) 228 return ret; 229 pdata = &pdata_of; 230 } 231 232 max1586 = devm_kzalloc(&client->dev, sizeof(struct max1586_data), 233 GFP_KERNEL); 234 if (!max1586) 235 return -ENOMEM; 236 237 max1586->client = client; 238 239 if (!pdata->v3_gain) 240 return -EINVAL; 241 242 max1586->min_uV = MAX1586_V3_MIN_UV / 1000 * pdata->v3_gain / 1000; 243 max1586->max_uV = MAX1586_V3_MAX_UV / 1000 * pdata->v3_gain / 1000; 244 245 /* Set curr_sel to default voltage on power-up */ 246 max1586->v3_curr_sel = 24; /* 1.3V */ 247 max1586->v6_curr_sel = 0; 248 249 for (i = 0; i < pdata->num_subdevs && i <= MAX1586_V6; i++) { 250 struct regulator_dev *rdev; 251 252 id = pdata->subdevs[i].id; 253 if (!pdata->subdevs[i].platform_data) 254 continue; 255 if (id < MAX1586_V3 || id > MAX1586_V6) { 256 dev_err(&client->dev, "invalid regulator id %d\n", id); 257 return -EINVAL; 258 } 259 260 if (id == MAX1586_V3) { 261 max1586_reg[id].min_uV = max1586->min_uV; 262 max1586_reg[id].uV_step = 263 (max1586->max_uV - max1586->min_uV) / 264 MAX1586_V3_MAX_VSEL; 265 } 266 267 config.dev = &client->dev; 268 config.init_data = pdata->subdevs[i].platform_data; 269 config.driver_data = max1586; 270 271 rdev = devm_regulator_register(&client->dev, 272 &max1586_reg[id], &config); 273 if (IS_ERR(rdev)) { 274 dev_err(&client->dev, "failed to register %s\n", 275 max1586_reg[id].name); 276 return PTR_ERR(rdev); 277 } 278 } 279 280 i2c_set_clientdata(client, max1586); 281 dev_info(&client->dev, "Maxim 1586 regulator driver loaded\n"); 282 return 0; 283 } 284 285 static const struct i2c_device_id max1586_id[] = { 286 { "max1586", 0 }, 287 { } 288 }; 289 MODULE_DEVICE_TABLE(i2c, max1586_id); 290 291 static struct i2c_driver max1586_pmic_driver = { 292 .probe = max1586_pmic_probe, 293 .driver = { 294 .name = "max1586", 295 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 296 .of_match_table = of_match_ptr(max1586_of_match), 297 }, 298 .id_table = max1586_id, 299 }; 300 301 static int __init max1586_pmic_init(void) 302 { 303 return i2c_add_driver(&max1586_pmic_driver); 304 } 305 subsys_initcall(max1586_pmic_init); 306 307 static void __exit max1586_pmic_exit(void) 308 { 309 i2c_del_driver(&max1586_pmic_driver); 310 } 311 module_exit(max1586_pmic_exit); 312 313 /* Module information */ 314 MODULE_DESCRIPTION("MAXIM 1586 voltage regulator driver"); 315 MODULE_AUTHOR("Robert Jarzmik"); 316 MODULE_LICENSE("GPL"); 317