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