]>
Commit | Line | Data |
---|---|---|
156f2528 | 1 | /* |
2c7e6f57 | 2 | * max8998.c - mfd core driver for the Maxim 8998 |
156f2528 KP |
3 | * |
4 | * Copyright (C) 2009-2010 Samsung Electronics | |
5 | * Kyungmin Park <kyungmin.park@samsung.com> | |
6 | * Marek Szyprowski <m.szyprowski@samsung.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
21 | */ | |
22 | ||
ee999fb3 | 23 | #include <linux/err.h> |
156f2528 KP |
24 | #include <linux/module.h> |
25 | #include <linux/moduleparam.h> | |
26 | #include <linux/init.h> | |
27 | #include <linux/slab.h> | |
28 | #include <linux/i2c.h> | |
cdd137c9 | 29 | #include <linux/interrupt.h> |
ee999fb3 TF |
30 | #include <linux/of.h> |
31 | #include <linux/of_irq.h> | |
cdd137c9 | 32 | #include <linux/pm_runtime.h> |
156f2528 KP |
33 | #include <linux/mutex.h> |
34 | #include <linux/mfd/core.h> | |
35 | #include <linux/mfd/max8998.h> | |
36 | #include <linux/mfd/max8998-private.h> | |
37 | ||
9b16c0a4 JS |
38 | #define RTC_I2C_ADDR (0x0c >> 1) |
39 | ||
156f2528 KP |
40 | static struct mfd_cell max8998_devs[] = { |
41 | { | |
42 | .name = "max8998-pmic", | |
9b16c0a4 JS |
43 | }, { |
44 | .name = "max8998-rtc", | |
bb4ce970 DK |
45 | }, { |
46 | .name = "max8998-battery", | |
9b16c0a4 | 47 | }, |
156f2528 KP |
48 | }; |
49 | ||
337ce5d1 MH |
50 | static struct mfd_cell lp3974_devs[] = { |
51 | { | |
52 | .name = "lp3974-pmic", | |
53 | }, { | |
54 | .name = "lp3974-rtc", | |
55 | }, | |
56 | }; | |
57 | ||
676e02d7 | 58 | int max8998_read_reg(struct i2c_client *i2c, u8 reg, u8 *dest) |
156f2528 | 59 | { |
676e02d7 | 60 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); |
156f2528 KP |
61 | int ret; |
62 | ||
63 | mutex_lock(&max8998->iolock); | |
676e02d7 | 64 | ret = i2c_smbus_read_byte_data(i2c, reg); |
156f2528 KP |
65 | mutex_unlock(&max8998->iolock); |
66 | if (ret < 0) | |
67 | return ret; | |
68 | ||
69 | ret &= 0xff; | |
70 | *dest = ret; | |
71 | return 0; | |
72 | } | |
676e02d7 | 73 | EXPORT_SYMBOL(max8998_read_reg); |
156f2528 | 74 | |
2c7e6f57 JS |
75 | int max8998_bulk_read(struct i2c_client *i2c, u8 reg, int count, u8 *buf) |
76 | { | |
77 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); | |
78 | int ret; | |
79 | ||
80 | mutex_lock(&max8998->iolock); | |
81 | ret = i2c_smbus_read_i2c_block_data(i2c, reg, count, buf); | |
82 | mutex_unlock(&max8998->iolock); | |
83 | if (ret < 0) | |
84 | return ret; | |
85 | ||
86 | return 0; | |
87 | } | |
88 | EXPORT_SYMBOL(max8998_bulk_read); | |
89 | ||
676e02d7 | 90 | int max8998_write_reg(struct i2c_client *i2c, u8 reg, u8 value) |
156f2528 | 91 | { |
676e02d7 | 92 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); |
156f2528 KP |
93 | int ret; |
94 | ||
95 | mutex_lock(&max8998->iolock); | |
676e02d7 | 96 | ret = i2c_smbus_write_byte_data(i2c, reg, value); |
156f2528 KP |
97 | mutex_unlock(&max8998->iolock); |
98 | return ret; | |
99 | } | |
676e02d7 | 100 | EXPORT_SYMBOL(max8998_write_reg); |
156f2528 | 101 | |
9b16c0a4 JS |
102 | int max8998_bulk_write(struct i2c_client *i2c, u8 reg, int count, u8 *buf) |
103 | { | |
104 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); | |
105 | int ret; | |
106 | ||
107 | mutex_lock(&max8998->iolock); | |
108 | ret = i2c_smbus_write_i2c_block_data(i2c, reg, count, buf); | |
109 | mutex_unlock(&max8998->iolock); | |
110 | if (ret < 0) | |
111 | return ret; | |
112 | ||
113 | return 0; | |
114 | } | |
115 | EXPORT_SYMBOL(max8998_bulk_write); | |
116 | ||
676e02d7 | 117 | int max8998_update_reg(struct i2c_client *i2c, u8 reg, u8 val, u8 mask) |
156f2528 | 118 | { |
676e02d7 | 119 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); |
156f2528 KP |
120 | int ret; |
121 | ||
122 | mutex_lock(&max8998->iolock); | |
676e02d7 | 123 | ret = i2c_smbus_read_byte_data(i2c, reg); |
156f2528 KP |
124 | if (ret >= 0) { |
125 | u8 old_val = ret & 0xff; | |
126 | u8 new_val = (val & mask) | (old_val & (~mask)); | |
676e02d7 | 127 | ret = i2c_smbus_write_byte_data(i2c, reg, new_val); |
156f2528 KP |
128 | } |
129 | mutex_unlock(&max8998->iolock); | |
130 | return ret; | |
131 | } | |
676e02d7 | 132 | EXPORT_SYMBOL(max8998_update_reg); |
156f2528 | 133 | |
ee999fb3 TF |
134 | #ifdef CONFIG_OF |
135 | static struct of_device_id max8998_dt_match[] = { | |
136 | { .compatible = "maxim,max8998", .data = (void *)TYPE_MAX8998 }, | |
137 | { .compatible = "national,lp3974", .data = (void *)TYPE_LP3974 }, | |
138 | { .compatible = "ti,lp3974", .data = (void *)TYPE_LP3974 }, | |
139 | {}, | |
140 | }; | |
141 | MODULE_DEVICE_TABLE(of, max8998_dt_match); | |
142 | #endif | |
143 | ||
144 | /* | |
145 | * Only the common platform data elements for max8998 are parsed here from the | |
146 | * device tree. Other sub-modules of max8998 such as pmic, rtc and others have | |
147 | * to parse their own platform data elements from device tree. | |
148 | * | |
149 | * The max8998 platform data structure is instantiated here and the drivers for | |
150 | * the sub-modules need not instantiate another instance while parsing their | |
151 | * platform data. | |
152 | */ | |
153 | static struct max8998_platform_data *max8998_i2c_parse_dt_pdata( | |
154 | struct device *dev) | |
155 | { | |
156 | struct max8998_platform_data *pd; | |
157 | ||
158 | pd = devm_kzalloc(dev, sizeof(*pd), GFP_KERNEL); | |
159 | if (!pd) | |
160 | return ERR_PTR(-ENOMEM); | |
161 | ||
162 | pd->ono = irq_of_parse_and_map(dev->of_node, 1); | |
163 | ||
164 | /* | |
165 | * ToDo: the 'wakeup' member in the platform data is more of a linux | |
166 | * specfic information. Hence, there is no binding for that yet and | |
167 | * not parsed here. | |
168 | */ | |
169 | return pd; | |
170 | } | |
171 | ||
172 | static inline int max8998_i2c_get_driver_data(struct i2c_client *i2c, | |
173 | const struct i2c_device_id *id) | |
174 | { | |
175 | if (IS_ENABLED(CONFIG_OF) && i2c->dev.of_node) { | |
176 | const struct of_device_id *match; | |
177 | match = of_match_node(max8998_dt_match, i2c->dev.of_node); | |
178 | return (int)match->data; | |
179 | } | |
180 | ||
181 | return (int)id->driver_data; | |
182 | } | |
183 | ||
156f2528 KP |
184 | static int max8998_i2c_probe(struct i2c_client *i2c, |
185 | const struct i2c_device_id *id) | |
186 | { | |
334a41ce | 187 | struct max8998_platform_data *pdata = dev_get_platdata(&i2c->dev); |
156f2528 KP |
188 | struct max8998_dev *max8998; |
189 | int ret = 0; | |
190 | ||
0010dd38 JH |
191 | max8998 = devm_kzalloc(&i2c->dev, sizeof(struct max8998_dev), |
192 | GFP_KERNEL); | |
8f1f151e | 193 | if (max8998 == NULL) |
156f2528 | 194 | return -ENOMEM; |
156f2528 | 195 | |
ee999fb3 TF |
196 | if (IS_ENABLED(CONFIG_OF) && i2c->dev.of_node) { |
197 | pdata = max8998_i2c_parse_dt_pdata(&i2c->dev); | |
198 | if (IS_ERR(pdata)) { | |
199 | ret = PTR_ERR(pdata); | |
200 | goto err; | |
201 | } | |
202 | } | |
203 | ||
156f2528 KP |
204 | i2c_set_clientdata(i2c, max8998); |
205 | max8998->dev = &i2c->dev; | |
676e02d7 | 206 | max8998->i2c = i2c; |
2c7e6f57 | 207 | max8998->irq = i2c->irq; |
ee999fb3 TF |
208 | max8998->type = max8998_i2c_get_driver_data(i2c, id); |
209 | max8998->pdata = pdata; | |
2c7e6f57 JS |
210 | if (pdata) { |
211 | max8998->ono = pdata->ono; | |
212 | max8998->irq_base = pdata->irq_base; | |
cdd137c9 | 213 | max8998->wakeup = pdata->wakeup; |
2c7e6f57 | 214 | } |
156f2528 KP |
215 | mutex_init(&max8998->iolock); |
216 | ||
9b16c0a4 JS |
217 | max8998->rtc = i2c_new_dummy(i2c->adapter, RTC_I2C_ADDR); |
218 | i2c_set_clientdata(max8998->rtc, max8998); | |
219 | ||
2c7e6f57 JS |
220 | max8998_irq_init(max8998); |
221 | ||
cdd137c9 MH |
222 | pm_runtime_set_active(max8998->dev); |
223 | ||
ee999fb3 | 224 | switch (max8998->type) { |
337ce5d1 MH |
225 | case TYPE_LP3974: |
226 | ret = mfd_add_devices(max8998->dev, -1, | |
0848c94f MB |
227 | lp3974_devs, ARRAY_SIZE(lp3974_devs), |
228 | NULL, 0, NULL); | |
337ce5d1 MH |
229 | break; |
230 | case TYPE_MAX8998: | |
231 | ret = mfd_add_devices(max8998->dev, -1, | |
0848c94f MB |
232 | max8998_devs, ARRAY_SIZE(max8998_devs), |
233 | NULL, 0, NULL); | |
337ce5d1 MH |
234 | break; |
235 | default: | |
236 | ret = -EINVAL; | |
237 | } | |
238 | ||
156f2528 KP |
239 | if (ret < 0) |
240 | goto err; | |
241 | ||
7ef73598 JC |
242 | device_init_wakeup(max8998->dev, max8998->wakeup); |
243 | ||
156f2528 KP |
244 | return ret; |
245 | ||
246 | err: | |
247 | mfd_remove_devices(max8998->dev); | |
7484552e AL |
248 | max8998_irq_exit(max8998); |
249 | i2c_unregister_device(max8998->rtc); | |
156f2528 KP |
250 | return ret; |
251 | } | |
252 | ||
253 | static int max8998_i2c_remove(struct i2c_client *i2c) | |
254 | { | |
255 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); | |
256 | ||
257 | mfd_remove_devices(max8998->dev); | |
7484552e AL |
258 | max8998_irq_exit(max8998); |
259 | i2c_unregister_device(max8998->rtc); | |
156f2528 KP |
260 | |
261 | return 0; | |
262 | } | |
263 | ||
264 | static const struct i2c_device_id max8998_i2c_id[] = { | |
509bd476 LM |
265 | { "max8998", TYPE_MAX8998 }, |
266 | { "lp3974", TYPE_LP3974}, | |
f8539ddc | 267 | { } |
156f2528 KP |
268 | }; |
269 | MODULE_DEVICE_TABLE(i2c, max8998_i2c_id); | |
270 | ||
cdd137c9 MH |
271 | static int max8998_suspend(struct device *dev) |
272 | { | |
273 | struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); | |
274 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); | |
275 | ||
7ef73598 | 276 | if (device_may_wakeup(dev)) |
d5bb1221 | 277 | irq_set_irq_wake(max8998->irq, 1); |
cdd137c9 MH |
278 | return 0; |
279 | } | |
280 | ||
281 | static int max8998_resume(struct device *dev) | |
282 | { | |
283 | struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); | |
284 | struct max8998_dev *max8998 = i2c_get_clientdata(i2c); | |
285 | ||
7ef73598 | 286 | if (device_may_wakeup(dev)) |
d5bb1221 | 287 | irq_set_irq_wake(max8998->irq, 0); |
cdd137c9 MH |
288 | /* |
289 | * In LP3974, if IRQ registers are not "read & clear" | |
290 | * when it's set during sleep, the interrupt becomes | |
291 | * disabled. | |
292 | */ | |
293 | return max8998_irq_resume(i2c_get_clientdata(i2c)); | |
294 | } | |
295 | ||
296 | struct max8998_reg_dump { | |
297 | u8 addr; | |
298 | u8 val; | |
299 | }; | |
300 | #define SAVE_ITEM(x) { .addr = (x), .val = 0x0, } | |
44be0a40 | 301 | static struct max8998_reg_dump max8998_dump[] = { |
cdd137c9 MH |
302 | SAVE_ITEM(MAX8998_REG_IRQM1), |
303 | SAVE_ITEM(MAX8998_REG_IRQM2), | |
304 | SAVE_ITEM(MAX8998_REG_IRQM3), | |
305 | SAVE_ITEM(MAX8998_REG_IRQM4), | |
306 | SAVE_ITEM(MAX8998_REG_STATUSM1), | |
307 | SAVE_ITEM(MAX8998_REG_STATUSM2), | |
308 | SAVE_ITEM(MAX8998_REG_CHGR1), | |
309 | SAVE_ITEM(MAX8998_REG_CHGR2), | |
310 | SAVE_ITEM(MAX8998_REG_LDO_ACTIVE_DISCHARGE1), | |
311 | SAVE_ITEM(MAX8998_REG_LDO_ACTIVE_DISCHARGE1), | |
312 | SAVE_ITEM(MAX8998_REG_BUCK_ACTIVE_DISCHARGE3), | |
313 | SAVE_ITEM(MAX8998_REG_ONOFF1), | |
314 | SAVE_ITEM(MAX8998_REG_ONOFF2), | |
315 | SAVE_ITEM(MAX8998_REG_ONOFF3), | |
316 | SAVE_ITEM(MAX8998_REG_ONOFF4), | |
317 | SAVE_ITEM(MAX8998_REG_BUCK1_VOLTAGE1), | |
318 | SAVE_ITEM(MAX8998_REG_BUCK1_VOLTAGE2), | |
319 | SAVE_ITEM(MAX8998_REG_BUCK1_VOLTAGE3), | |
320 | SAVE_ITEM(MAX8998_REG_BUCK1_VOLTAGE4), | |
321 | SAVE_ITEM(MAX8998_REG_BUCK2_VOLTAGE1), | |
322 | SAVE_ITEM(MAX8998_REG_BUCK2_VOLTAGE2), | |
323 | SAVE_ITEM(MAX8998_REG_LDO2_LDO3), | |
324 | SAVE_ITEM(MAX8998_REG_LDO4), | |
325 | SAVE_ITEM(MAX8998_REG_LDO5), | |
326 | SAVE_ITEM(MAX8998_REG_LDO6), | |
327 | SAVE_ITEM(MAX8998_REG_LDO7), | |
328 | SAVE_ITEM(MAX8998_REG_LDO8_LDO9), | |
329 | SAVE_ITEM(MAX8998_REG_LDO10_LDO11), | |
330 | SAVE_ITEM(MAX8998_REG_LDO12), | |
331 | SAVE_ITEM(MAX8998_REG_LDO13), | |
332 | SAVE_ITEM(MAX8998_REG_LDO14), | |
333 | SAVE_ITEM(MAX8998_REG_LDO15), | |
334 | SAVE_ITEM(MAX8998_REG_LDO16), | |
335 | SAVE_ITEM(MAX8998_REG_LDO17), | |
336 | SAVE_ITEM(MAX8998_REG_BKCHR), | |
337 | SAVE_ITEM(MAX8998_REG_LBCNFG1), | |
338 | SAVE_ITEM(MAX8998_REG_LBCNFG2), | |
339 | }; | |
340 | /* Save registers before hibernation */ | |
341 | static int max8998_freeze(struct device *dev) | |
342 | { | |
343 | struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); | |
344 | int i; | |
345 | ||
346 | for (i = 0; i < ARRAY_SIZE(max8998_dump); i++) | |
347 | max8998_read_reg(i2c, max8998_dump[i].addr, | |
348 | &max8998_dump[i].val); | |
349 | ||
350 | return 0; | |
351 | } | |
352 | ||
353 | /* Restore registers after hibernation */ | |
354 | static int max8998_restore(struct device *dev) | |
355 | { | |
356 | struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); | |
357 | int i; | |
358 | ||
359 | for (i = 0; i < ARRAY_SIZE(max8998_dump); i++) | |
360 | max8998_write_reg(i2c, max8998_dump[i].addr, | |
361 | max8998_dump[i].val); | |
362 | ||
363 | return 0; | |
364 | } | |
365 | ||
44be0a40 | 366 | static const struct dev_pm_ops max8998_pm = { |
cdd137c9 MH |
367 | .suspend = max8998_suspend, |
368 | .resume = max8998_resume, | |
369 | .freeze = max8998_freeze, | |
370 | .restore = max8998_restore, | |
371 | }; | |
372 | ||
156f2528 KP |
373 | static struct i2c_driver max8998_i2c_driver = { |
374 | .driver = { | |
375 | .name = "max8998", | |
376 | .owner = THIS_MODULE, | |
cdd137c9 | 377 | .pm = &max8998_pm, |
ee999fb3 | 378 | .of_match_table = of_match_ptr(max8998_dt_match), |
156f2528 KP |
379 | }, |
380 | .probe = max8998_i2c_probe, | |
381 | .remove = max8998_i2c_remove, | |
382 | .id_table = max8998_i2c_id, | |
383 | }; | |
384 | ||
385 | static int __init max8998_i2c_init(void) | |
386 | { | |
387 | return i2c_add_driver(&max8998_i2c_driver); | |
388 | } | |
389 | /* init early so consumer devices can complete system boot */ | |
390 | subsys_initcall(max8998_i2c_init); | |
391 | ||
392 | static void __exit max8998_i2c_exit(void) | |
393 | { | |
394 | i2c_del_driver(&max8998_i2c_driver); | |
395 | } | |
396 | module_exit(max8998_i2c_exit); | |
397 | ||
398 | MODULE_DESCRIPTION("MAXIM 8998 multi-function core driver"); | |
399 | MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>"); | |
400 | MODULE_LICENSE("GPL"); |