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