1 /* 2 * DA9150 GPADC Driver 3 * 4 * Copyright (c) 2014 Dialog Semiconductor 5 * 6 * Author: Adam Thomson <Adam.Thomson.Opensource@diasemi.com> 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the 10 * Free Software Foundation; either version 2 of the License, or (at your 11 * option) any later version. 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/slab.h> 16 #include <linux/module.h> 17 #include <linux/platform_device.h> 18 #include <linux/interrupt.h> 19 #include <linux/mutex.h> 20 #include <linux/completion.h> 21 #include <linux/iio/iio.h> 22 #include <linux/iio/machine.h> 23 #include <linux/iio/driver.h> 24 #include <linux/mfd/da9150/core.h> 25 #include <linux/mfd/da9150/registers.h> 26 27 /* Channels */ 28 enum da9150_gpadc_hw_channel { 29 DA9150_GPADC_HW_CHAN_GPIOA_2V = 0, 30 DA9150_GPADC_HW_CHAN_GPIOA_2V_, 31 DA9150_GPADC_HW_CHAN_GPIOB_2V, 32 DA9150_GPADC_HW_CHAN_GPIOB_2V_, 33 DA9150_GPADC_HW_CHAN_GPIOC_2V, 34 DA9150_GPADC_HW_CHAN_GPIOC_2V_, 35 DA9150_GPADC_HW_CHAN_GPIOD_2V, 36 DA9150_GPADC_HW_CHAN_GPIOD_2V_, 37 DA9150_GPADC_HW_CHAN_IBUS_SENSE, 38 DA9150_GPADC_HW_CHAN_IBUS_SENSE_, 39 DA9150_GPADC_HW_CHAN_VBUS_DIV, 40 DA9150_GPADC_HW_CHAN_VBUS_DIV_, 41 DA9150_GPADC_HW_CHAN_ID, 42 DA9150_GPADC_HW_CHAN_ID_, 43 DA9150_GPADC_HW_CHAN_VSYS, 44 DA9150_GPADC_HW_CHAN_VSYS_, 45 DA9150_GPADC_HW_CHAN_GPIOA_6V, 46 DA9150_GPADC_HW_CHAN_GPIOA_6V_, 47 DA9150_GPADC_HW_CHAN_GPIOB_6V, 48 DA9150_GPADC_HW_CHAN_GPIOB_6V_, 49 DA9150_GPADC_HW_CHAN_GPIOC_6V, 50 DA9150_GPADC_HW_CHAN_GPIOC_6V_, 51 DA9150_GPADC_HW_CHAN_GPIOD_6V, 52 DA9150_GPADC_HW_CHAN_GPIOD_6V_, 53 DA9150_GPADC_HW_CHAN_VBAT, 54 DA9150_GPADC_HW_CHAN_VBAT_, 55 DA9150_GPADC_HW_CHAN_TBAT, 56 DA9150_GPADC_HW_CHAN_TBAT_, 57 DA9150_GPADC_HW_CHAN_TJUNC_CORE, 58 DA9150_GPADC_HW_CHAN_TJUNC_CORE_, 59 DA9150_GPADC_HW_CHAN_TJUNC_OVP, 60 DA9150_GPADC_HW_CHAN_TJUNC_OVP_, 61 }; 62 63 enum da9150_gpadc_channel { 64 DA9150_GPADC_CHAN_GPIOA = 0, 65 DA9150_GPADC_CHAN_GPIOB, 66 DA9150_GPADC_CHAN_GPIOC, 67 DA9150_GPADC_CHAN_GPIOD, 68 DA9150_GPADC_CHAN_IBUS, 69 DA9150_GPADC_CHAN_VBUS, 70 DA9150_GPADC_CHAN_VSYS, 71 DA9150_GPADC_CHAN_VBAT, 72 DA9150_GPADC_CHAN_TBAT, 73 DA9150_GPADC_CHAN_TJUNC_CORE, 74 DA9150_GPADC_CHAN_TJUNC_OVP, 75 }; 76 77 /* Private data */ 78 struct da9150_gpadc { 79 struct da9150 *da9150; 80 struct device *dev; 81 82 struct mutex lock; 83 struct completion complete; 84 }; 85 86 87 static irqreturn_t da9150_gpadc_irq(int irq, void *data) 88 { 89 90 struct da9150_gpadc *gpadc = data; 91 92 complete(&gpadc->complete); 93 94 return IRQ_HANDLED; 95 } 96 97 static int da9150_gpadc_read_adc(struct da9150_gpadc *gpadc, int hw_chan) 98 { 99 u8 result_regs[2]; 100 int result; 101 102 mutex_lock(&gpadc->lock); 103 104 /* Set channel & enable measurement */ 105 da9150_reg_write(gpadc->da9150, DA9150_GPADC_MAN, 106 (DA9150_GPADC_EN_MASK | 107 hw_chan << DA9150_GPADC_MUX_SHIFT)); 108 109 /* Consume left-over completion from a previous timeout */ 110 try_wait_for_completion(&gpadc->complete); 111 112 /* Check for actual completion */ 113 wait_for_completion_timeout(&gpadc->complete, msecs_to_jiffies(5)); 114 115 /* Read result and status from device */ 116 da9150_bulk_read(gpadc->da9150, DA9150_GPADC_RES_A, 2, result_regs); 117 118 mutex_unlock(&gpadc->lock); 119 120 /* Check to make sure device really has completed reading */ 121 if (result_regs[1] & DA9150_GPADC_RUN_MASK) { 122 dev_err(gpadc->dev, "Timeout on channel %d of GPADC\n", 123 hw_chan); 124 return -ETIMEDOUT; 125 } 126 127 /* LSBs - 2 bits */ 128 result = (result_regs[1] & DA9150_GPADC_RES_L_MASK) >> 129 DA9150_GPADC_RES_L_SHIFT; 130 /* MSBs - 8 bits */ 131 result |= result_regs[0] << DA9150_GPADC_RES_L_BITS; 132 133 return result; 134 } 135 136 static inline int da9150_gpadc_gpio_6v_voltage_now(int raw_val) 137 { 138 /* Convert to mV */ 139 return (6 * ((raw_val * 1000) + 500)) / 1024; 140 } 141 142 static inline int da9150_gpadc_ibus_current_avg(int raw_val) 143 { 144 /* Convert to mA */ 145 return (4 * ((raw_val * 1000) + 500)) / 2048; 146 } 147 148 static inline int da9150_gpadc_vbus_21v_voltage_now(int raw_val) 149 { 150 /* Convert to mV */ 151 return (21 * ((raw_val * 1000) + 500)) / 1024; 152 } 153 154 static inline int da9150_gpadc_vsys_6v_voltage_now(int raw_val) 155 { 156 /* Convert to mV */ 157 return (3 * ((raw_val * 1000) + 500)) / 512; 158 } 159 160 static int da9150_gpadc_read_processed(struct da9150_gpadc *gpadc, int channel, 161 int hw_chan, int *val) 162 { 163 int raw_val; 164 165 raw_val = da9150_gpadc_read_adc(gpadc, hw_chan); 166 if (raw_val < 0) 167 return raw_val; 168 169 switch (channel) { 170 case DA9150_GPADC_CHAN_GPIOA: 171 case DA9150_GPADC_CHAN_GPIOB: 172 case DA9150_GPADC_CHAN_GPIOC: 173 case DA9150_GPADC_CHAN_GPIOD: 174 *val = da9150_gpadc_gpio_6v_voltage_now(raw_val); 175 break; 176 case DA9150_GPADC_CHAN_IBUS: 177 *val = da9150_gpadc_ibus_current_avg(raw_val); 178 break; 179 case DA9150_GPADC_CHAN_VBUS: 180 *val = da9150_gpadc_vbus_21v_voltage_now(raw_val); 181 break; 182 case DA9150_GPADC_CHAN_VSYS: 183 *val = da9150_gpadc_vsys_6v_voltage_now(raw_val); 184 break; 185 default: 186 /* No processing for other channels so return raw value */ 187 *val = raw_val; 188 break; 189 } 190 191 return IIO_VAL_INT; 192 } 193 194 static int da9150_gpadc_read_scale(int channel, int *val, int *val2) 195 { 196 switch (channel) { 197 case DA9150_GPADC_CHAN_VBAT: 198 *val = 2932; 199 *val2 = 1000; 200 return IIO_VAL_FRACTIONAL; 201 case DA9150_GPADC_CHAN_TJUNC_CORE: 202 case DA9150_GPADC_CHAN_TJUNC_OVP: 203 *val = 1000000; 204 *val2 = 4420; 205 return IIO_VAL_FRACTIONAL; 206 default: 207 return -EINVAL; 208 } 209 } 210 211 static int da9150_gpadc_read_offset(int channel, int *val) 212 { 213 switch (channel) { 214 case DA9150_GPADC_CHAN_VBAT: 215 *val = 1500000 / 2932; 216 return IIO_VAL_INT; 217 case DA9150_GPADC_CHAN_TJUNC_CORE: 218 case DA9150_GPADC_CHAN_TJUNC_OVP: 219 *val = -144; 220 return IIO_VAL_INT; 221 default: 222 return -EINVAL; 223 } 224 } 225 226 static int da9150_gpadc_read_raw(struct iio_dev *indio_dev, 227 struct iio_chan_spec const *chan, 228 int *val, int *val2, long mask) 229 { 230 struct da9150_gpadc *gpadc = iio_priv(indio_dev); 231 232 if ((chan->channel < DA9150_GPADC_CHAN_GPIOA) || 233 (chan->channel > DA9150_GPADC_CHAN_TJUNC_OVP)) 234 return -EINVAL; 235 236 switch (mask) { 237 case IIO_CHAN_INFO_RAW: 238 case IIO_CHAN_INFO_PROCESSED: 239 return da9150_gpadc_read_processed(gpadc, chan->channel, 240 chan->address, val); 241 case IIO_CHAN_INFO_SCALE: 242 return da9150_gpadc_read_scale(chan->channel, val, val2); 243 case IIO_CHAN_INFO_OFFSET: 244 return da9150_gpadc_read_offset(chan->channel, val); 245 default: 246 return -EINVAL; 247 } 248 } 249 250 static const struct iio_info da9150_gpadc_info = { 251 .read_raw = &da9150_gpadc_read_raw, 252 }; 253 254 #define DA9150_GPADC_CHANNEL(_id, _hw_id, _type, chan_info, \ 255 _ext_name) { \ 256 .type = _type, \ 257 .indexed = 1, \ 258 .channel = DA9150_GPADC_CHAN_##_id, \ 259 .address = DA9150_GPADC_HW_CHAN_##_hw_id, \ 260 .info_mask_separate = chan_info, \ 261 .extend_name = _ext_name, \ 262 .datasheet_name = #_id, \ 263 } 264 265 #define DA9150_GPADC_CHANNEL_RAW(_id, _hw_id, _type, _ext_name) \ 266 DA9150_GPADC_CHANNEL(_id, _hw_id, _type, \ 267 BIT(IIO_CHAN_INFO_RAW), _ext_name) 268 269 #define DA9150_GPADC_CHANNEL_SCALED(_id, _hw_id, _type, _ext_name) \ 270 DA9150_GPADC_CHANNEL(_id, _hw_id, _type, \ 271 BIT(IIO_CHAN_INFO_RAW) | \ 272 BIT(IIO_CHAN_INFO_SCALE) | \ 273 BIT(IIO_CHAN_INFO_OFFSET), \ 274 _ext_name) 275 276 #define DA9150_GPADC_CHANNEL_PROCESSED(_id, _hw_id, _type, _ext_name) \ 277 DA9150_GPADC_CHANNEL(_id, _hw_id, _type, \ 278 BIT(IIO_CHAN_INFO_PROCESSED), _ext_name) 279 280 /* Supported channels */ 281 static const struct iio_chan_spec da9150_gpadc_channels[] = { 282 DA9150_GPADC_CHANNEL_PROCESSED(GPIOA, GPIOA_6V, IIO_VOLTAGE, NULL), 283 DA9150_GPADC_CHANNEL_PROCESSED(GPIOB, GPIOB_6V, IIO_VOLTAGE, NULL), 284 DA9150_GPADC_CHANNEL_PROCESSED(GPIOC, GPIOC_6V, IIO_VOLTAGE, NULL), 285 DA9150_GPADC_CHANNEL_PROCESSED(GPIOD, GPIOD_6V, IIO_VOLTAGE, NULL), 286 DA9150_GPADC_CHANNEL_PROCESSED(IBUS, IBUS_SENSE, IIO_CURRENT, "ibus"), 287 DA9150_GPADC_CHANNEL_PROCESSED(VBUS, VBUS_DIV_, IIO_VOLTAGE, "vbus"), 288 DA9150_GPADC_CHANNEL_PROCESSED(VSYS, VSYS, IIO_VOLTAGE, "vsys"), 289 DA9150_GPADC_CHANNEL_SCALED(VBAT, VBAT, IIO_VOLTAGE, "vbat"), 290 DA9150_GPADC_CHANNEL_RAW(TBAT, TBAT, IIO_VOLTAGE, "tbat"), 291 DA9150_GPADC_CHANNEL_SCALED(TJUNC_CORE, TJUNC_CORE, IIO_TEMP, 292 "tjunc_core"), 293 DA9150_GPADC_CHANNEL_SCALED(TJUNC_OVP, TJUNC_OVP, IIO_TEMP, 294 "tjunc_ovp"), 295 }; 296 297 /* Default maps used by da9150-charger */ 298 static struct iio_map da9150_gpadc_default_maps[] = { 299 { 300 .consumer_dev_name = "da9150-charger", 301 .consumer_channel = "CHAN_IBUS", 302 .adc_channel_label = "IBUS", 303 }, 304 { 305 .consumer_dev_name = "da9150-charger", 306 .consumer_channel = "CHAN_VBUS", 307 .adc_channel_label = "VBUS", 308 }, 309 { 310 .consumer_dev_name = "da9150-charger", 311 .consumer_channel = "CHAN_TJUNC", 312 .adc_channel_label = "TJUNC_CORE", 313 }, 314 { 315 .consumer_dev_name = "da9150-charger", 316 .consumer_channel = "CHAN_VBAT", 317 .adc_channel_label = "VBAT", 318 }, 319 {}, 320 }; 321 322 static int da9150_gpadc_probe(struct platform_device *pdev) 323 { 324 struct device *dev = &pdev->dev; 325 struct da9150 *da9150 = dev_get_drvdata(dev->parent); 326 struct da9150_gpadc *gpadc; 327 struct iio_dev *indio_dev; 328 int irq, ret; 329 330 indio_dev = devm_iio_device_alloc(dev, sizeof(*gpadc)); 331 if (!indio_dev) { 332 dev_err(&pdev->dev, "Failed to allocate IIO device\n"); 333 return -ENOMEM; 334 } 335 gpadc = iio_priv(indio_dev); 336 337 platform_set_drvdata(pdev, indio_dev); 338 gpadc->da9150 = da9150; 339 gpadc->dev = dev; 340 mutex_init(&gpadc->lock); 341 init_completion(&gpadc->complete); 342 343 irq = platform_get_irq_byname(pdev, "GPADC"); 344 if (irq < 0) { 345 dev_err(dev, "Failed to get IRQ: %d\n", irq); 346 return irq; 347 } 348 349 ret = devm_request_threaded_irq(dev, irq, NULL, da9150_gpadc_irq, 350 IRQF_ONESHOT, "GPADC", gpadc); 351 if (ret) { 352 dev_err(dev, "Failed to request IRQ %d: %d\n", irq, ret); 353 return ret; 354 } 355 356 ret = iio_map_array_register(indio_dev, da9150_gpadc_default_maps); 357 if (ret) { 358 dev_err(dev, "Failed to register IIO maps: %d\n", ret); 359 return ret; 360 } 361 362 indio_dev->name = dev_name(dev); 363 indio_dev->dev.parent = dev; 364 indio_dev->dev.of_node = pdev->dev.of_node; 365 indio_dev->info = &da9150_gpadc_info; 366 indio_dev->modes = INDIO_DIRECT_MODE; 367 indio_dev->channels = da9150_gpadc_channels; 368 indio_dev->num_channels = ARRAY_SIZE(da9150_gpadc_channels); 369 370 ret = iio_device_register(indio_dev); 371 if (ret) { 372 dev_err(dev, "Failed to register IIO device: %d\n", ret); 373 goto iio_map_unreg; 374 } 375 376 return 0; 377 378 iio_map_unreg: 379 iio_map_array_unregister(indio_dev); 380 381 return ret; 382 } 383 384 static int da9150_gpadc_remove(struct platform_device *pdev) 385 { 386 struct iio_dev *indio_dev = platform_get_drvdata(pdev); 387 388 iio_device_unregister(indio_dev); 389 iio_map_array_unregister(indio_dev); 390 391 return 0; 392 } 393 394 static struct platform_driver da9150_gpadc_driver = { 395 .driver = { 396 .name = "da9150-gpadc", 397 }, 398 .probe = da9150_gpadc_probe, 399 .remove = da9150_gpadc_remove, 400 }; 401 402 module_platform_driver(da9150_gpadc_driver); 403 404 MODULE_DESCRIPTION("GPADC Driver for DA9150"); 405 MODULE_AUTHOR("Adam Thomson <Adam.Thomson.Opensource@diasemi.com>"); 406 MODULE_LICENSE("GPL"); 407