149d8c599SYunfan Zhang /* 249d8c599SYunfan Zhang * FAN53555 Fairchild Digitally Programmable TinyBuck Regulator Driver. 349d8c599SYunfan Zhang * 449d8c599SYunfan Zhang * Supported Part Numbers: 549d8c599SYunfan Zhang * FAN53555UC00X/01X/03X/04X/05X 649d8c599SYunfan Zhang * 749d8c599SYunfan Zhang * Copyright (c) 2012 Marvell Technology Ltd. 849d8c599SYunfan Zhang * Yunfan Zhang <yfzhang@marvell.com> 949d8c599SYunfan Zhang * 1049d8c599SYunfan Zhang * This package is free software; you can redistribute it and/or modify 1149d8c599SYunfan Zhang * it under the terms of the GNU General Public License version 2 as 1249d8c599SYunfan Zhang * published by the Free Software Foundation. 1349d8c599SYunfan Zhang * 1449d8c599SYunfan Zhang */ 1549d8c599SYunfan Zhang #include <linux/module.h> 1649d8c599SYunfan Zhang #include <linux/param.h> 1749d8c599SYunfan Zhang #include <linux/err.h> 1849d8c599SYunfan Zhang #include <linux/platform_device.h> 1949d8c599SYunfan Zhang #include <linux/regulator/driver.h> 2049d8c599SYunfan Zhang #include <linux/regulator/machine.h> 2191f23d8fSHeiko Stuebner #include <linux/regulator/of_regulator.h> 2291f23d8fSHeiko Stuebner #include <linux/of_device.h> 2349d8c599SYunfan Zhang #include <linux/i2c.h> 2449d8c599SYunfan Zhang #include <linux/slab.h> 2549d8c599SYunfan Zhang #include <linux/regmap.h> 2649d8c599SYunfan Zhang #include <linux/regulator/fan53555.h> 2749d8c599SYunfan Zhang 2849d8c599SYunfan Zhang /* Voltage setting */ 2949d8c599SYunfan Zhang #define FAN53555_VSEL0 0x00 3049d8c599SYunfan Zhang #define FAN53555_VSEL1 0x01 3149d8c599SYunfan Zhang /* Control register */ 3249d8c599SYunfan Zhang #define FAN53555_CONTROL 0x02 3349d8c599SYunfan Zhang /* IC Type */ 3449d8c599SYunfan Zhang #define FAN53555_ID1 0x03 3549d8c599SYunfan Zhang /* IC mask version */ 3649d8c599SYunfan Zhang #define FAN53555_ID2 0x04 3749d8c599SYunfan Zhang /* Monitor register */ 3849d8c599SYunfan Zhang #define FAN53555_MONITOR 0x05 3949d8c599SYunfan Zhang 4049d8c599SYunfan Zhang /* VSEL bit definitions */ 4149d8c599SYunfan Zhang #define VSEL_BUCK_EN (1 << 7) 4249d8c599SYunfan Zhang #define VSEL_MODE (1 << 6) 4349d8c599SYunfan Zhang #define VSEL_NSEL_MASK 0x3F 4449d8c599SYunfan Zhang /* Chip ID and Verison */ 4549d8c599SYunfan Zhang #define DIE_ID 0x0F /* ID1 */ 4649d8c599SYunfan Zhang #define DIE_REV 0x0F /* ID2 */ 4749d8c599SYunfan Zhang /* Control bit definitions */ 4849d8c599SYunfan Zhang #define CTL_OUTPUT_DISCHG (1 << 7) 4949d8c599SYunfan Zhang #define CTL_SLEW_MASK (0x7 << 4) 5049d8c599SYunfan Zhang #define CTL_SLEW_SHIFT 4 5149d8c599SYunfan Zhang #define CTL_RESET (1 << 2) 5249d8c599SYunfan Zhang 5349d8c599SYunfan Zhang #define FAN53555_NVOLTAGES 64 /* Numbers of voltages */ 5449d8c599SYunfan Zhang 55ee30928aSHeiko Stuebner enum fan53555_vendor { 56ee30928aSHeiko Stuebner FAN53555_VENDOR_FAIRCHILD = 0, 57ee30928aSHeiko Stuebner FAN53555_VENDOR_SILERGY, 58ee30928aSHeiko Stuebner }; 59ee30928aSHeiko Stuebner 6049d8c599SYunfan Zhang /* IC Type */ 6149d8c599SYunfan Zhang enum { 6249d8c599SYunfan Zhang FAN53555_CHIP_ID_00 = 0, 6349d8c599SYunfan Zhang FAN53555_CHIP_ID_01, 6449d8c599SYunfan Zhang FAN53555_CHIP_ID_02, 6549d8c599SYunfan Zhang FAN53555_CHIP_ID_03, 6649d8c599SYunfan Zhang FAN53555_CHIP_ID_04, 6749d8c599SYunfan Zhang FAN53555_CHIP_ID_05, 685e39cf49SWadim Egorov FAN53555_CHIP_ID_08 = 8, 6949d8c599SYunfan Zhang }; 7049d8c599SYunfan Zhang 71e57cbb70SWadim Egorov /* IC mask revision */ 72e57cbb70SWadim Egorov enum { 73e57cbb70SWadim Egorov FAN53555_CHIP_REV_00 = 0x3, 74e57cbb70SWadim Egorov FAN53555_CHIP_REV_13 = 0xf, 75e57cbb70SWadim Egorov }; 76e57cbb70SWadim Egorov 77ee30928aSHeiko Stuebner enum { 78ee30928aSHeiko Stuebner SILERGY_SYR82X = 8, 79ee30928aSHeiko Stuebner }; 80ee30928aSHeiko Stuebner 8149d8c599SYunfan Zhang struct fan53555_device_info { 82ee30928aSHeiko Stuebner enum fan53555_vendor vendor; 8349d8c599SYunfan Zhang struct regmap *regmap; 8449d8c599SYunfan Zhang struct device *dev; 8549d8c599SYunfan Zhang struct regulator_desc desc; 8649d8c599SYunfan Zhang struct regulator_dev *rdev; 8749d8c599SYunfan Zhang struct regulator_init_data *regulator; 8849d8c599SYunfan Zhang /* IC Type and Rev */ 8949d8c599SYunfan Zhang int chip_id; 9049d8c599SYunfan Zhang int chip_rev; 9149d8c599SYunfan Zhang /* Voltage setting register */ 9249d8c599SYunfan Zhang unsigned int vol_reg; 9349d8c599SYunfan Zhang unsigned int sleep_reg; 9449d8c599SYunfan Zhang /* Voltage range and step(linear) */ 9549d8c599SYunfan Zhang unsigned int vsel_min; 9649d8c599SYunfan Zhang unsigned int vsel_step; 9749d8c599SYunfan Zhang /* Voltage slew rate limiting */ 9849d8c599SYunfan Zhang unsigned int slew_rate; 9949d8c599SYunfan Zhang /* Sleep voltage cache */ 10049d8c599SYunfan Zhang unsigned int sleep_vol_cache; 10149d8c599SYunfan Zhang }; 10249d8c599SYunfan Zhang 10349d8c599SYunfan Zhang static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV) 10449d8c599SYunfan Zhang { 10549d8c599SYunfan Zhang struct fan53555_device_info *di = rdev_get_drvdata(rdev); 10649d8c599SYunfan Zhang int ret; 10749d8c599SYunfan Zhang 10849d8c599SYunfan Zhang if (di->sleep_vol_cache == uV) 10949d8c599SYunfan Zhang return 0; 11049d8c599SYunfan Zhang ret = regulator_map_voltage_linear(rdev, uV, uV); 11149d8c599SYunfan Zhang if (ret < 0) 112145fe1e1SSachin Kamat return ret; 11349d8c599SYunfan Zhang ret = regmap_update_bits(di->regmap, di->sleep_reg, 11449d8c599SYunfan Zhang VSEL_NSEL_MASK, ret); 11549d8c599SYunfan Zhang if (ret < 0) 116145fe1e1SSachin Kamat return ret; 11749d8c599SYunfan Zhang /* Cache the sleep voltage setting. 11849d8c599SYunfan Zhang * Might not be the real voltage which is rounded */ 11949d8c599SYunfan Zhang di->sleep_vol_cache = uV; 12049d8c599SYunfan Zhang 12149d8c599SYunfan Zhang return 0; 12249d8c599SYunfan Zhang } 12349d8c599SYunfan Zhang 124ab7cad33Szhangqing static int fan53555_set_suspend_enable(struct regulator_dev *rdev) 125ab7cad33Szhangqing { 126ab7cad33Szhangqing struct fan53555_device_info *di = rdev_get_drvdata(rdev); 127ab7cad33Szhangqing 128ab7cad33Szhangqing return regmap_update_bits(di->regmap, di->sleep_reg, 129ab7cad33Szhangqing VSEL_BUCK_EN, VSEL_BUCK_EN); 130ab7cad33Szhangqing } 131ab7cad33Szhangqing 132ab7cad33Szhangqing static int fan53555_set_suspend_disable(struct regulator_dev *rdev) 133ab7cad33Szhangqing { 134ab7cad33Szhangqing struct fan53555_device_info *di = rdev_get_drvdata(rdev); 135ab7cad33Szhangqing 136ab7cad33Szhangqing return regmap_update_bits(di->regmap, di->sleep_reg, 137ab7cad33Szhangqing VSEL_BUCK_EN, 0); 138ab7cad33Szhangqing } 139ab7cad33Szhangqing 14049d8c599SYunfan Zhang static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode) 14149d8c599SYunfan Zhang { 14249d8c599SYunfan Zhang struct fan53555_device_info *di = rdev_get_drvdata(rdev); 14349d8c599SYunfan Zhang 14449d8c599SYunfan Zhang switch (mode) { 14549d8c599SYunfan Zhang case REGULATOR_MODE_FAST: 14649d8c599SYunfan Zhang regmap_update_bits(di->regmap, di->vol_reg, 14749d8c599SYunfan Zhang VSEL_MODE, VSEL_MODE); 14849d8c599SYunfan Zhang break; 14949d8c599SYunfan Zhang case REGULATOR_MODE_NORMAL: 15049d8c599SYunfan Zhang regmap_update_bits(di->regmap, di->vol_reg, VSEL_MODE, 0); 15149d8c599SYunfan Zhang break; 15249d8c599SYunfan Zhang default: 15349d8c599SYunfan Zhang return -EINVAL; 15449d8c599SYunfan Zhang } 15549d8c599SYunfan Zhang return 0; 15649d8c599SYunfan Zhang } 15749d8c599SYunfan Zhang 15849d8c599SYunfan Zhang static unsigned int fan53555_get_mode(struct regulator_dev *rdev) 15949d8c599SYunfan Zhang { 16049d8c599SYunfan Zhang struct fan53555_device_info *di = rdev_get_drvdata(rdev); 16149d8c599SYunfan Zhang unsigned int val; 16249d8c599SYunfan Zhang int ret = 0; 16349d8c599SYunfan Zhang 16449d8c599SYunfan Zhang ret = regmap_read(di->regmap, di->vol_reg, &val); 16549d8c599SYunfan Zhang if (ret < 0) 16649d8c599SYunfan Zhang return ret; 16749d8c599SYunfan Zhang if (val & VSEL_MODE) 16849d8c599SYunfan Zhang return REGULATOR_MODE_FAST; 16949d8c599SYunfan Zhang else 17049d8c599SYunfan Zhang return REGULATOR_MODE_NORMAL; 17149d8c599SYunfan Zhang } 17249d8c599SYunfan Zhang 173121b567dSKrzysztof Kozlowski static const int slew_rates[] = { 174dd7e71fbSHeiko Stuebner 64000, 175dd7e71fbSHeiko Stuebner 32000, 176dd7e71fbSHeiko Stuebner 16000, 177dd7e71fbSHeiko Stuebner 8000, 178dd7e71fbSHeiko Stuebner 4000, 179dd7e71fbSHeiko Stuebner 2000, 180dd7e71fbSHeiko Stuebner 1000, 181dd7e71fbSHeiko Stuebner 500, 182dd7e71fbSHeiko Stuebner }; 183dd7e71fbSHeiko Stuebner 184dd7e71fbSHeiko Stuebner static int fan53555_set_ramp(struct regulator_dev *rdev, int ramp) 185dd7e71fbSHeiko Stuebner { 186dd7e71fbSHeiko Stuebner struct fan53555_device_info *di = rdev_get_drvdata(rdev); 187dd7e71fbSHeiko Stuebner int regval = -1, i; 188dd7e71fbSHeiko Stuebner 189dd7e71fbSHeiko Stuebner for (i = 0; i < ARRAY_SIZE(slew_rates); i++) { 190dd7e71fbSHeiko Stuebner if (ramp <= slew_rates[i]) 191dd7e71fbSHeiko Stuebner regval = i; 192dd7e71fbSHeiko Stuebner else 193dd7e71fbSHeiko Stuebner break; 194dd7e71fbSHeiko Stuebner } 195dd7e71fbSHeiko Stuebner 196dd7e71fbSHeiko Stuebner if (regval < 0) { 197dd7e71fbSHeiko Stuebner dev_err(di->dev, "unsupported ramp value %d\n", ramp); 198dd7e71fbSHeiko Stuebner return -EINVAL; 199dd7e71fbSHeiko Stuebner } 200dd7e71fbSHeiko Stuebner 201dd7e71fbSHeiko Stuebner return regmap_update_bits(di->regmap, FAN53555_CONTROL, 202dd7e71fbSHeiko Stuebner CTL_SLEW_MASK, regval << CTL_SLEW_SHIFT); 203dd7e71fbSHeiko Stuebner } 204dd7e71fbSHeiko Stuebner 20571880ab2SBhumika Goyal static const struct regulator_ops fan53555_regulator_ops = { 20649d8c599SYunfan Zhang .set_voltage_sel = regulator_set_voltage_sel_regmap, 20749d8c599SYunfan Zhang .get_voltage_sel = regulator_get_voltage_sel_regmap, 208fda87a42SHeiko Stuebner .set_voltage_time_sel = regulator_set_voltage_time_sel, 20949d8c599SYunfan Zhang .map_voltage = regulator_map_voltage_linear, 21049d8c599SYunfan Zhang .list_voltage = regulator_list_voltage_linear, 21149d8c599SYunfan Zhang .set_suspend_voltage = fan53555_set_suspend_voltage, 21249d8c599SYunfan Zhang .enable = regulator_enable_regmap, 21349d8c599SYunfan Zhang .disable = regulator_disable_regmap, 21449d8c599SYunfan Zhang .is_enabled = regulator_is_enabled_regmap, 21549d8c599SYunfan Zhang .set_mode = fan53555_set_mode, 21649d8c599SYunfan Zhang .get_mode = fan53555_get_mode, 217dd7e71fbSHeiko Stuebner .set_ramp_delay = fan53555_set_ramp, 218ab7cad33Szhangqing .set_suspend_enable = fan53555_set_suspend_enable, 219ab7cad33Szhangqing .set_suspend_disable = fan53555_set_suspend_disable, 22049d8c599SYunfan Zhang }; 22149d8c599SYunfan Zhang 222ee30928aSHeiko Stuebner static int fan53555_voltages_setup_fairchild(struct fan53555_device_info *di) 22349d8c599SYunfan Zhang { 22449d8c599SYunfan Zhang /* Init voltage range and step */ 22549d8c599SYunfan Zhang switch (di->chip_id) { 22649d8c599SYunfan Zhang case FAN53555_CHIP_ID_00: 227e57cbb70SWadim Egorov switch (di->chip_rev) { 228e57cbb70SWadim Egorov case FAN53555_CHIP_REV_00: 229e57cbb70SWadim Egorov di->vsel_min = 600000; 230e57cbb70SWadim Egorov di->vsel_step = 10000; 231e57cbb70SWadim Egorov break; 232e57cbb70SWadim Egorov case FAN53555_CHIP_REV_13: 233e57cbb70SWadim Egorov di->vsel_min = 800000; 234e57cbb70SWadim Egorov di->vsel_step = 10000; 235e57cbb70SWadim Egorov break; 236e57cbb70SWadim Egorov default: 237e57cbb70SWadim Egorov dev_err(di->dev, 238e57cbb70SWadim Egorov "Chip ID %d with rev %d not supported!\n", 239e57cbb70SWadim Egorov di->chip_id, di->chip_rev); 240e57cbb70SWadim Egorov return -EINVAL; 241e57cbb70SWadim Egorov } 242e57cbb70SWadim Egorov break; 24349d8c599SYunfan Zhang case FAN53555_CHIP_ID_01: 24449d8c599SYunfan Zhang case FAN53555_CHIP_ID_03: 24549d8c599SYunfan Zhang case FAN53555_CHIP_ID_05: 2465e39cf49SWadim Egorov case FAN53555_CHIP_ID_08: 24749d8c599SYunfan Zhang di->vsel_min = 600000; 24849d8c599SYunfan Zhang di->vsel_step = 10000; 24949d8c599SYunfan Zhang break; 25049d8c599SYunfan Zhang case FAN53555_CHIP_ID_04: 25149d8c599SYunfan Zhang di->vsel_min = 603000; 25249d8c599SYunfan Zhang di->vsel_step = 12826; 25349d8c599SYunfan Zhang break; 25449d8c599SYunfan Zhang default: 25549d8c599SYunfan Zhang dev_err(di->dev, 256ee30928aSHeiko Stuebner "Chip ID %d not supported!\n", di->chip_id); 25749d8c599SYunfan Zhang return -EINVAL; 25849d8c599SYunfan Zhang } 259dd7e71fbSHeiko Stuebner 260dd7e71fbSHeiko Stuebner return 0; 26149d8c599SYunfan Zhang } 26249d8c599SYunfan Zhang 263ee30928aSHeiko Stuebner static int fan53555_voltages_setup_silergy(struct fan53555_device_info *di) 264ee30928aSHeiko Stuebner { 265ee30928aSHeiko Stuebner /* Init voltage range and step */ 266ee30928aSHeiko Stuebner switch (di->chip_id) { 267ee30928aSHeiko Stuebner case SILERGY_SYR82X: 268ee30928aSHeiko Stuebner di->vsel_min = 712500; 269ee30928aSHeiko Stuebner di->vsel_step = 12500; 270ee30928aSHeiko Stuebner break; 271ee30928aSHeiko Stuebner default: 272ee30928aSHeiko Stuebner dev_err(di->dev, 273ee30928aSHeiko Stuebner "Chip ID %d not supported!\n", di->chip_id); 274ee30928aSHeiko Stuebner return -EINVAL; 275ee30928aSHeiko Stuebner } 276ee30928aSHeiko Stuebner 277ee30928aSHeiko Stuebner return 0; 278ee30928aSHeiko Stuebner } 279ee30928aSHeiko Stuebner 280ee30928aSHeiko Stuebner /* For 00,01,03,05 options: 281ee30928aSHeiko Stuebner * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V. 282ee30928aSHeiko Stuebner * For 04 option: 283ee30928aSHeiko Stuebner * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V. 284ee30928aSHeiko Stuebner * */ 285ee30928aSHeiko Stuebner static int fan53555_device_setup(struct fan53555_device_info *di, 286ee30928aSHeiko Stuebner struct fan53555_platform_data *pdata) 287ee30928aSHeiko Stuebner { 288ee30928aSHeiko Stuebner int ret = 0; 289ee30928aSHeiko Stuebner 290ee30928aSHeiko Stuebner /* Setup voltage control register */ 291ee30928aSHeiko Stuebner switch (pdata->sleep_vsel_id) { 292ee30928aSHeiko Stuebner case FAN53555_VSEL_ID_0: 293ee30928aSHeiko Stuebner di->sleep_reg = FAN53555_VSEL0; 294ee30928aSHeiko Stuebner di->vol_reg = FAN53555_VSEL1; 295ee30928aSHeiko Stuebner break; 296ee30928aSHeiko Stuebner case FAN53555_VSEL_ID_1: 297ee30928aSHeiko Stuebner di->sleep_reg = FAN53555_VSEL1; 298ee30928aSHeiko Stuebner di->vol_reg = FAN53555_VSEL0; 299ee30928aSHeiko Stuebner break; 300ee30928aSHeiko Stuebner default: 301ee30928aSHeiko Stuebner dev_err(di->dev, "Invalid VSEL ID!\n"); 302ee30928aSHeiko Stuebner return -EINVAL; 303ee30928aSHeiko Stuebner } 304ee30928aSHeiko Stuebner 305ee30928aSHeiko Stuebner switch (di->vendor) { 306ee30928aSHeiko Stuebner case FAN53555_VENDOR_FAIRCHILD: 307ee30928aSHeiko Stuebner ret = fan53555_voltages_setup_fairchild(di); 308ee30928aSHeiko Stuebner break; 309ee30928aSHeiko Stuebner case FAN53555_VENDOR_SILERGY: 310ee30928aSHeiko Stuebner ret = fan53555_voltages_setup_silergy(di); 311ee30928aSHeiko Stuebner break; 312ee30928aSHeiko Stuebner default: 313fe230531SAxel Lin dev_err(di->dev, "vendor %d not supported!\n", di->vendor); 314ee30928aSHeiko Stuebner return -EINVAL; 315ee30928aSHeiko Stuebner } 316ee30928aSHeiko Stuebner 317ee30928aSHeiko Stuebner return ret; 318ee30928aSHeiko Stuebner } 319ee30928aSHeiko Stuebner 32049d8c599SYunfan Zhang static int fan53555_regulator_register(struct fan53555_device_info *di, 32149d8c599SYunfan Zhang struct regulator_config *config) 32249d8c599SYunfan Zhang { 32349d8c599SYunfan Zhang struct regulator_desc *rdesc = &di->desc; 32449d8c599SYunfan Zhang 32549d8c599SYunfan Zhang rdesc->name = "fan53555-reg"; 3263415d601SHeiko Stuebner rdesc->supply_name = "vin"; 32749d8c599SYunfan Zhang rdesc->ops = &fan53555_regulator_ops; 32849d8c599SYunfan Zhang rdesc->type = REGULATOR_VOLTAGE; 32949d8c599SYunfan Zhang rdesc->n_voltages = FAN53555_NVOLTAGES; 33049d8c599SYunfan Zhang rdesc->enable_reg = di->vol_reg; 33149d8c599SYunfan Zhang rdesc->enable_mask = VSEL_BUCK_EN; 33249d8c599SYunfan Zhang rdesc->min_uV = di->vsel_min; 33349d8c599SYunfan Zhang rdesc->uV_step = di->vsel_step; 33449d8c599SYunfan Zhang rdesc->vsel_reg = di->vol_reg; 33549d8c599SYunfan Zhang rdesc->vsel_mask = VSEL_NSEL_MASK; 33649d8c599SYunfan Zhang rdesc->owner = THIS_MODULE; 33749d8c599SYunfan Zhang 338b15f5f76SAxel Lin di->rdev = devm_regulator_register(di->dev, &di->desc, config); 3398c6ffba0SRusty Russell return PTR_ERR_OR_ZERO(di->rdev); 34049d8c599SYunfan Zhang } 34149d8c599SYunfan Zhang 342121b567dSKrzysztof Kozlowski static const struct regmap_config fan53555_regmap_config = { 34349d8c599SYunfan Zhang .reg_bits = 8, 34449d8c599SYunfan Zhang .val_bits = 8, 34549d8c599SYunfan Zhang }; 34649d8c599SYunfan Zhang 34791f23d8fSHeiko Stuebner static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev, 348072e78b1SJavier Martinez Canillas struct device_node *np, 349072e78b1SJavier Martinez Canillas const struct regulator_desc *desc) 35091f23d8fSHeiko Stuebner { 35191f23d8fSHeiko Stuebner struct fan53555_platform_data *pdata; 35291f23d8fSHeiko Stuebner int ret; 35391f23d8fSHeiko Stuebner u32 tmp; 35491f23d8fSHeiko Stuebner 35591f23d8fSHeiko Stuebner pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 35691f23d8fSHeiko Stuebner if (!pdata) 35791f23d8fSHeiko Stuebner return NULL; 35891f23d8fSHeiko Stuebner 359072e78b1SJavier Martinez Canillas pdata->regulator = of_get_regulator_init_data(dev, np, desc); 36091f23d8fSHeiko Stuebner 36191f23d8fSHeiko Stuebner ret = of_property_read_u32(np, "fcs,suspend-voltage-selector", 36291f23d8fSHeiko Stuebner &tmp); 36391f23d8fSHeiko Stuebner if (!ret) 36491f23d8fSHeiko Stuebner pdata->sleep_vsel_id = tmp; 36591f23d8fSHeiko Stuebner 36691f23d8fSHeiko Stuebner return pdata; 36791f23d8fSHeiko Stuebner } 36891f23d8fSHeiko Stuebner 36991f23d8fSHeiko Stuebner static const struct of_device_id fan53555_dt_ids[] = { 37091f23d8fSHeiko Stuebner { 37191f23d8fSHeiko Stuebner .compatible = "fcs,fan53555", 372ee30928aSHeiko Stuebner .data = (void *)FAN53555_VENDOR_FAIRCHILD 373ee30928aSHeiko Stuebner }, { 374ee30928aSHeiko Stuebner .compatible = "silergy,syr827", 375ee30928aSHeiko Stuebner .data = (void *)FAN53555_VENDOR_SILERGY, 376ee30928aSHeiko Stuebner }, { 377ee30928aSHeiko Stuebner .compatible = "silergy,syr828", 378ee30928aSHeiko Stuebner .data = (void *)FAN53555_VENDOR_SILERGY, 37991f23d8fSHeiko Stuebner }, 38091f23d8fSHeiko Stuebner { } 38191f23d8fSHeiko Stuebner }; 38291f23d8fSHeiko Stuebner MODULE_DEVICE_TABLE(of, fan53555_dt_ids); 38391f23d8fSHeiko Stuebner 384a5023574SBill Pemberton static int fan53555_regulator_probe(struct i2c_client *client, 38549d8c599SYunfan Zhang const struct i2c_device_id *id) 38649d8c599SYunfan Zhang { 38791f23d8fSHeiko Stuebner struct device_node *np = client->dev.of_node; 38849d8c599SYunfan Zhang struct fan53555_device_info *di; 38949d8c599SYunfan Zhang struct fan53555_platform_data *pdata; 39049d8c599SYunfan Zhang struct regulator_config config = { }; 39149d8c599SYunfan Zhang unsigned int val; 39249d8c599SYunfan Zhang int ret; 39349d8c599SYunfan Zhang 394072e78b1SJavier Martinez Canillas di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info), 395072e78b1SJavier Martinez Canillas GFP_KERNEL); 396072e78b1SJavier Martinez Canillas if (!di) 397072e78b1SJavier Martinez Canillas return -ENOMEM; 398072e78b1SJavier Martinez Canillas 399dff91d0bSJingoo Han pdata = dev_get_platdata(&client->dev); 40091f23d8fSHeiko Stuebner if (!pdata) 401072e78b1SJavier Martinez Canillas pdata = fan53555_parse_dt(&client->dev, np, &di->desc); 40291f23d8fSHeiko Stuebner 40349d8c599SYunfan Zhang if (!pdata || !pdata->regulator) { 40449d8c599SYunfan Zhang dev_err(&client->dev, "Platform data not found!\n"); 40549d8c599SYunfan Zhang return -ENODEV; 40649d8c599SYunfan Zhang } 40749d8c599SYunfan Zhang 408e13426bfSAxel Lin di->regulator = pdata->regulator; 409ee30928aSHeiko Stuebner if (client->dev.of_node) { 410d110e3e9SJisheng Zhang di->vendor = 411d110e3e9SJisheng Zhang (unsigned long)of_device_get_match_data(&client->dev); 412ee30928aSHeiko Stuebner } else { 413dd7e71fbSHeiko Stuebner /* if no ramp constraint set, get the pdata ramp_delay */ 414dd7e71fbSHeiko Stuebner if (!di->regulator->constraints.ramp_delay) { 41591f23d8fSHeiko Stuebner int slew_idx = (pdata->slew_rate & 0x7) 41691f23d8fSHeiko Stuebner ? pdata->slew_rate : 0; 417dd7e71fbSHeiko Stuebner 41891f23d8fSHeiko Stuebner di->regulator->constraints.ramp_delay 41991f23d8fSHeiko Stuebner = slew_rates[slew_idx]; 42091f23d8fSHeiko Stuebner } 421ee30928aSHeiko Stuebner 422ee30928aSHeiko Stuebner di->vendor = id->driver_data; 423dd7e71fbSHeiko Stuebner } 424dd7e71fbSHeiko Stuebner 42549d8c599SYunfan Zhang di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config); 42649d8c599SYunfan Zhang if (IS_ERR(di->regmap)) { 42749d8c599SYunfan Zhang dev_err(&client->dev, "Failed to allocate regmap!\n"); 42849d8c599SYunfan Zhang return PTR_ERR(di->regmap); 42949d8c599SYunfan Zhang } 43049d8c599SYunfan Zhang di->dev = &client->dev; 43149d8c599SYunfan Zhang i2c_set_clientdata(client, di); 43249d8c599SYunfan Zhang /* Get chip ID */ 43349d8c599SYunfan Zhang ret = regmap_read(di->regmap, FAN53555_ID1, &val); 43449d8c599SYunfan Zhang if (ret < 0) { 43549d8c599SYunfan Zhang dev_err(&client->dev, "Failed to get chip ID!\n"); 436145fe1e1SSachin Kamat return ret; 43749d8c599SYunfan Zhang } 43849d8c599SYunfan Zhang di->chip_id = val & DIE_ID; 43949d8c599SYunfan Zhang /* Get chip revision */ 44049d8c599SYunfan Zhang ret = regmap_read(di->regmap, FAN53555_ID2, &val); 44149d8c599SYunfan Zhang if (ret < 0) { 44249d8c599SYunfan Zhang dev_err(&client->dev, "Failed to get chip Rev!\n"); 443145fe1e1SSachin Kamat return ret; 44449d8c599SYunfan Zhang } 44549d8c599SYunfan Zhang di->chip_rev = val & DIE_REV; 44649d8c599SYunfan Zhang dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n", 44749d8c599SYunfan Zhang di->chip_id, di->chip_rev); 44849d8c599SYunfan Zhang /* Device init */ 44949d8c599SYunfan Zhang ret = fan53555_device_setup(di, pdata); 45049d8c599SYunfan Zhang if (ret < 0) { 45149d8c599SYunfan Zhang dev_err(&client->dev, "Failed to setup device!\n"); 45249d8c599SYunfan Zhang return ret; 45349d8c599SYunfan Zhang } 45449d8c599SYunfan Zhang /* Register regulator */ 45549d8c599SYunfan Zhang config.dev = di->dev; 45649d8c599SYunfan Zhang config.init_data = di->regulator; 45749d8c599SYunfan Zhang config.regmap = di->regmap; 45849d8c599SYunfan Zhang config.driver_data = di; 45991f23d8fSHeiko Stuebner config.of_node = np; 46091f23d8fSHeiko Stuebner 46149d8c599SYunfan Zhang ret = fan53555_regulator_register(di, &config); 46249d8c599SYunfan Zhang if (ret < 0) 46349d8c599SYunfan Zhang dev_err(&client->dev, "Failed to register regulator!\n"); 46449d8c599SYunfan Zhang return ret; 46549d8c599SYunfan Zhang 46649d8c599SYunfan Zhang } 46749d8c599SYunfan Zhang 46849d8c599SYunfan Zhang static const struct i2c_device_id fan53555_id[] = { 469ee30928aSHeiko Stuebner { 470ee30928aSHeiko Stuebner .name = "fan53555", 471ee30928aSHeiko Stuebner .driver_data = FAN53555_VENDOR_FAIRCHILD 472ee30928aSHeiko Stuebner }, { 473ee30928aSHeiko Stuebner .name = "syr82x", 474ee30928aSHeiko Stuebner .driver_data = FAN53555_VENDOR_SILERGY 475ee30928aSHeiko Stuebner }, 47649d8c599SYunfan Zhang { }, 47749d8c599SYunfan Zhang }; 478e80c47bdSJavier Martinez Canillas MODULE_DEVICE_TABLE(i2c, fan53555_id); 47949d8c599SYunfan Zhang 48049d8c599SYunfan Zhang static struct i2c_driver fan53555_regulator_driver = { 48149d8c599SYunfan Zhang .driver = { 48249d8c599SYunfan Zhang .name = "fan53555-regulator", 48391f23d8fSHeiko Stuebner .of_match_table = of_match_ptr(fan53555_dt_ids), 48449d8c599SYunfan Zhang }, 48549d8c599SYunfan Zhang .probe = fan53555_regulator_probe, 48649d8c599SYunfan Zhang .id_table = fan53555_id, 48749d8c599SYunfan Zhang }; 48849d8c599SYunfan Zhang 48949d8c599SYunfan Zhang module_i2c_driver(fan53555_regulator_driver); 49049d8c599SYunfan Zhang 49149d8c599SYunfan Zhang MODULE_AUTHOR("Yunfan Zhang <yfzhang@marvell.com>"); 49249d8c599SYunfan Zhang MODULE_DESCRIPTION("FAN53555 regulator driver"); 49349d8c599SYunfan Zhang MODULE_LICENSE("GPL v2"); 494