drivers/mfd/rk8xx-i2c.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Rockchip RK805/RK808/RK816/RK817/RK818 Core (I2C) driver
   4  *
   5  * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
   6  * Copyright (C) 2016 PHYTEC Messtechnik GmbH
   7  *
   8  * Author: Chris Zhong <zyw@rock-chips.com>
   9  * Author: Zhang Qing <zhangqing@rock-chips.com>
  10  * Author: Wadim Egorov <w.egorov@phytec.de>
  11  */
  12
  13 #include <linux/i2c.h>
  14 #include <linux/mfd/rk808.h>
  15 #include <linux/module.h>
  16 #include <linux/of.h>
  17 #include <linux/regmap.h>
  18
  19 struct rk8xx_i2c_platform_data {
  20         const struct regmap_config *regmap_cfg;
  21         int variant;
  22 };
  23
  24 static bool rk806_is_volatile_reg(struct device *dev, unsigned int reg)
  25 {
  26         switch (reg) {
  27         case RK806_POWER_EN0 ... RK806_POWER_EN5:
  28         case RK806_DVS_START_CTRL ... RK806_INT_MSK1:
  29                 return true;
  30         }
  31
  32         return false;
  33 }
  34
  35 static bool rk808_is_volatile_reg(struct device *dev, unsigned int reg)
  36 {
  37         /*
  38          * Notes:
  39          * - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
  40          *   we don't use that feature.  It's better to cache.
  41          * - It's unlikely we care that RK808_DEVCTRL_REG is volatile since
  42          *   bits are cleared in case when we shutoff anyway, but better safe.
  43          */
  44
  45         switch (reg) {
  46         case RK808_SECONDS_REG ... RK808_WEEKS_REG:
  47         case RK808_RTC_STATUS_REG:
  48         case RK808_VB_MON_REG:
  49         case RK808_THERMAL_REG:
  50         case RK808_DCDC_UV_STS_REG:
  51         case RK808_LDO_UV_STS_REG:
  52         case RK808_DCDC_PG_REG:
  53         case RK808_LDO_PG_REG:
  54         case RK808_DEVCTRL_REG:
  55         case RK808_INT_STS_REG1:
  56         case RK808_INT_STS_REG2:
  57                 return true;
  58         }
  59
  60         return false;
  61 }
  62
  63 static bool rk816_is_volatile_reg(struct device *dev, unsigned int reg)
  64 {
  65         /*
  66          * Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but
  67          * we don't use that feature.  It's better to cache.
  68          */
  69
  70         switch (reg) {
  71         case RK808_SECONDS_REG ... RK808_WEEKS_REG:
  72         case RK808_RTC_STATUS_REG:
  73         case RK808_VB_MON_REG:
  74         case RK808_THERMAL_REG:
  75         case RK816_DCDC_EN_REG1:
  76         case RK816_DCDC_EN_REG2:
  77         case RK816_INT_STS_REG1:
  78         case RK816_INT_STS_REG2:
  79         case RK816_INT_STS_REG3:
  80         case RK808_DEVCTRL_REG:
  81         case RK816_SUP_STS_REG:
  82         case RK816_GGSTS_REG:
  83         case RK816_ZERO_CUR_ADC_REGH:
  84         case RK816_ZERO_CUR_ADC_REGL:
  85         case RK816_GASCNT_REG(0) ... RK816_BAT_VOL_REGL:
  86                 return true;
  87         }
  88
  89         return false;
  90 }
  91
  92 static bool rk817_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          */
  99
 100         switch (reg) {
 101         case RK817_SECONDS_REG ... RK817_WEEKS_REG:
 102         case RK817_RTC_STATUS_REG:
 103         case RK817_CODEC_DTOP_LPT_SRST:
 104         case RK817_GAS_GAUGE_ADC_CONFIG0 ... RK817_GAS_GAUGE_CUR_ADC_K0:
 105         case RK817_PMIC_CHRG_STS:
 106         case RK817_PMIC_CHRG_OUT:
 107         case RK817_PMIC_CHRG_IN:
 108         case RK817_INT_STS_REG0:
 109         case RK817_INT_STS_REG1:
 110         case RK817_INT_STS_REG2:
 111         case RK817_SYS_STS:
 112                 return true;
 113         }
 114
 115         return false;
 116 }
 117
 118
 119 static const struct regmap_config rk818_regmap_config = {
 120         .reg_bits = 8,
 121         .val_bits = 8,
 122         .max_register = RK818_USB_CTRL_REG,
 123         .cache_type = REGCACHE_MAPLE,
 124         .volatile_reg = rk808_is_volatile_reg,
 125 };
 126
 127 static const struct regmap_config rk805_regmap_config = {
 128         .reg_bits = 8,
 129         .val_bits = 8,
 130         .max_register = RK805_OFF_SOURCE_REG,
 131         .cache_type = REGCACHE_MAPLE,
 132         .volatile_reg = rk808_is_volatile_reg,
 133 };
 134
 135 static const struct regmap_config rk806_regmap_config = {
 136         .reg_bits = 8,
 137         .val_bits = 8,
 138         .max_register = RK806_BUCK_RSERVE_REG5,
 139         .cache_type = REGCACHE_MAPLE,
 140         .volatile_reg = rk806_is_volatile_reg,
 141 };
 142
 143 static const struct regmap_config rk808_regmap_config = {
 144         .reg_bits = 8,
 145         .val_bits = 8,
 146         .max_register = RK808_IO_POL_REG,
 147         .cache_type = REGCACHE_MAPLE,
 148         .volatile_reg = rk808_is_volatile_reg,
 149 };
 150
 151 static const struct regmap_config rk816_regmap_config = {
 152         .reg_bits = 8,
 153         .val_bits = 8,
 154         .max_register = RK816_DATA_REG(18),
 155         .cache_type = REGCACHE_MAPLE,
 156         .volatile_reg = rk816_is_volatile_reg,
 157 };
 158
 159 static const struct regmap_config rk817_regmap_config = {
 160         .reg_bits = 8,
 161         .val_bits = 8,
 162         .max_register = RK817_GPIO_INT_CFG,
 163         .cache_type = REGCACHE_NONE,
 164         .volatile_reg = rk817_is_volatile_reg,
 165 };
 166
 167 static const struct rk8xx_i2c_platform_data rk805_data = {
 168         .regmap_cfg = &rk805_regmap_config,
 169         .variant = RK805_ID,
 170 };
 171
 172 static const struct rk8xx_i2c_platform_data rk806_data = {
 173         .regmap_cfg = &rk806_regmap_config,
 174         .variant = RK806_ID,
 175 };
 176
 177 static const struct rk8xx_i2c_platform_data rk808_data = {
 178         .regmap_cfg = &rk808_regmap_config,
 179         .variant = RK808_ID,
 180 };
 181
 182 static const struct rk8xx_i2c_platform_data rk809_data = {
 183         .regmap_cfg = &rk817_regmap_config,
 184         .variant = RK809_ID,
 185 };
 186
 187 static const struct rk8xx_i2c_platform_data rk816_data = {
 188         .regmap_cfg = &rk816_regmap_config,
 189         .variant = RK816_ID,
 190 };
 191
 192 static const struct rk8xx_i2c_platform_data rk817_data = {
 193         .regmap_cfg = &rk817_regmap_config,
 194         .variant = RK817_ID,
 195 };
 196
 197 static const struct rk8xx_i2c_platform_data rk818_data = {
 198         .regmap_cfg = &rk818_regmap_config,
 199         .variant = RK818_ID,
 200 };
 201
 202 static int rk8xx_i2c_probe(struct i2c_client *client)
 203 {
 204         const struct rk8xx_i2c_platform_data *data;
 205         struct regmap *regmap;
 206
 207         data = device_get_match_data(&client->dev);
 208         if (!data)
 209                 return -ENODEV;
 210
 211         regmap = devm_regmap_init_i2c(client, data->regmap_cfg);
 212         if (IS_ERR(regmap))
 213                 return dev_err_probe(&client->dev, PTR_ERR(regmap),
 214                                      "regmap initialization failed\n");
 215
 216         return rk8xx_probe(&client->dev, data->variant, client->irq, regmap);
 217 }
 218
 219 static void rk8xx_i2c_shutdown(struct i2c_client *client)
 220 {
 221         rk8xx_shutdown(&client->dev);
 222 }
 223
 224 static SIMPLE_DEV_PM_OPS(rk8xx_i2c_pm_ops, rk8xx_suspend, rk8xx_resume);
 225
 226 static const struct of_device_id rk8xx_i2c_of_match[] = {
 227         { .compatible = "rockchip,rk805", .data = &rk805_data },
 228         { .compatible = "rockchip,rk806", .data = &rk806_data },
 229         { .compatible = "rockchip,rk808", .data = &rk808_data },
 230         { .compatible = "rockchip,rk809", .data = &rk809_data },
 231         { .compatible = "rockchip,rk816", .data = &rk816_data },
 232         { .compatible = "rockchip,rk817", .data = &rk817_data },
 233         { .compatible = "rockchip,rk818", .data = &rk818_data },
 234         { },
 235 };
 236 MODULE_DEVICE_TABLE(of, rk8xx_i2c_of_match);
 237
 238 static struct i2c_driver rk8xx_i2c_driver = {
 239         .driver = {
 240                 .name = "rk8xx-i2c",
 241                 .of_match_table = rk8xx_i2c_of_match,
 242                 .pm = &rk8xx_i2c_pm_ops,
 243         },
 244         .probe = rk8xx_i2c_probe,
 245         .shutdown  = rk8xx_i2c_shutdown,
 246 };
 247 module_i2c_driver(rk8xx_i2c_driver);
 248
 249 MODULE_LICENSE("GPL");
 250 MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
 251 MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>");
 252 MODULE_AUTHOR("Wadim Egorov <w.egorov@phytec.de>");
 253 MODULE_DESCRIPTION("RK8xx I2C PMIC driver");