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