]>
Commit | Line | Data |
---|---|---|
55f4fa4e RJ |
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> | |
5a0e3ad6 | 25 | #include <linux/slab.h> |
55f4fa4e RJ |
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 | |
55f4fa4e RJ |
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 | ||
b110a8fb PZ |
40 | struct max1586_data { |
41 | struct i2c_client *client; | |
42 | ||
43 | /* min/max V3 voltage */ | |
c8f1e502 PZ |
44 | unsigned int min_uV; |
45 | unsigned int max_uV; | |
b110a8fb | 46 | |
4efd9dfe AL |
47 | unsigned int v3_curr_sel; |
48 | unsigned int v6_curr_sel; | |
49 | ||
b110a8fb PZ |
50 | struct regulator_dev *rdev[0]; |
51 | }; | |
52 | ||
96d25221 AL |
53 | /* |
54 | * V6 voltage | |
55 | * On I2C bus, sending a "x" byte to the max1586 means : | |
56 | * set V6 to either 0V, 1.8V, 2.5V, 3V depending on (x & 0x3) | |
57 | * As regulator framework doesn't accept voltages to be 0V, we use 1uV. | |
58 | */ | |
59 | static int v6_voltages_uv[] = { 1, 1800000, 2500000, 3000000 }; | |
60 | ||
55f4fa4e RJ |
61 | /* |
62 | * V3 voltage | |
63 | * On I2C bus, sending a "x" byte to the max1586 means : | |
64 | * set V3 to 0.700V + (x & 0x1f) * 0.025V | |
b110a8fb PZ |
65 | * This voltage can be increased by external resistors |
66 | * R24 and R25=100kOhm as described in the data sheet. | |
67 | * The gain is approximately: 1 + R24/R25 + R24/185.5kOhm | |
55f4fa4e | 68 | */ |
4efd9dfe AL |
69 | static int max1586_v3_get_voltage_sel(struct regulator_dev *rdev) |
70 | { | |
71 | struct max1586_data *max1586 = rdev_get_drvdata(rdev); | |
72 | ||
73 | return max1586->v3_curr_sel; | |
74 | } | |
75 | ||
9b558950 AL |
76 | static int max1586_v3_set_voltage_sel(struct regulator_dev *rdev, |
77 | unsigned selector) | |
55f4fa4e | 78 | { |
b110a8fb PZ |
79 | struct max1586_data *max1586 = rdev_get_drvdata(rdev); |
80 | struct i2c_client *client = max1586->client; | |
4efd9dfe | 81 | int ret; |
55f4fa4e RJ |
82 | u8 v3_prog; |
83 | ||
55f4fa4e | 84 | dev_dbg(&client->dev, "changing voltage v3 to %dmv\n", |
9b558950 | 85 | regulator_list_voltage_linear(rdev, selector) / 1000); |
55f4fa4e | 86 | |
9b558950 | 87 | v3_prog = I2C_V3_SELECT | (u8) selector; |
4efd9dfe AL |
88 | ret = i2c_smbus_write_byte(client, v3_prog); |
89 | if (ret) | |
90 | return ret; | |
91 | ||
92 | max1586->v3_curr_sel = selector; | |
93 | ||
94 | return 0; | |
95 | } | |
96 | ||
97 | static int max1586_v6_get_voltage_sel(struct regulator_dev *rdev) | |
98 | { | |
99 | struct max1586_data *max1586 = rdev_get_drvdata(rdev); | |
100 | ||
101 | return max1586->v6_curr_sel; | |
55f4fa4e RJ |
102 | } |
103 | ||
0d032731 AL |
104 | static int max1586_v6_set_voltage_sel(struct regulator_dev *rdev, |
105 | unsigned int selector) | |
55f4fa4e | 106 | { |
4efd9dfe AL |
107 | struct max1586_data *max1586 = rdev_get_drvdata(rdev); |
108 | struct i2c_client *client = max1586->client; | |
55f4fa4e | 109 | u8 v6_prog; |
4efd9dfe | 110 | int ret; |
55f4fa4e | 111 | |
55f4fa4e | 112 | dev_dbg(&client->dev, "changing voltage v6 to %dmv\n", |
0d032731 | 113 | rdev->desc->volt_table[selector] / 1000); |
55f4fa4e | 114 | |
0d032731 | 115 | v6_prog = I2C_V6_SELECT | (u8) selector; |
4efd9dfe AL |
116 | ret = i2c_smbus_write_byte(client, v6_prog); |
117 | if (ret) | |
118 | return ret; | |
119 | ||
120 | max1586->v6_curr_sel = selector; | |
121 | ||
122 | return 0; | |
55f4fa4e RJ |
123 | } |
124 | ||
55f4fa4e RJ |
125 | /* |
126 | * The Maxim 1586 controls V3 and V6 voltages, but offers no way of reading back | |
127 | * the set up value. | |
128 | */ | |
129 | static struct regulator_ops max1586_v3_ops = { | |
4efd9dfe | 130 | .get_voltage_sel = max1586_v3_get_voltage_sel, |
9b558950 | 131 | .set_voltage_sel = max1586_v3_set_voltage_sel, |
93f5de5c | 132 | .list_voltage = regulator_list_voltage_linear, |
9b558950 | 133 | .map_voltage = regulator_map_voltage_linear, |
55f4fa4e RJ |
134 | }; |
135 | ||
136 | static struct regulator_ops max1586_v6_ops = { | |
4efd9dfe | 137 | .get_voltage_sel = max1586_v6_get_voltage_sel, |
0d032731 | 138 | .set_voltage_sel = max1586_v6_set_voltage_sel, |
96d25221 | 139 | .list_voltage = regulator_list_voltage_table, |
55f4fa4e RJ |
140 | }; |
141 | ||
93f5de5c | 142 | static struct regulator_desc max1586_reg[] = { |
55f4fa4e RJ |
143 | { |
144 | .name = "Output_V3", | |
145 | .id = MAX1586_V3, | |
146 | .ops = &max1586_v3_ops, | |
147 | .type = REGULATOR_VOLTAGE, | |
148 | .n_voltages = MAX1586_V3_MAX_VSEL + 1, | |
149 | .owner = THIS_MODULE, | |
150 | }, | |
151 | { | |
152 | .name = "Output_V6", | |
153 | .id = MAX1586_V6, | |
154 | .ops = &max1586_v6_ops, | |
155 | .type = REGULATOR_VOLTAGE, | |
156 | .n_voltages = MAX1586_V6_MAX_VSEL + 1, | |
96d25221 | 157 | .volt_table = v6_voltages_uv, |
55f4fa4e RJ |
158 | .owner = THIS_MODULE, |
159 | }, | |
160 | }; | |
161 | ||
a5023574 | 162 | static int max1586_pmic_probe(struct i2c_client *client, |
bd88c9b2 | 163 | const struct i2c_device_id *i2c_id) |
55f4fa4e RJ |
164 | { |
165 | struct regulator_dev **rdev; | |
166 | struct max1586_platform_data *pdata = client->dev.platform_data; | |
c172708d | 167 | struct regulator_config config = { }; |
b110a8fb PZ |
168 | struct max1586_data *max1586; |
169 | int i, id, ret = -ENOMEM; | |
170 | ||
b7bd05b8 | 171 | max1586 = devm_kzalloc(&client->dev, sizeof(struct max1586_data) + |
b110a8fb PZ |
172 | sizeof(struct regulator_dev *) * (MAX1586_V6 + 1), |
173 | GFP_KERNEL); | |
174 | if (!max1586) | |
b7bd05b8 | 175 | return -ENOMEM; |
55f4fa4e | 176 | |
b110a8fb | 177 | max1586->client = client; |
55f4fa4e | 178 | |
b7bd05b8 AL |
179 | if (!pdata->v3_gain) |
180 | return -EINVAL; | |
181 | ||
c8f1e502 PZ |
182 | max1586->min_uV = MAX1586_V3_MIN_UV / 1000 * pdata->v3_gain / 1000; |
183 | max1586->max_uV = MAX1586_V3_MAX_UV / 1000 * pdata->v3_gain / 1000; | |
b110a8fb | 184 | |
4efd9dfe AL |
185 | /* Set curr_sel to default voltage on power-up */ |
186 | max1586->v3_curr_sel = 24; /* 1.3V */ | |
187 | max1586->v6_curr_sel = 0; | |
188 | ||
b110a8fb | 189 | rdev = max1586->rdev; |
55f4fa4e RJ |
190 | for (i = 0; i < pdata->num_subdevs && i <= MAX1586_V6; i++) { |
191 | id = pdata->subdevs[i].id; | |
192 | if (!pdata->subdevs[i].platform_data) | |
193 | continue; | |
194 | if (id < MAX1586_V3 || id > MAX1586_V6) { | |
195 | dev_err(&client->dev, "invalid regulator id %d\n", id); | |
196 | goto err; | |
197 | } | |
c172708d | 198 | |
93f5de5c AL |
199 | if (id == MAX1586_V3) { |
200 | max1586_reg[id].min_uV = max1586->min_uV; | |
201 | max1586_reg[id].uV_step = | |
202 | (max1586->max_uV - max1586->min_uV) / | |
203 | MAX1586_V3_MAX_VSEL; | |
204 | } | |
205 | ||
c172708d MB |
206 | config.dev = &client->dev; |
207 | config.init_data = pdata->subdevs[i].platform_data; | |
208 | config.driver_data = max1586; | |
209 | ||
210 | rdev[i] = regulator_register(&max1586_reg[id], &config); | |
55f4fa4e RJ |
211 | if (IS_ERR(rdev[i])) { |
212 | ret = PTR_ERR(rdev[i]); | |
213 | dev_err(&client->dev, "failed to register %s\n", | |
214 | max1586_reg[id].name); | |
215 | goto err; | |
216 | } | |
217 | } | |
218 | ||
7c4c25e4 | 219 | i2c_set_clientdata(client, max1586); |
55f4fa4e RJ |
220 | dev_info(&client->dev, "Maxim 1586 regulator driver loaded\n"); |
221 | return 0; | |
222 | ||
223 | err: | |
224 | while (--i >= 0) | |
225 | regulator_unregister(rdev[i]); | |
55f4fa4e RJ |
226 | return ret; |
227 | } | |
228 | ||
8dc995f5 | 229 | static int max1586_pmic_remove(struct i2c_client *client) |
55f4fa4e | 230 | { |
7c4c25e4 | 231 | struct max1586_data *max1586 = i2c_get_clientdata(client); |
55f4fa4e RJ |
232 | int i; |
233 | ||
234 | for (i = 0; i <= MAX1586_V6; i++) | |
7c4c25e4 AL |
235 | if (max1586->rdev[i]) |
236 | regulator_unregister(max1586->rdev[i]); | |
55f4fa4e RJ |
237 | return 0; |
238 | } | |
239 | ||
240 | static const struct i2c_device_id max1586_id[] = { | |
241 | { "max1586", 0 }, | |
242 | { } | |
243 | }; | |
244 | MODULE_DEVICE_TABLE(i2c, max1586_id); | |
245 | ||
246 | static struct i2c_driver max1586_pmic_driver = { | |
247 | .probe = max1586_pmic_probe, | |
5eb9f2b9 | 248 | .remove = max1586_pmic_remove, |
55f4fa4e RJ |
249 | .driver = { |
250 | .name = "max1586", | |
bd88c9b2 | 251 | .owner = THIS_MODULE, |
55f4fa4e RJ |
252 | }, |
253 | .id_table = max1586_id, | |
254 | }; | |
255 | ||
256 | static int __init max1586_pmic_init(void) | |
257 | { | |
258 | return i2c_add_driver(&max1586_pmic_driver); | |
259 | } | |
260 | subsys_initcall(max1586_pmic_init); | |
261 | ||
262 | static void __exit max1586_pmic_exit(void) | |
263 | { | |
264 | i2c_del_driver(&max1586_pmic_driver); | |
265 | } | |
266 | module_exit(max1586_pmic_exit); | |
267 | ||
268 | /* Module information */ | |
269 | MODULE_DESCRIPTION("MAXIM 1586 voltage regulator driver"); | |
270 | MODULE_AUTHOR("Robert Jarzmik"); | |
271 | MODULE_LICENSE("GPL"); |