drivers/adc/adc-uclass.c

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