Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * max8973-regulator.c -- Maxim max8973A
0004  *
0005  * Regulator driver for MAXIM 8973A DC-DC step-down switching regulator.
0006  *
0007  * Copyright (c) 2012, NVIDIA Corporation.
0008  *
0009  * Author: Laxman Dewangan <ldewangan@nvidia.com>
0010  */
0011 
0012 #include <linux/kernel.h>
0013 #include <linux/module.h>
0014 #include <linux/init.h>
0015 #include <linux/err.h>
0016 #include <linux/of.h>
0017 #include <linux/of_device.h>
0018 #include <linux/platform_device.h>
0019 #include <linux/regulator/driver.h>
0020 #include <linux/regulator/machine.h>
0021 #include <linux/regulator/max8973-regulator.h>
0022 #include <linux/regulator/of_regulator.h>
0023 #include <linux/gpio.h>
0024 #include <linux/gpio/consumer.h>
0025 #include <linux/of_gpio.h>
0026 #include <linux/i2c.h>
0027 #include <linux/slab.h>
0028 #include <linux/regmap.h>
0029 #include <linux/thermal.h>
0030 #include <linux/irq.h>
0031 #include <linux/interrupt.h>
0032 
0033 /* Register definitions */
0034 #define MAX8973_VOUT                    0x0
0035 #define MAX8973_VOUT_DVS                0x1
0036 #define MAX8973_CONTROL1                0x2
0037 #define MAX8973_CONTROL2                0x3
0038 #define MAX8973_CHIPID1                 0x4
0039 #define MAX8973_CHIPID2                 0x5
0040 
0041 #define MAX8973_MAX_VOUT_REG                2
0042 
0043 /* MAX8973_VOUT */
0044 #define MAX8973_VOUT_ENABLE             BIT(7)
0045 #define MAX8973_VOUT_MASK               0x7F
0046 
0047 /* MAX8973_VOUT_DVS */
0048 #define MAX8973_DVS_VOUT_MASK               0x7F
0049 
0050 /* MAX8973_CONTROL1 */
0051 #define MAX8973_SNS_ENABLE              BIT(7)
0052 #define MAX8973_FPWM_EN_M               BIT(6)
0053 #define MAX8973_NFSR_ENABLE             BIT(5)
0054 #define MAX8973_AD_ENABLE               BIT(4)
0055 #define MAX8973_BIAS_ENABLE             BIT(3)
0056 #define MAX8973_FREQSHIFT_9PER              BIT(2)
0057 
0058 #define MAX8973_RAMP_12mV_PER_US            0x0
0059 #define MAX8973_RAMP_25mV_PER_US            0x1
0060 #define MAX8973_RAMP_50mV_PER_US            0x2
0061 #define MAX8973_RAMP_200mV_PER_US           0x3
0062 #define MAX8973_RAMP_MASK               0x3
0063 
0064 /* MAX8973_CONTROL2 */
0065 #define MAX8973_WDTMR_ENABLE                BIT(6)
0066 #define MAX8973_DISCH_ENBABLE               BIT(5)
0067 #define MAX8973_FT_ENABLE               BIT(4)
0068 #define MAX77621_T_JUNCTION_120             BIT(7)
0069 
0070 #define MAX8973_CKKADV_TRIP_MASK            0xC
0071 #define MAX8973_CKKADV_TRIP_DISABLE         0xC
0072 #define MAX8973_CKKADV_TRIP_75mV_PER_US         0x0
0073 #define MAX8973_CKKADV_TRIP_150mV_PER_US        0x4
0074 #define MAX8973_CKKADV_TRIP_75mV_PER_US_HIST_DIS    0x8
0075 #define MAX8973_CONTROL_CLKADV_TRIP_MASK        0x00030000
0076 
0077 #define MAX8973_INDUCTOR_MIN_30_PER         0x0
0078 #define MAX8973_INDUCTOR_NOMINAL            0x1
0079 #define MAX8973_INDUCTOR_PLUS_30_PER            0x2
0080 #define MAX8973_INDUCTOR_PLUS_60_PER            0x3
0081 #define MAX8973_CONTROL_INDUCTOR_VALUE_MASK     0x00300000
0082 
0083 #define MAX8973_MIN_VOLATGE             606250
0084 #define MAX8973_MAX_VOLATGE             1400000
0085 #define MAX8973_VOLATGE_STEP                6250
0086 #define MAX8973_BUCK_N_VOLTAGE              0x80
0087 
0088 #define MAX77621_CHIPID_TJINT_S             BIT(0)
0089 
0090 #define MAX77621_NORMAL_OPERATING_TEMP          100000
0091 #define MAX77621_TJINT_WARNING_TEMP_120         120000
0092 #define MAX77621_TJINT_WARNING_TEMP_140         140000
0093 
0094 enum device_id {
0095     MAX8973,
0096     MAX77621
0097 };
0098 
0099 /* Maxim 8973 chip information */
0100 struct max8973_chip {
0101     struct device *dev;
0102     struct regulator_desc desc;
0103     struct regmap *regmap;
0104     bool enable_external_control;
0105     int dvs_gpio;
0106     int lru_index[MAX8973_MAX_VOUT_REG];
0107     int curr_vout_val[MAX8973_MAX_VOUT_REG];
0108     int curr_vout_reg;
0109     int curr_gpio_val;
0110     struct regulator_ops ops;
0111     enum device_id id;
0112     int junction_temp_warning;
0113     int irq;
0114     struct thermal_zone_device *tz_device;
0115 };
0116 
0117 /*
0118  * find_voltage_set_register: Find new voltage configuration register (VOUT).
0119  * The finding of the new VOUT register will be based on the LRU mechanism.
0120  * Each VOUT register will have different voltage configured . This
0121  * Function will look if any of the VOUT register have requested voltage set
0122  * or not.
0123  *     - If it is already there then it will make that register as most
0124  *       recently used and return as found so that caller need not to set
0125  *       the VOUT register but need to set the proper gpios to select this
0126  *       VOUT register.
0127  *     - If requested voltage is not found then it will use the least
0128  *       recently mechanism to get new VOUT register for new configuration
0129  *       and will return not_found so that caller need to set new VOUT
0130  *       register and then gpios (both).
0131  */
0132 static bool find_voltage_set_register(struct max8973_chip *tps,
0133         int req_vsel, int *vout_reg, int *gpio_val)
0134 {
0135     int i;
0136     bool found = false;
0137     int new_vout_reg = tps->lru_index[MAX8973_MAX_VOUT_REG - 1];
0138     int found_index = MAX8973_MAX_VOUT_REG - 1;
0139 
0140     for (i = 0; i < MAX8973_MAX_VOUT_REG; ++i) {
0141         if (tps->curr_vout_val[tps->lru_index[i]] == req_vsel) {
0142             new_vout_reg = tps->lru_index[i];
0143             found_index = i;
0144             found = true;
0145             goto update_lru_index;
0146         }
0147     }
0148 
0149 update_lru_index:
0150     for (i = found_index; i > 0; i--)
0151         tps->lru_index[i] = tps->lru_index[i - 1];
0152 
0153     tps->lru_index[0] = new_vout_reg;
0154     *gpio_val = new_vout_reg;
0155     *vout_reg = MAX8973_VOUT + new_vout_reg;
0156     return found;
0157 }
0158 
0159 static int max8973_dcdc_get_voltage_sel(struct regulator_dev *rdev)
0160 {
0161     struct max8973_chip *max = rdev_get_drvdata(rdev);
0162     unsigned int data;
0163     int ret;
0164 
0165     ret = regmap_read(max->regmap, max->curr_vout_reg, &data);
0166     if (ret < 0) {
0167         dev_err(max->dev, "register %d read failed, err = %d\n",
0168             max->curr_vout_reg, ret);
0169         return ret;
0170     }
0171     return data & MAX8973_VOUT_MASK;
0172 }
0173 
0174 static int max8973_dcdc_set_voltage_sel(struct regulator_dev *rdev,
0175          unsigned vsel)
0176 {
0177     struct max8973_chip *max = rdev_get_drvdata(rdev);
0178     int ret;
0179     bool found = false;
0180     int vout_reg = max->curr_vout_reg;
0181     int gpio_val = max->curr_gpio_val;
0182 
0183     /*
0184      * If gpios are available to select the VOUT register then least
0185      * recently used register for new configuration.
0186      */
0187     if (gpio_is_valid(max->dvs_gpio))
0188         found = find_voltage_set_register(max, vsel,
0189                     &vout_reg, &gpio_val);
0190 
0191     if (!found) {
0192         ret = regmap_update_bits(max->regmap, vout_reg,
0193                     MAX8973_VOUT_MASK, vsel);
0194         if (ret < 0) {
0195             dev_err(max->dev, "register %d update failed, err %d\n",
0196                  vout_reg, ret);
0197             return ret;
0198         }
0199         max->curr_vout_reg = vout_reg;
0200         max->curr_vout_val[gpio_val] = vsel;
0201     }
0202 
0203     /* Select proper VOUT register vio gpios */
0204     if (gpio_is_valid(max->dvs_gpio)) {
0205         gpio_set_value_cansleep(max->dvs_gpio, gpio_val & 0x1);
0206         max->curr_gpio_val = gpio_val;
0207     }
0208     return 0;
0209 }
0210 
0211 static int max8973_dcdc_set_mode(struct regulator_dev *rdev, unsigned int mode)
0212 {
0213     struct max8973_chip *max = rdev_get_drvdata(rdev);
0214     int ret;
0215     int pwm;
0216 
0217     /* Enable force PWM mode in FAST mode only. */
0218     switch (mode) {
0219     case REGULATOR_MODE_FAST:
0220         pwm = MAX8973_FPWM_EN_M;
0221         break;
0222 
0223     case REGULATOR_MODE_NORMAL:
0224         pwm = 0;
0225         break;
0226 
0227     default:
0228         return -EINVAL;
0229     }
0230 
0231     ret = regmap_update_bits(max->regmap, MAX8973_CONTROL1,
0232                 MAX8973_FPWM_EN_M, pwm);
0233     if (ret < 0)
0234         dev_err(max->dev, "register %d update failed, err %d\n",
0235                 MAX8973_CONTROL1, ret);
0236     return ret;
0237 }
0238 
0239 static unsigned int max8973_dcdc_get_mode(struct regulator_dev *rdev)
0240 {
0241     struct max8973_chip *max = rdev_get_drvdata(rdev);
0242     unsigned int data;
0243     int ret;
0244 
0245     ret = regmap_read(max->regmap, MAX8973_CONTROL1, &data);
0246     if (ret < 0) {
0247         dev_err(max->dev, "register %d read failed, err %d\n",
0248                 MAX8973_CONTROL1, ret);
0249         return ret;
0250     }
0251     return (data & MAX8973_FPWM_EN_M) ?
0252         REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
0253 }
0254 
0255 static int max8973_set_current_limit(struct regulator_dev *rdev,
0256         int min_ua, int max_ua)
0257 {
0258     struct max8973_chip *max = rdev_get_drvdata(rdev);
0259     unsigned int val;
0260     int ret;
0261 
0262     if (max_ua <= 9000000)
0263         val = MAX8973_CKKADV_TRIP_75mV_PER_US;
0264     else if (max_ua <= 12000000)
0265         val = MAX8973_CKKADV_TRIP_150mV_PER_US;
0266     else
0267         val = MAX8973_CKKADV_TRIP_DISABLE;
0268 
0269     ret = regmap_update_bits(max->regmap, MAX8973_CONTROL2,
0270             MAX8973_CKKADV_TRIP_MASK, val);
0271     if (ret < 0) {
0272         dev_err(max->dev, "register %d update failed: %d\n",
0273                 MAX8973_CONTROL2, ret);
0274         return ret;
0275     }
0276     return 0;
0277 }
0278 
0279 static int max8973_get_current_limit(struct regulator_dev *rdev)
0280 {
0281     struct max8973_chip *max = rdev_get_drvdata(rdev);
0282     unsigned int control2;
0283     int ret;
0284 
0285     ret = regmap_read(max->regmap, MAX8973_CONTROL2, &control2);
0286     if (ret < 0) {
0287         dev_err(max->dev, "register %d read failed: %d\n",
0288                 MAX8973_CONTROL2, ret);
0289         return ret;
0290     }
0291     switch (control2 & MAX8973_CKKADV_TRIP_MASK) {
0292     case MAX8973_CKKADV_TRIP_DISABLE:
0293         return 15000000;
0294     case MAX8973_CKKADV_TRIP_150mV_PER_US:
0295         return 12000000;
0296     case MAX8973_CKKADV_TRIP_75mV_PER_US:
0297         return 9000000;
0298     default:
0299         break;
0300     }
0301     return 9000000;
0302 }
0303 
0304 static const unsigned int max8973_buck_ramp_table[] = {
0305     12000, 25000, 50000, 200000
0306 };
0307 
0308 static const struct regulator_ops max8973_dcdc_ops = {
0309     .get_voltage_sel    = max8973_dcdc_get_voltage_sel,
0310     .set_voltage_sel    = max8973_dcdc_set_voltage_sel,
0311     .list_voltage       = regulator_list_voltage_linear,
0312     .set_mode       = max8973_dcdc_set_mode,
0313     .get_mode       = max8973_dcdc_get_mode,
0314     .set_voltage_time_sel   = regulator_set_voltage_time_sel,
0315     .set_ramp_delay     = regulator_set_ramp_delay_regmap,
0316 };
0317 
0318 static int max8973_init_dcdc(struct max8973_chip *max,
0319                  struct max8973_regulator_platform_data *pdata)
0320 {
0321     int ret;
0322     uint8_t control1 = 0;
0323     uint8_t control2 = 0;
0324     unsigned int data;
0325 
0326     ret = regmap_read(max->regmap, MAX8973_CONTROL1, &data);
0327     if (ret < 0) {
0328         dev_err(max->dev, "register %d read failed, err = %d",
0329                 MAX8973_CONTROL1, ret);
0330         return ret;
0331     }
0332     control1 = data & MAX8973_RAMP_MASK;
0333     switch (control1) {
0334     case MAX8973_RAMP_12mV_PER_US:
0335         max->desc.ramp_delay = 12000;
0336         break;
0337     case MAX8973_RAMP_25mV_PER_US:
0338         max->desc.ramp_delay = 25000;
0339         break;
0340     case MAX8973_RAMP_50mV_PER_US:
0341         max->desc.ramp_delay = 50000;
0342         break;
0343     case MAX8973_RAMP_200mV_PER_US:
0344         max->desc.ramp_delay = 200000;
0345         break;
0346     }
0347 
0348     if (pdata->control_flags & MAX8973_CONTROL_REMOTE_SENSE_ENABLE)
0349         control1 |= MAX8973_SNS_ENABLE;
0350 
0351     if (!(pdata->control_flags & MAX8973_CONTROL_FALLING_SLEW_RATE_ENABLE))
0352         control1 |= MAX8973_NFSR_ENABLE;
0353 
0354     if (pdata->control_flags & MAX8973_CONTROL_OUTPUT_ACTIVE_DISCH_ENABLE)
0355         control1 |= MAX8973_AD_ENABLE;
0356 
0357     if (pdata->control_flags & MAX8973_CONTROL_BIAS_ENABLE) {
0358         control1 |= MAX8973_BIAS_ENABLE;
0359         max->desc.enable_time = 20;
0360     } else {
0361         max->desc.enable_time = 240;
0362     }
0363 
0364     if (pdata->control_flags & MAX8973_CONTROL_FREQ_SHIFT_9PER_ENABLE)
0365         control1 |= MAX8973_FREQSHIFT_9PER;
0366 
0367     if ((pdata->junction_temp_warning == MAX77621_TJINT_WARNING_TEMP_120) &&
0368         (max->id == MAX77621))
0369         control2 |= MAX77621_T_JUNCTION_120;
0370 
0371     if (!(pdata->control_flags & MAX8973_CONTROL_PULL_DOWN_ENABLE))
0372         control2 |= MAX8973_DISCH_ENBABLE;
0373 
0374     /*  Clock advance trip configuration */
0375     switch (pdata->control_flags & MAX8973_CONTROL_CLKADV_TRIP_MASK) {
0376     case MAX8973_CONTROL_CLKADV_TRIP_DISABLED:
0377         control2 |= MAX8973_CKKADV_TRIP_DISABLE;
0378         break;
0379 
0380     case MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US:
0381         control2 |= MAX8973_CKKADV_TRIP_75mV_PER_US;
0382         break;
0383 
0384     case MAX8973_CONTROL_CLKADV_TRIP_150mV_PER_US:
0385         control2 |= MAX8973_CKKADV_TRIP_150mV_PER_US;
0386         break;
0387 
0388     case MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US_HIST_DIS:
0389         control2 |= MAX8973_CKKADV_TRIP_75mV_PER_US_HIST_DIS;
0390         break;
0391     }
0392 
0393     /* Configure inductor value */
0394     switch (pdata->control_flags & MAX8973_CONTROL_INDUCTOR_VALUE_MASK) {
0395     case MAX8973_CONTROL_INDUCTOR_VALUE_NOMINAL:
0396         control2 |= MAX8973_INDUCTOR_NOMINAL;
0397         break;
0398 
0399     case MAX8973_CONTROL_INDUCTOR_VALUE_MINUS_30_PER:
0400         control2 |= MAX8973_INDUCTOR_MIN_30_PER;
0401         break;
0402 
0403     case MAX8973_CONTROL_INDUCTOR_VALUE_PLUS_30_PER:
0404         control2 |= MAX8973_INDUCTOR_PLUS_30_PER;
0405         break;
0406 
0407     case MAX8973_CONTROL_INDUCTOR_VALUE_PLUS_60_PER:
0408         control2 |= MAX8973_INDUCTOR_PLUS_60_PER;
0409         break;
0410     }
0411 
0412     ret = regmap_write(max->regmap, MAX8973_CONTROL1, control1);
0413     if (ret < 0) {
0414         dev_err(max->dev, "register %d write failed, err = %d",
0415                 MAX8973_CONTROL1, ret);
0416         return ret;
0417     }
0418 
0419     ret = regmap_write(max->regmap, MAX8973_CONTROL2, control2);
0420     if (ret < 0) {
0421         dev_err(max->dev, "register %d write failed, err = %d",
0422                 MAX8973_CONTROL2, ret);
0423         return ret;
0424     }
0425 
0426     /* If external control is enabled then disable EN bit */
0427     if (max->enable_external_control && (max->id == MAX8973)) {
0428         ret = regmap_update_bits(max->regmap, MAX8973_VOUT,
0429                         MAX8973_VOUT_ENABLE, 0);
0430         if (ret < 0)
0431             dev_err(max->dev, "register %d update failed, err = %d",
0432                 MAX8973_VOUT, ret);
0433     }
0434     return ret;
0435 }
0436 
0437 static int max8973_thermal_read_temp(void *data, int *temp)
0438 {
0439     struct max8973_chip *mchip = data;
0440     unsigned int val;
0441     int ret;
0442 
0443     ret = regmap_read(mchip->regmap, MAX8973_CHIPID1, &val);
0444     if (ret < 0) {
0445         dev_err(mchip->dev, "Failed to read register CHIPID1, %d", ret);
0446         return ret;
0447     }
0448 
0449     /* +1 degC to trigger cool device */
0450     if (val & MAX77621_CHIPID_TJINT_S)
0451         *temp = mchip->junction_temp_warning + 1000;
0452     else
0453         *temp = MAX77621_NORMAL_OPERATING_TEMP;
0454 
0455     return 0;
0456 }
0457 
0458 static irqreturn_t max8973_thermal_irq(int irq, void *data)
0459 {
0460     struct max8973_chip *mchip = data;
0461 
0462     thermal_zone_device_update(mchip->tz_device,
0463                    THERMAL_EVENT_UNSPECIFIED);
0464 
0465     return IRQ_HANDLED;
0466 }
0467 
0468 static const struct thermal_zone_of_device_ops max77621_tz_ops = {
0469     .get_temp = max8973_thermal_read_temp,
0470 };
0471 
0472 static int max8973_thermal_init(struct max8973_chip *mchip)
0473 {
0474     struct thermal_zone_device *tzd;
0475     struct irq_data *irq_data;
0476     unsigned long irq_flags = 0;
0477     int ret;
0478 
0479     if (mchip->id != MAX77621)
0480         return 0;
0481 
0482     tzd = devm_thermal_zone_of_sensor_register(mchip->dev, 0, mchip,
0483                            &max77621_tz_ops);
0484     if (IS_ERR(tzd)) {
0485         ret = PTR_ERR(tzd);
0486         dev_err(mchip->dev, "Failed to register thermal sensor: %d\n",
0487             ret);
0488         return ret;
0489     }
0490 
0491     if (mchip->irq <= 0)
0492         return 0;
0493 
0494     irq_data = irq_get_irq_data(mchip->irq);
0495     if (irq_data)
0496         irq_flags = irqd_get_trigger_type(irq_data);
0497 
0498     ret = devm_request_threaded_irq(mchip->dev, mchip->irq, NULL,
0499                     max8973_thermal_irq,
0500                     IRQF_ONESHOT | IRQF_SHARED | irq_flags,
0501                     dev_name(mchip->dev), mchip);
0502     if (ret < 0) {
0503         dev_err(mchip->dev, "Failed to request irq %d, %d\n",
0504             mchip->irq, ret);
0505         return ret;
0506     }
0507 
0508     return 0;
0509 }
0510 
0511 static const struct regmap_config max8973_regmap_config = {
0512     .reg_bits       = 8,
0513     .val_bits       = 8,
0514     .max_register       = MAX8973_CHIPID2,
0515     .cache_type     = REGCACHE_RBTREE,
0516 };
0517 
0518 static struct max8973_regulator_platform_data *max8973_parse_dt(
0519         struct device *dev)
0520 {
0521     struct max8973_regulator_platform_data *pdata;
0522     struct device_node *np = dev->of_node;
0523     int ret;
0524     u32 pval;
0525     bool etr_enable;
0526     bool etr_sensitivity_high;
0527 
0528     pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
0529     if (!pdata)
0530         return NULL;
0531 
0532     pdata->enable_ext_control = of_property_read_bool(np,
0533                         "maxim,externally-enable");
0534     pdata->dvs_gpio = of_get_named_gpio(np, "maxim,dvs-gpio", 0);
0535 
0536     ret = of_property_read_u32(np, "maxim,dvs-default-state", &pval);
0537     if (!ret)
0538         pdata->dvs_def_state = pval;
0539 
0540     if (of_property_read_bool(np, "maxim,enable-remote-sense"))
0541         pdata->control_flags  |= MAX8973_CONTROL_REMOTE_SENSE_ENABLE;
0542 
0543     if (of_property_read_bool(np, "maxim,enable-falling-slew-rate"))
0544         pdata->control_flags  |=
0545                 MAX8973_CONTROL_FALLING_SLEW_RATE_ENABLE;
0546 
0547     if (of_property_read_bool(np, "maxim,enable-active-discharge"))
0548         pdata->control_flags  |=
0549                 MAX8973_CONTROL_OUTPUT_ACTIVE_DISCH_ENABLE;
0550 
0551     if (of_property_read_bool(np, "maxim,enable-frequency-shift"))
0552         pdata->control_flags  |= MAX8973_CONTROL_FREQ_SHIFT_9PER_ENABLE;
0553 
0554     if (of_property_read_bool(np, "maxim,enable-bias-control"))
0555         pdata->control_flags  |= MAX8973_CONTROL_BIAS_ENABLE;
0556 
0557     etr_enable = of_property_read_bool(np, "maxim,enable-etr");
0558     etr_sensitivity_high = of_property_read_bool(np,
0559                 "maxim,enable-high-etr-sensitivity");
0560     if (etr_sensitivity_high)
0561         etr_enable = true;
0562 
0563     if (etr_enable) {
0564         if (etr_sensitivity_high)
0565             pdata->control_flags |=
0566                 MAX8973_CONTROL_CLKADV_TRIP_75mV_PER_US;
0567         else
0568             pdata->control_flags |=
0569                 MAX8973_CONTROL_CLKADV_TRIP_150mV_PER_US;
0570     } else {
0571         pdata->control_flags |= MAX8973_CONTROL_CLKADV_TRIP_DISABLED;
0572     }
0573 
0574     pdata->junction_temp_warning = MAX77621_TJINT_WARNING_TEMP_140;
0575     ret = of_property_read_u32(np, "junction-warn-millicelsius", &pval);
0576     if (!ret && (pval <= MAX77621_TJINT_WARNING_TEMP_120))
0577         pdata->junction_temp_warning = MAX77621_TJINT_WARNING_TEMP_120;
0578 
0579     return pdata;
0580 }
0581 
0582 static const struct of_device_id of_max8973_match_tbl[] = {
0583     { .compatible = "maxim,max8973", .data = (void *)MAX8973, },
0584     { .compatible = "maxim,max77621", .data = (void *)MAX77621, },
0585     { },
0586 };
0587 MODULE_DEVICE_TABLE(of, of_max8973_match_tbl);
0588 
0589 static int max8973_probe(struct i2c_client *client,
0590              const struct i2c_device_id *id)
0591 {
0592     struct max8973_regulator_platform_data *pdata;
0593     struct regulator_init_data *ridata;
0594     struct regulator_config config = { };
0595     struct regulator_dev *rdev;
0596     struct max8973_chip *max;
0597     bool pdata_from_dt = false;
0598     unsigned int chip_id;
0599     struct gpio_desc *gpiod;
0600     enum gpiod_flags gflags;
0601     int ret;
0602 
0603     pdata = dev_get_platdata(&client->dev);
0604 
0605     if (!pdata && client->dev.of_node) {
0606         pdata = max8973_parse_dt(&client->dev);
0607         pdata_from_dt = true;
0608     }
0609 
0610     if (!pdata) {
0611         dev_err(&client->dev, "No Platform data");
0612         return -EIO;
0613     }
0614 
0615     if (pdata->dvs_gpio == -EPROBE_DEFER)
0616         return -EPROBE_DEFER;
0617 
0618     max = devm_kzalloc(&client->dev, sizeof(*max), GFP_KERNEL);
0619     if (!max)
0620         return -ENOMEM;
0621 
0622     max->regmap = devm_regmap_init_i2c(client, &max8973_regmap_config);
0623     if (IS_ERR(max->regmap)) {
0624         ret = PTR_ERR(max->regmap);
0625         dev_err(&client->dev, "regmap init failed, err %d\n", ret);
0626         return ret;
0627     }
0628 
0629     if (client->dev.of_node) {
0630         const struct of_device_id *match;
0631 
0632         match = of_match_device(of_match_ptr(of_max8973_match_tbl),
0633                 &client->dev);
0634         if (!match)
0635             return -ENODATA;
0636         max->id = (u32)((uintptr_t)match->data);
0637     } else {
0638         max->id = id->driver_data;
0639     }
0640 
0641     ret = regmap_read(max->regmap, MAX8973_CHIPID1, &chip_id);
0642     if (ret < 0) {
0643         dev_err(&client->dev, "register CHIPID1 read failed, %d", ret);
0644         return ret;
0645     }
0646 
0647     dev_info(&client->dev, "CHIP-ID OTP: 0x%02x ID_M: 0x%02x\n",
0648             (chip_id >> 4) & 0xF, (chip_id >> 1) & 0x7);
0649 
0650     i2c_set_clientdata(client, max);
0651     max->ops = max8973_dcdc_ops;
0652     max->dev = &client->dev;
0653     max->desc.name = id->name;
0654     max->desc.id = 0;
0655     max->desc.ops = &max->ops;
0656     max->desc.type = REGULATOR_VOLTAGE;
0657     max->desc.owner = THIS_MODULE;
0658     max->desc.min_uV = MAX8973_MIN_VOLATGE;
0659     max->desc.uV_step = MAX8973_VOLATGE_STEP;
0660     max->desc.n_voltages = MAX8973_BUCK_N_VOLTAGE;
0661     max->desc.ramp_reg = MAX8973_CONTROL1;
0662     max->desc.ramp_mask = MAX8973_RAMP_MASK;
0663     max->desc.ramp_delay_table = max8973_buck_ramp_table;
0664     max->desc.n_ramp_values = ARRAY_SIZE(max8973_buck_ramp_table);
0665 
0666     max->dvs_gpio = (pdata->dvs_gpio) ? pdata->dvs_gpio : -EINVAL;
0667     max->enable_external_control = pdata->enable_ext_control;
0668     max->curr_gpio_val = pdata->dvs_def_state;
0669     max->curr_vout_reg = MAX8973_VOUT + pdata->dvs_def_state;
0670     max->junction_temp_warning = pdata->junction_temp_warning;
0671 
0672     max->lru_index[0] = max->curr_vout_reg;
0673 
0674     if (gpio_is_valid(max->dvs_gpio)) {
0675         int gpio_flags;
0676         int i;
0677 
0678         gpio_flags = (pdata->dvs_def_state) ?
0679                 GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
0680         ret = devm_gpio_request_one(&client->dev, max->dvs_gpio,
0681                 gpio_flags, "max8973-dvs");
0682         if (ret) {
0683             dev_err(&client->dev,
0684                 "gpio_request for gpio %d failed, err = %d\n",
0685                 max->dvs_gpio, ret);
0686             return ret;
0687         }
0688 
0689         /*
0690          * Initialize the lru index with vout_reg id
0691          * The index 0 will be most recently used and
0692          * set with the max->curr_vout_reg */
0693         for (i = 0; i < MAX8973_MAX_VOUT_REG; ++i)
0694             max->lru_index[i] = i;
0695         max->lru_index[0] = max->curr_vout_reg;
0696         max->lru_index[max->curr_vout_reg] = 0;
0697     } else {
0698         /*
0699          * If there is no DVS GPIO, the VOUT register
0700          * address is fixed.
0701          */
0702         max->ops.set_voltage_sel = regulator_set_voltage_sel_regmap;
0703         max->ops.get_voltage_sel = regulator_get_voltage_sel_regmap;
0704         max->desc.vsel_reg = max->curr_vout_reg;
0705         max->desc.vsel_mask = MAX8973_VOUT_MASK;
0706     }
0707 
0708     if (pdata_from_dt)
0709         pdata->reg_init_data = of_get_regulator_init_data(&client->dev,
0710                     client->dev.of_node, &max->desc);
0711 
0712     ridata = pdata->reg_init_data;
0713     switch (max->id) {
0714     case MAX8973:
0715         if (!pdata->enable_ext_control) {
0716             max->desc.enable_reg = MAX8973_VOUT;
0717             max->desc.enable_mask = MAX8973_VOUT_ENABLE;
0718             max->ops.enable = regulator_enable_regmap;
0719             max->ops.disable = regulator_disable_regmap;
0720             max->ops.is_enabled = regulator_is_enabled_regmap;
0721             break;
0722         }
0723 
0724         if (ridata && (ridata->constraints.always_on ||
0725                    ridata->constraints.boot_on))
0726             gflags = GPIOD_OUT_HIGH;
0727         else
0728             gflags = GPIOD_OUT_LOW;
0729         gflags |= GPIOD_FLAGS_BIT_NONEXCLUSIVE;
0730         gpiod = devm_gpiod_get_optional(&client->dev,
0731                         "maxim,enable",
0732                         gflags);
0733         if (IS_ERR(gpiod))
0734             return PTR_ERR(gpiod);
0735         if (gpiod) {
0736             config.ena_gpiod = gpiod;
0737             max->enable_external_control = true;
0738         }
0739 
0740         break;
0741 
0742     case MAX77621:
0743         /*
0744          * We do not let the core switch this regulator on/off,
0745          * we just leave it on.
0746          */
0747         gpiod = devm_gpiod_get_optional(&client->dev,
0748                         "maxim,enable",
0749                         GPIOD_OUT_HIGH);
0750         if (IS_ERR(gpiod))
0751             return PTR_ERR(gpiod);
0752         if (gpiod)
0753             max->enable_external_control = true;
0754 
0755         max->desc.enable_reg = MAX8973_VOUT;
0756         max->desc.enable_mask = MAX8973_VOUT_ENABLE;
0757         max->ops.enable = regulator_enable_regmap;
0758         max->ops.disable = regulator_disable_regmap;
0759         max->ops.is_enabled = regulator_is_enabled_regmap;
0760         max->ops.set_current_limit = max8973_set_current_limit;
0761         max->ops.get_current_limit = max8973_get_current_limit;
0762         break;
0763     default:
0764         break;
0765     }
0766 
0767     ret = max8973_init_dcdc(max, pdata);
0768     if (ret < 0) {
0769         dev_err(max->dev, "Max8973 Init failed, err = %d\n", ret);
0770         return ret;
0771     }
0772 
0773     config.dev = &client->dev;
0774     config.init_data = pdata->reg_init_data;
0775     config.driver_data = max;
0776     config.of_node = client->dev.of_node;
0777     config.regmap = max->regmap;
0778 
0779     /*
0780      * Register the regulators
0781      * Turn the GPIO descriptor over to the regulator core for
0782      * lifecycle management if we pass an ena_gpiod.
0783      */
0784     if (config.ena_gpiod)
0785         devm_gpiod_unhinge(&client->dev, config.ena_gpiod);
0786     rdev = devm_regulator_register(&client->dev, &max->desc, &config);
0787     if (IS_ERR(rdev)) {
0788         ret = PTR_ERR(rdev);
0789         dev_err(max->dev, "regulator register failed, err %d\n", ret);
0790         return ret;
0791     }
0792 
0793     max8973_thermal_init(max);
0794     return 0;
0795 }
0796 
0797 static const struct i2c_device_id max8973_id[] = {
0798     {.name = "max8973", .driver_data = MAX8973},
0799     {.name = "max77621", .driver_data = MAX77621},
0800     {},
0801 };
0802 MODULE_DEVICE_TABLE(i2c, max8973_id);
0803 
0804 static struct i2c_driver max8973_i2c_driver = {
0805     .driver = {
0806         .name = "max8973",
0807         .of_match_table = of_max8973_match_tbl,
0808     },
0809     .probe = max8973_probe,
0810     .id_table = max8973_id,
0811 };
0812 
0813 static int __init max8973_init(void)
0814 {
0815     return i2c_add_driver(&max8973_i2c_driver);
0816 }
0817 subsys_initcall(max8973_init);
0818 
0819 static void __exit max8973_cleanup(void)
0820 {
0821     i2c_del_driver(&max8973_i2c_driver);
0822 }
0823 module_exit(max8973_cleanup);
0824 
0825 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
0826 MODULE_DESCRIPTION("MAX8973 voltage regulator driver");
0827 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!