drivers/mfd/tps65910.c

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