Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
0004  */
0005 
0006 #include <linux/bitops.h>
0007 #include <linux/completion.h>
0008 #include <linux/delay.h>
0009 #include <linux/err.h>
0010 #include <linux/iio/adc/qcom-vadc-common.h>
0011 #include <linux/iio/iio.h>
0012 #include <linux/interrupt.h>
0013 #include <linux/kernel.h>
0014 #include <linux/math64.h>
0015 #include <linux/module.h>
0016 #include <linux/of.h>
0017 #include <linux/platform_device.h>
0018 #include <linux/regmap.h>
0019 #include <linux/slab.h>
0020 #include <linux/log2.h>
0021 
0022 #include <dt-bindings/iio/qcom,spmi-vadc.h>
0023 
0024 /* VADC register and bit definitions */
0025 #define VADC_REVISION2              0x1
0026 #define VADC_REVISION2_SUPPORTED_VADC       1
0027 
0028 #define VADC_PERPH_TYPE             0x4
0029 #define VADC_PERPH_TYPE_ADC         8
0030 
0031 #define VADC_PERPH_SUBTYPE          0x5
0032 #define VADC_PERPH_SUBTYPE_VADC         1
0033 
0034 #define VADC_STATUS1                0x8
0035 #define VADC_STATUS1_OP_MODE            4
0036 #define VADC_STATUS1_REQ_STS            BIT(1)
0037 #define VADC_STATUS1_EOC            BIT(0)
0038 #define VADC_STATUS1_REQ_STS_EOC_MASK       0x3
0039 
0040 #define VADC_MODE_CTL               0x40
0041 #define VADC_OP_MODE_SHIFT          3
0042 #define VADC_OP_MODE_NORMAL         0
0043 #define VADC_AMUX_TRIM_EN           BIT(1)
0044 #define VADC_ADC_TRIM_EN            BIT(0)
0045 
0046 #define VADC_EN_CTL1                0x46
0047 #define VADC_EN_CTL1_SET            BIT(7)
0048 
0049 #define VADC_ADC_CH_SEL_CTL         0x48
0050 
0051 #define VADC_ADC_DIG_PARAM          0x50
0052 #define VADC_ADC_DIG_DEC_RATIO_SEL_SHIFT    2
0053 
0054 #define VADC_HW_SETTLE_DELAY            0x51
0055 
0056 #define VADC_CONV_REQ               0x52
0057 #define VADC_CONV_REQ_SET           BIT(7)
0058 
0059 #define VADC_FAST_AVG_CTL           0x5a
0060 #define VADC_FAST_AVG_EN            0x5b
0061 #define VADC_FAST_AVG_EN_SET            BIT(7)
0062 
0063 #define VADC_ACCESS             0xd0
0064 #define VADC_ACCESS_DATA            0xa5
0065 
0066 #define VADC_PERH_RESET_CTL3            0xda
0067 #define VADC_FOLLOW_WARM_RB         BIT(2)
0068 
0069 #define VADC_DATA               0x60    /* 16 bits */
0070 
0071 #define VADC_CHAN_MIN           VADC_USBIN
0072 #define VADC_CHAN_MAX           VADC_LR_MUX3_BUF_PU1_PU2_XO_THERM
0073 
0074 /**
0075  * struct vadc_channel_prop - VADC channel property.
0076  * @channel: channel number, refer to the channel list.
0077  * @calibration: calibration type.
0078  * @decimation: sampling rate supported for the channel.
0079  * @prescale: channel scaling performed on the input signal.
0080  * @hw_settle_time: the time between AMUX being configured and the
0081  *  start of conversion.
0082  * @avg_samples: ability to provide single result from the ADC
0083  *  that is an average of multiple measurements.
0084  * @scale_fn_type: Represents the scaling function to convert voltage
0085  *  physical units desired by the client for the channel.
0086  */
0087 struct vadc_channel_prop {
0088     unsigned int channel;
0089     enum vadc_calibration calibration;
0090     unsigned int decimation;
0091     unsigned int prescale;
0092     unsigned int hw_settle_time;
0093     unsigned int avg_samples;
0094     enum vadc_scale_fn_type scale_fn_type;
0095 };
0096 
0097 /**
0098  * struct vadc_priv - VADC private structure.
0099  * @regmap: pointer to struct regmap.
0100  * @dev: pointer to struct device.
0101  * @base: base address for the ADC peripheral.
0102  * @nchannels: number of VADC channels.
0103  * @chan_props: array of VADC channel properties.
0104  * @iio_chans: array of IIO channels specification.
0105  * @are_ref_measured: are reference points measured.
0106  * @poll_eoc: use polling instead of interrupt.
0107  * @complete: VADC result notification after interrupt is received.
0108  * @graph: store parameters for calibration.
0109  * @lock: ADC lock for access to the peripheral.
0110  */
0111 struct vadc_priv {
0112     struct regmap        *regmap;
0113     struct device        *dev;
0114     u16          base;
0115     unsigned int         nchannels;
0116     struct vadc_channel_prop *chan_props;
0117     struct iio_chan_spec     *iio_chans;
0118     bool             are_ref_measured;
0119     bool             poll_eoc;
0120     struct completion    complete;
0121     struct vadc_linear_graph graph[2];
0122     struct mutex         lock;
0123 };
0124 
0125 static const struct u32_fract vadc_prescale_ratios[] = {
0126     { .numerator =  1, .denominator =  1 },
0127     { .numerator =  1, .denominator =  3 },
0128     { .numerator =  1, .denominator =  4 },
0129     { .numerator =  1, .denominator =  6 },
0130     { .numerator =  1, .denominator = 20 },
0131     { .numerator =  1, .denominator =  8 },
0132     { .numerator = 10, .denominator = 81 },
0133     { .numerator =  1, .denominator = 10 },
0134 };
0135 
0136 static int vadc_read(struct vadc_priv *vadc, u16 offset, u8 *data)
0137 {
0138     return regmap_bulk_read(vadc->regmap, vadc->base + offset, data, 1);
0139 }
0140 
0141 static int vadc_write(struct vadc_priv *vadc, u16 offset, u8 data)
0142 {
0143     return regmap_write(vadc->regmap, vadc->base + offset, data);
0144 }
0145 
0146 static int vadc_reset(struct vadc_priv *vadc)
0147 {
0148     u8 data;
0149     int ret;
0150 
0151     ret = vadc_write(vadc, VADC_ACCESS, VADC_ACCESS_DATA);
0152     if (ret)
0153         return ret;
0154 
0155     ret = vadc_read(vadc, VADC_PERH_RESET_CTL3, &data);
0156     if (ret)
0157         return ret;
0158 
0159     ret = vadc_write(vadc, VADC_ACCESS, VADC_ACCESS_DATA);
0160     if (ret)
0161         return ret;
0162 
0163     data |= VADC_FOLLOW_WARM_RB;
0164 
0165     return vadc_write(vadc, VADC_PERH_RESET_CTL3, data);
0166 }
0167 
0168 static int vadc_set_state(struct vadc_priv *vadc, bool state)
0169 {
0170     return vadc_write(vadc, VADC_EN_CTL1, state ? VADC_EN_CTL1_SET : 0);
0171 }
0172 
0173 static void vadc_show_status(struct vadc_priv *vadc)
0174 {
0175     u8 mode, sta1, chan, dig, en, req;
0176     int ret;
0177 
0178     ret = vadc_read(vadc, VADC_MODE_CTL, &mode);
0179     if (ret)
0180         return;
0181 
0182     ret = vadc_read(vadc, VADC_ADC_DIG_PARAM, &dig);
0183     if (ret)
0184         return;
0185 
0186     ret = vadc_read(vadc, VADC_ADC_CH_SEL_CTL, &chan);
0187     if (ret)
0188         return;
0189 
0190     ret = vadc_read(vadc, VADC_CONV_REQ, &req);
0191     if (ret)
0192         return;
0193 
0194     ret = vadc_read(vadc, VADC_STATUS1, &sta1);
0195     if (ret)
0196         return;
0197 
0198     ret = vadc_read(vadc, VADC_EN_CTL1, &en);
0199     if (ret)
0200         return;
0201 
0202     dev_err(vadc->dev,
0203         "mode:%02x en:%02x chan:%02x dig:%02x req:%02x sta1:%02x\n",
0204         mode, en, chan, dig, req, sta1);
0205 }
0206 
0207 static int vadc_configure(struct vadc_priv *vadc,
0208               struct vadc_channel_prop *prop)
0209 {
0210     u8 decimation, mode_ctrl;
0211     int ret;
0212 
0213     /* Mode selection */
0214     mode_ctrl = (VADC_OP_MODE_NORMAL << VADC_OP_MODE_SHIFT) |
0215              VADC_ADC_TRIM_EN | VADC_AMUX_TRIM_EN;
0216     ret = vadc_write(vadc, VADC_MODE_CTL, mode_ctrl);
0217     if (ret)
0218         return ret;
0219 
0220     /* Channel selection */
0221     ret = vadc_write(vadc, VADC_ADC_CH_SEL_CTL, prop->channel);
0222     if (ret)
0223         return ret;
0224 
0225     /* Digital parameter setup */
0226     decimation = prop->decimation << VADC_ADC_DIG_DEC_RATIO_SEL_SHIFT;
0227     ret = vadc_write(vadc, VADC_ADC_DIG_PARAM, decimation);
0228     if (ret)
0229         return ret;
0230 
0231     /* HW settle time delay */
0232     ret = vadc_write(vadc, VADC_HW_SETTLE_DELAY, prop->hw_settle_time);
0233     if (ret)
0234         return ret;
0235 
0236     ret = vadc_write(vadc, VADC_FAST_AVG_CTL, prop->avg_samples);
0237     if (ret)
0238         return ret;
0239 
0240     if (prop->avg_samples)
0241         ret = vadc_write(vadc, VADC_FAST_AVG_EN, VADC_FAST_AVG_EN_SET);
0242     else
0243         ret = vadc_write(vadc, VADC_FAST_AVG_EN, 0);
0244 
0245     return ret;
0246 }
0247 
0248 static int vadc_poll_wait_eoc(struct vadc_priv *vadc, unsigned int interval_us)
0249 {
0250     unsigned int count, retry;
0251     u8 sta1;
0252     int ret;
0253 
0254     retry = interval_us / VADC_CONV_TIME_MIN_US;
0255 
0256     for (count = 0; count < retry; count++) {
0257         ret = vadc_read(vadc, VADC_STATUS1, &sta1);
0258         if (ret)
0259             return ret;
0260 
0261         sta1 &= VADC_STATUS1_REQ_STS_EOC_MASK;
0262         if (sta1 == VADC_STATUS1_EOC)
0263             return 0;
0264 
0265         usleep_range(VADC_CONV_TIME_MIN_US, VADC_CONV_TIME_MAX_US);
0266     }
0267 
0268     vadc_show_status(vadc);
0269 
0270     return -ETIMEDOUT;
0271 }
0272 
0273 static int vadc_read_result(struct vadc_priv *vadc, u16 *data)
0274 {
0275     int ret;
0276 
0277     ret = regmap_bulk_read(vadc->regmap, vadc->base + VADC_DATA, data, 2);
0278     if (ret)
0279         return ret;
0280 
0281     *data = clamp_t(u16, *data, VADC_MIN_ADC_CODE, VADC_MAX_ADC_CODE);
0282 
0283     return 0;
0284 }
0285 
0286 static struct vadc_channel_prop *vadc_get_channel(struct vadc_priv *vadc,
0287                           unsigned int num)
0288 {
0289     unsigned int i;
0290 
0291     for (i = 0; i < vadc->nchannels; i++)
0292         if (vadc->chan_props[i].channel == num)
0293             return &vadc->chan_props[i];
0294 
0295     dev_dbg(vadc->dev, "no such channel %02x\n", num);
0296 
0297     return NULL;
0298 }
0299 
0300 static int vadc_do_conversion(struct vadc_priv *vadc,
0301                   struct vadc_channel_prop *prop, u16 *data)
0302 {
0303     unsigned int timeout;
0304     int ret;
0305 
0306     mutex_lock(&vadc->lock);
0307 
0308     ret = vadc_configure(vadc, prop);
0309     if (ret)
0310         goto unlock;
0311 
0312     if (!vadc->poll_eoc)
0313         reinit_completion(&vadc->complete);
0314 
0315     ret = vadc_set_state(vadc, true);
0316     if (ret)
0317         goto unlock;
0318 
0319     ret = vadc_write(vadc, VADC_CONV_REQ, VADC_CONV_REQ_SET);
0320     if (ret)
0321         goto err_disable;
0322 
0323     timeout = BIT(prop->avg_samples) * VADC_CONV_TIME_MIN_US * 2;
0324 
0325     if (vadc->poll_eoc) {
0326         ret = vadc_poll_wait_eoc(vadc, timeout);
0327     } else {
0328         ret = wait_for_completion_timeout(&vadc->complete, timeout);
0329         if (!ret) {
0330             ret = -ETIMEDOUT;
0331             goto err_disable;
0332         }
0333 
0334         /* Double check conversion status */
0335         ret = vadc_poll_wait_eoc(vadc, VADC_CONV_TIME_MIN_US);
0336         if (ret)
0337             goto err_disable;
0338     }
0339 
0340     ret = vadc_read_result(vadc, data);
0341 
0342 err_disable:
0343     vadc_set_state(vadc, false);
0344     if (ret)
0345         dev_err(vadc->dev, "conversion failed\n");
0346 unlock:
0347     mutex_unlock(&vadc->lock);
0348     return ret;
0349 }
0350 
0351 static int vadc_measure_ref_points(struct vadc_priv *vadc)
0352 {
0353     struct vadc_channel_prop *prop;
0354     u16 read_1, read_2;
0355     int ret;
0356 
0357     vadc->graph[VADC_CALIB_RATIOMETRIC].dx = VADC_RATIOMETRIC_RANGE;
0358     vadc->graph[VADC_CALIB_ABSOLUTE].dx = VADC_ABSOLUTE_RANGE_UV;
0359 
0360     prop = vadc_get_channel(vadc, VADC_REF_1250MV);
0361     ret = vadc_do_conversion(vadc, prop, &read_1);
0362     if (ret)
0363         goto err;
0364 
0365     /* Try with buffered 625mV channel first */
0366     prop = vadc_get_channel(vadc, VADC_SPARE1);
0367     if (!prop)
0368         prop = vadc_get_channel(vadc, VADC_REF_625MV);
0369 
0370     ret = vadc_do_conversion(vadc, prop, &read_2);
0371     if (ret)
0372         goto err;
0373 
0374     if (read_1 == read_2) {
0375         ret = -EINVAL;
0376         goto err;
0377     }
0378 
0379     vadc->graph[VADC_CALIB_ABSOLUTE].dy = read_1 - read_2;
0380     vadc->graph[VADC_CALIB_ABSOLUTE].gnd = read_2;
0381 
0382     /* Ratiometric calibration */
0383     prop = vadc_get_channel(vadc, VADC_VDD_VADC);
0384     ret = vadc_do_conversion(vadc, prop, &read_1);
0385     if (ret)
0386         goto err;
0387 
0388     prop = vadc_get_channel(vadc, VADC_GND_REF);
0389     ret = vadc_do_conversion(vadc, prop, &read_2);
0390     if (ret)
0391         goto err;
0392 
0393     if (read_1 == read_2) {
0394         ret = -EINVAL;
0395         goto err;
0396     }
0397 
0398     vadc->graph[VADC_CALIB_RATIOMETRIC].dy = read_1 - read_2;
0399     vadc->graph[VADC_CALIB_RATIOMETRIC].gnd = read_2;
0400 err:
0401     if (ret)
0402         dev_err(vadc->dev, "measure reference points failed\n");
0403 
0404     return ret;
0405 }
0406 
0407 static int vadc_prescaling_from_dt(u32 numerator, u32 denominator)
0408 {
0409     unsigned int pre;
0410 
0411     for (pre = 0; pre < ARRAY_SIZE(vadc_prescale_ratios); pre++)
0412         if (vadc_prescale_ratios[pre].numerator == numerator &&
0413             vadc_prescale_ratios[pre].denominator == denominator)
0414             break;
0415 
0416     if (pre == ARRAY_SIZE(vadc_prescale_ratios))
0417         return -EINVAL;
0418 
0419     return pre;
0420 }
0421 
0422 static int vadc_hw_settle_time_from_dt(u32 value)
0423 {
0424     if ((value <= 1000 && value % 100) || (value > 1000 && value % 2000))
0425         return -EINVAL;
0426 
0427     if (value <= 1000)
0428         value /= 100;
0429     else
0430         value = value / 2000 + 10;
0431 
0432     return value;
0433 }
0434 
0435 static int vadc_avg_samples_from_dt(u32 value)
0436 {
0437     if (!is_power_of_2(value) || value > VADC_AVG_SAMPLES_MAX)
0438         return -EINVAL;
0439 
0440     return __ffs64(value);
0441 }
0442 
0443 static int vadc_read_raw(struct iio_dev *indio_dev,
0444              struct iio_chan_spec const *chan, int *val, int *val2,
0445              long mask)
0446 {
0447     struct vadc_priv *vadc = iio_priv(indio_dev);
0448     struct vadc_channel_prop *prop;
0449     u16 adc_code;
0450     int ret;
0451 
0452     switch (mask) {
0453     case IIO_CHAN_INFO_PROCESSED:
0454         prop = &vadc->chan_props[chan->address];
0455         ret = vadc_do_conversion(vadc, prop, &adc_code);
0456         if (ret)
0457             break;
0458 
0459         ret = qcom_vadc_scale(prop->scale_fn_type,
0460                 &vadc->graph[prop->calibration],
0461                 &vadc_prescale_ratios[prop->prescale],
0462                 (prop->calibration == VADC_CALIB_ABSOLUTE),
0463                 adc_code, val);
0464         if (ret)
0465             break;
0466 
0467         return IIO_VAL_INT;
0468     case IIO_CHAN_INFO_RAW:
0469         prop = &vadc->chan_props[chan->address];
0470         ret = vadc_do_conversion(vadc, prop, &adc_code);
0471         if (ret)
0472             break;
0473 
0474         *val = (int)adc_code;
0475         return IIO_VAL_INT;
0476     default:
0477         ret = -EINVAL;
0478         break;
0479     }
0480 
0481     return ret;
0482 }
0483 
0484 static int vadc_of_xlate(struct iio_dev *indio_dev,
0485              const struct of_phandle_args *iiospec)
0486 {
0487     struct vadc_priv *vadc = iio_priv(indio_dev);
0488     unsigned int i;
0489 
0490     for (i = 0; i < vadc->nchannels; i++)
0491         if (vadc->iio_chans[i].channel == iiospec->args[0])
0492             return i;
0493 
0494     return -EINVAL;
0495 }
0496 
0497 static const struct iio_info vadc_info = {
0498     .read_raw = vadc_read_raw,
0499     .of_xlate = vadc_of_xlate,
0500 };
0501 
0502 struct vadc_channels {
0503     const char *datasheet_name;
0504     unsigned int prescale_index;
0505     enum iio_chan_type type;
0506     long info_mask;
0507     enum vadc_scale_fn_type scale_fn_type;
0508 };
0509 
0510 #define VADC_CHAN(_dname, _type, _mask, _pre, _scale)           \
0511     [VADC_##_dname] = {                     \
0512         .datasheet_name = __stringify(_dname),          \
0513         .prescale_index = _pre,                 \
0514         .type = _type,                      \
0515         .info_mask = _mask,                 \
0516         .scale_fn_type = _scale                 \
0517     },                              \
0518 
0519 #define VADC_NO_CHAN(_dname, _type, _mask, _pre)            \
0520     [VADC_##_dname] = {                     \
0521         .datasheet_name = __stringify(_dname),          \
0522         .prescale_index = _pre,                 \
0523         .type = _type,                      \
0524         .info_mask = _mask                  \
0525     },
0526 
0527 #define VADC_CHAN_TEMP(_dname, _pre, _scale)                \
0528     VADC_CHAN(_dname, IIO_TEMP,                 \
0529         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_PROCESSED),  \
0530         _pre, _scale)                       \
0531 
0532 #define VADC_CHAN_VOLT(_dname, _pre, _scale)                \
0533     VADC_CHAN(_dname, IIO_VOLTAGE,                  \
0534           BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_PROCESSED),\
0535           _pre, _scale)                     \
0536 
0537 #define VADC_CHAN_NO_SCALE(_dname, _pre)                \
0538     VADC_NO_CHAN(_dname, IIO_VOLTAGE,               \
0539           BIT(IIO_CHAN_INFO_RAW),               \
0540           _pre)                         \
0541 
0542 /*
0543  * The array represents all possible ADC channels found in the supported PMICs.
0544  * Every index in the array is equal to the channel number per datasheet. The
0545  * gaps in the array should be treated as reserved channels.
0546  */
0547 static const struct vadc_channels vadc_chans[] = {
0548     VADC_CHAN_VOLT(USBIN, 4, SCALE_DEFAULT)
0549     VADC_CHAN_VOLT(DCIN, 4, SCALE_DEFAULT)
0550     VADC_CHAN_NO_SCALE(VCHG_SNS, 3)
0551     VADC_CHAN_NO_SCALE(SPARE1_03, 1)
0552     VADC_CHAN_NO_SCALE(USB_ID_MV, 1)
0553     VADC_CHAN_VOLT(VCOIN, 1, SCALE_DEFAULT)
0554     VADC_CHAN_NO_SCALE(VBAT_SNS, 1)
0555     VADC_CHAN_VOLT(VSYS, 1, SCALE_DEFAULT)
0556     VADC_CHAN_TEMP(DIE_TEMP, 0, SCALE_PMIC_THERM)
0557     VADC_CHAN_VOLT(REF_625MV, 0, SCALE_DEFAULT)
0558     VADC_CHAN_VOLT(REF_1250MV, 0, SCALE_DEFAULT)
0559     VADC_CHAN_NO_SCALE(CHG_TEMP, 0)
0560     VADC_CHAN_NO_SCALE(SPARE1, 0)
0561     VADC_CHAN_TEMP(SPARE2, 0, SCALE_PMI_CHG_TEMP)
0562     VADC_CHAN_VOLT(GND_REF, 0, SCALE_DEFAULT)
0563     VADC_CHAN_VOLT(VDD_VADC, 0, SCALE_DEFAULT)
0564 
0565     VADC_CHAN_NO_SCALE(P_MUX1_1_1, 0)
0566     VADC_CHAN_NO_SCALE(P_MUX2_1_1, 0)
0567     VADC_CHAN_NO_SCALE(P_MUX3_1_1, 0)
0568     VADC_CHAN_NO_SCALE(P_MUX4_1_1, 0)
0569     VADC_CHAN_NO_SCALE(P_MUX5_1_1, 0)
0570     VADC_CHAN_NO_SCALE(P_MUX6_1_1, 0)
0571     VADC_CHAN_NO_SCALE(P_MUX7_1_1, 0)
0572     VADC_CHAN_NO_SCALE(P_MUX8_1_1, 0)
0573     VADC_CHAN_NO_SCALE(P_MUX9_1_1, 0)
0574     VADC_CHAN_NO_SCALE(P_MUX10_1_1, 0)
0575     VADC_CHAN_NO_SCALE(P_MUX11_1_1, 0)
0576     VADC_CHAN_NO_SCALE(P_MUX12_1_1, 0)
0577     VADC_CHAN_NO_SCALE(P_MUX13_1_1, 0)
0578     VADC_CHAN_NO_SCALE(P_MUX14_1_1, 0)
0579     VADC_CHAN_NO_SCALE(P_MUX15_1_1, 0)
0580     VADC_CHAN_NO_SCALE(P_MUX16_1_1, 0)
0581 
0582     VADC_CHAN_NO_SCALE(P_MUX1_1_3, 1)
0583     VADC_CHAN_NO_SCALE(P_MUX2_1_3, 1)
0584     VADC_CHAN_NO_SCALE(P_MUX3_1_3, 1)
0585     VADC_CHAN_NO_SCALE(P_MUX4_1_3, 1)
0586     VADC_CHAN_NO_SCALE(P_MUX5_1_3, 1)
0587     VADC_CHAN_NO_SCALE(P_MUX6_1_3, 1)
0588     VADC_CHAN_NO_SCALE(P_MUX7_1_3, 1)
0589     VADC_CHAN_NO_SCALE(P_MUX8_1_3, 1)
0590     VADC_CHAN_NO_SCALE(P_MUX9_1_3, 1)
0591     VADC_CHAN_NO_SCALE(P_MUX10_1_3, 1)
0592     VADC_CHAN_NO_SCALE(P_MUX11_1_3, 1)
0593     VADC_CHAN_NO_SCALE(P_MUX12_1_3, 1)
0594     VADC_CHAN_NO_SCALE(P_MUX13_1_3, 1)
0595     VADC_CHAN_NO_SCALE(P_MUX14_1_3, 1)
0596     VADC_CHAN_NO_SCALE(P_MUX15_1_3, 1)
0597     VADC_CHAN_NO_SCALE(P_MUX16_1_3, 1)
0598 
0599     VADC_CHAN_NO_SCALE(LR_MUX1_BAT_THERM, 0)
0600     VADC_CHAN_VOLT(LR_MUX2_BAT_ID, 0, SCALE_DEFAULT)
0601     VADC_CHAN_NO_SCALE(LR_MUX3_XO_THERM, 0)
0602     VADC_CHAN_NO_SCALE(LR_MUX4_AMUX_THM1, 0)
0603     VADC_CHAN_NO_SCALE(LR_MUX5_AMUX_THM2, 0)
0604     VADC_CHAN_NO_SCALE(LR_MUX6_AMUX_THM3, 0)
0605     VADC_CHAN_NO_SCALE(LR_MUX7_HW_ID, 0)
0606     VADC_CHAN_NO_SCALE(LR_MUX8_AMUX_THM4, 0)
0607     VADC_CHAN_NO_SCALE(LR_MUX9_AMUX_THM5, 0)
0608     VADC_CHAN_NO_SCALE(LR_MUX10_USB_ID, 0)
0609     VADC_CHAN_NO_SCALE(AMUX_PU1, 0)
0610     VADC_CHAN_NO_SCALE(AMUX_PU2, 0)
0611     VADC_CHAN_NO_SCALE(LR_MUX3_BUF_XO_THERM, 0)
0612 
0613     VADC_CHAN_NO_SCALE(LR_MUX1_PU1_BAT_THERM, 0)
0614     VADC_CHAN_NO_SCALE(LR_MUX2_PU1_BAT_ID, 0)
0615     VADC_CHAN_NO_SCALE(LR_MUX3_PU1_XO_THERM, 0)
0616     VADC_CHAN_TEMP(LR_MUX4_PU1_AMUX_THM1, 0, SCALE_THERM_100K_PULLUP)
0617     VADC_CHAN_TEMP(LR_MUX5_PU1_AMUX_THM2, 0, SCALE_THERM_100K_PULLUP)
0618     VADC_CHAN_TEMP(LR_MUX6_PU1_AMUX_THM3, 0, SCALE_THERM_100K_PULLUP)
0619     VADC_CHAN_NO_SCALE(LR_MUX7_PU1_AMUX_HW_ID, 0)
0620     VADC_CHAN_TEMP(LR_MUX8_PU1_AMUX_THM4, 0, SCALE_THERM_100K_PULLUP)
0621     VADC_CHAN_TEMP(LR_MUX9_PU1_AMUX_THM5, 0, SCALE_THERM_100K_PULLUP)
0622     VADC_CHAN_NO_SCALE(LR_MUX10_PU1_AMUX_USB_ID, 0)
0623     VADC_CHAN_TEMP(LR_MUX3_BUF_PU1_XO_THERM, 0, SCALE_XOTHERM)
0624 
0625     VADC_CHAN_NO_SCALE(LR_MUX1_PU2_BAT_THERM, 0)
0626     VADC_CHAN_NO_SCALE(LR_MUX2_PU2_BAT_ID, 0)
0627     VADC_CHAN_NO_SCALE(LR_MUX3_PU2_XO_THERM, 0)
0628     VADC_CHAN_NO_SCALE(LR_MUX4_PU2_AMUX_THM1, 0)
0629     VADC_CHAN_NO_SCALE(LR_MUX5_PU2_AMUX_THM2, 0)
0630     VADC_CHAN_NO_SCALE(LR_MUX6_PU2_AMUX_THM3, 0)
0631     VADC_CHAN_NO_SCALE(LR_MUX7_PU2_AMUX_HW_ID, 0)
0632     VADC_CHAN_NO_SCALE(LR_MUX8_PU2_AMUX_THM4, 0)
0633     VADC_CHAN_NO_SCALE(LR_MUX9_PU2_AMUX_THM5, 0)
0634     VADC_CHAN_NO_SCALE(LR_MUX10_PU2_AMUX_USB_ID, 0)
0635     VADC_CHAN_NO_SCALE(LR_MUX3_BUF_PU2_XO_THERM, 0)
0636 
0637     VADC_CHAN_NO_SCALE(LR_MUX1_PU1_PU2_BAT_THERM, 0)
0638     VADC_CHAN_NO_SCALE(LR_MUX2_PU1_PU2_BAT_ID, 0)
0639     VADC_CHAN_NO_SCALE(LR_MUX3_PU1_PU2_XO_THERM, 0)
0640     VADC_CHAN_NO_SCALE(LR_MUX4_PU1_PU2_AMUX_THM1, 0)
0641     VADC_CHAN_NO_SCALE(LR_MUX5_PU1_PU2_AMUX_THM2, 0)
0642     VADC_CHAN_NO_SCALE(LR_MUX6_PU1_PU2_AMUX_THM3, 0)
0643     VADC_CHAN_NO_SCALE(LR_MUX7_PU1_PU2_AMUX_HW_ID, 0)
0644     VADC_CHAN_NO_SCALE(LR_MUX8_PU1_PU2_AMUX_THM4, 0)
0645     VADC_CHAN_NO_SCALE(LR_MUX9_PU1_PU2_AMUX_THM5, 0)
0646     VADC_CHAN_NO_SCALE(LR_MUX10_PU1_PU2_AMUX_USB_ID, 0)
0647     VADC_CHAN_NO_SCALE(LR_MUX3_BUF_PU1_PU2_XO_THERM, 0)
0648 };
0649 
0650 static int vadc_get_dt_channel_data(struct device *dev,
0651                     struct vadc_channel_prop *prop,
0652                     struct device_node *node)
0653 {
0654     const char *name = node->name;
0655     u32 chan, value, varr[2];
0656     int ret;
0657 
0658     ret = of_property_read_u32(node, "reg", &chan);
0659     if (ret) {
0660         dev_err(dev, "invalid channel number %s\n", name);
0661         return ret;
0662     }
0663 
0664     if (chan > VADC_CHAN_MAX || chan < VADC_CHAN_MIN) {
0665         dev_err(dev, "%s invalid channel number %d\n", name, chan);
0666         return -EINVAL;
0667     }
0668 
0669     /* the channel has DT description */
0670     prop->channel = chan;
0671 
0672     ret = of_property_read_u32(node, "qcom,decimation", &value);
0673     if (!ret) {
0674         ret = qcom_vadc_decimation_from_dt(value);
0675         if (ret < 0) {
0676             dev_err(dev, "%02x invalid decimation %d\n",
0677                 chan, value);
0678             return ret;
0679         }
0680         prop->decimation = ret;
0681     } else {
0682         prop->decimation = VADC_DEF_DECIMATION;
0683     }
0684 
0685     ret = of_property_read_u32_array(node, "qcom,pre-scaling", varr, 2);
0686     if (!ret) {
0687         ret = vadc_prescaling_from_dt(varr[0], varr[1]);
0688         if (ret < 0) {
0689             dev_err(dev, "%02x invalid pre-scaling <%d %d>\n",
0690                 chan, varr[0], varr[1]);
0691             return ret;
0692         }
0693         prop->prescale = ret;
0694     } else {
0695         prop->prescale = vadc_chans[prop->channel].prescale_index;
0696     }
0697 
0698     ret = of_property_read_u32(node, "qcom,hw-settle-time", &value);
0699     if (!ret) {
0700         ret = vadc_hw_settle_time_from_dt(value);
0701         if (ret < 0) {
0702             dev_err(dev, "%02x invalid hw-settle-time %d us\n",
0703                 chan, value);
0704             return ret;
0705         }
0706         prop->hw_settle_time = ret;
0707     } else {
0708         prop->hw_settle_time = VADC_DEF_HW_SETTLE_TIME;
0709     }
0710 
0711     ret = of_property_read_u32(node, "qcom,avg-samples", &value);
0712     if (!ret) {
0713         ret = vadc_avg_samples_from_dt(value);
0714         if (ret < 0) {
0715             dev_err(dev, "%02x invalid avg-samples %d\n",
0716                 chan, value);
0717             return ret;
0718         }
0719         prop->avg_samples = ret;
0720     } else {
0721         prop->avg_samples = VADC_DEF_AVG_SAMPLES;
0722     }
0723 
0724     if (of_property_read_bool(node, "qcom,ratiometric"))
0725         prop->calibration = VADC_CALIB_RATIOMETRIC;
0726     else
0727         prop->calibration = VADC_CALIB_ABSOLUTE;
0728 
0729     dev_dbg(dev, "%02x name %s\n", chan, name);
0730 
0731     return 0;
0732 }
0733 
0734 static int vadc_get_dt_data(struct vadc_priv *vadc, struct device_node *node)
0735 {
0736     const struct vadc_channels *vadc_chan;
0737     struct iio_chan_spec *iio_chan;
0738     struct vadc_channel_prop prop;
0739     struct device_node *child;
0740     unsigned int index = 0;
0741     int ret;
0742 
0743     vadc->nchannels = of_get_available_child_count(node);
0744     if (!vadc->nchannels)
0745         return -EINVAL;
0746 
0747     vadc->iio_chans = devm_kcalloc(vadc->dev, vadc->nchannels,
0748                        sizeof(*vadc->iio_chans), GFP_KERNEL);
0749     if (!vadc->iio_chans)
0750         return -ENOMEM;
0751 
0752     vadc->chan_props = devm_kcalloc(vadc->dev, vadc->nchannels,
0753                     sizeof(*vadc->chan_props), GFP_KERNEL);
0754     if (!vadc->chan_props)
0755         return -ENOMEM;
0756 
0757     iio_chan = vadc->iio_chans;
0758 
0759     for_each_available_child_of_node(node, child) {
0760         ret = vadc_get_dt_channel_data(vadc->dev, &prop, child);
0761         if (ret) {
0762             of_node_put(child);
0763             return ret;
0764         }
0765 
0766         prop.scale_fn_type = vadc_chans[prop.channel].scale_fn_type;
0767         vadc->chan_props[index] = prop;
0768 
0769         vadc_chan = &vadc_chans[prop.channel];
0770 
0771         iio_chan->channel = prop.channel;
0772         iio_chan->datasheet_name = vadc_chan->datasheet_name;
0773         iio_chan->info_mask_separate = vadc_chan->info_mask;
0774         iio_chan->type = vadc_chan->type;
0775         iio_chan->indexed = 1;
0776         iio_chan->address = index++;
0777 
0778         iio_chan++;
0779     }
0780 
0781     /* These channels are mandatory, they are used as reference points */
0782     if (!vadc_get_channel(vadc, VADC_REF_1250MV)) {
0783         dev_err(vadc->dev, "Please define 1.25V channel\n");
0784         return -ENODEV;
0785     }
0786 
0787     if (!vadc_get_channel(vadc, VADC_REF_625MV)) {
0788         dev_err(vadc->dev, "Please define 0.625V channel\n");
0789         return -ENODEV;
0790     }
0791 
0792     if (!vadc_get_channel(vadc, VADC_VDD_VADC)) {
0793         dev_err(vadc->dev, "Please define VDD channel\n");
0794         return -ENODEV;
0795     }
0796 
0797     if (!vadc_get_channel(vadc, VADC_GND_REF)) {
0798         dev_err(vadc->dev, "Please define GND channel\n");
0799         return -ENODEV;
0800     }
0801 
0802     return 0;
0803 }
0804 
0805 static irqreturn_t vadc_isr(int irq, void *dev_id)
0806 {
0807     struct vadc_priv *vadc = dev_id;
0808 
0809     complete(&vadc->complete);
0810 
0811     return IRQ_HANDLED;
0812 }
0813 
0814 static int vadc_check_revision(struct vadc_priv *vadc)
0815 {
0816     u8 val;
0817     int ret;
0818 
0819     ret = vadc_read(vadc, VADC_PERPH_TYPE, &val);
0820     if (ret)
0821         return ret;
0822 
0823     if (val < VADC_PERPH_TYPE_ADC) {
0824         dev_err(vadc->dev, "%d is not ADC\n", val);
0825         return -ENODEV;
0826     }
0827 
0828     ret = vadc_read(vadc, VADC_PERPH_SUBTYPE, &val);
0829     if (ret)
0830         return ret;
0831 
0832     if (val < VADC_PERPH_SUBTYPE_VADC) {
0833         dev_err(vadc->dev, "%d is not VADC\n", val);
0834         return -ENODEV;
0835     }
0836 
0837     ret = vadc_read(vadc, VADC_REVISION2, &val);
0838     if (ret)
0839         return ret;
0840 
0841     if (val < VADC_REVISION2_SUPPORTED_VADC) {
0842         dev_err(vadc->dev, "revision %d not supported\n", val);
0843         return -ENODEV;
0844     }
0845 
0846     return 0;
0847 }
0848 
0849 static int vadc_probe(struct platform_device *pdev)
0850 {
0851     struct device_node *node = pdev->dev.of_node;
0852     struct device *dev = &pdev->dev;
0853     struct iio_dev *indio_dev;
0854     struct vadc_priv *vadc;
0855     struct regmap *regmap;
0856     int ret, irq_eoc;
0857     u32 reg;
0858 
0859     regmap = dev_get_regmap(dev->parent, NULL);
0860     if (!regmap)
0861         return -ENODEV;
0862 
0863     ret = of_property_read_u32(node, "reg", &reg);
0864     if (ret < 0)
0865         return ret;
0866 
0867     indio_dev = devm_iio_device_alloc(dev, sizeof(*vadc));
0868     if (!indio_dev)
0869         return -ENOMEM;
0870 
0871     vadc = iio_priv(indio_dev);
0872     vadc->regmap = regmap;
0873     vadc->dev = dev;
0874     vadc->base = reg;
0875     vadc->are_ref_measured = false;
0876     init_completion(&vadc->complete);
0877     mutex_init(&vadc->lock);
0878 
0879     ret = vadc_check_revision(vadc);
0880     if (ret)
0881         return ret;
0882 
0883     ret = vadc_get_dt_data(vadc, node);
0884     if (ret)
0885         return ret;
0886 
0887     irq_eoc = platform_get_irq(pdev, 0);
0888     if (irq_eoc < 0) {
0889         if (irq_eoc == -EPROBE_DEFER || irq_eoc == -EINVAL)
0890             return irq_eoc;
0891         vadc->poll_eoc = true;
0892     } else {
0893         ret = devm_request_irq(dev, irq_eoc, vadc_isr, 0,
0894                        "spmi-vadc", vadc);
0895         if (ret)
0896             return ret;
0897     }
0898 
0899     ret = vadc_reset(vadc);
0900     if (ret) {
0901         dev_err(dev, "reset failed\n");
0902         return ret;
0903     }
0904 
0905     ret = vadc_measure_ref_points(vadc);
0906     if (ret)
0907         return ret;
0908 
0909     indio_dev->name = pdev->name;
0910     indio_dev->modes = INDIO_DIRECT_MODE;
0911     indio_dev->info = &vadc_info;
0912     indio_dev->channels = vadc->iio_chans;
0913     indio_dev->num_channels = vadc->nchannels;
0914 
0915     return devm_iio_device_register(dev, indio_dev);
0916 }
0917 
0918 static const struct of_device_id vadc_match_table[] = {
0919     { .compatible = "qcom,spmi-vadc" },
0920     { }
0921 };
0922 MODULE_DEVICE_TABLE(of, vadc_match_table);
0923 
0924 static struct platform_driver vadc_driver = {
0925     .driver = {
0926            .name = "qcom-spmi-vadc",
0927            .of_match_table = vadc_match_table,
0928     },
0929     .probe = vadc_probe,
0930 };
0931 module_platform_driver(vadc_driver);
0932 
0933 MODULE_ALIAS("platform:qcom-spmi-vadc");
0934 MODULE_DESCRIPTION("Qualcomm SPMI PMIC voltage ADC driver");
0935 MODULE_LICENSE("GPL v2");
0936 MODULE_AUTHOR("Stanimir Varbanov <svarbanov@mm-sol.com>");
0937 MODULE_AUTHOR("Ivan T. Ivanov <iivanov@mm-sol.com>");
[ 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!