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 #if 0
  36 #define DBG(x...)       printk(KERN_INFO x)
  37 #else
  38 #define DBG(x...)
  39 #endif
  40 #if 1
  41 #define DBG_INFO(x...)  printk(KERN_INFO x)
  42 #else
  43 #define DBG_INFO(x...)
  44 #endif
  45 #define PM_CONTROL
  46
  47 #define SYR82X_SPEED 200*1000
  48 #define syr82x_NUM_REGULATORS 1
  49
  50 struct syr82x {
  51         struct device *dev;
  52         struct mutex io_lock;
  53         struct i2c_client *i2c;
  54         int num_regulators;
  55         struct regulator_dev **rdev;
  56         int irq_base;
  57         int chip_irq;
  58         int sleep_gpio; /* */
  59         unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
  60         bool pmic_sleep;
  61         struct regmap *regmap;
  62 };
  63
  64 struct syr82x_regulator {
  65         struct device           *dev;
  66         struct regulator_desc   *desc;
  67         struct regulator_dev    *rdev;
  68 };
  69 struct syr82x_board {
  70         int irq;
  71         int irq_base;
  72         struct regulator_init_data *syr82x_init_data[syr82x_NUM_REGULATORS];
  73         struct device_node *of_node[syr82x_NUM_REGULATORS];
  74         int sleep_gpio; /* */
  75         unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
  76         bool sleep;
  77 };
  78
  79 struct syr82x_regulator_subdev {
  80         int id;
  81         struct regulator_init_data *initdata;
  82         struct device_node *reg_node;
  83 };
  84
  85 struct syr82x_platform_data {
  86         int ono;
  87         int num_regulators;
  88         struct syr82x_regulator_subdev *regulators;
  89
  90         int sleep_gpio; /* */
  91         unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
  92         bool sleep;
  93 };
  94 struct syr82x *g_syr82x;
  95
  96 static int syr82x_reg_read(struct syr82x *syr82x, u8 reg);
  97 static int syr82x_set_bits(struct syr82x *syr82x, u8 reg, u16 mask, u16 val);
  98
  99
 100 #define SYR82X_BUCK1_SET_VOL_BASE 0x00
 101 #define SYR82X_BUCK1_SLP_VOL_BASE 0x01
 102 #define SYR82X_CONTR_REG1 0x02
 103 #define SYR82X_ID1_REG 0x03
 104 #define SYR82X_ID2_REG 0x04
 105 #define SYR82X_CONTR_REG2 0x05
 106
 107 #define BUCK_VOL_MASK 0x3f
 108 #define VOL_MIN_IDX 0x00
 109 #define VOL_MAX_IDX 0x3f
 110
 111 const static int buck_voltage_map[] = {
 112          712500, 725000, 737500,750000, 762500,775000,787500,800000,
 113          812500, 825000, 837500,850000, 862500,875000,887500,900000,
 114          912500, 925000, 937500,950000, 962500,975000,987500,1000000,
 115          1012500, 1025000, 1037500,1050000, 1062500,1075000,1087500,1100000,
 116          1112500, 1125000, 1137500,1150000, 1162500,1175000,1187500,1200000,
 117          1212500, 1225000, 1237500,1250000, 1262500,1275000,1287500,1300000,
 118          1312500, 1325000, 1337500,1350000, 1362500,1375000,1387500,1400000,
 119          1412500, 1425000, 1437500,1450000, 1462500,1475000,1487500,1500000,
 120 };
 121
 122 static int syr82x_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
 123 {
 124         if (index >= ARRAY_SIZE(buck_voltage_map))
 125                 return -EINVAL;
 126         return  buck_voltage_map[index];
 127 }
 128 static int syr82x_dcdc_is_enabled(struct regulator_dev *dev)
 129 {
 130         struct syr82x *syr82x = rdev_get_drvdata(dev);
 131         u16 val;
 132         u16 mask=0x80;
 133         val = syr82x_reg_read(syr82x, SYR82X_BUCK1_SET_VOL_BASE);
 134         if (val < 0)
 135                 return val;
 136          val=val&~0x7f;
 137         if (val & mask)
 138                 return 1;
 139         else
 140                 return 0;
 141 }
 142 static int syr82x_dcdc_enable(struct regulator_dev *dev)
 143 {
 144         struct syr82x *syr82x = rdev_get_drvdata(dev);
 145         u16 mask=0x80;
 146
 147         return syr82x_set_bits(syr82x, SYR82X_BUCK1_SET_VOL_BASE, mask, 0x80);
 148
 149 }
 150 static int syr82x_dcdc_disable(struct regulator_dev *dev)
 151 {
 152         struct syr82x *syr82x = rdev_get_drvdata(dev);
 153         u16 mask=0x80;
 154          return syr82x_set_bits(syr82x, SYR82X_BUCK1_SET_VOL_BASE, mask, 0);
 155 }
 156 static int syr82x_dcdc_get_voltage(struct regulator_dev *dev)
 157 {
 158         struct syr82x *syr82x = rdev_get_drvdata(dev);
 159         u16 reg = 0;
 160         int val;
 161         reg = syr82x_reg_read(syr82x,SYR82X_BUCK1_SET_VOL_BASE);
 162         reg &= BUCK_VOL_MASK;
 163         val = buck_voltage_map[reg];
 164         return val;
 165 }
 166 static int syr82x_dcdc_set_voltage(struct regulator_dev *dev,
 167                                   int min_uV, int max_uV,unsigned *selector)
 168 {
 169         struct syr82x *syr82x = rdev_get_drvdata(dev);
 170         const int *vol_map = buck_voltage_map;
 171         u16 val;
 172         int ret = 0;
 173
 174         if (min_uV < vol_map[VOL_MIN_IDX] ||
 175             min_uV > vol_map[VOL_MAX_IDX])
 176                 return -EINVAL;
 177
 178         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
 179                 if (vol_map[val] >= min_uV)
 180                         break;
 181         }
 182
 183         if (vol_map[val] > max_uV)
 184                 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
 185
 186         ret = syr82x_set_bits(syr82x, SYR82X_BUCK1_SET_VOL_BASE ,BUCK_VOL_MASK, val);
 187         if(ret < 0)
 188                 printk("###################WARNING:set voltage is error!voltage set is %d mv %d\n",vol_map[val],ret);
 189
 190         return ret;
 191 }
 192
 193 static unsigned int syr82x_dcdc_get_mode(struct regulator_dev *dev)
 194 {
 195         struct syr82x *syr82x = rdev_get_drvdata(dev);
 196         u16 mask = 0x40;
 197         u16 val;
 198         val = syr82x_reg_read(syr82x, SYR82X_BUCK1_SET_VOL_BASE);
 199         if (val < 0) {
 200                 return val;
 201         }
 202         val=val & mask;
 203         if (val== mask)
 204                 return REGULATOR_MODE_FAST;
 205         else
 206                 return REGULATOR_MODE_NORMAL;
 207
 208 }
 209 static int syr82x_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
 210 {
 211         struct syr82x *syr82x = rdev_get_drvdata(dev);
 212         u16 mask = 0x40;
 213
 214         switch(mode)
 215         {
 216         case REGULATOR_MODE_FAST:
 217                 return syr82x_set_bits(syr82x,SYR82X_BUCK1_SET_VOL_BASE, mask, mask);
 218         case REGULATOR_MODE_NORMAL:
 219                 return syr82x_set_bits(syr82x, SYR82X_BUCK1_SET_VOL_BASE, mask, 0);
 220         default:
 221                 printk("error:dcdc_syr82x only auto and pwm mode\n");
 222                 return -EINVAL;
 223         }
 224 }
 225 static int syr82x_dcdc_set_voltage_time_sel(struct regulator_dev *dev,   unsigned int old_selector,
 226                                      unsigned int new_selector)
 227 {
 228         int old_volt, new_volt;
 229
 230         old_volt = syr82x_dcdc_list_voltage(dev, old_selector);
 231         if (old_volt < 0)
 232                 return old_volt;
 233
 234         new_volt = syr82x_dcdc_list_voltage(dev, new_selector);
 235         if (new_volt < 0)
 236                 return new_volt;
 237
 238         return DIV_ROUND_UP(abs(old_volt - new_volt)*4, 10000);
 239 }
 240 static int syr82x_dcdc_suspend_enable(struct regulator_dev *dev)
 241 {
 242         struct syr82x *syr82x = rdev_get_drvdata(dev);
 243         u16 mask=0x80;
 244
 245         return syr82x_set_bits(syr82x, SYR82X_BUCK1_SLP_VOL_BASE, mask, 0x80);
 246
 247 }
 248 static int syr82x_dcdc_suspend_disable(struct regulator_dev *dev)
 249 {
 250         struct syr82x *syr82x = rdev_get_drvdata(dev);
 251         u16 mask=0x80;
 252          return syr82x_set_bits(syr82x, SYR82X_BUCK1_SLP_VOL_BASE, mask, 0);
 253 }
 254 static int syr82x_dcdc_set_sleep_voltage(struct regulator_dev *dev,
 255                                             int uV)
 256 {
 257         struct syr82x *syr82x = rdev_get_drvdata(dev);
 258         const int *vol_map = buck_voltage_map;
 259         u16 val;
 260         int ret = 0;
 261
 262         if (uV < vol_map[VOL_MIN_IDX] ||
 263             uV > vol_map[VOL_MAX_IDX])
 264                 return -EINVAL;
 265
 266         for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
 267                 if (vol_map[val] >= uV)
 268                         break;
 269         }
 270
 271         if (vol_map[val] > uV)
 272                 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
 273         ret = syr82x_set_bits(syr82x,SYR82X_BUCK1_SLP_VOL_BASE ,BUCK_VOL_MASK, val);
 274         return ret;
 275 }
 276
 277
 278 static int syr82x_dcdc_set_suspend_mode(struct regulator_dev *dev, unsigned int mode)
 279 {
 280         struct syr82x *syr82x = rdev_get_drvdata(dev);
 281         u16 mask = 0x40;
 282
 283         switch(mode)
 284         {
 285         case REGULATOR_MODE_FAST:
 286                 return syr82x_set_bits(syr82x,SYR82X_BUCK1_SLP_VOL_BASE, mask, mask);
 287         case REGULATOR_MODE_NORMAL:
 288                 return syr82x_set_bits(syr82x, SYR82X_BUCK1_SLP_VOL_BASE, mask, 0);
 289         default:
 290                 printk("error:dcdc_syr82x only auto and pwm mode\n");
 291                 return -EINVAL;
 292         }
 293 }
 294
 295 static struct regulator_ops syr82x_dcdc_ops = {
 296         .set_voltage = syr82x_dcdc_set_voltage,
 297         .get_voltage = syr82x_dcdc_get_voltage,
 298         .list_voltage= syr82x_dcdc_list_voltage,
 299         .is_enabled = syr82x_dcdc_is_enabled,
 300         .enable = syr82x_dcdc_enable,
 301         .disable = syr82x_dcdc_disable,
 302         .get_mode = syr82x_dcdc_get_mode,
 303         .set_mode = syr82x_dcdc_set_mode,
 304         .set_suspend_voltage = syr82x_dcdc_set_sleep_voltage,
 305         .set_suspend_enable = syr82x_dcdc_suspend_enable,
 306         .set_suspend_disable = syr82x_dcdc_suspend_disable,
 307         .set_suspend_mode = syr82x_dcdc_set_suspend_mode,
 308         .set_voltage_time_sel = syr82x_dcdc_set_voltage_time_sel,
 309 };
 310 static struct regulator_desc regulators[] = {
 311
 312         {
 313                 .name = "SY_DCDC1",
 314                 .id = 0,
 315                 .ops = &syr82x_dcdc_ops,
 316                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
 317                 .type = REGULATOR_VOLTAGE,
 318                 .owner = THIS_MODULE,
 319         },
 320 };
 321
 322 static int syr82x_i2c_read(struct i2c_client *i2c, char reg, int count, u16 *dest)
 323 {
 324       int ret;
 325     struct i2c_adapter *adap;
 326     struct i2c_msg msgs[2];
 327
 328     if(!i2c)
 329                 return ret;
 330
 331         if (count != 1)
 332                 return -EIO;
 333
 334     adap = i2c->adapter;
 335
 336     msgs[0].addr = i2c->addr;
 337     msgs[0].buf = &reg;
 338     msgs[0].flags = i2c->flags;
 339     msgs[0].len = 1;
 340     msgs[0].scl_rate = SYR82X_SPEED;
 341
 342     msgs[1].buf = (u8 *)dest;
 343     msgs[1].addr = i2c->addr;
 344     msgs[1].flags = i2c->flags | I2C_M_RD;
 345     msgs[1].len = 1;
 346     msgs[1].scl_rate = SYR82X_SPEED;
 347     ret = i2c_transfer(adap, msgs, 2);
 348
 349         DBG("***run in %s %d msgs[1].buf = %d\n",__FUNCTION__,__LINE__,*(msgs[1].buf));
 350
 351         return ret;
 352 }
 353
 354 static int syr82x_i2c_write(struct i2c_client *i2c, char reg, int count, const u16 src)
 355 {
 356         int ret=-1;
 357
 358         struct i2c_adapter *adap;
 359         struct i2c_msg msg;
 360         char tx_buf[2];
 361
 362         if(!i2c)
 363                 return ret;
 364         if (count != 1)
 365                 return -EIO;
 366
 367         adap = i2c->adapter;
 368         tx_buf[0] = reg;
 369         tx_buf[1] = src;
 370
 371         msg.addr = i2c->addr;
 372         msg.buf = &tx_buf[0];
 373         msg.len = 1 +1;
 374         msg.flags = i2c->flags;
 375         msg.scl_rate = SYR82X_SPEED;
 376
 377         ret = i2c_transfer(adap, &msg, 1);
 378         return ret;
 379 }
 380
 381 static int syr82x_reg_read(struct syr82x *syr82x, u8 reg)
 382 {
 383         u16 val = 0;
 384         int ret;
 385
 386         mutex_lock(&syr82x->io_lock);
 387
 388         ret = syr82x_i2c_read(syr82x->i2c, reg, 1, &val);
 389
 390         DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 391         if (ret < 0)
 392                 return ret;
 393
 394         mutex_unlock(&syr82x->io_lock);
 395
 396         return val & 0xff;
 397 }
 398
 399 static int syr82x_set_bits(struct syr82x *syr82x, u8 reg, u16 mask, u16 val)
 400 {
 401         u16 tmp;
 402         int ret;
 403
 404         mutex_lock(&syr82x->io_lock);
 405
 406         ret = syr82x_i2c_read(syr82x->i2c, reg, 1, &tmp);
 407         DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 408         if (ret < 0)
 409                 return ret;
 410         tmp = (tmp & ~mask) | val;
 411         ret = syr82x_i2c_write(syr82x->i2c, reg, 1, tmp);
 412         DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
 413         if (ret < 0)
 414                 return ret;
 415         ret = syr82x_i2c_read(syr82x->i2c, reg, 1, &tmp);
 416         DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
 417         if (ret < 0)
 418                 return ret;
 419         mutex_unlock(&syr82x->io_lock);
 420
 421         return 0;//ret;
 422 }
 423
 424 #ifdef CONFIG_OF
 425 static struct of_device_id syr82x_of_match[] = {
 426         { .compatible = "silergy,syr82x"},
 427         { },
 428 };
 429 MODULE_DEVICE_TABLE(of, syr82x_of_match);
 430 #endif
 431 #ifdef CONFIG_OF
 432 static struct of_regulator_match syr82x_reg_matches[] = {
 433         { .name = "syr82x_dcdc1" ,.driver_data = (void *)0},
 434 };
 435
 436 static struct syr82x_board *syr82x_parse_dt(struct syr82x *syr82x)
 437 {
 438         struct syr82x_board *pdata;
 439         struct device_node *regs;
 440         struct device_node *syr82x_np;
 441         int gpio,count;
 442         DBG("%s,line=%d\n", __func__,__LINE__);
 443
 444         syr82x_np = of_node_get(syr82x->dev->of_node);
 445         if (!syr82x_np) {
 446                 printk("could not find pmic sub-node\n");
 447                 return NULL;
 448         }
 449
 450         regs = of_find_node_by_name(syr82x_np, "regulators");
 451         if (!regs)
 452                 return NULL;
 453         count = of_regulator_match(syr82x->dev, regs, syr82x_reg_matches,
 454                                    syr82x_NUM_REGULATORS);
 455         of_node_put(regs);
 456         pdata = devm_kzalloc(syr82x->dev, sizeof(*pdata), GFP_KERNEL);
 457         if (!pdata)
 458                 return NULL;
 459         pdata->syr82x_init_data[0] = syr82x_reg_matches[0].init_data;
 460         pdata->of_node[0] = syr82x_reg_matches[0].of_node;
 461
 462         return pdata;
 463 }
 464
 465 #else
 466 static struct syr82x_board *syr82x_parse_dt(struct i2c_client *i2c)
 467 {
 468         return NULL;
 469 }
 470 #endif
 471
 472 static int syr82x_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
 473 {
 474         struct syr82x *syr82x;
 475         struct syr82x_board *pdev ;
 476         const struct of_device_id *match;
 477         struct regulator_config config = { };
 478         struct regulator_dev *sy_rdev;
 479         struct regulator_init_data *reg_data;
 480         const char *rail_name = NULL;
 481         int ret;
 482
 483         DBG("%s,line=%d\n", __func__,__LINE__);
 484
 485         if (i2c->dev.of_node) {
 486                 match = of_match_device(syr82x_of_match, &i2c->dev);
 487                 if (!match) {
 488                         printk("Failed to find matching dt id\n");
 489                         return -EINVAL;
 490                 }
 491         }
 492
 493         syr82x = devm_kzalloc(&i2c->dev,sizeof(struct syr82x), GFP_KERNEL);
 494         if (syr82x == NULL) {
 495                 ret = -ENOMEM;
 496                 goto err;
 497         }
 498         syr82x->i2c = i2c;
 499         syr82x->dev = &i2c->dev;
 500         i2c_set_clientdata(i2c, syr82x);
 501         g_syr82x = syr82x;
 502
 503         mutex_init(&syr82x->io_lock);
 504
 505         ret = syr82x_reg_read(syr82x,SYR82X_ID1_REG);
 506         if ((ret <0) ||(ret ==0xff) ||(ret ==0)){
 507                 printk("The device is not syr82x %x \n",ret);
 508                 goto err;
 509         }
 510
 511         ret = syr82x_set_bits(syr82x,SYR82X_CONTR_REG1,(1 << 6),(1<<6));  //10mv/2.4us
 512
 513         if (syr82x->dev->of_node)
 514                 pdev = syr82x_parse_dt(syr82x);
 515
 516         if (pdev) {
 517                 syr82x->num_regulators = syr82x_NUM_REGULATORS;
 518                 syr82x->rdev = kcalloc(syr82x_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
 519                 if (!syr82x->rdev) {
 520                         return -ENOMEM;
 521                 }
 522                 /* Instantiate the regulators */
 523                 reg_data = pdev->syr82x_init_data[0];
 524                 config.dev = syr82x->dev;
 525                 config.driver_data = syr82x;
 526                 if (syr82x->dev->of_node)
 527                         config.of_node = pdev->of_node[0];
 528                         if (reg_data && reg_data->constraints.name)
 529                                 rail_name = reg_data->constraints.name;
 530                         else
 531                                 rail_name = regulators[0].name;
 532                         reg_data->supply_regulator = rail_name;
 533
 534                 config.init_data =reg_data;
 535                 sy_rdev = regulator_register(&regulators[0],&config);
 536                 if (IS_ERR(sy_rdev)) {
 537                         printk("failed to register regulator\n");
 538                 goto err;
 539                 }
 540                 syr82x->rdev[0] = sy_rdev;
 541         }
 542         return 0;
 543 err:
 544         return ret;
 545
 546 }
 547
 548 static int  syr82x_i2c_remove(struct i2c_client *i2c)
 549 {
 550         struct syr82x *syr82x = i2c_get_clientdata(i2c);
 551
 552         if (syr82x->rdev[0])
 553                 regulator_unregister(syr82x->rdev[0]);
 554         i2c_set_clientdata(i2c, NULL);
 555         return 0;
 556 }
 557
 558 static const struct i2c_device_id syr82x_i2c_id[] = {
 559        { "syr82x", 0 },
 560        { }
 561 };
 562
 563 MODULE_DEVICE_TABLE(i2c, syr82x_i2c_id);
 564
 565 static struct i2c_driver syr82x_i2c_driver = {
 566         .driver = {
 567                 .name = "syr82x",
 568                 .owner = THIS_MODULE,
 569                 .of_match_table =of_match_ptr(syr82x_of_match),
 570         },
 571         .probe    = syr82x_i2c_probe,
 572         .remove   = syr82x_i2c_remove,
 573         .id_table = syr82x_i2c_id,
 574 };
 575
 576 static int __init syr82x_module_init(void)
 577 {
 578         int ret;
 579         ret = i2c_add_driver(&syr82x_i2c_driver);
 580         if (ret != 0)
 581                 pr_err("Failed to register I2C driver: %d\n", ret);
 582         return ret;
 583 }
 584 subsys_initcall_sync(syr82x_module_init);
 585
 586 static void __exit syr82x_module_exit(void)
 587 {
 588         i2c_del_driver(&syr82x_i2c_driver);
 589 }
 590 module_exit(syr82x_module_exit);
 591
 592 MODULE_LICENSE("GPL");
 593 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
 594 MODULE_DESCRIPTION("syr82x PMIC driver");
 595