1// SPDX-License-Identifier: GPL-2.0+
2//
3// Copyright (c) 2012 Samsung Electronics Co., Ltd
4// http://www.samsung.com
5
6#include <linux/module.h>
7#include <linux/moduleparam.h>
8#include <linux/init.h>
9#include <linux/err.h>
10#include <linux/slab.h>
11#include <linux/i2c.h>
12#include <linux/of.h>
13#include <linux/of_irq.h>
14#include <linux/interrupt.h>
15#include <linux/pm_runtime.h>
16#include <linux/mutex.h>
17#include <linux/mfd/core.h>
18#include <linux/mfd/samsung/core.h>
19#include <linux/mfd/samsung/irq.h>
20#include <linux/mfd/samsung/s2mpa01.h>
21#include <linux/mfd/samsung/s2mps11.h>
22#include <linux/mfd/samsung/s2mps13.h>
23#include <linux/mfd/samsung/s2mps14.h>
24#include <linux/mfd/samsung/s2mps15.h>
25#include <linux/mfd/samsung/s2mpu02.h>
26#include <linux/mfd/samsung/s5m8763.h>
27#include <linux/mfd/samsung/s5m8767.h>
28#include <linux/regmap.h>
29
30static const struct mfd_cell s5m8751_devs[] = {
31 {
32 .name = "s5m8751-pmic",
33 }, {
34 .name = "s5m-charger",
35 }, {
36 .name = "s5m8751-codec",
37 },
38};
39
40static const struct mfd_cell s5m8763_devs[] = {
41 {
42 .name = "s5m8763-pmic",
43 }, {
44 .name = "s5m-rtc",
45 }, {
46 .name = "s5m-charger",
47 },
48};
49
50static const struct mfd_cell s5m8767_devs[] = {
51 {
52 .name = "s5m8767-pmic",
53 }, {
54 .name = "s5m-rtc",
55 }, {
56 .name = "s5m8767-clk",
57 .of_compatible = "samsung,s5m8767-clk",
58 }
59};
60
61static const struct mfd_cell s2mps11_devs[] = {
62 {
63 .name = "s2mps11-regulator",
64 }, {
65 .name = "s2mps14-rtc",
66 }, {
67 .name = "s2mps11-clk",
68 .of_compatible = "samsung,s2mps11-clk",
69 }
70};
71
72static const struct mfd_cell s2mps13_devs[] = {
73 { .name = "s2mps13-regulator", },
74 { .name = "s2mps13-rtc", },
75 {
76 .name = "s2mps13-clk",
77 .of_compatible = "samsung,s2mps13-clk",
78 },
79};
80
81static const struct mfd_cell s2mps14_devs[] = {
82 {
83 .name = "s2mps14-regulator",
84 }, {
85 .name = "s2mps14-rtc",
86 }, {
87 .name = "s2mps14-clk",
88 .of_compatible = "samsung,s2mps14-clk",
89 }
90};
91
92static const struct mfd_cell s2mps15_devs[] = {
93 {
94 .name = "s2mps15-regulator",
95 }, {
96 .name = "s2mps15-rtc",
97 }, {
98 .name = "s2mps13-clk",
99 .of_compatible = "samsung,s2mps13-clk",
100 },
101};
102
103static const struct mfd_cell s2mpa01_devs[] = {
104 {
105 .name = "s2mpa01-pmic",
106 },
107};
108
109static const struct mfd_cell s2mpu02_devs[] = {
110 {
111 .name = "s2mpu02-regulator",
112 },
113};
114
115#ifdef CONFIG_OF
116static const struct of_device_id sec_dt_match[] = {
117 {
118 .compatible = "samsung,s5m8767-pmic",
119 .data = (void *)S5M8767X,
120 }, {
121 .compatible = "samsung,s2mps11-pmic",
122 .data = (void *)S2MPS11X,
123 }, {
124 .compatible = "samsung,s2mps13-pmic",
125 .data = (void *)S2MPS13X,
126 }, {
127 .compatible = "samsung,s2mps14-pmic",
128 .data = (void *)S2MPS14X,
129 }, {
130 .compatible = "samsung,s2mps15-pmic",
131 .data = (void *)S2MPS15X,
132 }, {
133 .compatible = "samsung,s2mpa01-pmic",
134 .data = (void *)S2MPA01,
135 }, {
136 .compatible = "samsung,s2mpu02-pmic",
137 .data = (void *)S2MPU02,
138 }, {
139 /* Sentinel */
140 },
141};
142MODULE_DEVICE_TABLE(of, sec_dt_match);
143#endif
144
145static bool s2mpa01_volatile(struct device *dev, unsigned int reg)
146{
147 switch (reg) {
148 case S2MPA01_REG_INT1M:
149 case S2MPA01_REG_INT2M:
150 case S2MPA01_REG_INT3M:
151 return false;
152 default:
153 return true;
154 }
155}
156
157static bool s2mps11_volatile(struct device *dev, unsigned int reg)
158{
159 switch (reg) {
160 case S2MPS11_REG_INT1M:
161 case S2MPS11_REG_INT2M:
162 case S2MPS11_REG_INT3M:
163 return false;
164 default:
165 return true;
166 }
167}
168
169static bool s2mpu02_volatile(struct device *dev, unsigned int reg)
170{
171 switch (reg) {
172 case S2MPU02_REG_INT1M:
173 case S2MPU02_REG_INT2M:
174 case S2MPU02_REG_INT3M:
175 return false;
176 default:
177 return true;
178 }
179}
180
181static bool s5m8763_volatile(struct device *dev, unsigned int reg)
182{
183 switch (reg) {
184 case S5M8763_REG_IRQM1:
185 case S5M8763_REG_IRQM2:
186 case S5M8763_REG_IRQM3:
187 case S5M8763_REG_IRQM4:
188 return false;
189 default:
190 return true;
191 }
192}
193
194static const struct regmap_config sec_regmap_config = {
195 .reg_bits = 8,
196 .val_bits = 8,
197};
198
199static const struct regmap_config s2mpa01_regmap_config = {
200 .reg_bits = 8,
201 .val_bits = 8,
202
203 .max_register = S2MPA01_REG_LDO_OVCB4,
204 .volatile_reg = s2mpa01_volatile,
205 .cache_type = REGCACHE_FLAT,
206};
207
208static const struct regmap_config s2mps11_regmap_config = {
209 .reg_bits = 8,
210 .val_bits = 8,
211
212 .max_register = S2MPS11_REG_L38CTRL,
213 .volatile_reg = s2mps11_volatile,
214 .cache_type = REGCACHE_FLAT,
215};
216
217static const struct regmap_config s2mps13_regmap_config = {
218 .reg_bits = 8,
219 .val_bits = 8,
220
221 .max_register = S2MPS13_REG_LDODSCH5,
222 .volatile_reg = s2mps11_volatile,
223 .cache_type = REGCACHE_FLAT,
224};
225
226static const struct regmap_config s2mps14_regmap_config = {
227 .reg_bits = 8,
228 .val_bits = 8,
229
230 .max_register = S2MPS14_REG_LDODSCH3,
231 .volatile_reg = s2mps11_volatile,
232 .cache_type = REGCACHE_FLAT,
233};
234
235static const struct regmap_config s2mps15_regmap_config = {
236 .reg_bits = 8,
237 .val_bits = 8,
238
239 .max_register = S2MPS15_REG_LDODSCH4,
240 .volatile_reg = s2mps11_volatile,
241 .cache_type = REGCACHE_FLAT,
242};
243
244static const struct regmap_config s2mpu02_regmap_config = {
245 .reg_bits = 8,
246 .val_bits = 8,
247
248 .max_register = S2MPU02_REG_DVSDATA,
249 .volatile_reg = s2mpu02_volatile,
250 .cache_type = REGCACHE_FLAT,
251};
252
253static const struct regmap_config s5m8763_regmap_config = {
254 .reg_bits = 8,
255 .val_bits = 8,
256
257 .max_register = S5M8763_REG_LBCNFG2,
258 .volatile_reg = s5m8763_volatile,
259 .cache_type = REGCACHE_FLAT,
260};
261
262static const struct regmap_config s5m8767_regmap_config = {
263 .reg_bits = 8,
264 .val_bits = 8,
265
266 .max_register = S5M8767_REG_LDO28CTRL,
267 .volatile_reg = s2mps11_volatile,
268 .cache_type = REGCACHE_FLAT,
269};
270
271static void sec_pmic_dump_rev(struct sec_pmic_dev *sec_pmic)
272{
273 unsigned int val;
274
275 /* For each device type, the REG_ID is always the first register */
276 if (!regmap_read(sec_pmic->regmap_pmic, S2MPS11_REG_ID, &val))
277 dev_dbg(sec_pmic->dev, "Revision: 0x%x\n", val);
278}
279
280static void sec_pmic_configure(struct sec_pmic_dev *sec_pmic)
281{
282 int err;
283
284 if (sec_pmic->device_type != S2MPS13X)
285 return;
286
287 if (sec_pmic->pdata->disable_wrstbi) {
288 /*
289 * If WRSTBI pin is pulled down this feature must be disabled
290 * because each Suspend to RAM will trigger buck voltage reset
291 * to default values.
292 */
293 err = regmap_update_bits(sec_pmic->regmap_pmic,
294 S2MPS13_REG_WRSTBI,
295 S2MPS13_REG_WRSTBI_MASK, 0x0);
296 if (err)
297 dev_warn(sec_pmic->dev,
298 "Cannot initialize WRSTBI config: %d\n",
299 err);
300 }
301}
302
303#ifdef CONFIG_OF
304/*
305 * Only the common platform data elements for s5m8767 are parsed here from the
306 * device tree. Other sub-modules of s5m8767 such as pmic, rtc , charger and
307 * others have to parse their own platform data elements from device tree.
308 *
309 * The s5m8767 platform data structure is instantiated here and the drivers for
310 * the sub-modules need not instantiate another instance while parsing their
311 * platform data.
312 */
313static struct sec_platform_data *
314sec_pmic_i2c_parse_dt_pdata(struct device *dev)
315{
316 struct sec_platform_data *pd;
317
318 pd = devm_kzalloc(dev, sizeof(*pd), GFP_KERNEL);
319 if (!pd)
320 return ERR_PTR(-ENOMEM);
321
322 /*
323 * ToDo: the 'wakeup' member in the platform data is more of a linux
324 * specfic information. Hence, there is no binding for that yet and
325 * not parsed here.
326 */
327
328 pd->manual_poweroff = of_property_read_bool(dev->of_node,
329 "samsung,s2mps11-acokb-ground");
330 pd->disable_wrstbi = of_property_read_bool(dev->of_node,
331 "samsung,s2mps11-wrstbi-ground");
332 return pd;
333}
334#else
335static struct sec_platform_data *
336sec_pmic_i2c_parse_dt_pdata(struct device *dev)
337{
338 return NULL;
339}
340#endif
341
342static inline unsigned long sec_i2c_get_driver_data(struct i2c_client *i2c,
343 const struct i2c_device_id *id)
344{
345#ifdef CONFIG_OF
346 if (i2c->dev.of_node) {
347 const struct of_device_id *match;
348
349 match = of_match_node(sec_dt_match, i2c->dev.of_node);
350 return (unsigned long)match->data;
351 }
352#endif
353 return id->driver_data;
354}
355
356static int sec_pmic_probe(struct i2c_client *i2c,
357 const struct i2c_device_id *id)
358{
359 struct sec_platform_data *pdata = dev_get_platdata(&i2c->dev);
360 const struct regmap_config *regmap;
361 const struct mfd_cell *sec_devs;
362 struct sec_pmic_dev *sec_pmic;
363 unsigned long device_type;
364 int ret, num_sec_devs;
365
366 sec_pmic = devm_kzalloc(&i2c->dev, sizeof(struct sec_pmic_dev),
367 GFP_KERNEL);
368 if (sec_pmic == NULL)
369 return -ENOMEM;
370
371 i2c_set_clientdata(i2c, sec_pmic);
372 sec_pmic->dev = &i2c->dev;
373 sec_pmic->i2c = i2c;
374 sec_pmic->irq = i2c->irq;
375 device_type = sec_i2c_get_driver_data(i2c, id);
376
377 if (sec_pmic->dev->of_node) {
378 pdata = sec_pmic_i2c_parse_dt_pdata(sec_pmic->dev);
379 if (IS_ERR(pdata)) {
380 ret = PTR_ERR(pdata);
381 return ret;
382 }
383 pdata->device_type = device_type;
384 }
385 if (pdata) {
386 sec_pmic->device_type = pdata->device_type;
387 sec_pmic->irq_base = pdata->irq_base;
388 sec_pmic->wakeup = pdata->wakeup;
389 sec_pmic->pdata = pdata;
390 }
391
392 switch (sec_pmic->device_type) {
393 case S2MPA01:
394 regmap = &s2mpa01_regmap_config;
395 break;
396 case S2MPS11X:
397 regmap = &s2mps11_regmap_config;
398 break;
399 case S2MPS13X:
400 regmap = &s2mps13_regmap_config;
401 break;
402 case S2MPS14X:
403 regmap = &s2mps14_regmap_config;
404 break;
405 case S2MPS15X:
406 regmap = &s2mps15_regmap_config;
407 break;
408 case S5M8763X:
409 regmap = &s5m8763_regmap_config;
410 break;
411 case S5M8767X:
412 regmap = &s5m8767_regmap_config;
413 break;
414 case S2MPU02:
415 regmap = &s2mpu02_regmap_config;
416 break;
417 default:
418 regmap = &sec_regmap_config;
419 break;
420 }
421
422 sec_pmic->regmap_pmic = devm_regmap_init_i2c(i2c, regmap);
423 if (IS_ERR(sec_pmic->regmap_pmic)) {
424 ret = PTR_ERR(sec_pmic->regmap_pmic);
425 dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
426 ret);
427 return ret;
428 }
429
430 if (pdata && pdata->cfg_pmic_irq)
431 pdata->cfg_pmic_irq();
432
433 sec_irq_init(sec_pmic);
434
435 pm_runtime_set_active(sec_pmic->dev);
436
437 switch (sec_pmic->device_type) {
438 case S5M8751X:
439 sec_devs = s5m8751_devs;
440 num_sec_devs = ARRAY_SIZE(s5m8751_devs);
441 break;
442 case S5M8763X:
443 sec_devs = s5m8763_devs;
444 num_sec_devs = ARRAY_SIZE(s5m8763_devs);
445 break;
446 case S5M8767X:
447 sec_devs = s5m8767_devs;
448 num_sec_devs = ARRAY_SIZE(s5m8767_devs);
449 break;
450 case S2MPA01:
451 sec_devs = s2mpa01_devs;
452 num_sec_devs = ARRAY_SIZE(s2mpa01_devs);
453 break;
454 case S2MPS11X:
455 sec_devs = s2mps11_devs;
456 num_sec_devs = ARRAY_SIZE(s2mps11_devs);
457 break;
458 case S2MPS13X:
459 sec_devs = s2mps13_devs;
460 num_sec_devs = ARRAY_SIZE(s2mps13_devs);
461 break;
462 case S2MPS14X:
463 sec_devs = s2mps14_devs;
464 num_sec_devs = ARRAY_SIZE(s2mps14_devs);
465 break;
466 case S2MPS15X:
467 sec_devs = s2mps15_devs;
468 num_sec_devs = ARRAY_SIZE(s2mps15_devs);
469 break;
470 case S2MPU02:
471 sec_devs = s2mpu02_devs;
472 num_sec_devs = ARRAY_SIZE(s2mpu02_devs);
473 break;
474 default:
475 dev_err(&i2c->dev, "Unsupported device type (%lu)\n",
476 sec_pmic->device_type);
477 return -ENODEV;
478 }
479 ret = devm_mfd_add_devices(sec_pmic->dev, -1, sec_devs, num_sec_devs,
480 NULL, 0, NULL);
481 if (ret)
482 return ret;
483
484 device_init_wakeup(sec_pmic->dev, sec_pmic->wakeup);
485 sec_pmic_configure(sec_pmic);
486 sec_pmic_dump_rev(sec_pmic);
487
488 return ret;
489}
490
491static void sec_pmic_shutdown(struct i2c_client *i2c)
492{
493 struct sec_pmic_dev *sec_pmic = i2c_get_clientdata(i2c);
494 unsigned int reg, mask;
495
496 if (!sec_pmic->pdata->manual_poweroff)
497 return;
498
499 switch (sec_pmic->device_type) {
500 case S2MPS11X:
501 reg = S2MPS11_REG_CTRL1;
502 mask = S2MPS11_CTRL1_PWRHOLD_MASK;
503 break;
504 default:
505 /*
506 * Currently only one board with S2MPS11 needs this, so just
507 * ignore the rest.
508 */
509 dev_warn(sec_pmic->dev,
510 "Unsupported device %lu for manual power off\n",
511 sec_pmic->device_type);
512 return;
513 }
514
515 regmap_update_bits(sec_pmic->regmap_pmic, reg, mask, 0);
516}
517
518#ifdef CONFIG_PM_SLEEP
519static int sec_pmic_suspend(struct device *dev)
520{
521 struct i2c_client *i2c = to_i2c_client(dev);
522 struct sec_pmic_dev *sec_pmic = i2c_get_clientdata(i2c);
523
524 if (device_may_wakeup(dev))
525 enable_irq_wake(sec_pmic->irq);
526 /*
527 * PMIC IRQ must be disabled during suspend for RTC alarm
528 * to work properly.
529 * When device is woken up from suspend, an
530 * interrupt occurs before resuming I2C bus controller.
531 * The interrupt is handled by regmap_irq_thread which tries
532 * to read RTC registers. This read fails (I2C is still
533 * suspended) and RTC Alarm interrupt is disabled.
534 */
535 disable_irq(sec_pmic->irq);
536
537 return 0;
538}
539
540static int sec_pmic_resume(struct device *dev)
541{
542 struct i2c_client *i2c = to_i2c_client(dev);
543 struct sec_pmic_dev *sec_pmic = i2c_get_clientdata(i2c);
544
545 if (device_may_wakeup(dev))
546 disable_irq_wake(sec_pmic->irq);
547 enable_irq(sec_pmic->irq);
548
549 return 0;
550}
551#endif /* CONFIG_PM_SLEEP */
552
553static SIMPLE_DEV_PM_OPS(sec_pmic_pm_ops, sec_pmic_suspend, sec_pmic_resume);
554
555static const struct i2c_device_id sec_pmic_id[] = {
556 { "sec_pmic", 0 },
557 { }
558};
559MODULE_DEVICE_TABLE(i2c, sec_pmic_id);
560
561static struct i2c_driver sec_pmic_driver = {
562 .driver = {
563 .name = "sec_pmic",
564 .pm = &sec_pmic_pm_ops,
565 .of_match_table = of_match_ptr(sec_dt_match),
566 },
567 .probe = sec_pmic_probe,
568 .shutdown = sec_pmic_shutdown,
569 .id_table = sec_pmic_id,
570};
571
572static int __init sec_pmic_init(void)
573{
574 return i2c_add_driver(&sec_pmic_driver);
575}
576
577subsys_initcall(sec_pmic_init);
578
579static void __exit sec_pmic_exit(void)
580{
581 i2c_del_driver(&sec_pmic_driver);
582}
583module_exit(sec_pmic_exit);
584
585MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
586MODULE_DESCRIPTION("Core support for the S5M MFD");
587MODULE_LICENSE("GPL");
588