Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 //
0003 // FAN53555 Fairchild Digitally Programmable TinyBuck Regulator Driver.
0004 //
0005 // Supported Part Numbers:
0006 // FAN53555UC00X/01X/03X/04X/05X
0007 //
0008 // Copyright (c) 2012 Marvell Technology Ltd.
0009 // Yunfan Zhang <yfzhang@marvell.com>
0010 
0011 #include <linux/module.h>
0012 #include <linux/param.h>
0013 #include <linux/err.h>
0014 #include <linux/platform_device.h>
0015 #include <linux/regulator/driver.h>
0016 #include <linux/regulator/machine.h>
0017 #include <linux/regulator/of_regulator.h>
0018 #include <linux/of_device.h>
0019 #include <linux/i2c.h>
0020 #include <linux/slab.h>
0021 #include <linux/regmap.h>
0022 #include <linux/regulator/fan53555.h>
0023 
0024 /* Voltage setting */
0025 #define FAN53555_VSEL0      0x00
0026 #define FAN53555_VSEL1      0x01
0027 
0028 #define TCS4525_VSEL0       0x11
0029 #define TCS4525_VSEL1       0x10
0030 #define TCS4525_TIME        0x13
0031 #define TCS4525_COMMAND     0x14
0032 
0033 /* Control register */
0034 #define FAN53555_CONTROL    0x02
0035 /* IC Type */
0036 #define FAN53555_ID1        0x03
0037 /* IC mask version */
0038 #define FAN53555_ID2        0x04
0039 /* Monitor register */
0040 #define FAN53555_MONITOR    0x05
0041 
0042 /* VSEL bit definitions */
0043 #define VSEL_BUCK_EN    (1 << 7)
0044 #define VSEL_MODE       (1 << 6)
0045 /* Chip ID and Verison */
0046 #define DIE_ID      0x0F    /* ID1 */
0047 #define DIE_REV     0x0F    /* ID2 */
0048 /* Control bit definitions */
0049 #define CTL_OUTPUT_DISCHG   (1 << 7)
0050 #define CTL_SLEW_MASK       (0x7 << 4)
0051 #define CTL_SLEW_SHIFT      4
0052 #define CTL_RESET           (1 << 2)
0053 #define CTL_MODE_VSEL0_MODE BIT(0)
0054 #define CTL_MODE_VSEL1_MODE BIT(1)
0055 
0056 #define FAN53555_NVOLTAGES  64  /* Numbers of voltages */
0057 #define FAN53526_NVOLTAGES  128
0058 
0059 #define TCS_VSEL0_MODE      (1 << 7)
0060 #define TCS_VSEL1_MODE      (1 << 6)
0061 
0062 #define TCS_SLEW_SHIFT      3
0063 #define TCS_SLEW_MASK       (0x3 < 3)
0064 
0065 enum fan53555_vendor {
0066     FAN53526_VENDOR_FAIRCHILD = 0,
0067     FAN53555_VENDOR_FAIRCHILD,
0068     FAN53555_VENDOR_SILERGY,
0069     FAN53526_VENDOR_TCS,
0070 };
0071 
0072 enum {
0073     FAN53526_CHIP_ID_01 = 1,
0074 };
0075 
0076 enum {
0077     FAN53526_CHIP_REV_08 = 8,
0078 };
0079 
0080 /* IC Type */
0081 enum {
0082     FAN53555_CHIP_ID_00 = 0,
0083     FAN53555_CHIP_ID_01,
0084     FAN53555_CHIP_ID_02,
0085     FAN53555_CHIP_ID_03,
0086     FAN53555_CHIP_ID_04,
0087     FAN53555_CHIP_ID_05,
0088     FAN53555_CHIP_ID_08 = 8,
0089 };
0090 
0091 enum {
0092     TCS4525_CHIP_ID_12 = 12,
0093 };
0094 
0095 enum {
0096     TCS4526_CHIP_ID_00 = 0,
0097 };
0098 
0099 /* IC mask revision */
0100 enum {
0101     FAN53555_CHIP_REV_00 = 0x3,
0102     FAN53555_CHIP_REV_13 = 0xf,
0103 };
0104 
0105 enum {
0106     SILERGY_SYR82X = 8,
0107     SILERGY_SYR83X = 9,
0108 };
0109 
0110 struct fan53555_device_info {
0111     enum fan53555_vendor vendor;
0112     struct device *dev;
0113     struct regulator_desc desc;
0114     struct regulator_init_data *regulator;
0115     /* IC Type and Rev */
0116     int chip_id;
0117     int chip_rev;
0118     /* Voltage setting register */
0119     unsigned int vol_reg;
0120     unsigned int sleep_reg;
0121     /* Voltage range and step(linear) */
0122     unsigned int vsel_min;
0123     unsigned int vsel_step;
0124     unsigned int vsel_count;
0125     /* Mode */
0126     unsigned int mode_reg;
0127     unsigned int mode_mask;
0128     /* Sleep voltage cache */
0129     unsigned int sleep_vol_cache;
0130     /* Slew rate */
0131     unsigned int slew_reg;
0132     unsigned int slew_mask;
0133     const unsigned int *ramp_delay_table;
0134     unsigned int n_ramp_values;
0135     unsigned int slew_rate;
0136 };
0137 
0138 static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV)
0139 {
0140     struct fan53555_device_info *di = rdev_get_drvdata(rdev);
0141     int ret;
0142 
0143     if (di->sleep_vol_cache == uV)
0144         return 0;
0145     ret = regulator_map_voltage_linear(rdev, uV, uV);
0146     if (ret < 0)
0147         return ret;
0148     ret = regmap_update_bits(rdev->regmap, di->sleep_reg,
0149                  di->desc.vsel_mask, ret);
0150     if (ret < 0)
0151         return ret;
0152     /* Cache the sleep voltage setting.
0153      * Might not be the real voltage which is rounded */
0154     di->sleep_vol_cache = uV;
0155 
0156     return 0;
0157 }
0158 
0159 static int fan53555_set_suspend_enable(struct regulator_dev *rdev)
0160 {
0161     struct fan53555_device_info *di = rdev_get_drvdata(rdev);
0162 
0163     return regmap_update_bits(rdev->regmap, di->sleep_reg,
0164                   VSEL_BUCK_EN, VSEL_BUCK_EN);
0165 }
0166 
0167 static int fan53555_set_suspend_disable(struct regulator_dev *rdev)
0168 {
0169     struct fan53555_device_info *di = rdev_get_drvdata(rdev);
0170 
0171     return regmap_update_bits(rdev->regmap, di->sleep_reg,
0172                   VSEL_BUCK_EN, 0);
0173 }
0174 
0175 static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode)
0176 {
0177     struct fan53555_device_info *di = rdev_get_drvdata(rdev);
0178 
0179     switch (mode) {
0180     case REGULATOR_MODE_FAST:
0181         regmap_update_bits(rdev->regmap, di->mode_reg,
0182                    di->mode_mask, di->mode_mask);
0183         break;
0184     case REGULATOR_MODE_NORMAL:
0185         regmap_update_bits(rdev->regmap, di->vol_reg, di->mode_mask, 0);
0186         break;
0187     default:
0188         return -EINVAL;
0189     }
0190     return 0;
0191 }
0192 
0193 static unsigned int fan53555_get_mode(struct regulator_dev *rdev)
0194 {
0195     struct fan53555_device_info *di = rdev_get_drvdata(rdev);
0196     unsigned int val;
0197     int ret = 0;
0198 
0199     ret = regmap_read(rdev->regmap, di->mode_reg, &val);
0200     if (ret < 0)
0201         return ret;
0202     if (val & di->mode_mask)
0203         return REGULATOR_MODE_FAST;
0204     else
0205         return REGULATOR_MODE_NORMAL;
0206 }
0207 
0208 static const unsigned int slew_rates[] = {
0209     64000,
0210     32000,
0211     16000,
0212      8000,
0213      4000,
0214      2000,
0215      1000,
0216       500,
0217 };
0218 
0219 static const unsigned int tcs_slew_rates[] = {
0220     18700,
0221      9300,
0222      4600,
0223      2300,
0224 };
0225 
0226 static const struct regulator_ops fan53555_regulator_ops = {
0227     .set_voltage_sel = regulator_set_voltage_sel_regmap,
0228     .get_voltage_sel = regulator_get_voltage_sel_regmap,
0229     .set_voltage_time_sel = regulator_set_voltage_time_sel,
0230     .map_voltage = regulator_map_voltage_linear,
0231     .list_voltage = regulator_list_voltage_linear,
0232     .set_suspend_voltage = fan53555_set_suspend_voltage,
0233     .enable = regulator_enable_regmap,
0234     .disable = regulator_disable_regmap,
0235     .is_enabled = regulator_is_enabled_regmap,
0236     .set_mode = fan53555_set_mode,
0237     .get_mode = fan53555_get_mode,
0238     .set_ramp_delay = regulator_set_ramp_delay_regmap,
0239     .set_suspend_enable = fan53555_set_suspend_enable,
0240     .set_suspend_disable = fan53555_set_suspend_disable,
0241 };
0242 
0243 static int fan53526_voltages_setup_fairchild(struct fan53555_device_info *di)
0244 {
0245     /* Init voltage range and step */
0246     switch (di->chip_id) {
0247     case FAN53526_CHIP_ID_01:
0248         switch (di->chip_rev) {
0249         case FAN53526_CHIP_REV_08:
0250             di->vsel_min = 600000;
0251             di->vsel_step = 6250;
0252             break;
0253         default:
0254             dev_err(di->dev,
0255                 "Chip ID %d with rev %d not supported!\n",
0256                 di->chip_id, di->chip_rev);
0257             return -EINVAL;
0258         }
0259         break;
0260     default:
0261         dev_err(di->dev,
0262             "Chip ID %d not supported!\n", di->chip_id);
0263         return -EINVAL;
0264     }
0265 
0266     di->slew_reg = FAN53555_CONTROL;
0267     di->slew_mask = CTL_SLEW_MASK;
0268     di->ramp_delay_table = slew_rates;
0269     di->n_ramp_values = ARRAY_SIZE(slew_rates);
0270     di->vsel_count = FAN53526_NVOLTAGES;
0271 
0272     return 0;
0273 }
0274 
0275 static int fan53555_voltages_setup_fairchild(struct fan53555_device_info *di)
0276 {
0277     /* Init voltage range and step */
0278     switch (di->chip_id) {
0279     case FAN53555_CHIP_ID_00:
0280         switch (di->chip_rev) {
0281         case FAN53555_CHIP_REV_00:
0282             di->vsel_min = 600000;
0283             di->vsel_step = 10000;
0284             break;
0285         case FAN53555_CHIP_REV_13:
0286             di->vsel_min = 800000;
0287             di->vsel_step = 10000;
0288             break;
0289         default:
0290             dev_err(di->dev,
0291                 "Chip ID %d with rev %d not supported!\n",
0292                 di->chip_id, di->chip_rev);
0293             return -EINVAL;
0294         }
0295         break;
0296     case FAN53555_CHIP_ID_01:
0297     case FAN53555_CHIP_ID_03:
0298     case FAN53555_CHIP_ID_05:
0299     case FAN53555_CHIP_ID_08:
0300         di->vsel_min = 600000;
0301         di->vsel_step = 10000;
0302         break;
0303     case FAN53555_CHIP_ID_04:
0304         di->vsel_min = 603000;
0305         di->vsel_step = 12826;
0306         break;
0307     default:
0308         dev_err(di->dev,
0309             "Chip ID %d not supported!\n", di->chip_id);
0310         return -EINVAL;
0311     }
0312     di->slew_reg = FAN53555_CONTROL;
0313     di->slew_mask = CTL_SLEW_MASK;
0314     di->ramp_delay_table = slew_rates;
0315     di->n_ramp_values = ARRAY_SIZE(slew_rates);
0316     di->vsel_count = FAN53555_NVOLTAGES;
0317 
0318     return 0;
0319 }
0320 
0321 static int fan53555_voltages_setup_silergy(struct fan53555_device_info *di)
0322 {
0323     /* Init voltage range and step */
0324     switch (di->chip_id) {
0325     case SILERGY_SYR82X:
0326     case SILERGY_SYR83X:
0327         di->vsel_min = 712500;
0328         di->vsel_step = 12500;
0329         break;
0330     default:
0331         dev_err(di->dev,
0332             "Chip ID %d not supported!\n", di->chip_id);
0333         return -EINVAL;
0334     }
0335     di->slew_reg = FAN53555_CONTROL;
0336     di->slew_mask = CTL_SLEW_MASK;
0337     di->ramp_delay_table = slew_rates;
0338     di->n_ramp_values = ARRAY_SIZE(slew_rates);
0339     di->vsel_count = FAN53555_NVOLTAGES;
0340 
0341     return 0;
0342 }
0343 
0344 static int fan53526_voltages_setup_tcs(struct fan53555_device_info *di)
0345 {
0346     switch (di->chip_id) {
0347     case TCS4525_CHIP_ID_12:
0348     case TCS4526_CHIP_ID_00:
0349         di->slew_reg = TCS4525_TIME;
0350         di->slew_mask = TCS_SLEW_MASK;
0351         di->ramp_delay_table = tcs_slew_rates;
0352         di->n_ramp_values = ARRAY_SIZE(tcs_slew_rates);
0353 
0354         /* Init voltage range and step */
0355         di->vsel_min = 600000;
0356         di->vsel_step = 6250;
0357         di->vsel_count = FAN53526_NVOLTAGES;
0358         break;
0359     default:
0360         dev_err(di->dev, "Chip ID %d not supported!\n", di->chip_id);
0361         return -EINVAL;
0362     }
0363 
0364     return 0;
0365 }
0366 
0367 /* For 00,01,03,05 options:
0368  * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V.
0369  * For 04 option:
0370  * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V.
0371  * */
0372 static int fan53555_device_setup(struct fan53555_device_info *di,
0373                 struct fan53555_platform_data *pdata)
0374 {
0375     int ret = 0;
0376 
0377     /* Setup voltage control register */
0378     switch (di->vendor) {
0379     case FAN53526_VENDOR_FAIRCHILD:
0380     case FAN53555_VENDOR_FAIRCHILD:
0381     case FAN53555_VENDOR_SILERGY:
0382         switch (pdata->sleep_vsel_id) {
0383         case FAN53555_VSEL_ID_0:
0384             di->sleep_reg = FAN53555_VSEL0;
0385             di->vol_reg = FAN53555_VSEL1;
0386             break;
0387         case FAN53555_VSEL_ID_1:
0388             di->sleep_reg = FAN53555_VSEL1;
0389             di->vol_reg = FAN53555_VSEL0;
0390             break;
0391         default:
0392             dev_err(di->dev, "Invalid VSEL ID!\n");
0393             return -EINVAL;
0394         }
0395         break;
0396     case FAN53526_VENDOR_TCS:
0397         switch (pdata->sleep_vsel_id) {
0398         case FAN53555_VSEL_ID_0:
0399             di->sleep_reg = TCS4525_VSEL0;
0400             di->vol_reg = TCS4525_VSEL1;
0401             break;
0402         case FAN53555_VSEL_ID_1:
0403             di->sleep_reg = TCS4525_VSEL1;
0404             di->vol_reg = TCS4525_VSEL0;
0405             break;
0406         default:
0407             dev_err(di->dev, "Invalid VSEL ID!\n");
0408             return -EINVAL;
0409         }
0410         break;
0411     default:
0412         dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
0413         return -EINVAL;
0414     }
0415 
0416     /* Setup mode control register */
0417     switch (di->vendor) {
0418     case FAN53526_VENDOR_FAIRCHILD:
0419         di->mode_reg = FAN53555_CONTROL;
0420 
0421         switch (pdata->sleep_vsel_id) {
0422         case FAN53555_VSEL_ID_0:
0423             di->mode_mask = CTL_MODE_VSEL1_MODE;
0424             break;
0425         case FAN53555_VSEL_ID_1:
0426             di->mode_mask = CTL_MODE_VSEL0_MODE;
0427             break;
0428         }
0429         break;
0430     case FAN53555_VENDOR_FAIRCHILD:
0431     case FAN53555_VENDOR_SILERGY:
0432         di->mode_reg = di->vol_reg;
0433         di->mode_mask = VSEL_MODE;
0434         break;
0435     case FAN53526_VENDOR_TCS:
0436         di->mode_reg = TCS4525_COMMAND;
0437 
0438         switch (pdata->sleep_vsel_id) {
0439         case FAN53555_VSEL_ID_0:
0440             di->mode_mask = TCS_VSEL1_MODE;
0441             break;
0442         case FAN53555_VSEL_ID_1:
0443             di->mode_mask = TCS_VSEL0_MODE;
0444             break;
0445         }
0446         break;
0447     default:
0448         dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
0449         return -EINVAL;
0450     }
0451 
0452     /* Setup voltage range */
0453     switch (di->vendor) {
0454     case FAN53526_VENDOR_FAIRCHILD:
0455         ret = fan53526_voltages_setup_fairchild(di);
0456         break;
0457     case FAN53555_VENDOR_FAIRCHILD:
0458         ret = fan53555_voltages_setup_fairchild(di);
0459         break;
0460     case FAN53555_VENDOR_SILERGY:
0461         ret = fan53555_voltages_setup_silergy(di);
0462         break;
0463     case FAN53526_VENDOR_TCS:
0464         ret = fan53526_voltages_setup_tcs(di);
0465         break;
0466     default:
0467         dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
0468         return -EINVAL;
0469     }
0470 
0471     return ret;
0472 }
0473 
0474 static int fan53555_regulator_register(struct fan53555_device_info *di,
0475             struct regulator_config *config)
0476 {
0477     struct regulator_desc *rdesc = &di->desc;
0478     struct regulator_dev *rdev;
0479 
0480     rdesc->name = "fan53555-reg";
0481     rdesc->supply_name = "vin";
0482     rdesc->ops = &fan53555_regulator_ops;
0483     rdesc->type = REGULATOR_VOLTAGE;
0484     rdesc->n_voltages = di->vsel_count;
0485     rdesc->enable_reg = di->vol_reg;
0486     rdesc->enable_mask = VSEL_BUCK_EN;
0487     rdesc->min_uV = di->vsel_min;
0488     rdesc->uV_step = di->vsel_step;
0489     rdesc->vsel_reg = di->vol_reg;
0490     rdesc->vsel_mask = di->vsel_count - 1;
0491     rdesc->ramp_reg = di->slew_reg;
0492     rdesc->ramp_mask = di->slew_mask;
0493     rdesc->ramp_delay_table = di->ramp_delay_table;
0494     rdesc->n_ramp_values = di->n_ramp_values;
0495     rdesc->owner = THIS_MODULE;
0496 
0497     rdev = devm_regulator_register(di->dev, &di->desc, config);
0498     return PTR_ERR_OR_ZERO(rdev);
0499 }
0500 
0501 static const struct regmap_config fan53555_regmap_config = {
0502     .reg_bits = 8,
0503     .val_bits = 8,
0504 };
0505 
0506 static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev,
0507                           struct device_node *np,
0508                           const struct regulator_desc *desc)
0509 {
0510     struct fan53555_platform_data *pdata;
0511     int ret;
0512     u32 tmp;
0513 
0514     pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
0515     if (!pdata)
0516         return NULL;
0517 
0518     pdata->regulator = of_get_regulator_init_data(dev, np, desc);
0519 
0520     ret = of_property_read_u32(np, "fcs,suspend-voltage-selector",
0521                    &tmp);
0522     if (!ret)
0523         pdata->sleep_vsel_id = tmp;
0524 
0525     return pdata;
0526 }
0527 
0528 static const struct of_device_id __maybe_unused fan53555_dt_ids[] = {
0529     {
0530         .compatible = "fcs,fan53526",
0531         .data = (void *)FAN53526_VENDOR_FAIRCHILD,
0532     }, {
0533         .compatible = "fcs,fan53555",
0534         .data = (void *)FAN53555_VENDOR_FAIRCHILD
0535     }, {
0536         .compatible = "silergy,syr827",
0537         .data = (void *)FAN53555_VENDOR_SILERGY,
0538     }, {
0539         .compatible = "silergy,syr828",
0540         .data = (void *)FAN53555_VENDOR_SILERGY,
0541     }, {
0542         .compatible = "tcs,tcs4525",
0543         .data = (void *)FAN53526_VENDOR_TCS
0544     }, {
0545         .compatible = "tcs,tcs4526",
0546         .data = (void *)FAN53526_VENDOR_TCS
0547     },
0548     { }
0549 };
0550 MODULE_DEVICE_TABLE(of, fan53555_dt_ids);
0551 
0552 static int fan53555_regulator_probe(struct i2c_client *client,
0553                 const struct i2c_device_id *id)
0554 {
0555     struct device_node *np = client->dev.of_node;
0556     struct fan53555_device_info *di;
0557     struct fan53555_platform_data *pdata;
0558     struct regulator_config config = { };
0559     struct regmap *regmap;
0560     unsigned int val;
0561     int ret;
0562 
0563     di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info),
0564                     GFP_KERNEL);
0565     if (!di)
0566         return -ENOMEM;
0567 
0568     pdata = dev_get_platdata(&client->dev);
0569     if (!pdata)
0570         pdata = fan53555_parse_dt(&client->dev, np, &di->desc);
0571 
0572     if (!pdata || !pdata->regulator) {
0573         dev_err(&client->dev, "Platform data not found!\n");
0574         return -ENODEV;
0575     }
0576 
0577     di->regulator = pdata->regulator;
0578     if (client->dev.of_node) {
0579         di->vendor =
0580             (unsigned long)of_device_get_match_data(&client->dev);
0581     } else {
0582         /* if no ramp constraint set, get the pdata ramp_delay */
0583         if (!di->regulator->constraints.ramp_delay) {
0584             if (pdata->slew_rate >= ARRAY_SIZE(slew_rates)) {
0585                 dev_err(&client->dev, "Invalid slew_rate\n");
0586                 return -EINVAL;
0587             }
0588 
0589             di->regulator->constraints.ramp_delay
0590                     = slew_rates[pdata->slew_rate];
0591         }
0592 
0593         di->vendor = id->driver_data;
0594     }
0595 
0596     regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config);
0597     if (IS_ERR(regmap)) {
0598         dev_err(&client->dev, "Failed to allocate regmap!\n");
0599         return PTR_ERR(regmap);
0600     }
0601     di->dev = &client->dev;
0602     i2c_set_clientdata(client, di);
0603     /* Get chip ID */
0604     ret = regmap_read(regmap, FAN53555_ID1, &val);
0605     if (ret < 0) {
0606         dev_err(&client->dev, "Failed to get chip ID!\n");
0607         return ret;
0608     }
0609     di->chip_id = val & DIE_ID;
0610     /* Get chip revision */
0611     ret = regmap_read(regmap, FAN53555_ID2, &val);
0612     if (ret < 0) {
0613         dev_err(&client->dev, "Failed to get chip Rev!\n");
0614         return ret;
0615     }
0616     di->chip_rev = val & DIE_REV;
0617     dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n",
0618                 di->chip_id, di->chip_rev);
0619     /* Device init */
0620     ret = fan53555_device_setup(di, pdata);
0621     if (ret < 0) {
0622         dev_err(&client->dev, "Failed to setup device!\n");
0623         return ret;
0624     }
0625     /* Register regulator */
0626     config.dev = di->dev;
0627     config.init_data = di->regulator;
0628     config.regmap = regmap;
0629     config.driver_data = di;
0630     config.of_node = np;
0631 
0632     ret = fan53555_regulator_register(di, &config);
0633     if (ret < 0)
0634         dev_err(&client->dev, "Failed to register regulator!\n");
0635     return ret;
0636 
0637 }
0638 
0639 static const struct i2c_device_id fan53555_id[] = {
0640     {
0641         .name = "fan53526",
0642         .driver_data = FAN53526_VENDOR_FAIRCHILD
0643     }, {
0644         .name = "fan53555",
0645         .driver_data = FAN53555_VENDOR_FAIRCHILD
0646     }, {
0647         .name = "syr827",
0648         .driver_data = FAN53555_VENDOR_SILERGY
0649     }, {
0650         .name = "syr828",
0651         .driver_data = FAN53555_VENDOR_SILERGY
0652     }, {
0653         .name = "tcs4525",
0654         .driver_data = FAN53526_VENDOR_TCS
0655     }, {
0656         .name = "tcs4526",
0657         .driver_data = FAN53526_VENDOR_TCS
0658     },
0659     { },
0660 };
0661 MODULE_DEVICE_TABLE(i2c, fan53555_id);
0662 
0663 static struct i2c_driver fan53555_regulator_driver = {
0664     .driver = {
0665         .name = "fan53555-regulator",
0666         .of_match_table = of_match_ptr(fan53555_dt_ids),
0667     },
0668     .probe = fan53555_regulator_probe,
0669     .id_table = fan53555_id,
0670 };
0671 
0672 module_i2c_driver(fan53555_regulator_driver);
0673 
0674 MODULE_AUTHOR("Yunfan Zhang <yfzhang@marvell.com>");
0675 MODULE_DESCRIPTION("FAN53555 regulator driver");
0676 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!