drivers/regulator/syr82x.c

   1 /*
   2  * Regulator driver for syr82x DCDC chip for rk32xx
   3  *
   4  * Copyright (C) 2010, 2011 ROCKCHIP, Inc.
   5
   6  * Based on syr82x.c that is work by zhangqing<zhangqing@rock-chips.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  */
  13
  14 #include <linux/bug.h>
  15 #include <linux/err.h>
  16 #include <linux/i2c.h>
  17 #include <linux/kernel.h>
  18 #include <linux/regulator/driver.h>
  19 #include <linux/delay.h>
  20 #include <linux/slab.h>
  21 #include <linux/mutex.h>
  22 #include <linux/mfd/core.h>
  23
  24 #include <linux/interrupt.h>
  25 #include <linux/module.h>
  26 #include <linux/of_irq.h>
  27 #include <linux/of_gpio.h>
  28 #include <linux/of.h>
  29 #include <linux/of_device.h>
  30 #include <linux/regulator/of_regulator.h>
  31 #include <linux/regulator/driver.h>
  32 #include <linux/regulator/machine.h>
  33 #include <linux/regmap.h>
  34
  35 #define syr82x_NUM_REGULATORS 1
  36
  37 struct syr82x {
  38         struct device *dev;
  39         struct mutex io_lock;
  40         struct i2c_client *i2c;
  41         int num_regulators;
  42         struct regulator_dev **rdev;
  43         int irq_base;
  44         int chip_irq;
  45         int sleep_gpio; /* */
  46         unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
  47         bool pmic_sleep;
  48         struct regmap *regmap;
  49 };
  50
  51 struct syr82x_regulator {
  52         struct device           *dev;
  53         struct regulator_desc   *desc;
  54         struct regulator_dev    *rdev;
  55 };
  56 struct syr82x_board {
  57         int irq;
  58         int irq_base;
  59         struct regulator_init_data *syr82x_init_data[syr82x_NUM_REGULATORS];
  60         struct device_node *of_node[syr82x_NUM_REGULATORS];
  61         int sleep_gpio; /* */
  62         unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
  63         bool sleep;
  64 };
  65
  66 struct syr82x_regulator_subdev {
  67         int id;
  68         struct regulator_init_data *initdata;
  69         struct device_node *reg_node;
  70 };
  71
  72 struct syr82x_platform_data {
  73         int ono;
  74         int num_regulators;
  75         struct syr82x_regulator_subdev *regulators;
  76
  77         int sleep_gpio; /* */
  78         unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
  79         bool sleep;
  80 };
  81 struct syr82x *g_syr82x;
  82
  83 #define SYR82X_BUCK1_SET_VOL_BASE 0x00
  84 #define SYR82X_BUCK1_SLP_VOL_BASE 0x01
  85 #define SYR82X_CONTR_REG1 0x02
  86 #define SYR82X_ID1_REG 0x03
  87 #define SYR82X_ID2_REG 0x04
  88 #define SYR82X_CONTR_REG2 0x05
  89
  90 #define BUCK_VOL_MASK 0x3f
  91 #define VOL_MIN_IDX 0x00
  92 #define VOL_MAX_IDX 0x3f
  93
  94 struct syr82x_reg_data {
  95         int addr;
  96         int mask;
  97         int value;
  98 };
  99
 100 static const struct regmap_config syr82x_regmap_config = {
 101         .reg_bits = 8,
 102         .val_bits = 8,
 103         .max_register = SYR82X_CONTR_REG2,
 104         .cache_type = REGCACHE_RBTREE,
 105 };
 106
 107 const static int buck_voltage_map[] = {
 108          712500, 725000, 737500,750000, 762500,775000,787500,800000,
 109          812500, 825000, 837500,850000, 862500,875000,887500,900000,
 110          912500, 925000, 937500,950000, 962500,975000,987500,1000000,
 111          1012500, 1025000, 1037500,1050000, 1062500,1075000,1087500,1100000,
 112          1112500, 1125000, 1137500,1150000, 1162500,1175000,1187500,1200000,
 113          1212500, 1225000, 1237500,1250000, 1262500,1275000,1287500,1300000,
 114          1312500, 1325000, 1337500,1350000, 1362500,1375000,1387500,1400000,
 115          1412500, 1425000, 1437500,1450000, 1462500,1475000,1487500,1500000,
 116 };
 117
 118 static int syr82x_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
 119 {
 120         if (index >= ARRAY_SIZE(buck_voltage_map))
 121                 return -EINVAL;
 122         return  buck_voltage_map[index];
 123 }
 124 static int syr82x_dcdc_is_enabled(struct regulator_dev *dev)
 125 {
 126         struct syr82x *syr82x = rdev_get_drvdata(dev);
 127         unsigned int val;
 128         u16 mask = 0x80;
 129         int ret = 0;
 130
 131         ret = regmap_read(syr82x->regmap, SYR82X_BUCK1_SET_VOL_BASE, &val);
 132         if (ret != 0)
 133                 return ret;
 134
 135         val &= (~0x7f);
 136         if (val & mask)
 137                 return 1;
 138         else
 139                 return 0;
 140 }
 141 static int syr82x_dcdc_enable(struct regulator_dev *dev)
 142 {
 143         struct syr82x *syr82x = rdev_get_drvdata(dev);
 144         u16 mask = 0x80;
 145         int ret = 0;
 146
 147         ret = regmap_update_bits(syr82x->regmap,
 148                                  SYR82X_BUCK1_SET_VOL_BASE,
 149                                  mask, 0x80);
 150         return ret;
 151 }
 152 static int syr82x_dcdc_disable(struct regulator_dev *dev)
 153 {
 154         struct syr82x *syr82x = rdev_get_drvdata(dev);
 155         u16 mask = 0x80;
 156         int ret = 0;
 157
 158         ret = regmap_update_bits(syr82x->regmap,
 159                                  SYR82X_BUCK1_SET_VOL_BASE,
 160                                  mask, 0);
 161         return ret;
 162 }
 163 static int syr82x_dcdc_get_voltage(struct regulator_dev *dev)
 164 {
 165         struct syr82x *syr82x = rdev_get_drvdata(dev);
 166         unsigned int reg;
 167         int val;
 168         int ret = 0;
 169
 170         ret = regmap_read(syr82x->regmap, SYR82X_BUCK1_SET_VOL_BASE, &reg);
 171         if (ret != 0)
 172                 return ret;
 173
 174         reg &= BUCK_VOL_MASK;
 175         val = buck_voltage_map[reg];
 176
 177         return val;
 178 }
 179 static int syr82x_dcdc_set_voltage(struct regulator_dev *dev,
 180                                   int min_uV, int max_uV,unsigned *selector)
 181 {
 182         struct syr82x *syr82x = rdev_get_drvdata(dev);
 183         const int *vol_map = buck_voltage_map;
 184         u16 val;
 185         int ret = 0;
 186
 187         if (min_uV < vol_map[VOL_MIN_IDX] ||
 188             min_uV > vol_map[VOL_MAX_IDX])
 189                 return -EINVAL;
 190
 191         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
 192                 if (vol_map[val] >= min_uV)
 193                         break;
 194         }
 195
 196         if (vol_map[val] > max_uV)
 197                 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
 198
 199         ret = regmap_update_bits(syr82x->regmap,
 200                                  SYR82X_BUCK1_SET_VOL_BASE,
 201                                  BUCK_VOL_MASK, val);
 202         if (ret != 0)
 203                 printk("###################WARNING:set voltage is error!voltage set is %d mv %d\n",vol_map[val],ret);
 204
 205         return ret;
 206 }
 207
 208 static unsigned int syr82x_dcdc_get_mode(struct regulator_dev *dev)
 209 {
 210         struct syr82x *syr82x = rdev_get_drvdata(dev);
 211         u16 mask = 0x40;
 212         unsigned int val;
 213         int ret = 0;
 214
 215         ret = regmap_read(syr82x->regmap, SYR82X_BUCK1_SET_VOL_BASE, &val);
 216         if (ret != 0)
 217                 return ret;
 218
 219         val &= mask;
 220         if (val == mask)
 221                 return REGULATOR_MODE_FAST;
 222         else
 223                 return REGULATOR_MODE_NORMAL;
 224
 225 }
 226 static int syr82x_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
 227 {
 228         struct syr82x *syr82x = rdev_get_drvdata(dev);
 229         u16 mask = 0x40;
 230
 231         switch(mode)
 232         {
 233         case REGULATOR_MODE_FAST:
 234                 return regmap_update_bits(syr82x->regmap,
 235                                  SYR82X_BUCK1_SET_VOL_BASE,
 236                                  mask, mask);
 237         case REGULATOR_MODE_NORMAL:
 238                 return regmap_update_bits(syr82x->regmap,
 239                                  SYR82X_BUCK1_SET_VOL_BASE,
 240                                  mask, 0);
 241         default:
 242                 printk("error:dcdc_syr82x only auto and pwm mode\n");
 243                 return -EINVAL;
 244         }
 245 }
 246 static int syr82x_dcdc_set_voltage_time_sel(struct regulator_dev *dev,   unsigned int old_selector,
 247                                      unsigned int new_selector)
 248 {
 249         int old_volt, new_volt;
 250
 251         old_volt = syr82x_dcdc_list_voltage(dev, old_selector);
 252         if (old_volt < 0)
 253                 return old_volt;
 254
 255         new_volt = syr82x_dcdc_list_voltage(dev, new_selector);
 256         if (new_volt < 0)
 257                 return new_volt;
 258
 259         return DIV_ROUND_UP(abs(old_volt - new_volt)*4, 10000);
 260 }
 261 static int syr82x_dcdc_suspend_enable(struct regulator_dev *dev)
 262 {
 263         struct syr82x *syr82x = rdev_get_drvdata(dev);
 264         u16 mask = 0x80;
 265
 266         return regmap_update_bits(syr82x->regmap,
 267                                  SYR82X_BUCK1_SLP_VOL_BASE,
 268                                  mask, 0x80);
 269 }
 270 static int syr82x_dcdc_suspend_disable(struct regulator_dev *dev)
 271 {
 272         struct syr82x *syr82x = rdev_get_drvdata(dev);
 273         u16 mask=0x80;
 274
 275         return regmap_update_bits(syr82x->regmap,
 276                                  SYR82X_BUCK1_SLP_VOL_BASE,
 277                                  mask, 0);
 278 }
 279 static int syr82x_dcdc_set_sleep_voltage(struct regulator_dev *dev,
 280                                             int uV)
 281 {
 282         struct syr82x *syr82x = rdev_get_drvdata(dev);
 283         const int *vol_map = buck_voltage_map;
 284         u16 val;
 285         int ret = 0;
 286
 287         if (uV < vol_map[VOL_MIN_IDX] ||
 288             uV > vol_map[VOL_MAX_IDX])
 289                 return -EINVAL;
 290
 291         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
 292                 if (vol_map[val] >= uV)
 293                         break;
 294         }
 295
 296         if (vol_map[val] > uV)
 297                 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
 298
 299         ret = regmap_update_bits(syr82x->regmap,
 300                                  SYR82X_BUCK1_SLP_VOL_BASE,
 301                                  BUCK_VOL_MASK, val);
 302         return ret;
 303 }
 304
 305
 306 static int syr82x_dcdc_set_suspend_mode(struct regulator_dev *dev, unsigned int mode)
 307 {
 308         struct syr82x *syr82x = rdev_get_drvdata(dev);
 309         u16 mask = 0x40;
 310
 311         switch(mode)
 312         {
 313         case REGULATOR_MODE_FAST:
 314                 return regmap_update_bits(syr82x->regmap,
 315                                  SYR82X_BUCK1_SLP_VOL_BASE,
 316                                  mask, mask);
 317         case REGULATOR_MODE_NORMAL:
 318                 return regmap_update_bits(syr82x->regmap,
 319                                  SYR82X_BUCK1_SLP_VOL_BASE,
 320                                  mask, 0);
 321         default:
 322                 printk("error:dcdc_syr82x only auto and pwm mode\n");
 323                 return -EINVAL;
 324         }
 325 }
 326
 327 static struct regulator_ops syr82x_dcdc_ops = {
 328         .set_voltage = syr82x_dcdc_set_voltage,
 329         .get_voltage = syr82x_dcdc_get_voltage,
 330         .list_voltage= syr82x_dcdc_list_voltage,
 331         .is_enabled = syr82x_dcdc_is_enabled,
 332         .enable = syr82x_dcdc_enable,
 333         .disable = syr82x_dcdc_disable,
 334         .get_mode = syr82x_dcdc_get_mode,
 335         .set_mode = syr82x_dcdc_set_mode,
 336         .set_suspend_voltage = syr82x_dcdc_set_sleep_voltage,
 337         .set_suspend_enable = syr82x_dcdc_suspend_enable,
 338         .set_suspend_disable = syr82x_dcdc_suspend_disable,
 339         .set_suspend_mode = syr82x_dcdc_set_suspend_mode,
 340         .set_voltage_time_sel = syr82x_dcdc_set_voltage_time_sel,
 341 };
 342 static struct regulator_desc regulators[] = {
 343
 344         {
 345                 .name = "SY_DCDC1",
 346                 .id = 0,
 347                 .ops = &syr82x_dcdc_ops,
 348                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 349                 .type = REGULATOR_VOLTAGE,
 350                 .owner = THIS_MODULE,
 351         },
 352 };
 353
 354 static struct of_device_id syr82x_of_match[] = {
 355         { .compatible = "silergy,syr82x"},
 356         { },
 357 };
 358 MODULE_DEVICE_TABLE(of, syr82x_of_match);
 359
 360 static struct of_regulator_match syr82x_reg_matches[] = {
 361         { .name = "syr82x_dcdc1" ,.driver_data = (void *)0},
 362 };
 363
 364 static struct syr82x_board *syr82x_parse_dt(struct syr82x *syr82x)
 365 {
 366         struct syr82x_board *pdata;
 367         struct device_node *regs;
 368         struct device_node *syr82x_np;
 369         int count;
 370
 371         syr82x_np = of_node_get(syr82x->dev->of_node);
 372         if (!syr82x_np) {
 373                 printk("could not find pmic sub-node\n");
 374                 return NULL;
 375         }
 376
 377         regs = of_find_node_by_name(syr82x_np, "regulators");
 378         if (!regs)
 379                 return NULL;
 380         count = of_regulator_match(syr82x->dev, regs, syr82x_reg_matches,
 381                                    syr82x_NUM_REGULATORS);
 382         of_node_put(regs);
 383         pdata = devm_kzalloc(syr82x->dev, sizeof(*pdata), GFP_KERNEL);
 384         if (!pdata)
 385                 return NULL;
 386         pdata->syr82x_init_data[0] = syr82x_reg_matches[0].init_data;
 387         pdata->of_node[0] = syr82x_reg_matches[0].of_node;
 388
 389         return pdata;
 390 }
 391
 392 static int syr82x_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
 393 {
 394         struct syr82x *syr82x;
 395         struct syr82x_board *pdev ;
 396         const struct of_device_id *match;
 397         struct regulator_config config = { };
 398         struct regulator_dev *sy_rdev;
 399         struct regulator_init_data *reg_data;
 400         const char *rail_name = NULL;
 401         int ret;
 402         unsigned int val;
 403
 404         if (i2c->dev.of_node) {
 405                 match = of_match_device(syr82x_of_match, &i2c->dev);
 406                 if (!match) {
 407                         printk("Failed to find matching dt id\n");
 408                         return -EINVAL;
 409                 }
 410         }
 411
 412         syr82x = devm_kzalloc(&i2c->dev,sizeof(struct syr82x), GFP_KERNEL);
 413         if (syr82x == NULL) {
 414                 ret = -ENOMEM;
 415                 goto err;
 416         }
 417
 418         syr82x->regmap = devm_regmap_init_i2c(i2c, &syr82x_regmap_config);
 419         if (IS_ERR(syr82x->regmap)) {
 420                 dev_err(&i2c->dev, "regmap initialization failed\n");
 421                 return PTR_ERR(syr82x->regmap);
 422         }
 423         syr82x->i2c = i2c;
 424         syr82x->dev = &i2c->dev;
 425         i2c_set_clientdata(i2c, syr82x);
 426         g_syr82x = syr82x;
 427
 428         mutex_init(&syr82x->io_lock);
 429         ret = regmap_read(syr82x->regmap, SYR82X_ID1_REG, &val);
 430         if ((ret < 0) || (val == 0xff) || (val == 0)) {
 431                 dev_err(&i2c->dev, "The device is not syr82x\n");
 432                 goto err;
 433         }
 434         ret = regmap_update_bits(syr82x->regmap,
 435                                  SYR82X_CONTR_REG1,
 436                                  (1 << 6), (1 << 6));
 437
 438         if (syr82x->dev->of_node)
 439                 pdev = syr82x_parse_dt(syr82x);
 440
 441         if (pdev) {
 442                 syr82x->num_regulators = syr82x_NUM_REGULATORS;
 443                 syr82x->rdev = kcalloc(syr82x_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
 444                 if (!syr82x->rdev) {
 445                         return -ENOMEM;
 446                 }
 447                 /* Instantiate the regulators */
 448                 reg_data = pdev->syr82x_init_data[0];
 449                 config.dev = syr82x->dev;
 450                 config.driver_data = syr82x;
 451                 if (syr82x->dev->of_node)
 452                         config.of_node = pdev->of_node[0];
 453                         if (reg_data && reg_data->constraints.name)
 454                                 rail_name = reg_data->constraints.name;
 455                         else
 456                                 rail_name = regulators[0].name;
 457                         reg_data->supply_regulator = rail_name;
 458
 459                 config.init_data =reg_data;
 460                 sy_rdev = regulator_register(&regulators[0],&config);
 461                 if (IS_ERR(sy_rdev)) {
 462                         printk("failed to register regulator\n");
 463                 goto err;
 464                 }
 465                 syr82x->rdev[0] = sy_rdev;
 466         }
 467         return 0;
 468 err:
 469         return ret;
 470
 471 }
 472
 473 static int  syr82x_i2c_remove(struct i2c_client *i2c)
 474 {
 475         struct syr82x *syr82x = i2c_get_clientdata(i2c);
 476
 477         if (syr82x->rdev[0])
 478                 regulator_unregister(syr82x->rdev[0]);
 479         i2c_set_clientdata(i2c, NULL);
 480         return 0;
 481 }
 482
 483 static const struct i2c_device_id syr82x_i2c_id[] = {
 484        { "syr82x", 0 },
 485        { }
 486 };
 487
 488 MODULE_DEVICE_TABLE(i2c, syr82x_i2c_id);
 489
 490 static struct i2c_driver syr82x_i2c_driver = {
 491         .driver = {
 492                 .name = "syr82x",
 493                 .owner = THIS_MODULE,
 494                 .of_match_table =of_match_ptr(syr82x_of_match),
 495         },
 496         .probe    = syr82x_i2c_probe,
 497         .remove   = syr82x_i2c_remove,
 498         .id_table = syr82x_i2c_id,
 499 };
 500
 501 static int __init syr82x_module_init(void)
 502 {
 503         int ret;
 504         ret = i2c_add_driver(&syr82x_i2c_driver);
 505         if (ret != 0)
 506                 pr_err("Failed to register I2C driver: %d\n", ret);
 507         return ret;
 508 }
 509 subsys_initcall_sync(syr82x_module_init);
 510
 511 static void __exit syr82x_module_exit(void)
 512 {
 513         i2c_del_driver(&syr82x_i2c_driver);
 514 }
 515 module_exit(syr82x_module_exit);
 516
 517 MODULE_LICENSE("GPL");
 518 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
 519 MODULE_DESCRIPTION("syr82x PMIC driver");
 520