drivers/mfd/rk808.c

   1 /*
   2  * MFD core driver for Rockchip RK808
   3  *
   4  * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
   5  *
   6  * Author: Chris Zhong <zyw@rock-chips.com>
   7  * Author: Zhang Qing <zhangqing@rock-chips.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms and conditions of the GNU General Public License,
  11  * version 2, as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16  * more details.
  17  */
  18
  19 #include <linux/i2c.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/mfd/rk808.h>
  22 #include <linux/mfd/core.h>
  23 #include <linux/module.h>
  24 #include <linux/regmap.h>
  25 #include <linux/of_device.h>
  26
  27 struct rk808_reg_data {
  28         int addr;
  29         int mask;
  30         int value;
  31 };
  32
  33 struct rk8xx_power_data {
  34         char *name;
  35         const struct rk808_reg_data *rk8xx_pre_init_reg;
  36         int reg_num;
  37         const struct regmap_config *rk8xx_regmap_config;
  38         const struct mfd_cell *rk8xx_cell;
  39         int cell_num;
  40         struct regmap_irq_chip *rk8xx_irq_chip;
  41         int (*pm_shutdown)(struct regmap *regmap);
  42 };
  43
  44 static bool rk808_is_volatile_reg(struct device *dev, unsigned int reg)
  45 {
  46         /*
  47          * Notes:
  48          * - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
  49          *   we don't use that feature.  It's better to cache.
  50          * - It's unlikely we care that RK808_DEVCTRL_REG is volatile since
  51          *   bits are cleared in case when we shutoff anyway, but better safe.
  52          */
  53
  54         switch (reg) {
  55         case RK808_SECONDS_REG ... RK808_WEEKS_REG:
  56         case RK808_RTC_STATUS_REG:
  57         case RK808_VB_MON_REG:
  58         case RK808_THERMAL_REG:
  59         case RK808_DCDC_UV_STS_REG:
  60         case RK808_LDO_UV_STS_REG:
  61         case RK808_DCDC_PG_REG:
  62         case RK808_LDO_PG_REG:
  63         case RK808_DEVCTRL_REG:
  64         case RK808_INT_STS_REG1:
  65         case RK808_INT_STS_REG2:
  66                 return true;
  67         }
  68
  69         return false;
  70 }
  71
  72 static int rk808_shutdown(struct regmap *regmap)
  73 {
  74         int ret;
  75
  76         ret = regmap_update_bits(regmap,
  77                                  RK808_DEVCTRL_REG,
  78                                  DEV_OFF_RST, DEV_OFF_RST);
  79         return ret;
  80 }
  81
  82 static int rk818_shutdown(struct regmap *regmap)
  83 {
  84         int ret;
  85
  86         ret = regmap_update_bits(regmap,
  87                                  RK818_DEVCTRL_REG,
  88                                  DEV_OFF, DEV_OFF);
  89         return ret;
  90 }
  91
  92 static bool rk818_is_volatile_reg(struct device *dev, unsigned int reg)
  93 {
  94         /*
  95          * Notes:
  96          * - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
  97          *   we don't use that feature.  It's better to cache.
  98          * - It's unlikely we care that RK808_DEVCTRL_REG is volatile since
  99          *   bits are cleared in case when we shutoff anyway, but better safe.
 100          */
 101
 102         switch (reg) {
 103         case RK808_SECONDS_REG ... RK808_WEEKS_REG:
 104         case RK808_RTC_STATUS_REG:
 105         case RK808_VB_MON_REG:
 106         case RK808_THERMAL_REG:
 107         case RK808_DCDC_EN_REG:
 108         case RK808_DCDC_UV_STS_REG:
 109         case RK808_LDO_UV_STS_REG:
 110         case RK808_DCDC_PG_REG:
 111         case RK808_LDO_PG_REG:
 112         case RK808_DEVCTRL_REG:
 113         case RK808_INT_STS_REG1:
 114         case RK808_INT_STS_REG2:
 115         case RK808_INT_STS_MSK_REG1:
 116         case RK808_INT_STS_MSK_REG2:
 117         case RK818_SUP_STS_REG ... RK818_SAVE_DATA19:
 118                 return true;
 119         }
 120
 121         return false;
 122 }
 123
 124 static const struct regmap_config rk808_regmap_config = {
 125         .reg_bits = 8,
 126         .val_bits = 8,
 127         .max_register = RK808_IO_POL_REG,
 128         .cache_type = REGCACHE_RBTREE,
 129         .volatile_reg = rk808_is_volatile_reg,
 130 };
 131
 132 static struct resource rtc_resources[] = {
 133         {
 134                 .start  = RK808_IRQ_RTC_ALARM,
 135                 .end    = RK808_IRQ_RTC_ALARM,
 136                 .flags  = IORESOURCE_IRQ,
 137         }
 138 };
 139
 140 static const struct mfd_cell rk808s[] = {
 141         { .name = "rk808-clkout", },
 142         { .name = "rk808-regulator", },
 143         {
 144                 .name = "rk808-rtc",
 145                 .num_resources = ARRAY_SIZE(rtc_resources),
 146                 .resources = &rtc_resources[0],
 147         },
 148 };
 149
 150 static const struct rk808_reg_data pre_init_reg[] = {
 151         { RK808_BUCK3_CONFIG_REG, BUCK_ILMIN_MASK,  BUCK_ILMIN_150MA },
 152         { RK808_BUCK4_CONFIG_REG, BUCK_ILMIN_MASK,  BUCK_ILMIN_200MA },
 153         { RK808_BOOST_CONFIG_REG, BOOST_ILMIN_MASK, BOOST_ILMIN_100MA },
 154         { RK808_BUCK1_CONFIG_REG, BUCK1_RATE_MASK,  BUCK_ILMIN_200MA },
 155         { RK808_BUCK2_CONFIG_REG, BUCK2_RATE_MASK,  BUCK_ILMIN_200MA },
 156         { RK808_DCDC_UV_ACT_REG,  BUCK_UV_ACT_MASK, BUCK_UV_ACT_DISABLE},
 157         { RK808_VB_MON_REG,       MASK_ALL,         VB_LO_ACT |
 158                                                     VB_LO_SEL_3500MV },
 159 };
 160
 161 static const struct regmap_irq rk808_irqs[] = {
 162         /* INT_STS */
 163         [RK808_IRQ_VOUT_LO] = {
 164                 .mask = RK808_IRQ_VOUT_LO_MSK,
 165                 .reg_offset = 0,
 166         },
 167         [RK808_IRQ_VB_LO] = {
 168                 .mask = RK808_IRQ_VB_LO_MSK,
 169                 .reg_offset = 0,
 170         },
 171         [RK808_IRQ_PWRON] = {
 172                 .mask = RK808_IRQ_PWRON_MSK,
 173                 .reg_offset = 0,
 174         },
 175         [RK808_IRQ_PWRON_LP] = {
 176                 .mask = RK808_IRQ_PWRON_LP_MSK,
 177                 .reg_offset = 0,
 178         },
 179         [RK808_IRQ_HOTDIE] = {
 180                 .mask = RK808_IRQ_HOTDIE_MSK,
 181                 .reg_offset = 0,
 182         },
 183         [RK808_IRQ_RTC_ALARM] = {
 184                 .mask = RK808_IRQ_RTC_ALARM_MSK,
 185                 .reg_offset = 0,
 186         },
 187         [RK808_IRQ_RTC_PERIOD] = {
 188                 .mask = RK808_IRQ_RTC_PERIOD_MSK,
 189                 .reg_offset = 0,
 190         },
 191
 192         /* INT_STS2 */
 193         [RK808_IRQ_PLUG_IN_INT] = {
 194                 .mask = RK808_IRQ_PLUG_IN_INT_MSK,
 195                 .reg_offset = 1,
 196         },
 197         [RK808_IRQ_PLUG_OUT_INT] = {
 198                 .mask = RK808_IRQ_PLUG_OUT_INT_MSK,
 199                 .reg_offset = 1,
 200         },
 201 };
 202
 203 static struct regmap_irq_chip rk808_irq_chip = {
 204         .name = "rk808",
 205         .irqs = rk808_irqs,
 206         .num_irqs = ARRAY_SIZE(rk808_irqs),
 207         .num_regs = 2,
 208         .irq_reg_stride = 2,
 209         .status_base = RK808_INT_STS_REG1,
 210         .mask_base = RK808_INT_STS_MSK_REG1,
 211         .ack_base = RK808_INT_STS_REG1,
 212         .init_ack_masked = true,
 213 };
 214
 215 static const struct regmap_config rk818_regmap_config = {
 216         .reg_bits = 8,
 217         .val_bits = 8,
 218         .max_register = RK818_SAVE_DATA19,
 219         .cache_type = REGCACHE_RBTREE,
 220         .volatile_reg = rk818_is_volatile_reg,
 221 };
 222
 223 static const struct mfd_cell rk818s[] = {
 224         { .name = "rk808-clkout", },
 225         { .name = "rk818-regulator", },
 226         { .name = "rk818-battery", .of_compatible = "rk818-battery", },
 227         { .name = "rk818-charger", },
 228         {
 229                 .name = "rk808-rtc",
 230                 .num_resources = ARRAY_SIZE(rtc_resources),
 231                 .resources = &rtc_resources[0],
 232         },
 233 };
 234
 235 static const struct rk808_reg_data rk818_pre_init_reg[] = {
 236         { RK818_H5V_EN_REG, REF_RDY_CTRL_ENABLE | H5V_EN_MASK,
 237                                         REF_RDY_CTRL_ENABLE | H5V_EN_ENABLE },
 238         { RK818_DCDC_EN_REG, BOOST_EN_MASK | SWITCH_EN_MASK,
 239                                         BOOST_EN_ENABLE | SWITCH_EN_ENABLE },
 240         { RK818_SLEEP_SET_OFF_REG1, OTG_SLP_SET_MASK, OTG_SLP_SET_OFF },
 241         { RK818_BUCK4_CONFIG_REG, BUCK_ILMIN_MASK,  BUCK_ILMIN_250MA },
 242 };
 243
 244 static const struct regmap_irq rk818_irqs[] = {
 245         /* INT_STS */
 246         [RK818_IRQ_VOUT_LO] = {
 247                 .mask = VOUT_LO_MASK,
 248                 .reg_offset = 0,
 249         },
 250         [RK818_IRQ_VB_LO] = {
 251                 .mask = VB_LO_MASK,
 252                 .reg_offset = 0,
 253         },
 254         [RK818_IRQ_PWRON] = {
 255                 .mask = PWRON_MASK,
 256                 .reg_offset = 0,
 257         },
 258         [RK818_IRQ_PWRON_LP] = {
 259                 .mask = PWRON_LP_MASK,
 260                 .reg_offset = 0,
 261         },
 262         [RK818_IRQ_HOTDIE] = {
 263                 .mask = HOTDIE_MASK,
 264                 .reg_offset = 0,
 265         },
 266         [RK818_IRQ_RTC_ALARM] = {
 267                 .mask = RTC_ALARM_MASK,
 268                 .reg_offset = 0,
 269         },
 270         [RK818_IRQ_RTC_PERIOD] = {
 271                 .mask = RTC_PERIOD_MASK,
 272                 .reg_offset = 0,
 273         },
 274         [RK818_IRQ_USB_OV] = {
 275                 .mask = USB_OV_MASK,
 276                 .reg_offset = 0,
 277         },
 278         /* INT_STS2 */
 279         [RK818_IRQ_PLUG_IN] = {
 280                 .mask = PLUG_IN_MASK,
 281                 .reg_offset = 1,
 282         },
 283         [RK818_IRQ_PLUG_OUT] = {
 284                 .mask = PLUG_OUT_MASK,
 285                 .reg_offset = 1,
 286         },
 287         [RK818_IRQ_CHG_OK] = {
 288                 .mask = CHGOK_MASK,
 289                 .reg_offset = 1,
 290         },
 291         [RK818_IRQ_CHG_TE] = {
 292                 .mask = CHGTE_MASK,
 293                 .reg_offset = 1,
 294         },
 295         [RK818_IRQ_CHG_TS1] = {
 296                 .mask = CHGTS1_MASK,
 297                 .reg_offset = 1,
 298         },
 299         [RK818_IRQ_TS2] = {
 300                 .mask = TS2_MASK,
 301                 .reg_offset = 1,
 302         },
 303         [RK818_IRQ_DISCHG_ILIM] = {
 304                 .mask = DISCHG_ILIM_MASK,
 305                 .reg_offset = 1,
 306         },
 307 };
 308
 309 static struct regmap_irq_chip rk818_irq_chip = {
 310         .name = "rk818",
 311         .irqs = rk818_irqs,
 312         .num_irqs = ARRAY_SIZE(rk818_irqs),
 313         .num_regs = 2,
 314         .irq_reg_stride = 2,
 315         .status_base = RK808_INT_STS_REG1,
 316         .mask_base = RK808_INT_STS_MSK_REG1,
 317         .ack_base = RK808_INT_STS_REG1,
 318         .init_ack_masked = true,
 319 };
 320
 321 static struct rk8xx_power_data rk808_power_data = {
 322         .name = "rk808",
 323         .rk8xx_pre_init_reg = pre_init_reg,
 324         .reg_num = ARRAY_SIZE(pre_init_reg),
 325         .rk8xx_regmap_config = &rk808_regmap_config,
 326         .rk8xx_cell = rk808s,
 327         .cell_num = ARRAY_SIZE(rk808s),
 328         .rk8xx_irq_chip = &rk808_irq_chip,
 329         .pm_shutdown = rk808_shutdown,
 330 };
 331
 332 static struct rk8xx_power_data rk818_power_data = {
 333         .name = "rk818",
 334         .rk8xx_pre_init_reg = rk818_pre_init_reg,
 335         .reg_num = ARRAY_SIZE(rk818_pre_init_reg),
 336         .rk8xx_regmap_config = &rk818_regmap_config,
 337         .rk8xx_cell = rk818s,
 338         .cell_num = ARRAY_SIZE(rk818s),
 339         .rk8xx_irq_chip = &rk818_irq_chip,
 340         .pm_shutdown = rk818_shutdown,
 341 };
 342
 343 static int (*pm_shutdown)(struct regmap *regmap);
 344 static struct i2c_client *rk808_i2c_client;
 345
 346 static void rk808_device_shutdown(void)
 347 {
 348         int ret;
 349         struct rk808 *rk808 = i2c_get_clientdata(rk808_i2c_client);
 350
 351         if (!rk808) {
 352                 dev_warn(&rk808_i2c_client->dev,
 353                          "have no rk808, so do nothing here\n");
 354                 return;
 355         }
 356
 357         ret = pm_shutdown(rk808->regmap);
 358         if (ret)
 359                 dev_err(&rk808_i2c_client->dev, "power off error!\n");
 360 }
 361
 362 static const struct of_device_id rk808_of_match[] = {
 363         {
 364                 .compatible = "rockchip,rk808",
 365                 .data = &rk808_power_data,
 366         },
 367         {
 368                 .compatible = "rockchip,rk818",
 369                 .data = &rk818_power_data,
 370         },
 371         { },
 372 };
 373 MODULE_DEVICE_TABLE(of, rk808_of_match);
 374
 375 static int rk808_probe(struct i2c_client *client,
 376                        const struct i2c_device_id *id)
 377 {
 378         const struct of_device_id *of_id =
 379                         of_match_device(rk808_of_match, &client->dev);
 380         const struct rk8xx_power_data *pdata = of_id->data;
 381         struct device_node *np = client->dev.of_node;
 382         struct rk808 *rk808;
 383         int pm_off = 0;
 384         int ret;
 385         int i;
 386
 387         if (!of_id) {
 388                 dev_err(&client->dev, "Failed to find matching dt id\n");
 389                 return -ENODEV;
 390         }
 391
 392         if (!client->irq) {
 393                 dev_err(&client->dev, "No interrupt support, no core IRQ\n");
 394                 return -EINVAL;
 395         }
 396
 397         rk808 = devm_kzalloc(&client->dev, sizeof(*rk808), GFP_KERNEL);
 398         if (!rk808)
 399                 return -ENOMEM;
 400
 401         rk808->regmap = devm_regmap_init_i2c(client,
 402                                              pdata->rk8xx_regmap_config);
 403         if (IS_ERR(rk808->regmap)) {
 404                 dev_err(&client->dev, "regmap initialization failed\n");
 405                 return PTR_ERR(rk808->regmap);
 406         }
 407
 408         pm_shutdown = pdata->pm_shutdown;
 409         if (!pm_shutdown) {
 410                 dev_err(&client->dev, "shutdown initialization failed\n");
 411                 return -EINVAL;
 412         }
 413
 414         for (i = 0; i < pdata->reg_num; i++) {
 415                 ret = regmap_update_bits(rk808->regmap,
 416                                          pdata->rk8xx_pre_init_reg[i].addr,
 417                                          pdata->rk8xx_pre_init_reg[i].mask,
 418                                          pdata->rk8xx_pre_init_reg[i].value);
 419                 if (ret) {
 420                         dev_err(&client->dev,
 421                                 "0x%x write err\n",
 422                                 pdata->rk8xx_pre_init_reg[i].addr);
 423                         return ret;
 424                 }
 425         }
 426
 427         ret = regmap_add_irq_chip(rk808->regmap, client->irq,
 428                                   IRQF_ONESHOT, -1,
 429                                   pdata->rk8xx_irq_chip, &rk808->irq_data);
 430         if (ret) {
 431                 dev_err(&client->dev, "Failed to add irq_chip %d\n", ret);
 432                 return ret;
 433         }
 434
 435         rk808->i2c = client;
 436         i2c_set_clientdata(client, rk808);
 437
 438         ret = mfd_add_devices(&client->dev, -1,
 439                               pdata->rk8xx_cell, pdata->cell_num,
 440                               NULL, 0, regmap_irq_get_domain(rk808->irq_data));
 441         if (ret) {
 442                 dev_err(&client->dev, "failed to add MFD devices %d\n", ret);
 443                 goto err_irq;
 444         }
 445
 446         pm_off = of_property_read_bool(np,
 447                                 "rockchip,system-power-controller");
 448         if (pm_off) {
 449                 rk808_i2c_client = client;
 450                 pm_power_off = rk808_device_shutdown;
 451         }
 452
 453         return 0;
 454
 455 err_irq:
 456         regmap_del_irq_chip(client->irq, rk808->irq_data);
 457         return ret;
 458 }
 459
 460 static int rk808_remove(struct i2c_client *client)
 461 {
 462         struct rk808 *rk808 = i2c_get_clientdata(client);
 463
 464         regmap_del_irq_chip(client->irq, rk808->irq_data);
 465         mfd_remove_devices(&client->dev);
 466         pm_power_off = NULL;
 467
 468         return 0;
 469 }
 470
 471 static const struct i2c_device_id rk808_ids[] = {
 472         { "rk808" },
 473         { "rk818" },
 474         { },
 475 };
 476 MODULE_DEVICE_TABLE(i2c, rk808_ids);
 477
 478 static struct i2c_driver rk808_i2c_driver = {
 479         .driver = {
 480                 .name = "rk808",
 481                 .of_match_table = rk808_of_match,
 482         },
 483         .probe    = rk808_probe,
 484         .remove   = rk808_remove,
 485         .id_table = rk808_ids,
 486 };
 487
 488 module_i2c_driver(rk808_i2c_driver);
 489
 490 MODULE_LICENSE("GPL");
 491 MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
 492 MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>");
 493 MODULE_DESCRIPTION("RK808 PMIC driver");