Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 1 | /* |
| 2 | * FAN53555 Fairchild Digitally Programmable TinyBuck Regulator Driver. |
| 3 | * |
| 4 | * Supported Part Numbers: |
| 5 | * FAN53555UC00X/01X/03X/04X/05X |
| 6 | * |
| 7 | * Copyright (c) 2012 Marvell Technology Ltd. |
| 8 | * Yunfan Zhang <yfzhang@marvell.com> |
| 9 | * |
| 10 | * This package is free software; you can redistribute it and/or modify |
| 11 | * it under the terms of the GNU General Public License version 2 as |
| 12 | * published by the Free Software Foundation. |
| 13 | * |
| 14 | */ |
| 15 | #include <linux/module.h> |
| 16 | #include <linux/param.h> |
| 17 | #include <linux/err.h> |
| 18 | #include <linux/platform_device.h> |
| 19 | #include <linux/regulator/driver.h> |
| 20 | #include <linux/regulator/machine.h> |
Heiko Stuebner | 91f23d8 | 2014-09-16 21:22:53 +0200 | [diff] [blame] | 21 | #include <linux/regulator/of_regulator.h> |
| 22 | #include <linux/of_device.h> |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 23 | #include <linux/i2c.h> |
| 24 | #include <linux/slab.h> |
| 25 | #include <linux/regmap.h> |
| 26 | #include <linux/regulator/fan53555.h> |
| 27 | |
| 28 | /* Voltage setting */ |
| 29 | #define FAN53555_VSEL0 0x00 |
| 30 | #define FAN53555_VSEL1 0x01 |
| 31 | /* Control register */ |
| 32 | #define FAN53555_CONTROL 0x02 |
| 33 | /* IC Type */ |
| 34 | #define FAN53555_ID1 0x03 |
| 35 | /* IC mask version */ |
| 36 | #define FAN53555_ID2 0x04 |
| 37 | /* Monitor register */ |
| 38 | #define FAN53555_MONITOR 0x05 |
| 39 | |
| 40 | /* VSEL bit definitions */ |
| 41 | #define VSEL_BUCK_EN (1 << 7) |
| 42 | #define VSEL_MODE (1 << 6) |
| 43 | #define VSEL_NSEL_MASK 0x3F |
| 44 | /* Chip ID and Verison */ |
| 45 | #define DIE_ID 0x0F /* ID1 */ |
| 46 | #define DIE_REV 0x0F /* ID2 */ |
| 47 | /* Control bit definitions */ |
| 48 | #define CTL_OUTPUT_DISCHG (1 << 7) |
| 49 | #define CTL_SLEW_MASK (0x7 << 4) |
| 50 | #define CTL_SLEW_SHIFT 4 |
| 51 | #define CTL_RESET (1 << 2) |
| 52 | |
| 53 | #define FAN53555_NVOLTAGES 64 /* Numbers of voltages */ |
| 54 | |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 55 | enum fan53555_vendor { |
| 56 | FAN53555_VENDOR_FAIRCHILD = 0, |
| 57 | FAN53555_VENDOR_SILERGY, |
Subbaraman Narayanamurthy | 5da0024 | 2015-12-07 16:42:03 -0800 | [diff] [blame] | 58 | HALO_HL7509, |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 59 | }; |
| 60 | |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 61 | /* IC Type */ |
| 62 | enum { |
| 63 | FAN53555_CHIP_ID_00 = 0, |
| 64 | FAN53555_CHIP_ID_01, |
| 65 | FAN53555_CHIP_ID_02, |
| 66 | FAN53555_CHIP_ID_03, |
| 67 | FAN53555_CHIP_ID_04, |
| 68 | FAN53555_CHIP_ID_05, |
Wadim Egorov | 5e39cf4 | 2016-04-20 10:01:07 +0200 | [diff] [blame] | 69 | FAN53555_CHIP_ID_08 = 8, |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 70 | }; |
| 71 | |
Wadim Egorov | e57cbb7 | 2016-04-20 10:01:08 +0200 | [diff] [blame] | 72 | /* IC mask revision */ |
| 73 | enum { |
| 74 | FAN53555_CHIP_REV_00 = 0x3, |
| 75 | FAN53555_CHIP_REV_13 = 0xf, |
| 76 | }; |
| 77 | |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 78 | enum { |
| 79 | SILERGY_SYR82X = 8, |
| 80 | }; |
| 81 | |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 82 | struct fan53555_device_info { |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 83 | enum fan53555_vendor vendor; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 84 | struct regmap *regmap; |
| 85 | struct device *dev; |
| 86 | struct regulator_desc desc; |
| 87 | struct regulator_dev *rdev; |
| 88 | struct regulator_init_data *regulator; |
| 89 | /* IC Type and Rev */ |
| 90 | int chip_id; |
| 91 | int chip_rev; |
| 92 | /* Voltage setting register */ |
| 93 | unsigned int vol_reg; |
| 94 | unsigned int sleep_reg; |
| 95 | /* Voltage range and step(linear) */ |
| 96 | unsigned int vsel_min; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 97 | unsigned int vsel_step; |
| 98 | /* Voltage slew rate limiting */ |
| 99 | unsigned int slew_rate; |
| 100 | /* Sleep voltage cache */ |
| 101 | unsigned int sleep_vol_cache; |
Subbaraman Narayanamurthy | b359004 | 2015-12-14 16:49:05 -0800 | [diff] [blame] | 102 | /* Disable suspend */ |
| 103 | bool disable_suspend; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 104 | }; |
| 105 | |
| 106 | static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV) |
| 107 | { |
| 108 | struct fan53555_device_info *di = rdev_get_drvdata(rdev); |
| 109 | int ret; |
| 110 | |
Subbaraman Narayanamurthy | b359004 | 2015-12-14 16:49:05 -0800 | [diff] [blame] | 111 | if (di->disable_suspend) |
| 112 | return 0; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 113 | if (di->sleep_vol_cache == uV) |
| 114 | return 0; |
| 115 | ret = regulator_map_voltage_linear(rdev, uV, uV); |
| 116 | if (ret < 0) |
Sachin Kamat | 145fe1e | 2014-02-18 16:11:04 +0530 | [diff] [blame] | 117 | return ret; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 118 | ret = regmap_update_bits(di->regmap, di->sleep_reg, |
| 119 | VSEL_NSEL_MASK, ret); |
| 120 | if (ret < 0) |
Sachin Kamat | 145fe1e | 2014-02-18 16:11:04 +0530 | [diff] [blame] | 121 | return ret; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 122 | /* Cache the sleep voltage setting. |
| 123 | * Might not be the real voltage which is rounded */ |
| 124 | di->sleep_vol_cache = uV; |
| 125 | |
| 126 | return 0; |
| 127 | } |
| 128 | |
zhangqing | ab7cad3 | 2016-01-12 03:05:56 -0800 | [diff] [blame] | 129 | static int fan53555_set_suspend_enable(struct regulator_dev *rdev) |
| 130 | { |
| 131 | struct fan53555_device_info *di = rdev_get_drvdata(rdev); |
| 132 | |
| 133 | return regmap_update_bits(di->regmap, di->sleep_reg, |
| 134 | VSEL_BUCK_EN, VSEL_BUCK_EN); |
| 135 | } |
| 136 | |
| 137 | static int fan53555_set_suspend_disable(struct regulator_dev *rdev) |
| 138 | { |
| 139 | struct fan53555_device_info *di = rdev_get_drvdata(rdev); |
| 140 | |
| 141 | return regmap_update_bits(di->regmap, di->sleep_reg, |
| 142 | VSEL_BUCK_EN, 0); |
| 143 | } |
| 144 | |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 145 | static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode) |
| 146 | { |
| 147 | struct fan53555_device_info *di = rdev_get_drvdata(rdev); |
| 148 | |
| 149 | switch (mode) { |
| 150 | case REGULATOR_MODE_FAST: |
| 151 | regmap_update_bits(di->regmap, di->vol_reg, |
| 152 | VSEL_MODE, VSEL_MODE); |
| 153 | break; |
| 154 | case REGULATOR_MODE_NORMAL: |
| 155 | regmap_update_bits(di->regmap, di->vol_reg, VSEL_MODE, 0); |
| 156 | break; |
| 157 | default: |
| 158 | return -EINVAL; |
| 159 | } |
| 160 | return 0; |
| 161 | } |
| 162 | |
| 163 | static unsigned int fan53555_get_mode(struct regulator_dev *rdev) |
| 164 | { |
| 165 | struct fan53555_device_info *di = rdev_get_drvdata(rdev); |
| 166 | unsigned int val; |
| 167 | int ret = 0; |
| 168 | |
| 169 | ret = regmap_read(di->regmap, di->vol_reg, &val); |
| 170 | if (ret < 0) |
| 171 | return ret; |
| 172 | if (val & VSEL_MODE) |
| 173 | return REGULATOR_MODE_FAST; |
| 174 | else |
| 175 | return REGULATOR_MODE_NORMAL; |
| 176 | } |
| 177 | |
Krzysztof Kozlowski | 121b567 | 2015-01-05 10:04:19 +0100 | [diff] [blame] | 178 | static const int slew_rates[] = { |
Heiko Stuebner | dd7e71f | 2014-09-16 17:54:01 +0200 | [diff] [blame] | 179 | 64000, |
| 180 | 32000, |
| 181 | 16000, |
| 182 | 8000, |
| 183 | 4000, |
| 184 | 2000, |
| 185 | 1000, |
| 186 | 500, |
| 187 | }; |
| 188 | |
| 189 | static int fan53555_set_ramp(struct regulator_dev *rdev, int ramp) |
| 190 | { |
| 191 | struct fan53555_device_info *di = rdev_get_drvdata(rdev); |
| 192 | int regval = -1, i; |
| 193 | |
| 194 | for (i = 0; i < ARRAY_SIZE(slew_rates); i++) { |
| 195 | if (ramp <= slew_rates[i]) |
| 196 | regval = i; |
| 197 | else |
| 198 | break; |
| 199 | } |
| 200 | |
| 201 | if (regval < 0) { |
| 202 | dev_err(di->dev, "unsupported ramp value %d\n", ramp); |
| 203 | return -EINVAL; |
| 204 | } |
| 205 | |
| 206 | return regmap_update_bits(di->regmap, FAN53555_CONTROL, |
| 207 | CTL_SLEW_MASK, regval << CTL_SLEW_SHIFT); |
| 208 | } |
| 209 | |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 210 | static struct regulator_ops fan53555_regulator_ops = { |
| 211 | .set_voltage_sel = regulator_set_voltage_sel_regmap, |
| 212 | .get_voltage_sel = regulator_get_voltage_sel_regmap, |
Heiko Stuebner | fda87a4 | 2015-05-26 18:19:45 +0200 | [diff] [blame] | 213 | .set_voltage_time_sel = regulator_set_voltage_time_sel, |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 214 | .map_voltage = regulator_map_voltage_linear, |
| 215 | .list_voltage = regulator_list_voltage_linear, |
| 216 | .set_suspend_voltage = fan53555_set_suspend_voltage, |
| 217 | .enable = regulator_enable_regmap, |
| 218 | .disable = regulator_disable_regmap, |
| 219 | .is_enabled = regulator_is_enabled_regmap, |
| 220 | .set_mode = fan53555_set_mode, |
| 221 | .get_mode = fan53555_get_mode, |
Heiko Stuebner | dd7e71f | 2014-09-16 17:54:01 +0200 | [diff] [blame] | 222 | .set_ramp_delay = fan53555_set_ramp, |
zhangqing | ab7cad3 | 2016-01-12 03:05:56 -0800 | [diff] [blame] | 223 | .set_suspend_enable = fan53555_set_suspend_enable, |
| 224 | .set_suspend_disable = fan53555_set_suspend_disable, |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 225 | }; |
| 226 | |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 227 | static int fan53555_voltages_setup_fairchild(struct fan53555_device_info *di) |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 228 | { |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 229 | /* Init voltage range and step */ |
| 230 | switch (di->chip_id) { |
| 231 | case FAN53555_CHIP_ID_00: |
Wadim Egorov | e57cbb7 | 2016-04-20 10:01:08 +0200 | [diff] [blame] | 232 | switch (di->chip_rev) { |
| 233 | case FAN53555_CHIP_REV_00: |
| 234 | di->vsel_min = 600000; |
| 235 | di->vsel_step = 10000; |
| 236 | break; |
| 237 | case FAN53555_CHIP_REV_13: |
| 238 | di->vsel_min = 800000; |
| 239 | di->vsel_step = 10000; |
| 240 | break; |
| 241 | default: |
| 242 | dev_err(di->dev, |
| 243 | "Chip ID %d with rev %d not supported!\n", |
| 244 | di->chip_id, di->chip_rev); |
| 245 | return -EINVAL; |
| 246 | } |
| 247 | break; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 248 | case FAN53555_CHIP_ID_01: |
| 249 | case FAN53555_CHIP_ID_03: |
| 250 | case FAN53555_CHIP_ID_05: |
Wadim Egorov | 5e39cf4 | 2016-04-20 10:01:07 +0200 | [diff] [blame] | 251 | case FAN53555_CHIP_ID_08: |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 252 | di->vsel_min = 600000; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 253 | di->vsel_step = 10000; |
| 254 | break; |
| 255 | case FAN53555_CHIP_ID_04: |
| 256 | di->vsel_min = 603000; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 257 | di->vsel_step = 12826; |
| 258 | break; |
| 259 | default: |
| 260 | dev_err(di->dev, |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 261 | "Chip ID %d not supported!\n", di->chip_id); |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 262 | return -EINVAL; |
| 263 | } |
Heiko Stuebner | dd7e71f | 2014-09-16 17:54:01 +0200 | [diff] [blame] | 264 | |
| 265 | return 0; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 266 | } |
| 267 | |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 268 | static int fan53555_voltages_setup_silergy(struct fan53555_device_info *di) |
| 269 | { |
| 270 | /* Init voltage range and step */ |
| 271 | switch (di->chip_id) { |
| 272 | case SILERGY_SYR82X: |
| 273 | di->vsel_min = 712500; |
| 274 | di->vsel_step = 12500; |
| 275 | break; |
| 276 | default: |
| 277 | dev_err(di->dev, |
| 278 | "Chip ID %d not supported!\n", di->chip_id); |
| 279 | return -EINVAL; |
| 280 | } |
| 281 | |
| 282 | return 0; |
| 283 | } |
| 284 | |
| 285 | /* For 00,01,03,05 options: |
| 286 | * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V. |
| 287 | * For 04 option: |
| 288 | * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V. |
| 289 | * */ |
| 290 | static int fan53555_device_setup(struct fan53555_device_info *di, |
| 291 | struct fan53555_platform_data *pdata) |
| 292 | { |
| 293 | int ret = 0; |
| 294 | |
| 295 | /* Setup voltage control register */ |
| 296 | switch (pdata->sleep_vsel_id) { |
| 297 | case FAN53555_VSEL_ID_0: |
| 298 | di->sleep_reg = FAN53555_VSEL0; |
| 299 | di->vol_reg = FAN53555_VSEL1; |
| 300 | break; |
| 301 | case FAN53555_VSEL_ID_1: |
| 302 | di->sleep_reg = FAN53555_VSEL1; |
| 303 | di->vol_reg = FAN53555_VSEL0; |
| 304 | break; |
| 305 | default: |
| 306 | dev_err(di->dev, "Invalid VSEL ID!\n"); |
| 307 | return -EINVAL; |
| 308 | } |
| 309 | |
| 310 | switch (di->vendor) { |
| 311 | case FAN53555_VENDOR_FAIRCHILD: |
| 312 | ret = fan53555_voltages_setup_fairchild(di); |
| 313 | break; |
| 314 | case FAN53555_VENDOR_SILERGY: |
| 315 | ret = fan53555_voltages_setup_silergy(di); |
| 316 | break; |
Subbaraman Narayanamurthy | 5da0024 | 2015-12-07 16:42:03 -0800 | [diff] [blame] | 317 | case HALO_HL7509: |
| 318 | ret = fan53555_voltages_setup_fairchild(di); |
| 319 | break; |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 320 | default: |
Axel Lin | fe23053 | 2014-09-18 21:48:48 +0800 | [diff] [blame] | 321 | dev_err(di->dev, "vendor %d not supported!\n", di->vendor); |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 322 | return -EINVAL; |
| 323 | } |
| 324 | |
| 325 | return ret; |
| 326 | } |
| 327 | |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 328 | static int fan53555_regulator_register(struct fan53555_device_info *di, |
| 329 | struct regulator_config *config) |
| 330 | { |
| 331 | struct regulator_desc *rdesc = &di->desc; |
| 332 | |
| 333 | rdesc->name = "fan53555-reg"; |
Heiko Stuebner | 3415d60 | 2014-09-14 21:23:01 +0200 | [diff] [blame] | 334 | rdesc->supply_name = "vin"; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 335 | rdesc->ops = &fan53555_regulator_ops; |
| 336 | rdesc->type = REGULATOR_VOLTAGE; |
| 337 | rdesc->n_voltages = FAN53555_NVOLTAGES; |
| 338 | rdesc->enable_reg = di->vol_reg; |
| 339 | rdesc->enable_mask = VSEL_BUCK_EN; |
| 340 | rdesc->min_uV = di->vsel_min; |
| 341 | rdesc->uV_step = di->vsel_step; |
| 342 | rdesc->vsel_reg = di->vol_reg; |
| 343 | rdesc->vsel_mask = VSEL_NSEL_MASK; |
| 344 | rdesc->owner = THIS_MODULE; |
| 345 | |
Axel Lin | b15f5f7 | 2013-09-03 14:27:56 +0800 | [diff] [blame] | 346 | di->rdev = devm_regulator_register(di->dev, &di->desc, config); |
Rusty Russell | 8c6ffba | 2013-07-15 11:20:32 +0930 | [diff] [blame] | 347 | return PTR_ERR_OR_ZERO(di->rdev); |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 348 | } |
| 349 | |
Krzysztof Kozlowski | 121b567 | 2015-01-05 10:04:19 +0100 | [diff] [blame] | 350 | static const struct regmap_config fan53555_regmap_config = { |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 351 | .reg_bits = 8, |
| 352 | .val_bits = 8, |
| 353 | }; |
| 354 | |
Subbaraman Narayanamurthy | 349cf06 | 2015-12-14 15:42:47 -0800 | [diff] [blame] | 355 | static int fan53555_parse_dt(struct fan53555_device_info *di, |
| 356 | struct fan53555_platform_data *pdata, |
| 357 | const struct regulator_desc *desc) |
Heiko Stuebner | 91f23d8 | 2014-09-16 21:22:53 +0200 | [diff] [blame] | 358 | { |
Subbaraman Narayanamurthy | 349cf06 | 2015-12-14 15:42:47 -0800 | [diff] [blame] | 359 | struct device *dev = di->dev; |
| 360 | struct device_node *np = dev->of_node; |
Heiko Stuebner | 91f23d8 | 2014-09-16 21:22:53 +0200 | [diff] [blame] | 361 | int ret; |
| 362 | u32 tmp; |
| 363 | |
Javier Martinez Canillas | 072e78b | 2014-11-10 14:43:53 +0100 | [diff] [blame] | 364 | pdata->regulator = of_get_regulator_init_data(dev, np, desc); |
Subbaraman Narayanamurthy | 349cf06 | 2015-12-14 15:42:47 -0800 | [diff] [blame] | 365 | if (!pdata->regulator) { |
| 366 | dev_err(dev, "regulator init data is missing\n"); |
| 367 | return -ENODEV; |
| 368 | } |
Heiko Stuebner | 91f23d8 | 2014-09-16 21:22:53 +0200 | [diff] [blame] | 369 | |
| 370 | ret = of_property_read_u32(np, "fcs,suspend-voltage-selector", |
| 371 | &tmp); |
| 372 | if (!ret) |
| 373 | pdata->sleep_vsel_id = tmp; |
| 374 | |
Subbaraman Narayanamurthy | b359004 | 2015-12-14 16:49:05 -0800 | [diff] [blame] | 375 | di->disable_suspend = of_property_read_bool(np, "fcs,disable-suspend"); |
| 376 | |
Subbaraman Narayanamurthy | 349cf06 | 2015-12-14 15:42:47 -0800 | [diff] [blame] | 377 | return ret; |
Heiko Stuebner | 91f23d8 | 2014-09-16 21:22:53 +0200 | [diff] [blame] | 378 | } |
| 379 | |
| 380 | static const struct of_device_id fan53555_dt_ids[] = { |
| 381 | { |
| 382 | .compatible = "fcs,fan53555", |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 383 | .data = (void *)FAN53555_VENDOR_FAIRCHILD |
| 384 | }, { |
| 385 | .compatible = "silergy,syr827", |
| 386 | .data = (void *)FAN53555_VENDOR_SILERGY, |
| 387 | }, { |
| 388 | .compatible = "silergy,syr828", |
| 389 | .data = (void *)FAN53555_VENDOR_SILERGY, |
Subbaraman Narayanamurthy | 5da0024 | 2015-12-07 16:42:03 -0800 | [diff] [blame] | 390 | }, { |
| 391 | .compatible = "halo,hl7509", |
| 392 | .data = (void *)HALO_HL7509, |
Heiko Stuebner | 91f23d8 | 2014-09-16 21:22:53 +0200 | [diff] [blame] | 393 | }, |
| 394 | { } |
| 395 | }; |
| 396 | MODULE_DEVICE_TABLE(of, fan53555_dt_ids); |
| 397 | |
Bill Pemberton | a502357 | 2012-11-19 13:22:22 -0500 | [diff] [blame] | 398 | static int fan53555_regulator_probe(struct i2c_client *client, |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 399 | const struct i2c_device_id *id) |
| 400 | { |
| 401 | struct fan53555_device_info *di; |
| 402 | struct fan53555_platform_data *pdata; |
| 403 | struct regulator_config config = { }; |
| 404 | unsigned int val; |
| 405 | int ret; |
| 406 | |
Javier Martinez Canillas | 072e78b | 2014-11-10 14:43:53 +0100 | [diff] [blame] | 407 | di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info), |
| 408 | GFP_KERNEL); |
| 409 | if (!di) |
| 410 | return -ENOMEM; |
| 411 | |
Jingoo Han | dff91d0 | 2013-07-30 17:20:47 +0900 | [diff] [blame] | 412 | pdata = dev_get_platdata(&client->dev); |
Subbaraman Narayanamurthy | 349cf06 | 2015-12-14 15:42:47 -0800 | [diff] [blame] | 413 | if (!pdata) { |
| 414 | pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL); |
| 415 | if (!pdata) |
| 416 | return -ENOMEM; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 417 | } |
| 418 | |
Subbaraman Narayanamurthy | 349cf06 | 2015-12-14 15:42:47 -0800 | [diff] [blame] | 419 | di->dev = &client->dev; |
| 420 | ret = fan53555_parse_dt(di, pdata, &di->desc); |
| 421 | if (ret) |
| 422 | return ret; |
| 423 | |
Axel Lin | e13426b | 2014-09-18 21:49:38 +0800 | [diff] [blame] | 424 | di->regulator = pdata->regulator; |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 425 | if (client->dev.of_node) { |
| 426 | const struct of_device_id *match; |
| 427 | |
| 428 | match = of_match_device(of_match_ptr(fan53555_dt_ids), |
| 429 | &client->dev); |
| 430 | if (!match) |
| 431 | return -ENODEV; |
| 432 | |
Heiko Stübner | 6f34163 | 2014-09-17 13:21:48 +0200 | [diff] [blame] | 433 | di->vendor = (unsigned long) match->data; |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 434 | } else { |
Heiko Stuebner | 91f23d8 | 2014-09-16 21:22:53 +0200 | [diff] [blame] | 435 | /* if no ramp constraint set, get the pdata ramp_delay */ |
| 436 | if (!di->regulator->constraints.ramp_delay) { |
| 437 | int slew_idx = (pdata->slew_rate & 0x7) |
| 438 | ? pdata->slew_rate : 0; |
Heiko Stuebner | dd7e71f | 2014-09-16 17:54:01 +0200 | [diff] [blame] | 439 | |
Heiko Stuebner | 91f23d8 | 2014-09-16 21:22:53 +0200 | [diff] [blame] | 440 | di->regulator->constraints.ramp_delay |
| 441 | = slew_rates[slew_idx]; |
| 442 | } |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 443 | |
| 444 | di->vendor = id->driver_data; |
Heiko Stuebner | dd7e71f | 2014-09-16 17:54:01 +0200 | [diff] [blame] | 445 | } |
| 446 | |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 447 | di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config); |
| 448 | if (IS_ERR(di->regmap)) { |
| 449 | dev_err(&client->dev, "Failed to allocate regmap!\n"); |
| 450 | return PTR_ERR(di->regmap); |
| 451 | } |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 452 | i2c_set_clientdata(client, di); |
| 453 | /* Get chip ID */ |
| 454 | ret = regmap_read(di->regmap, FAN53555_ID1, &val); |
| 455 | if (ret < 0) { |
| 456 | dev_err(&client->dev, "Failed to get chip ID!\n"); |
Sachin Kamat | 145fe1e | 2014-02-18 16:11:04 +0530 | [diff] [blame] | 457 | return ret; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 458 | } |
| 459 | di->chip_id = val & DIE_ID; |
| 460 | /* Get chip revision */ |
| 461 | ret = regmap_read(di->regmap, FAN53555_ID2, &val); |
| 462 | if (ret < 0) { |
| 463 | dev_err(&client->dev, "Failed to get chip Rev!\n"); |
Sachin Kamat | 145fe1e | 2014-02-18 16:11:04 +0530 | [diff] [blame] | 464 | return ret; |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 465 | } |
| 466 | di->chip_rev = val & DIE_REV; |
| 467 | dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n", |
| 468 | di->chip_id, di->chip_rev); |
| 469 | /* Device init */ |
| 470 | ret = fan53555_device_setup(di, pdata); |
| 471 | if (ret < 0) { |
| 472 | dev_err(&client->dev, "Failed to setup device!\n"); |
| 473 | return ret; |
| 474 | } |
| 475 | /* Register regulator */ |
| 476 | config.dev = di->dev; |
| 477 | config.init_data = di->regulator; |
| 478 | config.regmap = di->regmap; |
| 479 | config.driver_data = di; |
Subbaraman Narayanamurthy | 349cf06 | 2015-12-14 15:42:47 -0800 | [diff] [blame] | 480 | config.of_node = client->dev.of_node; |
Heiko Stuebner | 91f23d8 | 2014-09-16 21:22:53 +0200 | [diff] [blame] | 481 | |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 482 | ret = fan53555_regulator_register(di, &config); |
| 483 | if (ret < 0) |
| 484 | dev_err(&client->dev, "Failed to register regulator!\n"); |
| 485 | return ret; |
| 486 | |
| 487 | } |
| 488 | |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 489 | static const struct i2c_device_id fan53555_id[] = { |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 490 | { |
| 491 | .name = "fan53555", |
| 492 | .driver_data = FAN53555_VENDOR_FAIRCHILD |
| 493 | }, { |
Guillaume Tucker | bdcb6c9 | 2017-08-21 13:47:43 +0100 | [diff] [blame] | 494 | .name = "syr827", |
| 495 | .driver_data = FAN53555_VENDOR_SILERGY |
| 496 | }, { |
| 497 | .name = "syr828", |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 498 | .driver_data = FAN53555_VENDOR_SILERGY |
Subbaraman Narayanamurthy | 5da0024 | 2015-12-07 16:42:03 -0800 | [diff] [blame] | 499 | }, { |
| 500 | .name = "hl7509", |
| 501 | .driver_data = HALO_HL7509 |
Heiko Stuebner | ee30928 | 2014-09-16 21:22:54 +0200 | [diff] [blame] | 502 | }, |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 503 | { }, |
| 504 | }; |
Javier Martinez Canillas | e80c47b | 2015-07-30 18:18:40 +0200 | [diff] [blame] | 505 | MODULE_DEVICE_TABLE(i2c, fan53555_id); |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 506 | |
| 507 | static struct i2c_driver fan53555_regulator_driver = { |
| 508 | .driver = { |
| 509 | .name = "fan53555-regulator", |
Heiko Stuebner | 91f23d8 | 2014-09-16 21:22:53 +0200 | [diff] [blame] | 510 | .of_match_table = of_match_ptr(fan53555_dt_ids), |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 511 | }, |
| 512 | .probe = fan53555_regulator_probe, |
Yunfan Zhang | 49d8c59 | 2012-09-08 03:52:18 -0700 | [diff] [blame] | 513 | .id_table = fan53555_id, |
| 514 | }; |
| 515 | |
| 516 | module_i2c_driver(fan53555_regulator_driver); |
| 517 | |
| 518 | MODULE_AUTHOR("Yunfan Zhang <yfzhang@marvell.com>"); |
| 519 | MODULE_DESCRIPTION("FAN53555 regulator driver"); |
| 520 | MODULE_LICENSE("GPL v2"); |