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