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 #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_stop(struct udevice *dev) 82 { 83 const struct adc_ops *ops = dev_get_driver_ops(dev); 84 85 if (!ops->stop) 86 return -ENOSYS; 87 88 return ops->stop(dev); 89 } 90 91 int adc_start_channel(struct udevice *dev, int channel) 92 { 93 const struct adc_ops *ops = dev_get_driver_ops(dev); 94 int ret; 95 96 if (!ops->start_channel) 97 return -ENOSYS; 98 99 ret = check_channel(dev, channel, CHECK_NUMBER, __func__); 100 if (ret) 101 return ret; 102 103 ret = adc_supply_enable(dev); 104 if (ret) 105 return ret; 106 107 return ops->start_channel(dev, channel); 108 } 109 110 int adc_start_channels(struct udevice *dev, unsigned int channel_mask) 111 { 112 const struct adc_ops *ops = dev_get_driver_ops(dev); 113 int ret; 114 115 if (!ops->start_channels) 116 return -ENOSYS; 117 118 ret = check_channel(dev, channel_mask, CHECK_MASK, __func__); 119 if (ret) 120 return ret; 121 122 ret = adc_supply_enable(dev); 123 if (ret) 124 return ret; 125 126 return ops->start_channels(dev, channel_mask); 127 } 128 129 int adc_channel_data(struct udevice *dev, int channel, unsigned int *data) 130 { 131 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev); 132 const struct adc_ops *ops = dev_get_driver_ops(dev); 133 unsigned int timeout_us = uc_pdata->data_timeout_us; 134 int ret; 135 136 if (!ops->channel_data) 137 return -ENOSYS; 138 139 ret = check_channel(dev, channel, CHECK_NUMBER, __func__); 140 if (ret) 141 return ret; 142 143 do { 144 ret = ops->channel_data(dev, channel, data); 145 if (!ret || ret != -EBUSY) 146 break; 147 148 /* TODO: use timer uclass (for early calls). */ 149 sdelay(5); 150 } while (timeout_us--); 151 152 return ret; 153 } 154 155 int adc_channels_data(struct udevice *dev, unsigned int channel_mask, 156 struct adc_channel *channels) 157 { 158 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev); 159 unsigned int timeout_us = uc_pdata->multidata_timeout_us; 160 const struct adc_ops *ops = dev_get_driver_ops(dev); 161 int ret; 162 163 if (!ops->channels_data) 164 return -ENOSYS; 165 166 ret = check_channel(dev, channel_mask, CHECK_MASK, __func__); 167 if (ret) 168 return ret; 169 170 do { 171 ret = ops->channels_data(dev, channel_mask, channels); 172 if (!ret || ret != -EBUSY) 173 break; 174 175 /* TODO: use timer uclass (for early calls). */ 176 sdelay(5); 177 } while (timeout_us--); 178 179 return ret; 180 } 181 182 int adc_channel_single_shot(const char *name, int channel, unsigned int *data) 183 { 184 struct udevice *dev; 185 int ret; 186 187 ret = uclass_get_device_by_name(UCLASS_ADC, name, &dev); 188 if (ret) 189 return ret; 190 191 ret = adc_start_channel(dev, channel); 192 if (ret) 193 return ret; 194 195 ret = adc_channel_data(dev, channel, data); 196 if (ret) 197 return ret; 198 199 return 0; 200 } 201 202 static int _adc_channels_single_shot(struct udevice *dev, 203 unsigned int channel_mask, 204 struct adc_channel *channels) 205 { 206 unsigned int data; 207 int channel, ret; 208 209 for (channel = 0; channel <= ADC_MAX_CHANNEL; channel++) { 210 /* Check channel bit. */ 211 if (!((channel_mask >> channel) & 0x1)) 212 continue; 213 214 ret = adc_start_channel(dev, channel); 215 if (ret) 216 return ret; 217 218 ret = adc_channel_data(dev, channel, &data); 219 if (ret) 220 return ret; 221 222 channels->id = channel; 223 channels->data = data; 224 channels++; 225 } 226 227 return 0; 228 } 229 230 int adc_channels_single_shot(const char *name, unsigned int channel_mask, 231 struct adc_channel *channels) 232 { 233 struct udevice *dev; 234 int ret; 235 236 ret = uclass_get_device_by_name(UCLASS_ADC, name, &dev); 237 if (ret) 238 return ret; 239 240 ret = adc_start_channels(dev, channel_mask); 241 if (ret) 242 goto try_manual; 243 244 ret = adc_channels_data(dev, channel_mask, channels); 245 if (ret) 246 return ret; 247 248 return 0; 249 250 try_manual: 251 if (ret != -ENOSYS) 252 return ret; 253 254 return _adc_channels_single_shot(dev, channel_mask, channels); 255 } 256 257 static int adc_vdd_platdata_update(struct udevice *dev) 258 { 259 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev); 260 int ret; 261 262 /* Warning! 263 * This function can't return supply device before its bind. 264 * Please pay attention to proper fdt scan sequence. If ADC device 265 * will bind before its supply regulator device, then the below 'get' 266 * will return an error. 267 */ 268 ret = device_get_supply_regulator(dev, "vdd-supply", 269 &uc_pdata->vdd_supply); 270 if (ret) 271 return ret; 272 273 ret = regulator_get_value(uc_pdata->vdd_supply); 274 if (ret < 0) 275 return ret; 276 277 uc_pdata->vdd_microvolts = ret; 278 279 return 0; 280 } 281 282 static int adc_vss_platdata_update(struct udevice *dev) 283 { 284 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev); 285 int ret; 286 287 ret = device_get_supply_regulator(dev, "vss-supply", 288 &uc_pdata->vss_supply); 289 if (ret) 290 return ret; 291 292 ret = regulator_get_value(uc_pdata->vss_supply); 293 if (ret < 0) 294 return ret; 295 296 uc_pdata->vss_microvolts = ret; 297 298 return 0; 299 } 300 301 int adc_vdd_value(struct udevice *dev, int *uV) 302 { 303 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev); 304 int ret, value_sign = uc_pdata->vdd_polarity_negative ? -1 : 1; 305 306 if (!uc_pdata->vdd_supply) 307 goto nodev; 308 309 /* Update the regulator Value. */ 310 ret = adc_vdd_platdata_update(dev); 311 if (ret) 312 return ret; 313 nodev: 314 if (uc_pdata->vdd_microvolts == -ENODATA) 315 return -ENODATA; 316 317 *uV = uc_pdata->vdd_microvolts * value_sign; 318 319 return 0; 320 } 321 322 int adc_vss_value(struct udevice *dev, int *uV) 323 { 324 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev); 325 int ret, value_sign = uc_pdata->vss_polarity_negative ? -1 : 1; 326 327 if (!uc_pdata->vss_supply) 328 goto nodev; 329 330 /* Update the regulator Value. */ 331 ret = adc_vss_platdata_update(dev); 332 if (ret) 333 return ret; 334 nodev: 335 if (uc_pdata->vss_microvolts == -ENODATA) 336 return -ENODATA; 337 338 *uV = uc_pdata->vss_microvolts * value_sign; 339 340 return 0; 341 } 342 343 static int adc_vdd_platdata_set(struct udevice *dev) 344 { 345 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev); 346 int ret; 347 char *prop; 348 349 prop = "vdd-polarity-negative"; 350 uc_pdata->vdd_polarity_negative = dev_read_bool(dev, prop); 351 352 ret = adc_vdd_platdata_update(dev); 353 if (ret != -ENOENT) 354 return ret; 355 356 /* No vdd-supply phandle. */ 357 prop = "vdd-microvolts"; 358 uc_pdata->vdd_microvolts = dev_read_u32_default(dev, prop, -ENODATA); 359 360 return 0; 361 } 362 363 static int adc_vss_platdata_set(struct udevice *dev) 364 { 365 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev); 366 int ret; 367 char *prop; 368 369 prop = "vss-polarity-negative"; 370 uc_pdata->vss_polarity_negative = dev_read_bool(dev, prop); 371 372 ret = adc_vss_platdata_update(dev); 373 if (ret != -ENOENT) 374 return ret; 375 376 /* No vss-supply phandle. */ 377 prop = "vss-microvolts"; 378 uc_pdata->vss_microvolts = dev_read_u32_default(dev, prop, -ENODATA); 379 380 return 0; 381 } 382 383 static int adc_pre_probe(struct udevice *dev) 384 { 385 int ret; 386 387 /* Set ADC VDD platdata: polarity, uV, regulator (phandle). */ 388 ret = adc_vdd_platdata_set(dev); 389 if (ret) 390 pr_err("%s: Can't update Vdd. Error: %d", dev->name, ret); 391 392 /* Set ADC VSS platdata: polarity, uV, regulator (phandle). */ 393 ret = adc_vss_platdata_set(dev); 394 if (ret) 395 pr_err("%s: Can't update Vss. Error: %d", dev->name, ret); 396 397 return 0; 398 } 399 400 UCLASS_DRIVER(adc) = { 401 .id = UCLASS_ADC, 402 .name = "adc", 403 .pre_probe = adc_pre_probe, 404 .per_device_platdata_auto_alloc_size = ADC_UCLASS_PLATDATA_SIZE, 405 }; 406