LXR uboot/drivers/adc/adc-uclass.c

   1/*
   2 * Copyright (C) 2015 Samsung Electronics
   3 * Przemyslaw Marczak <p.marczak@samsung.com>
   4 *
   5 * SPDX-License-Identifier:     GPL-2.0+
   6 */
   7
   8#include <common.h>
   9#include <errno.h>
  10#include <dm.h>
  11#include <dm/lists.h>
  12#include <dm/device-internal.h>
  13#include <dm/uclass-internal.h>
  14#include <adc.h>
  15#include <power/regulator.h>
  16
  17DECLARE_GLOBAL_DATA_PTR;
  18
  19#define ADC_UCLASS_PLATDATA_SIZE        sizeof(struct adc_uclass_platdata)
  20#define CHECK_NUMBER                    true
  21#define CHECK_MASK                      (!CHECK_NUMBER)
  22
  23/* TODO: add support for timer uclass (for early calls) */
  24#ifdef CONFIG_SANDBOX_ARCH
  25#define sdelay(x)       udelay(x)
  26#else
  27extern void sdelay(unsigned long loops);
  28#endif
  29
  30static int check_channel(struct udevice *dev, int value, bool number_or_mask,
  31                         const char *caller_function)
  32{
  33        struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  34        unsigned mask = number_or_mask ? (1 << value) : value;
  35
  36        /* For the real ADC hardware, some ADC channels can be inactive.
  37         * For example if device has 4 analog channels, and only channels
  38         * 1-st and 3-rd are valid, then channel mask is: 0b1010, so request
  39         * with mask 0b1110 should return an error.
  40        */
  41        if ((uc_pdata->channel_mask >= mask) && (uc_pdata->channel_mask & mask))
  42                return 0;
  43
  44        printf("Error in %s/%s().\nWrong channel selection for device: %s\n",
  45               __FILE__, caller_function, dev->name);
  46
  47        return -EINVAL;
  48}
  49
  50static int adc_supply_enable(struct udevice *dev)
  51{
  52        struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  53        const char *supply_type;
  54        int ret = 0;
  55
  56        if (uc_pdata->vdd_supply) {
  57                supply_type = "vdd";
  58                ret = regulator_set_enable(uc_pdata->vdd_supply, true);
  59        }
  60
  61        if (!ret && uc_pdata->vss_supply) {
  62                supply_type = "vss";
  63                ret = regulator_set_enable(uc_pdata->vss_supply, true);
  64        }
  65
  66        if (ret)
  67                pr_err("%s: can't enable %s-supply!", dev->name, supply_type);
  68
  69        return ret;
  70}
  71
  72int adc_data_mask(struct udevice *dev, unsigned int *data_mask)
  73{
  74        struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  75
  76        if (!uc_pdata)
  77                return -ENOSYS;
  78
  79        *data_mask = uc_pdata->data_mask;
  80        return 0;
  81}
  82
  83int adc_stop(struct udevice *dev)
  84{
  85        const struct adc_ops *ops = dev_get_driver_ops(dev);
  86
  87        if (!ops->stop)
  88                return -ENOSYS;
  89
  90        return ops->stop(dev);
  91}
  92
  93int adc_start_channel(struct udevice *dev, int channel)
  94{
  95        const struct adc_ops *ops = dev_get_driver_ops(dev);
  96        int ret;
  97
  98        if (!ops->start_channel)
  99                return -ENOSYS;
 100
 101        ret = check_channel(dev, channel, CHECK_NUMBER, __func__);
 102        if (ret)
 103                return ret;
 104
 105        ret = adc_supply_enable(dev);
 106        if (ret)
 107                return ret;
 108
 109        return ops->start_channel(dev, channel);
 110}
 111
 112int adc_start_channels(struct udevice *dev, unsigned int channel_mask)
 113{
 114        const struct adc_ops *ops = dev_get_driver_ops(dev);
 115        int ret;
 116
 117        if (!ops->start_channels)
 118                return -ENOSYS;
 119
 120        ret = check_channel(dev, channel_mask, CHECK_MASK, __func__);
 121        if (ret)
 122                return ret;
 123
 124        ret = adc_supply_enable(dev);
 125        if (ret)
 126                return ret;
 127
 128        return ops->start_channels(dev, channel_mask);
 129}
 130
 131int adc_channel_data(struct udevice *dev, int channel, unsigned int *data)
 132{
 133        struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
 134        const struct adc_ops *ops = dev_get_driver_ops(dev);
 135        unsigned int timeout_us = uc_pdata->data_timeout_us;
 136        int ret;
 137
 138        if (!ops->channel_data)
 139                return -ENOSYS;
 140
 141        ret = check_channel(dev, channel, CHECK_NUMBER, __func__);
 142        if (ret)
 143                return ret;
 144
 145        do {
 146                ret = ops->channel_data(dev, channel, data);
 147                if (!ret || ret != -EBUSY)
 148                        break;
 149
 150                /* TODO: use timer uclass (for early calls). */
 151                sdelay(5);
 152        } while (timeout_us--);
 153
 154        return ret;
 155}
 156
 157int adc_channels_data(struct udevice *dev, unsigned int channel_mask,
 158                      struct adc_channel *channels)
 159{
 160        struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
 161        unsigned int timeout_us = uc_pdata->multidata_timeout_us;
 162        const struct adc_ops *ops = dev_get_driver_ops(dev);
 163        int ret;
 164
 165        if (!ops->channels_data)
 166                return -ENOSYS;
 167
 168        ret = check_channel(dev, channel_mask, CHECK_MASK, __func__);
 169        if (ret)
 170                return ret;
 171
 172        do {
 173                ret = ops->channels_data(dev, channel_mask, channels);
 174                if (!ret || ret != -EBUSY)
 175                        break;
 176
 177                /* TODO: use timer uclass (for early calls). */
 178                sdelay(5);
 179        } while (timeout_us--);
 180
 181        return ret;
 182}
 183
 184int adc_channel_single_shot(const char *name, int channel, unsigned int *data)
 185{
 186        struct udevice *dev;
 187        int ret;
 188
 189        ret = uclass_get_device_by_name(UCLASS_ADC, name, &dev);
 190        if (ret)
 191                return ret;
 192
 193        ret = adc_start_channel(dev, channel);
 194        if (ret)
 195                return ret;
 196
 197        ret = adc_channel_data(dev, channel, data);
 198        if (ret)
 199                return ret;
 200
 201        return 0;
 202}
 203
 204static int _adc_channels_single_shot(struct udevice *dev,
 205                                     unsigned int channel_mask,
 206                                     struct adc_channel *channels)
 207{
 208        unsigned int data;
 209        int channel, ret;
 210
 211        for (channel = 0; channel <= ADC_MAX_CHANNEL; channel++) {
 212                /* Check channel bit. */
 213                if (!((channel_mask >> channel) & 0x1))
 214                        continue;
 215
 216                ret = adc_start_channel(dev, channel);
 217                if (ret)
 218                        return ret;
 219
 220                ret = adc_channel_data(dev, channel, &data);
 221                if (ret)
 222                        return ret;
 223
 224                channels->id = channel;
 225                channels->data = data;
 226                channels++;
 227        }
 228
 229        return 0;
 230}
 231
 232int adc_channels_single_shot(const char *name, unsigned int channel_mask,
 233                             struct adc_channel *channels)
 234{
 235        struct udevice *dev;
 236        int ret;
 237
 238        ret = uclass_get_device_by_name(UCLASS_ADC, name, &dev);
 239        if (ret)
 240                return ret;
 241
 242        ret = adc_start_channels(dev, channel_mask);
 243        if (ret)
 244                goto try_manual;
 245
 246        ret = adc_channels_data(dev, channel_mask, channels);
 247        if (ret)
 248                return ret;
 249
 250        return 0;
 251
 252try_manual:
 253        if (ret != -ENOSYS)
 254                return ret;
 255
 256        return _adc_channels_single_shot(dev, channel_mask, channels);
 257}
 258
 259static int adc_vdd_platdata_update(struct udevice *dev)
 260{
 261        struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
 262        int ret;
 263
 264        /* Warning!
 265         * This function can't return supply device before its bind.
 266         * Please pay attention to proper fdt scan sequence. If ADC device
 267         * will bind before its supply regulator device, then the below 'get'
 268         * will return an error.
 269         */
 270        ret = device_get_supply_regulator(dev, "vdd-supply",
 271                                          &uc_pdata->vdd_supply);
 272        if (ret)
 273                return ret;
 274
 275        ret = regulator_get_value(uc_pdata->vdd_supply);
 276        if (ret < 0)
 277                return ret;
 278
 279        uc_pdata->vdd_microvolts = ret;
 280
 281        return 0;
 282}
 283
 284static int adc_vss_platdata_update(struct udevice *dev)
 285{
 286        struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
 287        int ret;
 288
 289        ret = device_get_supply_regulator(dev, "vss-supply",
 290                                          &uc_pdata->vss_supply);
 291        if (ret)
 292                return ret;
 293
 294        ret = regulator_get_value(uc_pdata->vss_supply);
 295        if (ret < 0)
 296                return ret;
 297
 298        uc_pdata->vss_microvolts = ret;
 299
 300        return 0;
 301}
 302
 303int adc_vdd_value(struct udevice *dev, int *uV)
 304{
 305        struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
 306        int ret, value_sign = uc_pdata->vdd_polarity_negative ? -1 : 1;
 307
 308        if (!uc_pdata->vdd_supply)
 309                goto nodev;
 310
 311        /* Update the regulator Value. */
 312        ret = adc_vdd_platdata_update(dev);
 313        if (ret)
 314                return ret;
 315nodev:
 316        if (uc_pdata->vdd_microvolts == -ENODATA)
 317                return -ENODATA;
 318
 319        *uV = uc_pdata->vdd_microvolts * value_sign;
 320
 321        return 0;
 322}
 323
 324int adc_vss_value(struct udevice *dev, int *uV)
 325{
 326        struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
 327        int ret, value_sign = uc_pdata->vss_polarity_negative ? -1 : 1;
 328
 329        if (!uc_pdata->vss_supply)
 330                goto nodev;
 331
 332        /* Update the regulator Value. */
 333        ret = adc_vss_platdata_update(dev);
 334        if (ret)
 335                return ret;
 336nodev:
 337        if (uc_pdata->vss_microvolts == -ENODATA)
 338                return -ENODATA;
 339
 340        *uV = uc_pdata->vss_microvolts * value_sign;
 341
 342        return 0;
 343}
 344
 345static int adc_vdd_platdata_set(struct udevice *dev)
 346{
 347        struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
 348        int ret;
 349        char *prop;
 350
 351        prop = "vdd-polarity-negative";
 352        uc_pdata->vdd_polarity_negative = dev_read_bool(dev, prop);
 353
 354        ret = adc_vdd_platdata_update(dev);
 355        if (ret != -ENOENT)
 356                return ret;
 357
 358        /* No vdd-supply phandle. */
 359        prop  = "vdd-microvolts";
 360        uc_pdata->vdd_microvolts = dev_read_u32_default(dev, prop, -ENODATA);
 361
 362        return 0;
 363}
 364
 365static int adc_vss_platdata_set(struct udevice *dev)
 366{
 367        struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
 368        int ret;
 369        char *prop;
 370
 371        prop = "vss-polarity-negative";
 372        uc_pdata->vss_polarity_negative = dev_read_bool(dev, prop);
 373
 374        ret = adc_vss_platdata_update(dev);
 375        if (ret != -ENOENT)
 376                return ret;
 377
 378        /* No vss-supply phandle. */
 379        prop = "vss-microvolts";
 380        uc_pdata->vss_microvolts = dev_read_u32_default(dev, prop, -ENODATA);
 381
 382        return 0;
 383}
 384
 385static int adc_pre_probe(struct udevice *dev)
 386{
 387        int ret;
 388
 389        /* Set ADC VDD platdata: polarity, uV, regulator (phandle). */
 390        ret = adc_vdd_platdata_set(dev);
 391        if (ret)
 392                pr_err("%s: Can't update Vdd. Error: %d", dev->name, ret);
 393
 394        /* Set ADC VSS platdata: polarity, uV, regulator (phandle). */
 395        ret = adc_vss_platdata_set(dev);
 396        if (ret)
 397                pr_err("%s: Can't update Vss. Error: %d", dev->name, ret);
 398
 399        return 0;
 400}
 401
 402UCLASS_DRIVER(adc) = {
 403        .id     = UCLASS_ADC,
 404        .name   = "adc",
 405        .pre_probe =  adc_pre_probe,
 406        .per_device_platdata_auto_alloc_size = ADC_UCLASS_PLATDATA_SIZE,
 407};
 408