drivers/mfd/sec-core.c

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