Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 1 | /* |
| 2 | * max1586.c -- Voltage and current regulation for the Maxim 1586 |
| 3 | * |
| 4 | * Copyright (C) 2008 Robert Jarzmik |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 19 | */ |
| 20 | #include <linux/module.h> |
| 21 | #include <linux/err.h> |
| 22 | #include <linux/i2c.h> |
| 23 | #include <linux/platform_device.h> |
| 24 | #include <linux/regulator/driver.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 25 | #include <linux/slab.h> |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 26 | #include <linux/regulator/max1586.h> |
| 27 | |
| 28 | #define MAX1586_V3_MAX_VSEL 31 |
| 29 | #define MAX1586_V6_MAX_VSEL 3 |
| 30 | |
| 31 | #define MAX1586_V3_MIN_UV 700000 |
| 32 | #define MAX1586_V3_MAX_UV 1475000 |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 33 | |
| 34 | #define MAX1586_V6_MIN_UV 0 |
| 35 | #define MAX1586_V6_MAX_UV 3000000 |
| 36 | |
| 37 | #define I2C_V3_SELECT (0 << 5) |
| 38 | #define I2C_V6_SELECT (1 << 5) |
| 39 | |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 40 | struct max1586_data { |
| 41 | struct i2c_client *client; |
| 42 | |
| 43 | /* min/max V3 voltage */ |
Philipp Zabel | c8f1e50 | 2009-05-28 21:00:03 +0200 | [diff] [blame] | 44 | unsigned int min_uV; |
| 45 | unsigned int max_uV; |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 46 | |
| 47 | struct regulator_dev *rdev[0]; |
| 48 | }; |
| 49 | |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 50 | /* |
| 51 | * V3 voltage |
| 52 | * On I2C bus, sending a "x" byte to the max1586 means : |
| 53 | * set V3 to 0.700V + (x & 0x1f) * 0.025V |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 54 | * This voltage can be increased by external resistors |
| 55 | * R24 and R25=100kOhm as described in the data sheet. |
| 56 | * The gain is approximately: 1 + R24/R25 + R24/185.5kOhm |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 57 | */ |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 58 | static int max1586_v3_calc_voltage(struct max1586_data *max1586, |
| 59 | unsigned selector) |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 60 | { |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 61 | unsigned range_uV = max1586->max_uV - max1586->min_uV; |
| 62 | |
| 63 | return max1586->min_uV + (selector * range_uV / MAX1586_V3_MAX_VSEL); |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 64 | } |
| 65 | |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 66 | static int max1586_v3_set(struct regulator_dev *rdev, int min_uV, int max_uV, |
| 67 | unsigned *selector) |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 68 | { |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 69 | struct max1586_data *max1586 = rdev_get_drvdata(rdev); |
| 70 | struct i2c_client *client = max1586->client; |
| 71 | unsigned range_uV = max1586->max_uV - max1586->min_uV; |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 72 | u8 v3_prog; |
| 73 | |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 74 | if (min_uV > max1586->max_uV || max_uV < max1586->min_uV) |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 75 | return -EINVAL; |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 76 | if (min_uV < max1586->min_uV) |
| 77 | min_uV = max1586->min_uV; |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 78 | |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 79 | *selector = ((min_uV - max1586->min_uV) * MAX1586_V3_MAX_VSEL + |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 80 | range_uV - 1) / range_uV; |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 81 | if (max1586_v3_calc_voltage(max1586, *selector) > max_uV) |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 82 | return -EINVAL; |
| 83 | |
| 84 | dev_dbg(&client->dev, "changing voltage v3 to %dmv\n", |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 85 | max1586_v3_calc_voltage(max1586, *selector) / 1000); |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 86 | |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 87 | v3_prog = I2C_V3_SELECT | (u8) *selector; |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 88 | return i2c_smbus_write_byte(client, v3_prog); |
| 89 | } |
| 90 | |
| 91 | static int max1586_v3_list(struct regulator_dev *rdev, unsigned selector) |
| 92 | { |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 93 | struct max1586_data *max1586 = rdev_get_drvdata(rdev); |
| 94 | |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 95 | if (selector > MAX1586_V3_MAX_VSEL) |
| 96 | return -EINVAL; |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 97 | return max1586_v3_calc_voltage(max1586, selector); |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 98 | } |
| 99 | |
| 100 | /* |
| 101 | * V6 voltage |
| 102 | * On I2C bus, sending a "x" byte to the max1586 means : |
| 103 | * set V6 to either 0V, 1.8V, 2.5V, 3V depending on (x & 0x3) |
| 104 | * As regulator framework doesn't accept voltages to be 0V, we use 1uV. |
| 105 | */ |
| 106 | static int max1586_v6_calc_voltage(unsigned selector) |
| 107 | { |
| 108 | static int voltages_uv[] = { 1, 1800000, 2500000, 3000000 }; |
| 109 | |
| 110 | return voltages_uv[selector]; |
| 111 | } |
| 112 | |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 113 | static int max1586_v6_set(struct regulator_dev *rdev, int min_uV, int max_uV, |
| 114 | unsigned int *selector) |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 115 | { |
| 116 | struct i2c_client *client = rdev_get_drvdata(rdev); |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 117 | u8 v6_prog; |
| 118 | |
| 119 | if (min_uV < MAX1586_V6_MIN_UV || min_uV > MAX1586_V6_MAX_UV) |
| 120 | return -EINVAL; |
| 121 | if (max_uV < MAX1586_V6_MIN_UV || max_uV > MAX1586_V6_MAX_UV) |
| 122 | return -EINVAL; |
| 123 | |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 124 | if (min_uV < 1800000) |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 125 | *selector = 0; |
Axel Lin | 3e352f9 | 2010-08-18 11:37:21 +0800 | [diff] [blame] | 126 | else if (min_uV < 2500000) |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 127 | *selector = 1; |
Axel Lin | 3e352f9 | 2010-08-18 11:37:21 +0800 | [diff] [blame] | 128 | else if (min_uV < 3000000) |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 129 | *selector = 2; |
Axel Lin | 3e352f9 | 2010-08-18 11:37:21 +0800 | [diff] [blame] | 130 | else if (min_uV >= 3000000) |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 131 | *selector = 3; |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 132 | |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 133 | if (max1586_v6_calc_voltage(*selector) > max_uV) |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 134 | return -EINVAL; |
| 135 | |
| 136 | dev_dbg(&client->dev, "changing voltage v6 to %dmv\n", |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 137 | max1586_v6_calc_voltage(*selector) / 1000); |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 138 | |
Mark Brown | 3a93f2a | 2010-11-10 14:38:29 +0000 | [diff] [blame^] | 139 | v6_prog = I2C_V6_SELECT | (u8) *selector; |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 140 | return i2c_smbus_write_byte(client, v6_prog); |
| 141 | } |
| 142 | |
| 143 | static int max1586_v6_list(struct regulator_dev *rdev, unsigned selector) |
| 144 | { |
| 145 | if (selector > MAX1586_V6_MAX_VSEL) |
| 146 | return -EINVAL; |
| 147 | return max1586_v6_calc_voltage(selector); |
| 148 | } |
| 149 | |
| 150 | /* |
| 151 | * The Maxim 1586 controls V3 and V6 voltages, but offers no way of reading back |
| 152 | * the set up value. |
| 153 | */ |
| 154 | static struct regulator_ops max1586_v3_ops = { |
| 155 | .set_voltage = max1586_v3_set, |
| 156 | .list_voltage = max1586_v3_list, |
| 157 | }; |
| 158 | |
| 159 | static struct regulator_ops max1586_v6_ops = { |
| 160 | .set_voltage = max1586_v6_set, |
| 161 | .list_voltage = max1586_v6_list, |
| 162 | }; |
| 163 | |
| 164 | static struct regulator_desc max1586_reg[] = { |
| 165 | { |
| 166 | .name = "Output_V3", |
| 167 | .id = MAX1586_V3, |
| 168 | .ops = &max1586_v3_ops, |
| 169 | .type = REGULATOR_VOLTAGE, |
| 170 | .n_voltages = MAX1586_V3_MAX_VSEL + 1, |
| 171 | .owner = THIS_MODULE, |
| 172 | }, |
| 173 | { |
| 174 | .name = "Output_V6", |
| 175 | .id = MAX1586_V6, |
| 176 | .ops = &max1586_v6_ops, |
| 177 | .type = REGULATOR_VOLTAGE, |
| 178 | .n_voltages = MAX1586_V6_MAX_VSEL + 1, |
| 179 | .owner = THIS_MODULE, |
| 180 | }, |
| 181 | }; |
| 182 | |
Dmitry Torokhov | bd88c9b | 2010-02-23 23:38:23 -0800 | [diff] [blame] | 183 | static int __devinit max1586_pmic_probe(struct i2c_client *client, |
| 184 | const struct i2c_device_id *i2c_id) |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 185 | { |
| 186 | struct regulator_dev **rdev; |
| 187 | struct max1586_platform_data *pdata = client->dev.platform_data; |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 188 | struct max1586_data *max1586; |
| 189 | int i, id, ret = -ENOMEM; |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 190 | |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 191 | max1586 = kzalloc(sizeof(struct max1586_data) + |
| 192 | sizeof(struct regulator_dev *) * (MAX1586_V6 + 1), |
| 193 | GFP_KERNEL); |
| 194 | if (!max1586) |
| 195 | goto out; |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 196 | |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 197 | max1586->client = client; |
| 198 | |
| 199 | if (!pdata->v3_gain) { |
| 200 | ret = -EINVAL; |
| 201 | goto out_unmap; |
| 202 | } |
Philipp Zabel | c8f1e50 | 2009-05-28 21:00:03 +0200 | [diff] [blame] | 203 | max1586->min_uV = MAX1586_V3_MIN_UV / 1000 * pdata->v3_gain / 1000; |
| 204 | max1586->max_uV = MAX1586_V3_MAX_UV / 1000 * pdata->v3_gain / 1000; |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 205 | |
| 206 | rdev = max1586->rdev; |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 207 | for (i = 0; i < pdata->num_subdevs && i <= MAX1586_V6; i++) { |
| 208 | id = pdata->subdevs[i].id; |
| 209 | if (!pdata->subdevs[i].platform_data) |
| 210 | continue; |
| 211 | if (id < MAX1586_V3 || id > MAX1586_V6) { |
| 212 | dev_err(&client->dev, "invalid regulator id %d\n", id); |
| 213 | goto err; |
| 214 | } |
| 215 | rdev[i] = regulator_register(&max1586_reg[id], &client->dev, |
| 216 | pdata->subdevs[i].platform_data, |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 217 | max1586); |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 218 | if (IS_ERR(rdev[i])) { |
| 219 | ret = PTR_ERR(rdev[i]); |
| 220 | dev_err(&client->dev, "failed to register %s\n", |
| 221 | max1586_reg[id].name); |
| 222 | goto err; |
| 223 | } |
| 224 | } |
| 225 | |
Axel Lin | 7c4c25e | 2010-08-06 13:33:15 +0800 | [diff] [blame] | 226 | i2c_set_clientdata(client, max1586); |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 227 | dev_info(&client->dev, "Maxim 1586 regulator driver loaded\n"); |
| 228 | return 0; |
| 229 | |
| 230 | err: |
| 231 | while (--i >= 0) |
| 232 | regulator_unregister(rdev[i]); |
Philipp Zabel | b110a8f | 2009-05-28 07:15:16 +0200 | [diff] [blame] | 233 | out_unmap: |
| 234 | kfree(max1586); |
| 235 | out: |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 236 | return ret; |
| 237 | } |
| 238 | |
Dmitry Torokhov | bd88c9b | 2010-02-23 23:38:23 -0800 | [diff] [blame] | 239 | static int __devexit max1586_pmic_remove(struct i2c_client *client) |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 240 | { |
Axel Lin | 7c4c25e | 2010-08-06 13:33:15 +0800 | [diff] [blame] | 241 | struct max1586_data *max1586 = i2c_get_clientdata(client); |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 242 | int i; |
| 243 | |
| 244 | for (i = 0; i <= MAX1586_V6; i++) |
Axel Lin | 7c4c25e | 2010-08-06 13:33:15 +0800 | [diff] [blame] | 245 | if (max1586->rdev[i]) |
| 246 | regulator_unregister(max1586->rdev[i]); |
| 247 | kfree(max1586); |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 248 | |
| 249 | return 0; |
| 250 | } |
| 251 | |
| 252 | static const struct i2c_device_id max1586_id[] = { |
| 253 | { "max1586", 0 }, |
| 254 | { } |
| 255 | }; |
| 256 | MODULE_DEVICE_TABLE(i2c, max1586_id); |
| 257 | |
| 258 | static struct i2c_driver max1586_pmic_driver = { |
| 259 | .probe = max1586_pmic_probe, |
Dmitry Torokhov | bd88c9b | 2010-02-23 23:38:23 -0800 | [diff] [blame] | 260 | .remove = __devexit_p(max1586_pmic_remove), |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 261 | .driver = { |
| 262 | .name = "max1586", |
Dmitry Torokhov | bd88c9b | 2010-02-23 23:38:23 -0800 | [diff] [blame] | 263 | .owner = THIS_MODULE, |
Robert Jarzmik | 55f4fa4 | 2009-04-23 20:10:43 +0200 | [diff] [blame] | 264 | }, |
| 265 | .id_table = max1586_id, |
| 266 | }; |
| 267 | |
| 268 | static int __init max1586_pmic_init(void) |
| 269 | { |
| 270 | return i2c_add_driver(&max1586_pmic_driver); |
| 271 | } |
| 272 | subsys_initcall(max1586_pmic_init); |
| 273 | |
| 274 | static void __exit max1586_pmic_exit(void) |
| 275 | { |
| 276 | i2c_del_driver(&max1586_pmic_driver); |
| 277 | } |
| 278 | module_exit(max1586_pmic_exit); |
| 279 | |
| 280 | /* Module information */ |
| 281 | MODULE_DESCRIPTION("MAXIM 1586 voltage regulator driver"); |
| 282 | MODULE_AUTHOR("Robert Jarzmik"); |
| 283 | MODULE_LICENSE("GPL"); |