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 const struct regmap_config rk808_regmap_config = {
  93         .reg_bits = 8,
  94         .val_bits = 8,
  95         .max_register = RK808_IO_POL_REG,
  96         .cache_type = REGCACHE_RBTREE,
  97         .volatile_reg = rk808_is_volatile_reg,
  98 };
  99
 100 static struct resource rtc_resources[] = {
 101         {
 102                 .start  = RK808_IRQ_RTC_ALARM,
 103                 .end    = RK808_IRQ_RTC_ALARM,
 104                 .flags  = IORESOURCE_IRQ,
 105         }
 106 };
 107
 108 static const struct mfd_cell rk808s[] = {
 109         { .name = "rk808-clkout", },
 110         { .name = "rk808-regulator", },
 111         {
 112                 .name = "rk808-rtc",
 113                 .num_resources = ARRAY_SIZE(rtc_resources),
 114                 .resources = &rtc_resources[0],
 115         },
 116 };
 117
 118 static const struct rk808_reg_data pre_init_reg[] = {
 119         { RK808_BUCK3_CONFIG_REG, BUCK_ILMIN_MASK,  BUCK_ILMIN_150MA },
 120         { RK808_BUCK4_CONFIG_REG, BUCK_ILMIN_MASK,  BUCK_ILMIN_200MA },
 121         { RK808_BOOST_CONFIG_REG, BOOST_ILMIN_MASK, BOOST_ILMIN_100MA },
 122         { RK808_BUCK1_CONFIG_REG, BUCK1_RATE_MASK,  BUCK_ILMIN_200MA },
 123         { RK808_BUCK2_CONFIG_REG, BUCK2_RATE_MASK,  BUCK_ILMIN_200MA },
 124         { RK808_DCDC_UV_ACT_REG,  BUCK_UV_ACT_MASK, BUCK_UV_ACT_DISABLE},
 125         { RK808_VB_MON_REG,       MASK_ALL,         VB_LO_ACT |
 126                                                     VB_LO_SEL_3500MV },
 127 };
 128
 129 static const struct regmap_irq rk808_irqs[] = {
 130         /* INT_STS */
 131         [RK808_IRQ_VOUT_LO] = {
 132                 .mask = RK808_IRQ_VOUT_LO_MSK,
 133                 .reg_offset = 0,
 134         },
 135         [RK808_IRQ_VB_LO] = {
 136                 .mask = RK808_IRQ_VB_LO_MSK,
 137                 .reg_offset = 0,
 138         },
 139         [RK808_IRQ_PWRON] = {
 140                 .mask = RK808_IRQ_PWRON_MSK,
 141                 .reg_offset = 0,
 142         },
 143         [RK808_IRQ_PWRON_LP] = {
 144                 .mask = RK808_IRQ_PWRON_LP_MSK,
 145                 .reg_offset = 0,
 146         },
 147         [RK808_IRQ_HOTDIE] = {
 148                 .mask = RK808_IRQ_HOTDIE_MSK,
 149                 .reg_offset = 0,
 150         },
 151         [RK808_IRQ_RTC_ALARM] = {
 152                 .mask = RK808_IRQ_RTC_ALARM_MSK,
 153                 .reg_offset = 0,
 154         },
 155         [RK808_IRQ_RTC_PERIOD] = {
 156                 .mask = RK808_IRQ_RTC_PERIOD_MSK,
 157                 .reg_offset = 0,
 158         },
 159
 160         /* INT_STS2 */
 161         [RK808_IRQ_PLUG_IN_INT] = {
 162                 .mask = RK808_IRQ_PLUG_IN_INT_MSK,
 163                 .reg_offset = 1,
 164         },
 165         [RK808_IRQ_PLUG_OUT_INT] = {
 166                 .mask = RK808_IRQ_PLUG_OUT_INT_MSK,
 167                 .reg_offset = 1,
 168         },
 169 };
 170
 171 static struct regmap_irq_chip rk808_irq_chip = {
 172         .name = "rk808",
 173         .irqs = rk808_irqs,
 174         .num_irqs = ARRAY_SIZE(rk808_irqs),
 175         .num_regs = 2,
 176         .irq_reg_stride = 2,
 177         .status_base = RK808_INT_STS_REG1,
 178         .mask_base = RK808_INT_STS_MSK_REG1,
 179         .ack_base = RK808_INT_STS_REG1,
 180         .init_ack_masked = true,
 181 };
 182
 183 static const struct regmap_config rk818_regmap_config = {
 184         .reg_bits = 8,
 185         .val_bits = 8,
 186         .max_register = RK818_SAVE_DATA19,
 187         .cache_type = REGCACHE_RBTREE,
 188         .volatile_reg = rk808_is_volatile_reg,
 189 };
 190
 191 static const struct mfd_cell rk818s[] = {
 192         { .name = "rk808-clkout", },
 193         { .name = "rk818-regulator", },
 194         {
 195                 .name = "rk808-rtc",
 196                 .num_resources = ARRAY_SIZE(rtc_resources),
 197                 .resources = &rtc_resources[0],
 198         },
 199 };
 200
 201 static const struct rk808_reg_data rk818_pre_init_reg[] = {
 202         { RK818_H5V_EN_REG, REF_RDY_CTRL_ENABLE | H5V_EN_MASK,
 203                                         REF_RDY_CTRL_ENABLE | H5V_EN_ENABLE },
 204         { RK818_DCDC_EN_REG, BOOST_EN_MASK | SWITCH_EN_MASK,
 205                                         BOOST_EN_ENABLE | SWITCH_EN_ENABLE },
 206         { RK818_SLEEP_SET_OFF_REG1, OTG_SLP_SET_MASK, OTG_SLP_SET_OFF },
 207         { RK818_BUCK4_CONFIG_REG, BUCK_ILMIN_MASK,  BUCK_ILMIN_250MA },
 208 };
 209
 210 static const struct regmap_irq rk818_irqs[] = {
 211         /* INT_STS */
 212         [RK818_IRQ_VOUT_LO] = {
 213                 .mask = VOUT_LO_MASK,
 214                 .reg_offset = 0,
 215         },
 216         [RK818_IRQ_VB_LO] = {
 217                 .mask = VB_LO_MASK,
 218                 .reg_offset = 0,
 219         },
 220         [RK818_IRQ_PWRON] = {
 221                 .mask = PWRON_MASK,
 222                 .reg_offset = 0,
 223         },
 224         [RK818_IRQ_PWRON_LP] = {
 225                 .mask = PWRON_LP_MASK,
 226                 .reg_offset = 0,
 227         },
 228         [RK818_IRQ_HOTDIE] = {
 229                 .mask = HOTDIE_MASK,
 230                 .reg_offset = 0,
 231         },
 232         [RK818_IRQ_RTC_ALARM] = {
 233                 .mask = RTC_ALARM_MASK,
 234                 .reg_offset = 0,
 235         },
 236         [RK818_IRQ_RTC_PERIOD] = {
 237                 .mask = RTC_PERIOD_MASK,
 238                 .reg_offset = 0,
 239         },
 240         [RK818_IRQ_USB_OV] = {
 241                 .mask = USB_OV_MASK,
 242                 .reg_offset = 0,
 243         },
 244         /* INT_STS2 */
 245         [RK818_IRQ_PLUG_IN] = {
 246                 .mask = PLUG_IN_MASK,
 247                 .reg_offset = 1,
 248         },
 249         [RK818_IRQ_PLUG_OUT] = {
 250                 .mask = PLUG_OUT_MASK,
 251                 .reg_offset = 1,
 252         },
 253         [RK818_IRQ_CHG_OK] = {
 254                 .mask = CHGOK_MASK,
 255                 .reg_offset = 1,
 256         },
 257         [RK818_IRQ_CHG_TE] = {
 258                 .mask = CHGTE_MASK,
 259                 .reg_offset = 1,
 260         },
 261         [RK818_IRQ_CHG_TS1] = {
 262                 .mask = CHGTS1_MASK,
 263                 .reg_offset = 1,
 264         },
 265         [RK818_IRQ_TS2] = {
 266                 .mask = TS2_MASK,
 267                 .reg_offset = 1,
 268         },
 269         [RK818_IRQ_DISCHG_ILIM] = {
 270                 .mask = DISCHG_ILIM_MASK,
 271                 .reg_offset = 1,
 272         },
 273 };
 274
 275 static struct regmap_irq_chip rk818_irq_chip = {
 276         .name = "rk818",
 277         .irqs = rk818_irqs,
 278         .num_irqs = ARRAY_SIZE(rk818_irqs),
 279         .num_regs = 2,
 280         .irq_reg_stride = 2,
 281         .status_base = RK808_INT_STS_REG1,
 282         .mask_base = RK808_INT_STS_MSK_REG1,
 283         .ack_base = RK808_INT_STS_REG1,
 284         .init_ack_masked = true,
 285 };
 286
 287 static struct rk8xx_power_data rk808_power_data = {
 288         .name = "rk808",
 289         .rk8xx_pre_init_reg = pre_init_reg,
 290         .reg_num = ARRAY_SIZE(pre_init_reg),
 291         .rk8xx_regmap_config = &rk808_regmap_config,
 292         .rk8xx_cell = rk808s,
 293         .cell_num = ARRAY_SIZE(rk808s),
 294         .rk8xx_irq_chip = &rk808_irq_chip,
 295         .pm_shutdown = rk808_shutdown,
 296 };
 297
 298 static struct rk8xx_power_data rk818_power_data = {
 299         .name = "rk818",
 300         .rk8xx_pre_init_reg = rk818_pre_init_reg,
 301         .reg_num = ARRAY_SIZE(rk818_pre_init_reg),
 302         .rk8xx_regmap_config = &rk818_regmap_config,
 303         .rk8xx_cell = rk818s,
 304         .cell_num = ARRAY_SIZE(rk818s),
 305         .rk8xx_irq_chip = &rk818_irq_chip,
 306         .pm_shutdown = rk818_shutdown,
 307 };
 308
 309 static int (*pm_shutdown)(struct regmap *regmap);
 310 static struct i2c_client *rk808_i2c_client;
 311
 312 static void rk808_device_shutdown(void)
 313 {
 314         int ret;
 315         struct rk808 *rk808 = i2c_get_clientdata(rk808_i2c_client);
 316
 317         if (!rk808) {
 318                 dev_warn(&rk808_i2c_client->dev,
 319                          "have no rk808, so do nothing here\n");
 320                 return;
 321         }
 322
 323         ret = pm_shutdown(rk808->regmap);
 324         if (ret)
 325                 dev_err(&rk808_i2c_client->dev, "power off error!\n");
 326 }
 327
 328 static const struct of_device_id rk808_of_match[] = {
 329         {
 330                 .compatible = "rockchip,rk808",
 331                 .data = &rk808_power_data,
 332         },
 333         {
 334                 .compatible = "rockchip,rk818",
 335                 .data = &rk818_power_data,
 336         },
 337         { },
 338 };
 339 MODULE_DEVICE_TABLE(of, rk808_of_match);
 340
 341 static int rk808_probe(struct i2c_client *client,
 342                        const struct i2c_device_id *id)
 343 {
 344         const struct of_device_id *of_id =
 345                         of_match_device(rk808_of_match, &client->dev);
 346         const struct rk8xx_power_data *pdata = of_id->data;
 347         struct device_node *np = client->dev.of_node;
 348         struct rk808 *rk808;
 349         int pm_off = 0;
 350         int ret;
 351         int i;
 352
 353         if (!of_id) {
 354                 dev_err(&client->dev, "Failed to find matching dt id\n");
 355                 return -ENODEV;
 356         }
 357
 358         if (!client->irq) {
 359                 dev_err(&client->dev, "No interrupt support, no core IRQ\n");
 360                 return -EINVAL;
 361         }
 362
 363         rk808 = devm_kzalloc(&client->dev, sizeof(*rk808), GFP_KERNEL);
 364         if (!rk808)
 365                 return -ENOMEM;
 366
 367         rk808->regmap = devm_regmap_init_i2c(client,
 368                                              pdata->rk8xx_regmap_config);
 369         if (IS_ERR(rk808->regmap)) {
 370                 dev_err(&client->dev, "regmap initialization failed\n");
 371                 return PTR_ERR(rk808->regmap);
 372         }
 373
 374         pm_shutdown = pdata->pm_shutdown;
 375         if (!pm_shutdown) {
 376                 dev_err(&client->dev, "shutdown initialization failed\n");
 377                 return -EINVAL;
 378         }
 379
 380         for (i = 0; i < pdata->reg_num; i++) {
 381                 ret = regmap_update_bits(rk808->regmap,
 382                                          pdata->rk8xx_pre_init_reg[i].addr,
 383                                          pdata->rk8xx_pre_init_reg[i].mask,
 384                                          pdata->rk8xx_pre_init_reg[i].value);
 385                 if (ret) {
 386                         dev_err(&client->dev,
 387                                 "0x%x write err\n",
 388                                 pdata->rk8xx_pre_init_reg[i].addr);
 389                         return ret;
 390                 }
 391         }
 392
 393         ret = regmap_add_irq_chip(rk808->regmap, client->irq,
 394                                   IRQF_ONESHOT, -1,
 395                                   pdata->rk8xx_irq_chip, &rk808->irq_data);
 396         if (ret) {
 397                 dev_err(&client->dev, "Failed to add irq_chip %d\n", ret);
 398                 return ret;
 399         }
 400
 401         rk808->i2c = client;
 402         i2c_set_clientdata(client, rk808);
 403
 404         ret = mfd_add_devices(&client->dev, -1,
 405                               pdata->rk8xx_cell, pdata->cell_num,
 406                               NULL, 0, regmap_irq_get_domain(rk808->irq_data));
 407         if (ret) {
 408                 dev_err(&client->dev, "failed to add MFD devices %d\n", ret);
 409                 goto err_irq;
 410         }
 411
 412         pm_off = of_property_read_bool(np,
 413                                 "rockchip,system-power-controller");
 414         if (pm_off) {
 415                 rk808_i2c_client = client;
 416                 pm_power_off = rk808_device_shutdown;
 417         }
 418
 419         return 0;
 420
 421 err_irq:
 422         regmap_del_irq_chip(client->irq, rk808->irq_data);
 423         return ret;
 424 }
 425
 426 static int rk808_remove(struct i2c_client *client)
 427 {
 428         struct rk808 *rk808 = i2c_get_clientdata(client);
 429
 430         regmap_del_irq_chip(client->irq, rk808->irq_data);
 431         mfd_remove_devices(&client->dev);
 432         pm_power_off = NULL;
 433
 434         return 0;
 435 }
 436
 437 static const struct i2c_device_id rk808_ids[] = {
 438         { "rk808" },
 439         { "rk818" },
 440         { },
 441 };
 442 MODULE_DEVICE_TABLE(i2c, rk808_ids);
 443
 444 static struct i2c_driver rk808_i2c_driver = {
 445         .driver = {
 446                 .name = "rk808",
 447                 .of_match_table = rk808_of_match,
 448         },
 449         .probe    = rk808_probe,
 450         .remove   = rk808_remove,
 451         .id_table = rk808_ids,
 452 };
 453
 454 module_i2c_driver(rk808_i2c_driver);
 455
 456 MODULE_LICENSE("GPL");
 457 MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
 458 MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>");
 459 MODULE_DESCRIPTION("RK808 PMIC driver");