drivers/regulator/xz3216.c

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