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