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