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