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