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 pr_err("%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; 349 char *prop; 350 351 prop = "vdd-polarity-negative"; 352 uc_pdata->vdd_polarity_negative = dev_read_bool(dev, prop); 353 354 ret = adc_vdd_platdata_update(dev); 355 if (ret != -ENOENT) 356 return ret; 357 358 /* No vdd-supply phandle. */ 359 prop = "vdd-microvolts"; 360 uc_pdata->vdd_microvolts = dev_read_u32_default(dev, prop, -ENODATA); 361 362 return 0; 363 } 364 365 static int adc_vss_platdata_set(struct udevice *dev) 366 { 367 struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev); 368 int ret; 369 char *prop; 370 371 prop = "vss-polarity-negative"; 372 uc_pdata->vss_polarity_negative = dev_read_bool(dev, prop); 373 374 ret = adc_vss_platdata_update(dev); 375 if (ret != -ENOENT) 376 return ret; 377 378 /* No vss-supply phandle. */ 379 prop = "vss-microvolts"; 380 uc_pdata->vss_microvolts = dev_read_u32_default(dev, prop, -ENODATA); 381 382 return 0; 383 } 384 385 static int adc_pre_probe(struct udevice *dev) 386 { 387 int ret; 388 389 /* Set ADC VDD platdata: polarity, uV, regulator (phandle). */ 390 ret = adc_vdd_platdata_set(dev); 391 if (ret) 392 pr_err("%s: Can't update Vdd. Error: %d", dev->name, ret); 393 394 /* Set ADC VSS platdata: polarity, uV, regulator (phandle). */ 395 ret = adc_vss_platdata_set(dev); 396 if (ret) 397 pr_err("%s: Can't update Vss. Error: %d", dev->name, ret); 398 399 return 0; 400 } 401 402 UCLASS_DRIVER(adc) = { 403 .id = UCLASS_ADC, 404 .name = "adc", 405 .pre_probe = adc_pre_probe, 406 .per_device_platdata_auto_alloc_size = ADC_UCLASS_PLATDATA_SIZE, 407 }; 408