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 mfd_cell tps65910s[] = { 28 { 29 .name = "tps65910-gpio", 30 }, 31 { 32 .name = "tps65910-pmic", 33 }, 34 { 35 .name = "tps65910-rtc", 36 }, 37 { 38 .name = "tps65910-power", 39 }, 40 }; 41 42 43 static bool is_volatile_reg(struct device *dev, unsigned int reg) 44 { 45 struct tps65910 *tps65910 = dev_get_drvdata(dev); 46 47 /* 48 * Caching all regulator registers. 49 * All regualator register address range is same for 50 * TPS65910 and TPS65911 51 */ 52 if ((reg >= TPS65910_VIO) && (reg <= TPS65910_VDAC)) { 53 /* Check for non-existing register */ 54 if (tps65910_chip_id(tps65910) == TPS65910) 55 if ((reg == TPS65911_VDDCTRL_OP) || 56 (reg == TPS65911_VDDCTRL_SR)) 57 return true; 58 return false; 59 } 60 return true; 61 } 62 63 static const struct regmap_config tps65910_regmap_config = { 64 .reg_bits = 8, 65 .val_bits = 8, 66 .volatile_reg = is_volatile_reg, 67 .max_register = TPS65910_MAX_REGISTER - 1, 68 .cache_type = REGCACHE_RBTREE, 69 }; 70 71 static int __devinit tps65910_sleepinit(struct tps65910 *tps65910, 72 struct tps65910_board *pmic_pdata) 73 { 74 struct device *dev = NULL; 75 int ret = 0; 76 77 dev = tps65910->dev; 78 79 if (!pmic_pdata->en_dev_slp) 80 return 0; 81 82 /* enabling SLEEP device state */ 83 ret = tps65910_reg_set_bits(tps65910, TPS65910_DEVCTRL, 84 DEVCTRL_DEV_SLP_MASK); 85 if (ret < 0) { 86 dev_err(dev, "set dev_slp failed: %d\n", ret); 87 goto err_sleep_init; 88 } 89 90 /* Return if there is no sleep keepon data. */ 91 if (!pmic_pdata->slp_keepon) 92 return 0; 93 94 if (pmic_pdata->slp_keepon->therm_keepon) { 95 ret = tps65910_reg_set_bits(tps65910, 96 TPS65910_SLEEP_KEEP_RES_ON, 97 SLEEP_KEEP_RES_ON_THERM_KEEPON_MASK); 98 if (ret < 0) { 99 dev_err(dev, "set therm_keepon failed: %d\n", ret); 100 goto disable_dev_slp; 101 } 102 } 103 104 if (pmic_pdata->slp_keepon->clkout32k_keepon) { 105 ret = tps65910_reg_set_bits(tps65910, 106 TPS65910_SLEEP_KEEP_RES_ON, 107 SLEEP_KEEP_RES_ON_CLKOUT32K_KEEPON_MASK); 108 if (ret < 0) { 109 dev_err(dev, "set clkout32k_keepon failed: %d\n", ret); 110 goto disable_dev_slp; 111 } 112 } 113 114 if (pmic_pdata->slp_keepon->i2chs_keepon) { 115 ret = tps65910_reg_set_bits(tps65910, 116 TPS65910_SLEEP_KEEP_RES_ON, 117 SLEEP_KEEP_RES_ON_I2CHS_KEEPON_MASK); 118 if (ret < 0) { 119 dev_err(dev, "set i2chs_keepon failed: %d\n", ret); 120 goto disable_dev_slp; 121 } 122 } 123 124 return 0; 125 126 disable_dev_slp: 127 tps65910_reg_clear_bits(tps65910, TPS65910_DEVCTRL, 128 DEVCTRL_DEV_SLP_MASK); 129 130 err_sleep_init: 131 return ret; 132 } 133 134 #ifdef CONFIG_OF 135 static struct of_device_id tps65910_of_match[] = { 136 { .compatible = "ti,tps65910", .data = (void *)TPS65910}, 137 { .compatible = "ti,tps65911", .data = (void *)TPS65911}, 138 { }, 139 }; 140 MODULE_DEVICE_TABLE(of, tps65910_of_match); 141 142 static struct tps65910_board *tps65910_parse_dt(struct i2c_client *client, 143 int *chip_id) 144 { 145 struct device_node *np = client->dev.of_node; 146 struct tps65910_board *board_info; 147 unsigned int prop; 148 const struct of_device_id *match; 149 int ret = 0; 150 151 match = of_match_device(tps65910_of_match, &client->dev); 152 if (!match) { 153 dev_err(&client->dev, "Failed to find matching dt id\n"); 154 return NULL; 155 } 156 157 *chip_id = (int)match->data; 158 159 board_info = devm_kzalloc(&client->dev, sizeof(*board_info), 160 GFP_KERNEL); 161 if (!board_info) { 162 dev_err(&client->dev, "Failed to allocate pdata\n"); 163 return NULL; 164 } 165 166 ret = of_property_read_u32(np, "ti,vmbch-threshold", &prop); 167 if (!ret) 168 board_info->vmbch_threshold = prop; 169 else if (*chip_id == TPS65911) 170 dev_warn(&client->dev, "VMBCH-Threshold not specified"); 171 172 ret = of_property_read_u32(np, "ti,vmbch2-threshold", &prop); 173 if (!ret) 174 board_info->vmbch2_threshold = prop; 175 else if (*chip_id == TPS65911) 176 dev_warn(&client->dev, "VMBCH2-Threshold not specified"); 177 178 board_info->irq = client->irq; 179 board_info->irq_base = -1; 180 181 return board_info; 182 } 183 #else 184 static inline 185 struct tps65910_board *tps65910_parse_dt(struct i2c_client *client, 186 int *chip_id) 187 { 188 return NULL; 189 } 190 #endif 191 192 static __devinit int tps65910_i2c_probe(struct i2c_client *i2c, 193 const struct i2c_device_id *id) 194 { 195 struct tps65910 *tps65910; 196 struct tps65910_board *pmic_plat_data; 197 struct tps65910_board *of_pmic_plat_data = NULL; 198 struct tps65910_platform_data *init_data; 199 int ret = 0; 200 int chip_id = id->driver_data; 201 202 pmic_plat_data = dev_get_platdata(&i2c->dev); 203 204 if (!pmic_plat_data && i2c->dev.of_node) { 205 pmic_plat_data = tps65910_parse_dt(i2c, &chip_id); 206 of_pmic_plat_data = pmic_plat_data; 207 } 208 209 if (!pmic_plat_data) 210 return -EINVAL; 211 212 init_data = devm_kzalloc(&i2c->dev, sizeof(*init_data), GFP_KERNEL); 213 if (init_data == NULL) 214 return -ENOMEM; 215 216 tps65910 = devm_kzalloc(&i2c->dev, sizeof(*tps65910), GFP_KERNEL); 217 if (tps65910 == NULL) 218 return -ENOMEM; 219 220 tps65910->of_plat_data = of_pmic_plat_data; 221 i2c_set_clientdata(i2c, tps65910); 222 tps65910->dev = &i2c->dev; 223 tps65910->i2c_client = i2c; 224 tps65910->id = chip_id; 225 mutex_init(&tps65910->io_mutex); 226 227 tps65910->regmap = devm_regmap_init_i2c(i2c, &tps65910_regmap_config); 228 if (IS_ERR(tps65910->regmap)) { 229 ret = PTR_ERR(tps65910->regmap); 230 dev_err(&i2c->dev, "regmap initialization failed: %d\n", ret); 231 return ret; 232 } 233 234 ret = mfd_add_devices(tps65910->dev, -1, 235 tps65910s, ARRAY_SIZE(tps65910s), 236 NULL, 0); 237 if (ret < 0) { 238 dev_err(&i2c->dev, "mfd_add_devices failed: %d\n", ret); 239 return ret; 240 } 241 242 init_data->irq = pmic_plat_data->irq; 243 init_data->irq_base = pmic_plat_data->irq_base; 244 245 tps65910_irq_init(tps65910, init_data->irq, init_data); 246 247 tps65910_sleepinit(tps65910, pmic_plat_data); 248 249 return ret; 250 } 251 252 static __devexit int tps65910_i2c_remove(struct i2c_client *i2c) 253 { 254 struct tps65910 *tps65910 = i2c_get_clientdata(i2c); 255 256 tps65910_irq_exit(tps65910); 257 mfd_remove_devices(tps65910->dev); 258 259 return 0; 260 } 261 262 static const struct i2c_device_id tps65910_i2c_id[] = { 263 { "tps65910", TPS65910 }, 264 { "tps65911", TPS65911 }, 265 { } 266 }; 267 MODULE_DEVICE_TABLE(i2c, tps65910_i2c_id); 268 269 270 static struct i2c_driver tps65910_i2c_driver = { 271 .driver = { 272 .name = "tps65910", 273 .owner = THIS_MODULE, 274 .of_match_table = of_match_ptr(tps65910_of_match), 275 }, 276 .probe = tps65910_i2c_probe, 277 .remove = __devexit_p(tps65910_i2c_remove), 278 .id_table = tps65910_i2c_id, 279 }; 280 281 static int __init tps65910_i2c_init(void) 282 { 283 return i2c_add_driver(&tps65910_i2c_driver); 284 } 285 /* init early so consumer devices can complete system boot */ 286 subsys_initcall(tps65910_i2c_init); 287 288 static void __exit tps65910_i2c_exit(void) 289 { 290 i2c_del_driver(&tps65910_i2c_driver); 291 } 292 module_exit(tps65910_i2c_exit); 293 294 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>"); 295 MODULE_AUTHOR("Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>"); 296 MODULE_DESCRIPTION("TPS6591x chip family multi-function driver"); 297 MODULE_LICENSE("GPL"); 298