Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5

Linux/drivers/mfd/sec-core.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us