782 lines · c
1// SPDX-License-Identifier: GPL-2.02//3// FAN53555 Fairchild Digitally Programmable TinyBuck Regulator Driver.4//5// Supported Part Numbers:6// FAN53555UC00X/01X/03X/04X/05X7//8// Copyright (c) 2012 Marvell Technology Ltd.9// Yunfan Zhang <yfzhang@marvell.com>10 11#include <linux/bitops.h>12#include <linux/err.h>13#include <linux/i2c.h>14#include <linux/module.h>15#include <linux/of.h>16#include <linux/param.h>17#include <linux/platform_device.h>18#include <linux/regmap.h>19#include <linux/regulator/driver.h>20#include <linux/regulator/fan53555.h>21#include <linux/regulator/machine.h>22#include <linux/regulator/of_regulator.h>23#include <linux/slab.h>24 25/* Voltage setting */26#define FAN53555_VSEL0 0x0027#define FAN53555_VSEL1 0x0128 29#define RK8602_VSEL0 0x0630#define RK8602_VSEL1 0x0731 32#define TCS4525_VSEL0 0x1133#define TCS4525_VSEL1 0x1034#define TCS4525_TIME 0x1335#define TCS4525_COMMAND 0x1436 37/* Control register */38#define FAN53555_CONTROL 0x0239/* IC Type */40#define FAN53555_ID1 0x0341/* IC mask version */42#define FAN53555_ID2 0x0443/* Monitor register */44#define FAN53555_MONITOR 0x0545 46/* VSEL bit definitions */47#define VSEL_BUCK_EN BIT(7)48#define VSEL_MODE BIT(6)49/* Chip ID and Version */50#define DIE_ID 0x0F /* ID1 */51#define DIE_REV 0x0F /* ID2 */52/* Control bit definitions */53#define CTL_OUTPUT_DISCHG BIT(7)54#define CTL_SLEW_MASK GENMASK(6, 4)55#define CTL_RESET BIT(2)56#define CTL_MODE_VSEL0_MODE BIT(0)57#define CTL_MODE_VSEL1_MODE BIT(1)58 59#define FAN53555_NVOLTAGES 64 /* Numbers of voltages */60#define FAN53526_NVOLTAGES 12861#define RK8602_NVOLTAGES 16062 63#define TCS_VSEL0_MODE BIT(7)64#define TCS_VSEL1_MODE BIT(6)65 66#define TCS_SLEW_MASK GENMASK(4, 3)67 68enum fan53555_vendor {69 FAN53526_VENDOR_FAIRCHILD = 0,70 FAN53555_VENDOR_FAIRCHILD,71 FAN53555_VENDOR_ROCKCHIP, /* RK8600, RK8601 */72 RK8602_VENDOR_ROCKCHIP, /* RK8602, RK8603 */73 FAN53555_VENDOR_SILERGY,74 FAN53526_VENDOR_TCS,75};76 77enum {78 FAN53526_CHIP_ID_01 = 1,79};80 81enum {82 FAN53526_CHIP_REV_08 = 8,83};84 85/* IC Type */86enum {87 FAN53555_CHIP_ID_00 = 0,88 FAN53555_CHIP_ID_01,89 FAN53555_CHIP_ID_02,90 FAN53555_CHIP_ID_03,91 FAN53555_CHIP_ID_04,92 FAN53555_CHIP_ID_05,93 FAN53555_CHIP_ID_08 = 8,94};95 96enum {97 RK8600_CHIP_ID_08 = 8, /* RK8600, RK8601 */98};99 100enum {101 RK8602_CHIP_ID_10 = 10, /* RK8602, RK8603 */102};103 104enum {105 TCS4525_CHIP_ID_12 = 12,106};107 108enum {109 TCS4526_CHIP_ID_00 = 0,110};111 112/* IC mask revision */113enum {114 FAN53555_CHIP_REV_00 = 0x3,115 FAN53555_CHIP_REV_13 = 0xf,116};117 118enum {119 SILERGY_SYR82X = 8,120 SILERGY_SYR83X = 9,121};122 123struct fan53555_device_info {124 enum fan53555_vendor vendor;125 struct device *dev;126 struct regulator_desc desc;127 struct regulator_init_data *regulator;128 /* IC Type and Rev */129 int chip_id;130 int chip_rev;131 /* Voltage setting register */132 unsigned int vol_reg;133 unsigned int sleep_reg;134 unsigned int en_reg;135 unsigned int sleep_en_reg;136 /* Voltage range and step(linear) */137 unsigned int vsel_min;138 unsigned int vsel_step;139 unsigned int vsel_count;140 /* Mode */141 unsigned int mode_reg;142 unsigned int mode_mask;143 /* Sleep voltage cache */144 unsigned int sleep_vol_cache;145 /* Slew rate */146 unsigned int slew_reg;147 unsigned int slew_mask;148 const unsigned int *ramp_delay_table;149 unsigned int n_ramp_values;150 unsigned int slew_rate;151};152 153static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV)154{155 struct fan53555_device_info *di = rdev_get_drvdata(rdev);156 int ret;157 158 if (di->sleep_vol_cache == uV)159 return 0;160 ret = regulator_map_voltage_linear(rdev, uV, uV);161 if (ret < 0)162 return ret;163 ret = regmap_update_bits(rdev->regmap, di->sleep_reg,164 di->desc.vsel_mask, ret);165 if (ret < 0)166 return ret;167 /* Cache the sleep voltage setting.168 * Might not be the real voltage which is rounded */169 di->sleep_vol_cache = uV;170 171 return 0;172}173 174static int fan53555_set_suspend_enable(struct regulator_dev *rdev)175{176 struct fan53555_device_info *di = rdev_get_drvdata(rdev);177 178 return regmap_update_bits(rdev->regmap, di->sleep_en_reg,179 VSEL_BUCK_EN, VSEL_BUCK_EN);180}181 182static int fan53555_set_suspend_disable(struct regulator_dev *rdev)183{184 struct fan53555_device_info *di = rdev_get_drvdata(rdev);185 186 return regmap_update_bits(rdev->regmap, di->sleep_en_reg,187 VSEL_BUCK_EN, 0);188}189 190static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode)191{192 struct fan53555_device_info *di = rdev_get_drvdata(rdev);193 194 switch (mode) {195 case REGULATOR_MODE_FAST:196 regmap_update_bits(rdev->regmap, di->mode_reg,197 di->mode_mask, di->mode_mask);198 break;199 case REGULATOR_MODE_NORMAL:200 regmap_update_bits(rdev->regmap, di->vol_reg, di->mode_mask, 0);201 break;202 default:203 return -EINVAL;204 }205 return 0;206}207 208static unsigned int fan53555_get_mode(struct regulator_dev *rdev)209{210 struct fan53555_device_info *di = rdev_get_drvdata(rdev);211 unsigned int val;212 int ret = 0;213 214 ret = regmap_read(rdev->regmap, di->mode_reg, &val);215 if (ret < 0)216 return ret;217 if (val & di->mode_mask)218 return REGULATOR_MODE_FAST;219 else220 return REGULATOR_MODE_NORMAL;221}222 223static const unsigned int slew_rates[] = {224 64000,225 32000,226 16000,227 8000,228 4000,229 2000,230 1000,231 500,232};233 234static const unsigned int tcs_slew_rates[] = {235 18700,236 9300,237 4600,238 2300,239};240 241static const struct regulator_ops fan53555_regulator_ops = {242 .set_voltage_sel = regulator_set_voltage_sel_regmap,243 .get_voltage_sel = regulator_get_voltage_sel_regmap,244 .set_voltage_time_sel = regulator_set_voltage_time_sel,245 .map_voltage = regulator_map_voltage_linear,246 .list_voltage = regulator_list_voltage_linear,247 .set_suspend_voltage = fan53555_set_suspend_voltage,248 .enable = regulator_enable_regmap,249 .disable = regulator_disable_regmap,250 .is_enabled = regulator_is_enabled_regmap,251 .set_mode = fan53555_set_mode,252 .get_mode = fan53555_get_mode,253 .set_ramp_delay = regulator_set_ramp_delay_regmap,254 .set_suspend_enable = fan53555_set_suspend_enable,255 .set_suspend_disable = fan53555_set_suspend_disable,256};257 258static int fan53526_voltages_setup_fairchild(struct fan53555_device_info *di)259{260 /* Init voltage range and step */261 switch (di->chip_id) {262 case FAN53526_CHIP_ID_01:263 switch (di->chip_rev) {264 case FAN53526_CHIP_REV_08:265 di->vsel_min = 600000;266 di->vsel_step = 6250;267 break;268 default:269 dev_err(di->dev,270 "Chip ID %d with rev %d not supported!\n",271 di->chip_id, di->chip_rev);272 return -EINVAL;273 }274 break;275 default:276 dev_err(di->dev,277 "Chip ID %d not supported!\n", di->chip_id);278 return -EINVAL;279 }280 281 di->slew_reg = FAN53555_CONTROL;282 di->slew_mask = CTL_SLEW_MASK;283 di->ramp_delay_table = slew_rates;284 di->n_ramp_values = ARRAY_SIZE(slew_rates);285 di->vsel_count = FAN53526_NVOLTAGES;286 287 return 0;288}289 290static int fan53555_voltages_setup_fairchild(struct fan53555_device_info *di)291{292 /* Init voltage range and step */293 switch (di->chip_id) {294 case FAN53555_CHIP_ID_00:295 switch (di->chip_rev) {296 case FAN53555_CHIP_REV_00:297 di->vsel_min = 600000;298 di->vsel_step = 10000;299 break;300 case FAN53555_CHIP_REV_13:301 di->vsel_min = 800000;302 di->vsel_step = 10000;303 break;304 default:305 dev_err(di->dev,306 "Chip ID %d with rev %d not supported!\n",307 di->chip_id, di->chip_rev);308 return -EINVAL;309 }310 break;311 case FAN53555_CHIP_ID_01:312 case FAN53555_CHIP_ID_03:313 case FAN53555_CHIP_ID_05:314 case FAN53555_CHIP_ID_08:315 di->vsel_min = 600000;316 di->vsel_step = 10000;317 break;318 case FAN53555_CHIP_ID_04:319 di->vsel_min = 603000;320 di->vsel_step = 12826;321 break;322 default:323 dev_err(di->dev,324 "Chip ID %d not supported!\n", di->chip_id);325 return -EINVAL;326 }327 di->slew_reg = FAN53555_CONTROL;328 di->slew_mask = CTL_SLEW_MASK;329 di->ramp_delay_table = slew_rates;330 di->n_ramp_values = ARRAY_SIZE(slew_rates);331 di->vsel_count = FAN53555_NVOLTAGES;332 333 return 0;334}335 336static int fan53555_voltages_setup_rockchip(struct fan53555_device_info *di)337{338 /* Init voltage range and step */339 switch (di->chip_id) {340 case RK8600_CHIP_ID_08:341 di->vsel_min = 712500;342 di->vsel_step = 12500;343 break;344 default:345 dev_err(di->dev,346 "Chip ID %d not supported!\n", di->chip_id);347 return -EINVAL;348 }349 di->slew_reg = FAN53555_CONTROL;350 di->slew_mask = CTL_SLEW_MASK;351 di->ramp_delay_table = slew_rates;352 di->n_ramp_values = ARRAY_SIZE(slew_rates);353 di->vsel_count = FAN53555_NVOLTAGES;354 355 return 0;356}357 358static int rk8602_voltages_setup_rockchip(struct fan53555_device_info *di)359{360 /* Init voltage range and step */361 switch (di->chip_id) {362 case RK8602_CHIP_ID_10:363 di->vsel_min = 500000;364 di->vsel_step = 6250;365 break;366 default:367 dev_err(di->dev,368 "Chip ID %d not supported!\n", di->chip_id);369 return -EINVAL;370 }371 di->slew_reg = FAN53555_CONTROL;372 di->slew_mask = CTL_SLEW_MASK;373 di->ramp_delay_table = slew_rates;374 di->n_ramp_values = ARRAY_SIZE(slew_rates);375 di->vsel_count = RK8602_NVOLTAGES;376 377 return 0;378}379 380static int fan53555_voltages_setup_silergy(struct fan53555_device_info *di)381{382 /* Init voltage range and step */383 switch (di->chip_id) {384 case SILERGY_SYR82X:385 case SILERGY_SYR83X:386 di->vsel_min = 712500;387 di->vsel_step = 12500;388 break;389 default:390 dev_err(di->dev,391 "Chip ID %d not supported!\n", di->chip_id);392 return -EINVAL;393 }394 di->slew_reg = FAN53555_CONTROL;395 di->slew_mask = CTL_SLEW_MASK;396 di->ramp_delay_table = slew_rates;397 di->n_ramp_values = ARRAY_SIZE(slew_rates);398 di->vsel_count = FAN53555_NVOLTAGES;399 400 return 0;401}402 403static int fan53526_voltages_setup_tcs(struct fan53555_device_info *di)404{405 switch (di->chip_id) {406 case TCS4525_CHIP_ID_12:407 case TCS4526_CHIP_ID_00:408 di->slew_reg = TCS4525_TIME;409 di->slew_mask = TCS_SLEW_MASK;410 di->ramp_delay_table = tcs_slew_rates;411 di->n_ramp_values = ARRAY_SIZE(tcs_slew_rates);412 413 /* Init voltage range and step */414 di->vsel_min = 600000;415 di->vsel_step = 6250;416 di->vsel_count = FAN53526_NVOLTAGES;417 break;418 default:419 dev_err(di->dev, "Chip ID %d not supported!\n", di->chip_id);420 return -EINVAL;421 }422 423 return 0;424}425 426/* For 00,01,03,05 options:427 * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V.428 * For 04 option:429 * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V.430 * */431static int fan53555_device_setup(struct fan53555_device_info *di,432 struct fan53555_platform_data *pdata)433{434 int ret = 0;435 436 /* Setup voltage control register */437 switch (di->vendor) {438 case FAN53526_VENDOR_FAIRCHILD:439 case FAN53555_VENDOR_FAIRCHILD:440 case FAN53555_VENDOR_ROCKCHIP:441 case FAN53555_VENDOR_SILERGY:442 switch (pdata->sleep_vsel_id) {443 case FAN53555_VSEL_ID_0:444 di->sleep_reg = FAN53555_VSEL0;445 di->vol_reg = FAN53555_VSEL1;446 break;447 case FAN53555_VSEL_ID_1:448 di->sleep_reg = FAN53555_VSEL1;449 di->vol_reg = FAN53555_VSEL0;450 break;451 default:452 dev_err(di->dev, "Invalid VSEL ID!\n");453 return -EINVAL;454 }455 di->sleep_en_reg = di->sleep_reg;456 di->en_reg = di->vol_reg;457 break;458 case RK8602_VENDOR_ROCKCHIP:459 switch (pdata->sleep_vsel_id) {460 case FAN53555_VSEL_ID_0:461 di->sleep_reg = RK8602_VSEL0;462 di->vol_reg = RK8602_VSEL1;463 di->sleep_en_reg = FAN53555_VSEL0;464 di->en_reg = FAN53555_VSEL1;465 break;466 case FAN53555_VSEL_ID_1:467 di->sleep_reg = RK8602_VSEL1;468 di->vol_reg = RK8602_VSEL0;469 di->sleep_en_reg = FAN53555_VSEL1;470 di->en_reg = FAN53555_VSEL0;471 break;472 default:473 dev_err(di->dev, "Invalid VSEL ID!\n");474 return -EINVAL;475 }476 break;477 case FAN53526_VENDOR_TCS:478 switch (pdata->sleep_vsel_id) {479 case FAN53555_VSEL_ID_0:480 di->sleep_reg = TCS4525_VSEL0;481 di->vol_reg = TCS4525_VSEL1;482 break;483 case FAN53555_VSEL_ID_1:484 di->sleep_reg = TCS4525_VSEL1;485 di->vol_reg = TCS4525_VSEL0;486 break;487 default:488 dev_err(di->dev, "Invalid VSEL ID!\n");489 return -EINVAL;490 }491 di->sleep_en_reg = di->sleep_reg;492 di->en_reg = di->vol_reg;493 break;494 default:495 dev_err(di->dev, "vendor %d not supported!\n", di->vendor);496 return -EINVAL;497 }498 499 /* Setup mode control register */500 switch (di->vendor) {501 case FAN53526_VENDOR_FAIRCHILD:502 di->mode_reg = FAN53555_CONTROL;503 504 switch (pdata->sleep_vsel_id) {505 case FAN53555_VSEL_ID_0:506 di->mode_mask = CTL_MODE_VSEL1_MODE;507 break;508 case FAN53555_VSEL_ID_1:509 di->mode_mask = CTL_MODE_VSEL0_MODE;510 break;511 }512 break;513 case FAN53555_VENDOR_FAIRCHILD:514 case FAN53555_VENDOR_ROCKCHIP:515 case FAN53555_VENDOR_SILERGY:516 di->mode_reg = di->vol_reg;517 di->mode_mask = VSEL_MODE;518 break;519 case RK8602_VENDOR_ROCKCHIP:520 di->mode_mask = VSEL_MODE;521 522 switch (pdata->sleep_vsel_id) {523 case FAN53555_VSEL_ID_0:524 di->mode_reg = FAN53555_VSEL1;525 break;526 case FAN53555_VSEL_ID_1:527 di->mode_reg = FAN53555_VSEL0;528 break;529 }530 break;531 case FAN53526_VENDOR_TCS:532 di->mode_reg = TCS4525_COMMAND;533 534 switch (pdata->sleep_vsel_id) {535 case FAN53555_VSEL_ID_0:536 di->mode_mask = TCS_VSEL1_MODE;537 break;538 case FAN53555_VSEL_ID_1:539 di->mode_mask = TCS_VSEL0_MODE;540 break;541 }542 break;543 default:544 dev_err(di->dev, "vendor %d not supported!\n", di->vendor);545 return -EINVAL;546 }547 548 /* Setup voltage range */549 switch (di->vendor) {550 case FAN53526_VENDOR_FAIRCHILD:551 ret = fan53526_voltages_setup_fairchild(di);552 break;553 case FAN53555_VENDOR_FAIRCHILD:554 ret = fan53555_voltages_setup_fairchild(di);555 break;556 case FAN53555_VENDOR_ROCKCHIP:557 ret = fan53555_voltages_setup_rockchip(di);558 break;559 case RK8602_VENDOR_ROCKCHIP:560 ret = rk8602_voltages_setup_rockchip(di);561 break;562 case FAN53555_VENDOR_SILERGY:563 ret = fan53555_voltages_setup_silergy(di);564 break;565 case FAN53526_VENDOR_TCS:566 ret = fan53526_voltages_setup_tcs(di);567 break;568 default:569 dev_err(di->dev, "vendor %d not supported!\n", di->vendor);570 return -EINVAL;571 }572 573 return ret;574}575 576static int fan53555_regulator_register(struct fan53555_device_info *di,577 struct regulator_config *config)578{579 struct regulator_desc *rdesc = &di->desc;580 struct regulator_dev *rdev;581 582 rdesc->name = "fan53555-reg";583 rdesc->supply_name = "vin";584 rdesc->ops = &fan53555_regulator_ops;585 rdesc->type = REGULATOR_VOLTAGE;586 rdesc->n_voltages = di->vsel_count;587 rdesc->enable_reg = di->en_reg;588 rdesc->enable_mask = VSEL_BUCK_EN;589 rdesc->min_uV = di->vsel_min;590 rdesc->uV_step = di->vsel_step;591 rdesc->vsel_reg = di->vol_reg;592 rdesc->vsel_mask = BIT(fls(di->vsel_count - 1)) - 1;593 rdesc->ramp_reg = di->slew_reg;594 rdesc->ramp_mask = di->slew_mask;595 rdesc->ramp_delay_table = di->ramp_delay_table;596 rdesc->n_ramp_values = di->n_ramp_values;597 rdesc->owner = THIS_MODULE;598 599 rdev = devm_regulator_register(di->dev, &di->desc, config);600 return PTR_ERR_OR_ZERO(rdev);601}602 603static const struct regmap_config fan53555_regmap_config = {604 .reg_bits = 8,605 .val_bits = 8,606};607 608static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev,609 struct device_node *np,610 const struct regulator_desc *desc)611{612 struct fan53555_platform_data *pdata;613 int ret;614 u32 tmp;615 616 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);617 if (!pdata)618 return NULL;619 620 pdata->regulator = of_get_regulator_init_data(dev, np, desc);621 622 ret = of_property_read_u32(np, "fcs,suspend-voltage-selector",623 &tmp);624 if (!ret)625 pdata->sleep_vsel_id = tmp;626 627 return pdata;628}629 630static const struct of_device_id __maybe_unused fan53555_dt_ids[] = {631 {632 .compatible = "fcs,fan53526",633 .data = (void *)FAN53526_VENDOR_FAIRCHILD,634 }, {635 .compatible = "fcs,fan53555",636 .data = (void *)FAN53555_VENDOR_FAIRCHILD637 }, {638 .compatible = "rockchip,rk8600",639 .data = (void *)FAN53555_VENDOR_ROCKCHIP640 }, {641 .compatible = "rockchip,rk8602",642 .data = (void *)RK8602_VENDOR_ROCKCHIP643 }, {644 .compatible = "silergy,syr827",645 .data = (void *)FAN53555_VENDOR_SILERGY,646 }, {647 .compatible = "silergy,syr828",648 .data = (void *)FAN53555_VENDOR_SILERGY,649 }, {650 .compatible = "tcs,tcs4525",651 .data = (void *)FAN53526_VENDOR_TCS652 }, {653 .compatible = "tcs,tcs4526",654 .data = (void *)FAN53526_VENDOR_TCS655 },656 { }657};658MODULE_DEVICE_TABLE(of, fan53555_dt_ids);659 660static int fan53555_regulator_probe(struct i2c_client *client)661{662 struct device_node *np = client->dev.of_node;663 struct fan53555_device_info *di;664 struct fan53555_platform_data *pdata;665 struct regulator_config config = { };666 struct regmap *regmap;667 unsigned int val;668 int ret;669 670 di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info),671 GFP_KERNEL);672 if (!di)673 return -ENOMEM;674 675 pdata = dev_get_platdata(&client->dev);676 if (!pdata)677 pdata = fan53555_parse_dt(&client->dev, np, &di->desc);678 679 if (!pdata || !pdata->regulator)680 return dev_err_probe(&client->dev, -ENODEV,681 "Platform data not found!\n");682 683 di->regulator = pdata->regulator;684 di->vendor = (uintptr_t)i2c_get_match_data(client);685 if (!dev_fwnode(&client->dev)) {686 /* if no ramp constraint set, get the pdata ramp_delay */687 if (!di->regulator->constraints.ramp_delay) {688 if (pdata->slew_rate >= ARRAY_SIZE(slew_rates))689 return dev_err_probe(&client->dev, -EINVAL,690 "Invalid slew_rate\n");691 692 di->regulator->constraints.ramp_delay693 = slew_rates[pdata->slew_rate];694 }695 }696 697 regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config);698 if (IS_ERR(regmap))699 return dev_err_probe(&client->dev, PTR_ERR(regmap),700 "Failed to allocate regmap!\n");701 702 di->dev = &client->dev;703 i2c_set_clientdata(client, di);704 /* Get chip ID */705 ret = regmap_read(regmap, FAN53555_ID1, &val);706 if (ret < 0)707 return dev_err_probe(&client->dev, ret, "Failed to get chip ID!\n");708 709 di->chip_id = val & DIE_ID;710 /* Get chip revision */711 ret = regmap_read(regmap, FAN53555_ID2, &val);712 if (ret < 0)713 return dev_err_probe(&client->dev, ret, "Failed to get chip Rev!\n");714 715 di->chip_rev = val & DIE_REV;716 dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n",717 di->chip_id, di->chip_rev);718 /* Device init */719 ret = fan53555_device_setup(di, pdata);720 if (ret < 0)721 return dev_err_probe(&client->dev, ret, "Failed to setup device!\n");722 723 /* Register regulator */724 config.dev = di->dev;725 config.init_data = di->regulator;726 config.regmap = regmap;727 config.driver_data = di;728 config.of_node = np;729 730 ret = fan53555_regulator_register(di, &config);731 if (ret < 0)732 dev_err_probe(&client->dev, ret, "Failed to register regulator!\n");733 734 return ret;735}736 737static const struct i2c_device_id fan53555_id[] = {738 {739 .name = "fan53526",740 .driver_data = FAN53526_VENDOR_FAIRCHILD741 }, {742 .name = "fan53555",743 .driver_data = FAN53555_VENDOR_FAIRCHILD744 }, {745 .name = "rk8600",746 .driver_data = FAN53555_VENDOR_ROCKCHIP747 }, {748 .name = "rk8602",749 .driver_data = RK8602_VENDOR_ROCKCHIP750 }, {751 .name = "syr827",752 .driver_data = FAN53555_VENDOR_SILERGY753 }, {754 .name = "syr828",755 .driver_data = FAN53555_VENDOR_SILERGY756 }, {757 .name = "tcs4525",758 .driver_data = FAN53526_VENDOR_TCS759 }, {760 .name = "tcs4526",761 .driver_data = FAN53526_VENDOR_TCS762 },763 { },764};765MODULE_DEVICE_TABLE(i2c, fan53555_id);766 767static struct i2c_driver fan53555_regulator_driver = {768 .driver = {769 .name = "fan53555-regulator",770 .probe_type = PROBE_PREFER_ASYNCHRONOUS,771 .of_match_table = of_match_ptr(fan53555_dt_ids),772 },773 .probe = fan53555_regulator_probe,774 .id_table = fan53555_id,775};776 777module_i2c_driver(fan53555_regulator_driver);778 779MODULE_AUTHOR("Yunfan Zhang <yfzhang@marvell.com>");780MODULE_DESCRIPTION("FAN53555 regulator driver");781MODULE_LICENSE("GPL v2");782