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
  17 DECLARE_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
  27 extern void sdelay(unsigned long loops);
  28 #endif
  29
  30 static 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
  50 static 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                 error("%s: can't enable %s-supply!", dev->name, supply_type);
  68
  69         return ret;
  70 }
  71
  72 int 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
  83 int 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
  93 int 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
 112 int 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
 131 int 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
 157 int 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
 184 int 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
 204 static 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
 232 int 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
 252 try_manual:
 253         if (ret != -ENOSYS)
 254                 return ret;
 255
 256         return _adc_channels_single_shot(dev, channel_mask, channels);
 257 }
 258
 259 static 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
 284 static 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
 303 int 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;
 315 nodev:
 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
 324 int 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;
 336 nodev:
 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
 345 static int adc_vdd_platdata_set(struct udevice *dev)
 346 {
 347         struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
 348         int ret, offset = dev->of_offset;
 349         const void *fdt = gd->fdt_blob;
 350         char *prop;
 351
 352         prop = "vdd-polarity-negative";
 353         uc_pdata->vdd_polarity_negative = fdtdec_get_bool(fdt, offset, prop);
 354
 355         ret = adc_vdd_platdata_update(dev);
 356         if (ret != -ENOENT)
 357                 return ret;
 358
 359         /* No vdd-supply phandle. */
 360         prop  = "vdd-microvolts";
 361         uc_pdata->vdd_microvolts = fdtdec_get_int(fdt, offset, prop, -ENODATA);
 362
 363         return 0;
 364 }
 365
 366 static int adc_vss_platdata_set(struct udevice *dev)
 367 {
 368         struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
 369         int ret, offset = dev->of_offset;
 370         const void *fdt = gd->fdt_blob;
 371         char *prop;
 372
 373         prop = "vss-polarity-negative";
 374         uc_pdata->vss_polarity_negative = fdtdec_get_bool(fdt, offset, prop);
 375
 376         ret = adc_vss_platdata_update(dev);
 377         if (ret != -ENOENT)
 378                 return ret;
 379
 380         /* No vss-supply phandle. */
 381         prop = "vss-microvolts";
 382         uc_pdata->vss_microvolts = fdtdec_get_int(fdt, offset, prop, -ENODATA);
 383
 384         return 0;
 385 }
 386
 387 static int adc_pre_probe(struct udevice *dev)
 388 {
 389         int ret;
 390
 391         /* Set ADC VDD platdata: polarity, uV, regulator (phandle). */
 392         ret = adc_vdd_platdata_set(dev);
 393         if (ret)
 394                 error("%s: Can't update Vdd. Error: %d", dev->name, ret);
 395
 396         /* Set ADC VSS platdata: polarity, uV, regulator (phandle). */
 397         ret = adc_vss_platdata_set(dev);
 398         if (ret)
 399                 error("%s: Can't update Vss. Error: %d", dev->name, ret);
 400
 401         return 0;
 402 }
 403
 404 UCLASS_DRIVER(adc) = {
 405         .id     = UCLASS_ADC,
 406         .name   = "adc",
 407         .pre_probe =  adc_pre_probe,
 408         .per_device_platdata_auto_alloc_size = ADC_UCLASS_PLATDATA_SIZE,
 409 };