1 /* 2 * tps65910.c -- TI TPS6591x 3 * 4 * Copyright 2010 Texas Instruments Inc. 5 * 6 * Author: Graeme Gregory <gg@slimlogic.co.uk> 7 * Author: Jorge Eduardo Candelaria <jedu@slimlogic.co.uk> 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the 11 * Free Software Foundation; either version 2 of the License, or (at your 12 * option) any later version. 13 * 14 */ 15 16 #include <linux/module.h> 17 #include <linux/moduleparam.h> 18 #include <linux/init.h> 19 #include <linux/err.h> 20 #include <linux/slab.h> 21 #include <linux/i2c.h> 22 #include <linux/mfd/core.h> 23 #include <linux/regmap.h> 24 #include <linux/mfd/tps65910.h> 25 #include <linux/of_device.h> 26 27 static struct resource rtc_resources[] = { 28 { 29 .start = TPS65910_IRQ_RTC_ALARM, 30 .end = TPS65910_IRQ_RTC_ALARM, 31 .flags = IORESOURCE_IRQ, 32 } 33 }; 34 35 static struct mfd_cell tps65910s[] = { 36 { 37 .name = "tps65910-gpio", 38 }, 39 { 40 .name = "tps65910-pmic", 41 }, 42 { 43 .name = "tps65910-rtc", 44 .num_resources = ARRAY_SIZE(rtc_resources), 45 .resources = &rtc_resources[0], 46 }, 47 { 48 .name = "tps65910-power", 49 }, 50 }; 51 52 53 static bool is_volatile_reg(struct device *dev, unsigned int reg) 54 { 55 struct tps65910 *tps65910 = dev_get_drvdata(dev); 56 57 /* 58 * Caching all regulator registers. 59 * All regualator register address range is same for 60 * TPS65910 and TPS65911 61 */ 62 if ((reg >= TPS65910_VIO) && (reg <= TPS65910_VDAC)) { 63 /* Check for non-existing register */ 64 if (tps65910_chip_id(tps65910) == TPS65910) 65 if ((reg == TPS65911_VDDCTRL_OP) || 66 (reg == TPS65911_VDDCTRL_SR)) 67 return true; 68 return false; 69 } 70 return true; 71 } 72 73 static const struct regmap_config tps65910_regmap_config = { 74 .reg_bits = 8, 75 .val_bits = 8, 76 .volatile_reg = is_volatile_reg, 77 .max_register = TPS65910_MAX_REGISTER - 1, 78 .cache_type = REGCACHE_RBTREE, 79 }; 80 81 static int __devinit tps65910_ck32k_init(struct tps65910 *tps65910, 82 struct tps65910_board *pmic_pdata) 83 { 84 int ret; 85 86 if (!pmic_pdata->en_ck32k_xtal) 87 return 0; 88 89 ret = tps65910_reg_clear_bits(tps65910, TPS65910_DEVCTRL, 90 DEVCTRL_CK32K_CTRL_MASK); 91 if (ret < 0) { 92 dev_err(tps65910->dev, "clear ck32k_ctrl failed: %d\n", ret); 93 return ret; 94 } 95 96 return 0; 97 } 98 99 static int __devinit tps65910_sleepinit(struct tps65910 *tps65910, 100 struct tps65910_board *pmic_pdata) 101 { 102 struct device *dev = NULL; 103 int ret = 0; 104 105 dev = tps65910->dev; 106 107 if (!pmic_pdata->en_dev_slp) 108 return 0; 109 110 /* enabling SLEEP device state */ 111 ret = tps65910_reg_set_bits(tps65910, TPS65910_DEVCTRL, 112 DEVCTRL_DEV_SLP_MASK); 113 if (ret < 0) { 114 dev_err(dev, "set dev_slp failed: %d\n", ret); 115 goto err_sleep_init; 116 } 117 118 /* Return if there is no sleep keepon data. */ 119 if (!pmic_pdata->slp_keepon) 120 return 0; 121 122 if (pmic_pdata->slp_keepon->therm_keepon) { 123 ret = tps65910_reg_set_bits(tps65910, 124 TPS65910_SLEEP_KEEP_RES_ON, 125 SLEEP_KEEP_RES_ON_THERM_KEEPON_MASK); 126 if (ret < 0) { 127 dev_err(dev, "set therm_keepon failed: %d\n", ret); 128 goto disable_dev_slp; 129 } 130 } 131 132 if (pmic_pdata->slp_keepon->clkout32k_keepon) { 133 ret = tps65910_reg_set_bits(tps65910, 134 TPS65910_SLEEP_KEEP_RES_ON, 135 SLEEP_KEEP_RES_ON_CLKOUT32K_KEEPON_MASK); 136 if (ret < 0) { 137 dev_err(dev, "set clkout32k_keepon failed: %d\n", ret); 138 goto disable_dev_slp; 139 } 140 } 141 142 if (pmic_pdata->slp_keepon->i2chs_keepon) { 143 ret = tps65910_reg_set_bits(tps65910, 144 TPS65910_SLEEP_KEEP_RES_ON, 145 SLEEP_KEEP_RES_ON_I2CHS_KEEPON_MASK); 146 if (ret < 0) { 147 dev_err(dev, "set i2chs_keepon failed: %d\n", ret); 148 goto disable_dev_slp; 149 } 150 } 151 152 return 0; 153 154 disable_dev_slp: 155 tps65910_reg_clear_bits(tps65910, TPS65910_DEVCTRL, 156 DEVCTRL_DEV_SLP_MASK); 157 158 err_sleep_init: 159 return ret; 160 } 161 162 #ifdef CONFIG_OF 163 static struct of_device_id tps65910_of_match[] = { 164 { .compatible = "ti,tps65910", .data = (void *)TPS65910}, 165 { .compatible = "ti,tps65911", .data = (void *)TPS65911}, 166 { }, 167 }; 168 MODULE_DEVICE_TABLE(of, tps65910_of_match); 169 170 static struct tps65910_board *tps65910_parse_dt(struct i2c_client *client, 171 int *chip_id) 172 { 173 struct device_node *np = client->dev.of_node; 174 struct tps65910_board *board_info; 175 unsigned int prop; 176 const struct of_device_id *match; 177 int ret = 0; 178 179 match = of_match_device(tps65910_of_match, &client->dev); 180 if (!match) { 181 dev_err(&client->dev, "Failed to find matching dt id\n"); 182 return NULL; 183 } 184 185 *chip_id = (int)match->data; 186 187 board_info = devm_kzalloc(&client->dev, sizeof(*board_info), 188 GFP_KERNEL); 189 if (!board_info) { 190 dev_err(&client->dev, "Failed to allocate pdata\n"); 191 return NULL; 192 } 193 194 ret = of_property_read_u32(np, "ti,vmbch-threshold", &prop); 195 if (!ret) 196 board_info->vmbch_threshold = prop; 197 else if (*chip_id == TPS65911) 198 dev_warn(&client->dev, "VMBCH-Threshold not specified"); 199 200 ret = of_property_read_u32(np, "ti,vmbch2-threshold", &prop); 201 if (!ret) 202 board_info->vmbch2_threshold = prop; 203 else if (*chip_id == TPS65911) 204 dev_warn(&client->dev, "VMBCH2-Threshold not specified"); 205 206 prop = of_property_read_bool(np, "ti,en-ck32k-xtal"); 207 board_info->en_ck32k_xtal = prop; 208 209 board_info->irq = client->irq; 210 board_info->irq_base = -1; 211 board_info->pm_off = of_property_read_bool(np, 212 "ti,system-power-controller"); 213 214 return board_info; 215 } 216 #else 217 static inline 218 struct tps65910_board *tps65910_parse_dt(struct i2c_client *client, 219 int *chip_id) 220 { 221 return NULL; 222 } 223 #endif 224 225 static struct i2c_client *tps65910_i2c_client; 226 static void tps65910_power_off(void) 227 { 228 struct tps65910 *tps65910; 229 230 tps65910 = dev_get_drvdata(&tps65910_i2c_client->dev); 231 232 if (tps65910_reg_set_bits(tps65910, TPS65910_DEVCTRL, 233 DEVCTRL_PWR_OFF_MASK) < 0) 234 return; 235 236 tps65910_reg_clear_bits(tps65910, TPS65910_DEVCTRL, 237 DEVCTRL_DEV_ON_MASK); 238 } 239 240 static __devinit int tps65910_i2c_probe(struct i2c_client *i2c, 241 const struct i2c_device_id *id) 242 { 243 struct tps65910 *tps65910; 244 struct tps65910_board *pmic_plat_data; 245 struct tps65910_board *of_pmic_plat_data = NULL; 246 struct tps65910_platform_data *init_data; 247 int ret = 0; 248 int chip_id = id->driver_data; 249 250 pmic_plat_data = dev_get_platdata(&i2c->dev); 251 252 if (!pmic_plat_data && i2c->dev.of_node) { 253 pmic_plat_data = tps65910_parse_dt(i2c, &chip_id); 254 of_pmic_plat_data = pmic_plat_data; 255 } 256 257 if (!pmic_plat_data) 258 return -EINVAL; 259 260 init_data = devm_kzalloc(&i2c->dev, sizeof(*init_data), GFP_KERNEL); 261 if (init_data == NULL) 262 return -ENOMEM; 263 264 tps65910 = devm_kzalloc(&i2c->dev, sizeof(*tps65910), GFP_KERNEL); 265 if (tps65910 == NULL) 266 return -ENOMEM; 267 268 tps65910->of_plat_data = of_pmic_plat_data; 269 i2c_set_clientdata(i2c, tps65910); 270 tps65910->dev = &i2c->dev; 271 tps65910->i2c_client = i2c; 272 tps65910->id = chip_id; 273 mutex_init(&tps65910->io_mutex); 274 275 tps65910->regmap = devm_regmap_init_i2c(i2c, &tps65910_regmap_config); 276 if (IS_ERR(tps65910->regmap)) { 277 ret = PTR_ERR(tps65910->regmap); 278 dev_err(&i2c->dev, "regmap initialization failed: %d\n", ret); 279 return ret; 280 } 281 282 ret = mfd_add_devices(tps65910->dev, -1, 283 tps65910s, ARRAY_SIZE(tps65910s), 284 NULL, 0, NULL); 285 if (ret < 0) { 286 dev_err(&i2c->dev, "mfd_add_devices failed: %d\n", ret); 287 return ret; 288 } 289 290 init_data->irq = pmic_plat_data->irq; 291 init_data->irq_base = pmic_plat_data->irq_base; 292 293 tps65910_irq_init(tps65910, init_data->irq, init_data); 294 tps65910_ck32k_init(tps65910, pmic_plat_data); 295 tps65910_sleepinit(tps65910, pmic_plat_data); 296 297 if (pmic_plat_data->pm_off && !pm_power_off) { 298 tps65910_i2c_client = i2c; 299 pm_power_off = tps65910_power_off; 300 } 301 302 return ret; 303 } 304 305 static __devexit int tps65910_i2c_remove(struct i2c_client *i2c) 306 { 307 struct tps65910 *tps65910 = i2c_get_clientdata(i2c); 308 309 tps65910_irq_exit(tps65910); 310 mfd_remove_devices(tps65910->dev); 311 312 return 0; 313 } 314 315 static const struct i2c_device_id tps65910_i2c_id[] = { 316 { "tps65910", TPS65910 }, 317 { "tps65911", TPS65911 }, 318 { } 319 }; 320 MODULE_DEVICE_TABLE(i2c, tps65910_i2c_id); 321 322 323 static struct i2c_driver tps65910_i2c_driver = { 324 .driver = { 325 .name = "tps65910", 326 .owner = THIS_MODULE, 327 .of_match_table = of_match_ptr(tps65910_of_match), 328 }, 329 .probe = tps65910_i2c_probe, 330 .remove = __devexit_p(tps65910_i2c_remove), 331 .id_table = tps65910_i2c_id, 332 }; 333 334 static int __init tps65910_i2c_init(void) 335 { 336 return i2c_add_driver(&tps65910_i2c_driver); 337 } 338 /* init early so consumer devices can complete system boot */ 339 subsys_initcall(tps65910_i2c_init); 340 341 static void __exit tps65910_i2c_exit(void) 342 { 343 i2c_del_driver(&tps65910_i2c_driver); 344 } 345 module_exit(tps65910_i2c_exit); 346 347 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>"); 348 MODULE_AUTHOR("Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>"); 349 MODULE_DESCRIPTION("TPS6591x chip family multi-function driver"); 350 MODULE_LICENSE("GPL"); 351