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/rtc.h> 29 #include <linux/mfd/samsung/s2mpa01.h> 30 #include <linux/mfd/samsung/s2mps11.h> 31 #include <linux/mfd/samsung/s2mps14.h> 32 #include <linux/mfd/samsung/s5m8763.h> 33 #include <linux/mfd/samsung/s5m8767.h> 34 #include <linux/regmap.h> 35 36 static const struct mfd_cell s5m8751_devs[] = { 37 { 38 .name = "s5m8751-pmic", 39 }, { 40 .name = "s5m-charger", 41 }, { 42 .name = "s5m8751-codec", 43 }, 44 }; 45 46 static const struct mfd_cell s5m8763_devs[] = { 47 { 48 .name = "s5m8763-pmic", 49 }, { 50 .name = "s5m-rtc", 51 }, { 52 .name = "s5m-charger", 53 }, 54 }; 55 56 static const struct mfd_cell s5m8767_devs[] = { 57 { 58 .name = "s5m8767-pmic", 59 }, { 60 .name = "s5m-rtc", 61 }, { 62 .name = "s5m8767-clk", 63 .of_compatible = "samsung,s5m8767-clk", 64 } 65 }; 66 67 static const struct mfd_cell s2mps11_devs[] = { 68 { 69 .name = "s2mps11-pmic", 70 }, { 71 .name = "s2mps11-clk", 72 .of_compatible = "samsung,s2mps11-clk", 73 } 74 }; 75 76 static const struct mfd_cell s2mps14_devs[] = { 77 { 78 .name = "s2mps14-pmic", 79 }, { 80 .name = "s2mps14-rtc", 81 }, { 82 .name = "s2mps14-clk", 83 .of_compatible = "samsung,s2mps14-clk", 84 } 85 }; 86 87 static const struct mfd_cell s2mpa01_devs[] = { 88 { 89 .name = "s2mpa01-pmic", 90 }, 91 }; 92 93 #ifdef CONFIG_OF 94 static struct of_device_id sec_dt_match[] = { 95 { .compatible = "samsung,s5m8767-pmic", 96 .data = (void *)S5M8767X, 97 }, { 98 .compatible = "samsung,s2mps11-pmic", 99 .data = (void *)S2MPS11X, 100 }, { 101 .compatible = "samsung,s2mps14-pmic", 102 .data = (void *)S2MPS14X, 103 }, { 104 .compatible = "samsung,s2mpa01-pmic", 105 .data = (void *)S2MPA01, 106 }, { 107 /* Sentinel */ 108 }, 109 }; 110 #endif 111 112 static 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 124 static 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 136 static bool s5m8763_volatile(struct device *dev, unsigned int reg) 137 { 138 switch (reg) { 139 case S5M8763_REG_IRQM1: 140 case S5M8763_REG_IRQM2: 141 case S5M8763_REG_IRQM3: 142 case S5M8763_REG_IRQM4: 143 return false; 144 default: 145 return true; 146 } 147 } 148 149 static const struct regmap_config sec_regmap_config = { 150 .reg_bits = 8, 151 .val_bits = 8, 152 }; 153 154 static const struct regmap_config s2mpa01_regmap_config = { 155 .reg_bits = 8, 156 .val_bits = 8, 157 158 .max_register = S2MPA01_REG_LDO_OVCB4, 159 .volatile_reg = s2mpa01_volatile, 160 .cache_type = REGCACHE_FLAT, 161 }; 162 163 static const struct regmap_config s2mps11_regmap_config = { 164 .reg_bits = 8, 165 .val_bits = 8, 166 167 .max_register = S2MPS11_REG_L38CTRL, 168 .volatile_reg = s2mps11_volatile, 169 .cache_type = REGCACHE_FLAT, 170 }; 171 172 static const struct regmap_config s2mps14_regmap_config = { 173 .reg_bits = 8, 174 .val_bits = 8, 175 176 .max_register = S2MPS14_REG_LDODSCH3, 177 .volatile_reg = s2mps11_volatile, 178 .cache_type = REGCACHE_FLAT, 179 }; 180 181 static const struct regmap_config s5m8763_regmap_config = { 182 .reg_bits = 8, 183 .val_bits = 8, 184 185 .max_register = S5M8763_REG_LBCNFG2, 186 .volatile_reg = s5m8763_volatile, 187 .cache_type = REGCACHE_FLAT, 188 }; 189 190 static const struct regmap_config s5m8767_regmap_config = { 191 .reg_bits = 8, 192 .val_bits = 8, 193 194 .max_register = S5M8767_REG_LDO28CTRL, 195 .volatile_reg = s2mps11_volatile, 196 .cache_type = REGCACHE_FLAT, 197 }; 198 199 static const struct regmap_config s5m_rtc_regmap_config = { 200 .reg_bits = 8, 201 .val_bits = 8, 202 203 .max_register = SEC_RTC_REG_MAX, 204 }; 205 206 static const struct regmap_config s2mps14_rtc_regmap_config = { 207 .reg_bits = 8, 208 .val_bits = 8, 209 210 .max_register = S2MPS_RTC_REG_MAX, 211 }; 212 213 #ifdef CONFIG_OF 214 /* 215 * Only the common platform data elements for s5m8767 are parsed here from the 216 * device tree. Other sub-modules of s5m8767 such as pmic, rtc , charger and 217 * others have to parse their own platform data elements from device tree. 218 * 219 * The s5m8767 platform data structure is instantiated here and the drivers for 220 * the sub-modules need not instantiate another instance while parsing their 221 * platform data. 222 */ 223 static struct sec_platform_data *sec_pmic_i2c_parse_dt_pdata( 224 struct device *dev) 225 { 226 struct sec_platform_data *pd; 227 228 pd = devm_kzalloc(dev, sizeof(*pd), GFP_KERNEL); 229 if (!pd) { 230 dev_err(dev, "could not allocate memory for pdata\n"); 231 return ERR_PTR(-ENOMEM); 232 } 233 234 /* 235 * ToDo: the 'wakeup' member in the platform data is more of a linux 236 * specfic information. Hence, there is no binding for that yet and 237 * not parsed here. 238 */ 239 240 return pd; 241 } 242 #else 243 static struct sec_platform_data *sec_pmic_i2c_parse_dt_pdata( 244 struct device *dev) 245 { 246 return NULL; 247 } 248 #endif 249 250 static inline unsigned long sec_i2c_get_driver_data(struct i2c_client *i2c, 251 const struct i2c_device_id *id) 252 { 253 #ifdef CONFIG_OF 254 if (i2c->dev.of_node) { 255 const struct of_device_id *match; 256 match = of_match_node(sec_dt_match, i2c->dev.of_node); 257 return (unsigned long)match->data; 258 } 259 #endif 260 return id->driver_data; 261 } 262 263 static int sec_pmic_probe(struct i2c_client *i2c, 264 const struct i2c_device_id *id) 265 { 266 struct sec_platform_data *pdata = dev_get_platdata(&i2c->dev); 267 const struct regmap_config *regmap, *regmap_rtc; 268 struct sec_pmic_dev *sec_pmic; 269 int ret; 270 271 sec_pmic = devm_kzalloc(&i2c->dev, sizeof(struct sec_pmic_dev), 272 GFP_KERNEL); 273 if (sec_pmic == NULL) 274 return -ENOMEM; 275 276 i2c_set_clientdata(i2c, sec_pmic); 277 sec_pmic->dev = &i2c->dev; 278 sec_pmic->i2c = i2c; 279 sec_pmic->irq = i2c->irq; 280 sec_pmic->type = sec_i2c_get_driver_data(i2c, id); 281 282 if (sec_pmic->dev->of_node) { 283 pdata = sec_pmic_i2c_parse_dt_pdata(sec_pmic->dev); 284 if (IS_ERR(pdata)) { 285 ret = PTR_ERR(pdata); 286 return ret; 287 } 288 pdata->device_type = sec_pmic->type; 289 } 290 if (pdata) { 291 sec_pmic->device_type = pdata->device_type; 292 sec_pmic->ono = pdata->ono; 293 sec_pmic->irq_base = pdata->irq_base; 294 sec_pmic->wakeup = pdata->wakeup; 295 sec_pmic->pdata = pdata; 296 } 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 /* 305 * The rtc-s5m driver does not support S2MPS11 and there 306 * is no mfd_cell for S2MPS11 RTC device. 307 * However we must pass something to devm_regmap_init_i2c() 308 * so use S5M-like regmap config even though it wouldn't work. 309 */ 310 regmap_rtc = &s5m_rtc_regmap_config; 311 break; 312 case S2MPS14X: 313 regmap = &s2mps14_regmap_config; 314 regmap_rtc = &s2mps14_rtc_regmap_config; 315 break; 316 case S5M8763X: 317 regmap = &s5m8763_regmap_config; 318 regmap_rtc = &s5m_rtc_regmap_config; 319 break; 320 case S5M8767X: 321 regmap = &s5m8767_regmap_config; 322 regmap_rtc = &s5m_rtc_regmap_config; 323 break; 324 default: 325 regmap = &sec_regmap_config; 326 regmap_rtc = &s5m_rtc_regmap_config; 327 break; 328 } 329 330 sec_pmic->regmap_pmic = devm_regmap_init_i2c(i2c, regmap); 331 if (IS_ERR(sec_pmic->regmap_pmic)) { 332 ret = PTR_ERR(sec_pmic->regmap_pmic); 333 dev_err(&i2c->dev, "Failed to allocate register map: %d\n", 334 ret); 335 return ret; 336 } 337 338 sec_pmic->rtc = i2c_new_dummy(i2c->adapter, RTC_I2C_ADDR); 339 if (!sec_pmic->rtc) { 340 dev_err(&i2c->dev, "Failed to allocate I2C for RTC\n"); 341 return -ENODEV; 342 } 343 i2c_set_clientdata(sec_pmic->rtc, sec_pmic); 344 345 sec_pmic->regmap_rtc = devm_regmap_init_i2c(sec_pmic->rtc, regmap_rtc); 346 if (IS_ERR(sec_pmic->regmap_rtc)) { 347 ret = PTR_ERR(sec_pmic->regmap_rtc); 348 dev_err(&i2c->dev, "Failed to allocate RTC register map: %d\n", 349 ret); 350 return ret; 351 } 352 353 if (pdata && pdata->cfg_pmic_irq) 354 pdata->cfg_pmic_irq(); 355 356 sec_irq_init(sec_pmic); 357 358 pm_runtime_set_active(sec_pmic->dev); 359 360 switch (sec_pmic->device_type) { 361 case S5M8751X: 362 ret = mfd_add_devices(sec_pmic->dev, -1, s5m8751_devs, 363 ARRAY_SIZE(s5m8751_devs), NULL, 0, NULL); 364 break; 365 case S5M8763X: 366 ret = mfd_add_devices(sec_pmic->dev, -1, s5m8763_devs, 367 ARRAY_SIZE(s5m8763_devs), NULL, 0, NULL); 368 break; 369 case S5M8767X: 370 ret = mfd_add_devices(sec_pmic->dev, -1, s5m8767_devs, 371 ARRAY_SIZE(s5m8767_devs), NULL, 0, NULL); 372 break; 373 case S2MPA01: 374 ret = mfd_add_devices(sec_pmic->dev, -1, s2mpa01_devs, 375 ARRAY_SIZE(s2mpa01_devs), NULL, 0, NULL); 376 break; 377 case S2MPS11X: 378 ret = mfd_add_devices(sec_pmic->dev, -1, s2mps11_devs, 379 ARRAY_SIZE(s2mps11_devs), NULL, 0, NULL); 380 break; 381 case S2MPS14X: 382 ret = mfd_add_devices(sec_pmic->dev, -1, s2mps14_devs, 383 ARRAY_SIZE(s2mps14_devs), NULL, 0, NULL); 384 break; 385 default: 386 /* If this happens the probe function is problem */ 387 BUG(); 388 } 389 390 if (ret) 391 goto err; 392 393 device_init_wakeup(sec_pmic->dev, sec_pmic->wakeup); 394 395 return ret; 396 397 err: 398 sec_irq_exit(sec_pmic); 399 i2c_unregister_device(sec_pmic->rtc); 400 return ret; 401 } 402 403 static int sec_pmic_remove(struct i2c_client *i2c) 404 { 405 struct sec_pmic_dev *sec_pmic = i2c_get_clientdata(i2c); 406 407 mfd_remove_devices(sec_pmic->dev); 408 sec_irq_exit(sec_pmic); 409 i2c_unregister_device(sec_pmic->rtc); 410 return 0; 411 } 412 413 #ifdef CONFIG_PM_SLEEP 414 static int sec_pmic_suspend(struct device *dev) 415 { 416 struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); 417 struct sec_pmic_dev *sec_pmic = i2c_get_clientdata(i2c); 418 419 if (device_may_wakeup(dev)) { 420 enable_irq_wake(sec_pmic->irq); 421 /* 422 * PMIC IRQ must be disabled during suspend for RTC alarm 423 * to work properly. 424 * When device is woken up from suspend by RTC Alarm, an 425 * interrupt occurs before resuming I2C bus controller. 426 * The interrupt is handled by regmap_irq_thread which tries 427 * to read RTC registers. This read fails (I2C is still 428 * suspended) and RTC Alarm interrupt is disabled. 429 */ 430 disable_irq(sec_pmic->irq); 431 } 432 433 return 0; 434 } 435 436 static int sec_pmic_resume(struct device *dev) 437 { 438 struct i2c_client *i2c = container_of(dev, struct i2c_client, dev); 439 struct sec_pmic_dev *sec_pmic = i2c_get_clientdata(i2c); 440 441 if (device_may_wakeup(dev)) { 442 disable_irq_wake(sec_pmic->irq); 443 enable_irq(sec_pmic->irq); 444 } 445 446 return 0; 447 } 448 #endif /* CONFIG_PM_SLEEP */ 449 450 static SIMPLE_DEV_PM_OPS(sec_pmic_pm_ops, sec_pmic_suspend, sec_pmic_resume); 451 452 static const struct i2c_device_id sec_pmic_id[] = { 453 { "sec_pmic", 0 }, 454 { } 455 }; 456 MODULE_DEVICE_TABLE(i2c, sec_pmic_id); 457 458 static struct i2c_driver sec_pmic_driver = { 459 .driver = { 460 .name = "sec_pmic", 461 .owner = THIS_MODULE, 462 .pm = &sec_pmic_pm_ops, 463 .of_match_table = of_match_ptr(sec_dt_match), 464 }, 465 .probe = sec_pmic_probe, 466 .remove = sec_pmic_remove, 467 .id_table = sec_pmic_id, 468 }; 469 470 static int __init sec_pmic_init(void) 471 { 472 return i2c_add_driver(&sec_pmic_driver); 473 } 474 475 subsys_initcall(sec_pmic_init); 476 477 static void __exit sec_pmic_exit(void) 478 { 479 i2c_del_driver(&sec_pmic_driver); 480 } 481 module_exit(sec_pmic_exit); 482 483 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>"); 484 MODULE_DESCRIPTION("Core support for the S5M MFD"); 485 MODULE_LICENSE("GPL"); 486