iio/adc/da9150-gpadc.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * DA9150 GPADC Driver
0004  *
0005  * Copyright (c) 2014 Dialog Semiconductor
0006  *
0007  * Author: Adam Thomson <Adam.Thomson.Opensource@diasemi.com>
0008  */
0009
0010 #include <linux/kernel.h>
0011 #include <linux/slab.h>
0012 #include <linux/module.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/interrupt.h>
0015 #include <linux/mutex.h>
0016 #include <linux/completion.h>
0017 #include <linux/iio/iio.h>
0018 #include <linux/iio/machine.h>
0019 #include <linux/iio/driver.h>
0020 #include <linux/mfd/da9150/core.h>
0021 #include <linux/mfd/da9150/registers.h>
0022
0023 /* Channels */
0024 enum da9150_gpadc_hw_channel {
0025     DA9150_GPADC_HW_CHAN_GPIOA_2V = 0,
0026     DA9150_GPADC_HW_CHAN_GPIOA_2V_,
0027     DA9150_GPADC_HW_CHAN_GPIOB_2V,
0028     DA9150_GPADC_HW_CHAN_GPIOB_2V_,
0029     DA9150_GPADC_HW_CHAN_GPIOC_2V,
0030     DA9150_GPADC_HW_CHAN_GPIOC_2V_,
0031     DA9150_GPADC_HW_CHAN_GPIOD_2V,
0032     DA9150_GPADC_HW_CHAN_GPIOD_2V_,
0033     DA9150_GPADC_HW_CHAN_IBUS_SENSE,
0034     DA9150_GPADC_HW_CHAN_IBUS_SENSE_,
0035     DA9150_GPADC_HW_CHAN_VBUS_DIV,
0036     DA9150_GPADC_HW_CHAN_VBUS_DIV_,
0037     DA9150_GPADC_HW_CHAN_ID,
0038     DA9150_GPADC_HW_CHAN_ID_,
0039     DA9150_GPADC_HW_CHAN_VSYS,
0040     DA9150_GPADC_HW_CHAN_VSYS_,
0041     DA9150_GPADC_HW_CHAN_GPIOA_6V,
0042     DA9150_GPADC_HW_CHAN_GPIOA_6V_,
0043     DA9150_GPADC_HW_CHAN_GPIOB_6V,
0044     DA9150_GPADC_HW_CHAN_GPIOB_6V_,
0045     DA9150_GPADC_HW_CHAN_GPIOC_6V,
0046     DA9150_GPADC_HW_CHAN_GPIOC_6V_,
0047     DA9150_GPADC_HW_CHAN_GPIOD_6V,
0048     DA9150_GPADC_HW_CHAN_GPIOD_6V_,
0049     DA9150_GPADC_HW_CHAN_VBAT,
0050     DA9150_GPADC_HW_CHAN_VBAT_,
0051     DA9150_GPADC_HW_CHAN_TBAT,
0052     DA9150_GPADC_HW_CHAN_TBAT_,
0053     DA9150_GPADC_HW_CHAN_TJUNC_CORE,
0054     DA9150_GPADC_HW_CHAN_TJUNC_CORE_,
0055     DA9150_GPADC_HW_CHAN_TJUNC_OVP,
0056     DA9150_GPADC_HW_CHAN_TJUNC_OVP_,
0057 };
0058
0059 enum da9150_gpadc_channel {
0060     DA9150_GPADC_CHAN_GPIOA = 0,
0061     DA9150_GPADC_CHAN_GPIOB,
0062     DA9150_GPADC_CHAN_GPIOC,
0063     DA9150_GPADC_CHAN_GPIOD,
0064     DA9150_GPADC_CHAN_IBUS,
0065     DA9150_GPADC_CHAN_VBUS,
0066     DA9150_GPADC_CHAN_VSYS,
0067     DA9150_GPADC_CHAN_VBAT,
0068     DA9150_GPADC_CHAN_TBAT,
0069     DA9150_GPADC_CHAN_TJUNC_CORE,
0070     DA9150_GPADC_CHAN_TJUNC_OVP,
0071 };
0072
0073 /* Private data */
0074 struct da9150_gpadc {
0075     struct da9150 *da9150;
0076     struct device *dev;
0077
0078     struct mutex lock;
0079     struct completion complete;
0080 };
0081
0082
0083 static irqreturn_t da9150_gpadc_irq(int irq, void *data)
0084 {
0085
0086     struct da9150_gpadc *gpadc = data;
0087
0088     complete(&gpadc->complete);
0089
0090     return IRQ_HANDLED;
0091 }
0092
0093 static int da9150_gpadc_read_adc(struct da9150_gpadc *gpadc, int hw_chan)
0094 {
0095     u8 result_regs[2];
0096     int result;
0097
0098     mutex_lock(&gpadc->lock);
0099
0100     /* Set channel & enable measurement */
0101     da9150_reg_write(gpadc->da9150, DA9150_GPADC_MAN,
0102              (DA9150_GPADC_EN_MASK |
0103               hw_chan << DA9150_GPADC_MUX_SHIFT));
0104
0105     /* Consume left-over completion from a previous timeout */
0106     try_wait_for_completion(&gpadc->complete);
0107
0108     /* Check for actual completion */
0109     wait_for_completion_timeout(&gpadc->complete, msecs_to_jiffies(5));
0110
0111     /* Read result and status from device */
0112     da9150_bulk_read(gpadc->da9150, DA9150_GPADC_RES_A, 2, result_regs);
0113
0114     mutex_unlock(&gpadc->lock);
0115
0116     /* Check to make sure device really has completed reading */
0117     if (result_regs[1] & DA9150_GPADC_RUN_MASK) {
0118         dev_err(gpadc->dev, "Timeout on channel %d of GPADC\n",
0119             hw_chan);
0120         return -ETIMEDOUT;
0121     }
0122
0123     /* LSBs - 2 bits */
0124     result = (result_regs[1] & DA9150_GPADC_RES_L_MASK) >>
0125          DA9150_GPADC_RES_L_SHIFT;
0126     /* MSBs - 8 bits */
0127     result |= result_regs[0] << DA9150_GPADC_RES_L_BITS;
0128
0129     return result;
0130 }
0131
0132 static inline int da9150_gpadc_gpio_6v_voltage_now(int raw_val)
0133 {
0134     /* Convert to mV */
0135     return (6 * ((raw_val * 1000) + 500)) / 1024;
0136 }
0137
0138 static inline int da9150_gpadc_ibus_current_avg(int raw_val)
0139 {
0140     /* Convert to mA */
0141     return (4 * ((raw_val * 1000) + 500)) / 2048;
0142 }
0143
0144 static inline int da9150_gpadc_vbus_21v_voltage_now(int raw_val)
0145 {
0146     /* Convert to mV */
0147     return (21 * ((raw_val * 1000) + 500)) / 1024;
0148 }
0149
0150 static inline int da9150_gpadc_vsys_6v_voltage_now(int raw_val)
0151 {
0152     /* Convert to mV */
0153     return (3 * ((raw_val * 1000) + 500)) / 512;
0154 }
0155
0156 static int da9150_gpadc_read_processed(struct da9150_gpadc *gpadc, int channel,
0157                        int hw_chan, int *val)
0158 {
0159     int raw_val;
0160
0161     raw_val = da9150_gpadc_read_adc(gpadc, hw_chan);
0162     if (raw_val < 0)
0163         return raw_val;
0164
0165     switch (channel) {
0166     case DA9150_GPADC_CHAN_GPIOA:
0167     case DA9150_GPADC_CHAN_GPIOB:
0168     case DA9150_GPADC_CHAN_GPIOC:
0169     case DA9150_GPADC_CHAN_GPIOD:
0170         *val = da9150_gpadc_gpio_6v_voltage_now(raw_val);
0171         break;
0172     case DA9150_GPADC_CHAN_IBUS:
0173         *val = da9150_gpadc_ibus_current_avg(raw_val);
0174         break;
0175     case DA9150_GPADC_CHAN_VBUS:
0176         *val = da9150_gpadc_vbus_21v_voltage_now(raw_val);
0177         break;
0178     case DA9150_GPADC_CHAN_VSYS:
0179         *val = da9150_gpadc_vsys_6v_voltage_now(raw_val);
0180         break;
0181     default:
0182         /* No processing for other channels so return raw value */
0183         *val = raw_val;
0184         break;
0185     }
0186
0187     return IIO_VAL_INT;
0188 }
0189
0190 static int da9150_gpadc_read_scale(int channel, int *val, int *val2)
0191 {
0192     switch (channel) {
0193     case DA9150_GPADC_CHAN_VBAT:
0194         *val = 2932;
0195         *val2 = 1000;
0196         return IIO_VAL_FRACTIONAL;
0197     case DA9150_GPADC_CHAN_TJUNC_CORE:
0198     case DA9150_GPADC_CHAN_TJUNC_OVP:
0199         *val = 1000000;
0200         *val2 = 4420;
0201         return IIO_VAL_FRACTIONAL;
0202     default:
0203         return -EINVAL;
0204     }
0205 }
0206
0207 static int da9150_gpadc_read_offset(int channel, int *val)
0208 {
0209     switch (channel) {
0210     case DA9150_GPADC_CHAN_VBAT:
0211         *val = 1500000 / 2932;
0212         return IIO_VAL_INT;
0213     case DA9150_GPADC_CHAN_TJUNC_CORE:
0214     case DA9150_GPADC_CHAN_TJUNC_OVP:
0215         *val = -144;
0216         return IIO_VAL_INT;
0217     default:
0218         return -EINVAL;
0219     }
0220 }
0221
0222 static int da9150_gpadc_read_raw(struct iio_dev *indio_dev,
0223                  struct iio_chan_spec const *chan,
0224                  int *val, int *val2, long mask)
0225 {
0226     struct da9150_gpadc *gpadc = iio_priv(indio_dev);
0227
0228     if ((chan->channel < DA9150_GPADC_CHAN_GPIOA) ||
0229         (chan->channel > DA9150_GPADC_CHAN_TJUNC_OVP))
0230         return -EINVAL;
0231
0232     switch (mask) {
0233     case IIO_CHAN_INFO_RAW:
0234     case IIO_CHAN_INFO_PROCESSED:
0235         return da9150_gpadc_read_processed(gpadc, chan->channel,
0236                            chan->address, val);
0237     case IIO_CHAN_INFO_SCALE:
0238         return da9150_gpadc_read_scale(chan->channel, val, val2);
0239     case IIO_CHAN_INFO_OFFSET:
0240         return da9150_gpadc_read_offset(chan->channel, val);
0241     default:
0242         return -EINVAL;
0243     }
0244 }
0245
0246 static const struct iio_info da9150_gpadc_info = {
0247     .read_raw = &da9150_gpadc_read_raw,
0248 };
0249
0250 #define DA9150_GPADC_CHANNEL(_id, _hw_id, _type, chan_info, \
0251                  _ext_name) {           \
0252     .type = _type,                      \
0253     .indexed = 1,                       \
0254     .channel = DA9150_GPADC_CHAN_##_id,         \
0255     .address = DA9150_GPADC_HW_CHAN_##_hw_id,       \
0256     .info_mask_separate = chan_info,            \
0257     .extend_name = _ext_name,               \
0258     .datasheet_name = #_id,                 \
0259 }
0260
0261 #define DA9150_GPADC_CHANNEL_RAW(_id, _hw_id, _type, _ext_name) \
0262     DA9150_GPADC_CHANNEL(_id, _hw_id, _type,        \
0263                  BIT(IIO_CHAN_INFO_RAW), _ext_name)
0264
0265 #define DA9150_GPADC_CHANNEL_SCALED(_id, _hw_id, _type, _ext_name)  \
0266     DA9150_GPADC_CHANNEL(_id, _hw_id, _type,            \
0267                  BIT(IIO_CHAN_INFO_RAW) |           \
0268                  BIT(IIO_CHAN_INFO_SCALE) |         \
0269                  BIT(IIO_CHAN_INFO_OFFSET),         \
0270                  _ext_name)
0271
0272 #define DA9150_GPADC_CHANNEL_PROCESSED(_id, _hw_id, _type, _ext_name)   \
0273     DA9150_GPADC_CHANNEL(_id, _hw_id, _type,            \
0274                  BIT(IIO_CHAN_INFO_PROCESSED), _ext_name)
0275
0276 /* Supported channels */
0277 static const struct iio_chan_spec da9150_gpadc_channels[] = {
0278     DA9150_GPADC_CHANNEL_PROCESSED(GPIOA, GPIOA_6V, IIO_VOLTAGE, NULL),
0279     DA9150_GPADC_CHANNEL_PROCESSED(GPIOB, GPIOB_6V, IIO_VOLTAGE, NULL),
0280     DA9150_GPADC_CHANNEL_PROCESSED(GPIOC, GPIOC_6V, IIO_VOLTAGE, NULL),
0281     DA9150_GPADC_CHANNEL_PROCESSED(GPIOD, GPIOD_6V, IIO_VOLTAGE, NULL),
0282     DA9150_GPADC_CHANNEL_PROCESSED(IBUS, IBUS_SENSE, IIO_CURRENT, "ibus"),
0283     DA9150_GPADC_CHANNEL_PROCESSED(VBUS, VBUS_DIV_, IIO_VOLTAGE, "vbus"),
0284     DA9150_GPADC_CHANNEL_PROCESSED(VSYS, VSYS, IIO_VOLTAGE, "vsys"),
0285     DA9150_GPADC_CHANNEL_SCALED(VBAT, VBAT, IIO_VOLTAGE, "vbat"),
0286     DA9150_GPADC_CHANNEL_RAW(TBAT, TBAT, IIO_VOLTAGE, "tbat"),
0287     DA9150_GPADC_CHANNEL_SCALED(TJUNC_CORE, TJUNC_CORE, IIO_TEMP,
0288                     "tjunc_core"),
0289     DA9150_GPADC_CHANNEL_SCALED(TJUNC_OVP, TJUNC_OVP, IIO_TEMP,
0290                     "tjunc_ovp"),
0291 };
0292
0293 /* Default maps used by da9150-charger */
0294 static struct iio_map da9150_gpadc_default_maps[] = {
0295     {
0296         .consumer_dev_name = "da9150-charger",
0297         .consumer_channel = "CHAN_IBUS",
0298         .adc_channel_label = "IBUS",
0299     },
0300     {
0301         .consumer_dev_name = "da9150-charger",
0302         .consumer_channel = "CHAN_VBUS",
0303         .adc_channel_label = "VBUS",
0304     },
0305     {
0306         .consumer_dev_name = "da9150-charger",
0307         .consumer_channel = "CHAN_TJUNC",
0308         .adc_channel_label = "TJUNC_CORE",
0309     },
0310     {
0311         .consumer_dev_name = "da9150-charger",
0312         .consumer_channel = "CHAN_VBAT",
0313         .adc_channel_label = "VBAT",
0314     },
0315     {},
0316 };
0317
0318 static int da9150_gpadc_probe(struct platform_device *pdev)
0319 {
0320     struct device *dev = &pdev->dev;
0321     struct da9150 *da9150 = dev_get_drvdata(dev->parent);
0322     struct da9150_gpadc *gpadc;
0323     struct iio_dev *indio_dev;
0324     int irq, ret;
0325
0326     indio_dev = devm_iio_device_alloc(dev, sizeof(*gpadc));
0327     if (!indio_dev) {
0328         dev_err(&pdev->dev, "Failed to allocate IIO device\n");
0329         return -ENOMEM;
0330     }
0331     gpadc = iio_priv(indio_dev);
0332
0333     gpadc->da9150 = da9150;
0334     gpadc->dev = dev;
0335     mutex_init(&gpadc->lock);
0336     init_completion(&gpadc->complete);
0337
0338     irq = platform_get_irq_byname(pdev, "GPADC");
0339     if (irq < 0)
0340         return irq;
0341
0342     ret = devm_request_threaded_irq(dev, irq, NULL, da9150_gpadc_irq,
0343                     IRQF_ONESHOT, "GPADC", gpadc);
0344     if (ret) {
0345         dev_err(dev, "Failed to request IRQ %d: %d\n", irq, ret);
0346         return ret;
0347     }
0348
0349     ret = devm_iio_map_array_register(&pdev->dev, indio_dev, da9150_gpadc_default_maps);
0350     if (ret) {
0351         dev_err(dev, "Failed to register IIO maps: %d\n", ret);
0352         return ret;
0353     }
0354
0355     indio_dev->name = dev_name(dev);
0356     indio_dev->info = &da9150_gpadc_info;
0357     indio_dev->modes = INDIO_DIRECT_MODE;
0358     indio_dev->channels = da9150_gpadc_channels;
0359     indio_dev->num_channels = ARRAY_SIZE(da9150_gpadc_channels);
0360
0361     return devm_iio_device_register(&pdev->dev, indio_dev);
0362 }
0363
0364 static struct platform_driver da9150_gpadc_driver = {
0365     .driver = {
0366         .name = "da9150-gpadc",
0367     },
0368     .probe = da9150_gpadc_probe,
0369 };
0370
0371 module_platform_driver(da9150_gpadc_driver);
0372
0373 MODULE_DESCRIPTION("GPADC Driver for DA9150");
0374 MODULE_AUTHOR("Adam Thomson <Adam.Thomson.Opensource@diasemi.com>");
0375 MODULE_LICENSE("GPL");