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