1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * STMicroelectronics STMPE811 IIO ADC Driver 4 * 5 * 4 channel, 10/12-bit ADC 6 * 7 * Copyright (C) 2013-2018 Toradex AG <stefan.agner@toradex.com> 8 */ 9 10 #include <linux/completion.h> 11 #include <linux/err.h> 12 #include <linux/iio/iio.h> 13 #include <linux/interrupt.h> 14 #include <linux/kernel.h> 15 #include <linux/mfd/stmpe.h> 16 #include <linux/module.h> 17 #include <linux/of_platform.h> 18 #include <linux/platform_device.h> 19 #include <linux/device.h> 20 21 #define STMPE_REG_INT_STA 0x0B 22 #define STMPE_REG_ADC_INT_EN 0x0E 23 #define STMPE_REG_ADC_INT_STA 0x0F 24 25 #define STMPE_REG_ADC_CTRL1 0x20 26 #define STMPE_REG_ADC_CTRL2 0x21 27 #define STMPE_REG_ADC_CAPT 0x22 28 #define STMPE_REG_ADC_DATA_CH(channel) (0x30 + 2 * (channel)) 29 30 #define STMPE_REG_TEMP_CTRL 0x60 31 #define STMPE_TEMP_CTRL_ENABLE BIT(0) 32 #define STMPE_TEMP_CTRL_ACQ BIT(1) 33 #define STMPE_TEMP_CTRL_THRES_EN BIT(3) 34 #define STMPE_START_ONE_TEMP_CONV (STMPE_TEMP_CTRL_ENABLE | \ 35 STMPE_TEMP_CTRL_ACQ | \ 36 STMPE_TEMP_CTRL_THRES_EN) 37 #define STMPE_REG_TEMP_DATA 0x61 38 #define STMPE_REG_TEMP_TH 0x63 39 #define STMPE_ADC_LAST_NR 7 40 #define STMPE_TEMP_CHANNEL (STMPE_ADC_LAST_NR + 1) 41 42 #define STMPE_ADC_CH(channel) ((1 << (channel)) & 0xff) 43 44 #define STMPE_ADC_TIMEOUT msecs_to_jiffies(1000) 45 46 struct stmpe_adc { 47 struct stmpe *stmpe; 48 struct clk *clk; 49 struct device *dev; 50 struct mutex lock; 51 52 /* We are allocating plus one for the temperature channel */ 53 struct iio_chan_spec stmpe_adc_iio_channels[STMPE_ADC_LAST_NR + 2]; 54 55 struct completion completion; 56 57 u8 channel; 58 u32 value; 59 }; 60 61 static int stmpe_read_voltage(struct stmpe_adc *info, 62 struct iio_chan_spec const *chan, int *val) 63 { 64 long ret; 65 66 mutex_lock(&info->lock); 67 68 reinit_completion(&info->completion); 69 70 info->channel = (u8)chan->channel; 71 72 if (info->channel > STMPE_ADC_LAST_NR) { 73 mutex_unlock(&info->lock); 74 return -EINVAL; 75 } 76 77 stmpe_reg_write(info->stmpe, STMPE_REG_ADC_CAPT, 78 STMPE_ADC_CH(info->channel)); 79 80 ret = wait_for_completion_timeout(&info->completion, STMPE_ADC_TIMEOUT); 81 82 if (ret <= 0) { 83 stmpe_reg_write(info->stmpe, STMPE_REG_ADC_INT_STA, 84 STMPE_ADC_CH(info->channel)); 85 mutex_unlock(&info->lock); 86 return -ETIMEDOUT; 87 } 88 89 *val = info->value; 90 91 mutex_unlock(&info->lock); 92 93 return 0; 94 } 95 96 static int stmpe_read_temp(struct stmpe_adc *info, 97 struct iio_chan_spec const *chan, int *val) 98 { 99 long ret; 100 101 mutex_lock(&info->lock); 102 103 reinit_completion(&info->completion); 104 105 info->channel = (u8)chan->channel; 106 107 if (info->channel != STMPE_TEMP_CHANNEL) { 108 mutex_unlock(&info->lock); 109 return -EINVAL; 110 } 111 112 stmpe_reg_write(info->stmpe, STMPE_REG_TEMP_CTRL, 113 STMPE_START_ONE_TEMP_CONV); 114 115 ret = wait_for_completion_timeout(&info->completion, STMPE_ADC_TIMEOUT); 116 117 if (ret <= 0) { 118 mutex_unlock(&info->lock); 119 return -ETIMEDOUT; 120 } 121 122 /* 123 * absolute temp = +V3.3 * value /7.51 [K] 124 * scale to [milli °C] 125 */ 126 *val = ((449960l * info->value) / 1024l) - 273150; 127 128 mutex_unlock(&info->lock); 129 130 return 0; 131 } 132 133 static int stmpe_read_raw(struct iio_dev *indio_dev, 134 struct iio_chan_spec const *chan, 135 int *val, 136 int *val2, 137 long mask) 138 { 139 struct stmpe_adc *info = iio_priv(indio_dev); 140 long ret; 141 142 switch (mask) { 143 case IIO_CHAN_INFO_RAW: 144 case IIO_CHAN_INFO_PROCESSED: 145 146 switch (chan->type) { 147 case IIO_VOLTAGE: 148 ret = stmpe_read_voltage(info, chan, val); 149 break; 150 151 case IIO_TEMP: 152 ret = stmpe_read_temp(info, chan, val); 153 break; 154 default: 155 return -EINVAL; 156 } 157 158 if (ret < 0) 159 return ret; 160 161 return IIO_VAL_INT; 162 163 case IIO_CHAN_INFO_SCALE: 164 *val = 3300; 165 *val2 = info->stmpe->mod_12b ? 12 : 10; 166 return IIO_VAL_FRACTIONAL_LOG2; 167 168 default: 169 break; 170 } 171 172 return -EINVAL; 173 } 174 175 static irqreturn_t stmpe_adc_isr(int irq, void *dev_id) 176 { 177 struct stmpe_adc *info = (struct stmpe_adc *)dev_id; 178 __be16 data; 179 180 if (info->channel <= STMPE_ADC_LAST_NR) { 181 int int_sta; 182 183 int_sta = stmpe_reg_read(info->stmpe, STMPE_REG_ADC_INT_STA); 184 185 /* Is the interrupt relevant */ 186 if (!(int_sta & STMPE_ADC_CH(info->channel))) 187 return IRQ_NONE; 188 189 /* Read value */ 190 stmpe_block_read(info->stmpe, 191 STMPE_REG_ADC_DATA_CH(info->channel), 2, (u8 *) &data); 192 193 stmpe_reg_write(info->stmpe, STMPE_REG_ADC_INT_STA, int_sta); 194 } else if (info->channel == STMPE_TEMP_CHANNEL) { 195 /* Read value */ 196 stmpe_block_read(info->stmpe, STMPE_REG_TEMP_DATA, 2, 197 (u8 *) &data); 198 } else { 199 return IRQ_NONE; 200 } 201 202 info->value = (u32) be16_to_cpu(data); 203 complete(&info->completion); 204 205 return IRQ_HANDLED; 206 } 207 208 static const struct iio_info stmpe_adc_iio_info = { 209 .read_raw = &stmpe_read_raw, 210 }; 211 212 static void stmpe_adc_voltage_chan(struct iio_chan_spec *ics, int chan) 213 { 214 ics->type = IIO_VOLTAGE; 215 ics->info_mask_separate = BIT(IIO_CHAN_INFO_RAW); 216 ics->info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE); 217 ics->indexed = 1; 218 ics->channel = chan; 219 } 220 221 static void stmpe_adc_temp_chan(struct iio_chan_spec *ics, int chan) 222 { 223 ics->type = IIO_TEMP; 224 ics->info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED); 225 ics->indexed = 1; 226 ics->channel = chan; 227 } 228 229 static int stmpe_adc_init_hw(struct stmpe_adc *adc) 230 { 231 int ret; 232 struct stmpe *stmpe = adc->stmpe; 233 234 ret = stmpe_enable(stmpe, STMPE_BLOCK_ADC); 235 if (ret) { 236 dev_err(stmpe->dev, "Could not enable clock for ADC\n"); 237 return ret; 238 } 239 240 ret = stmpe811_adc_common_init(stmpe); 241 if (ret) { 242 stmpe_disable(stmpe, STMPE_BLOCK_ADC); 243 return ret; 244 } 245 246 /* use temp irq for each conversion completion */ 247 stmpe_reg_write(stmpe, STMPE_REG_TEMP_TH, 0); 248 stmpe_reg_write(stmpe, STMPE_REG_TEMP_TH + 1, 0); 249 250 return 0; 251 } 252 253 static int stmpe_adc_probe(struct platform_device *pdev) 254 { 255 struct iio_dev *indio_dev; 256 struct stmpe_adc *info; 257 struct device_node *np; 258 u32 norequest_mask = 0; 259 int irq_temp, irq_adc; 260 int num_chan = 0; 261 int i = 0; 262 int ret; 263 264 irq_adc = platform_get_irq_byname(pdev, "STMPE_ADC"); 265 if (irq_adc < 0) 266 return irq_adc; 267 268 indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(struct stmpe_adc)); 269 if (!indio_dev) { 270 dev_err(&pdev->dev, "failed allocating iio device\n"); 271 return -ENOMEM; 272 } 273 274 info = iio_priv(indio_dev); 275 mutex_init(&info->lock); 276 277 init_completion(&info->completion); 278 ret = devm_request_threaded_irq(&pdev->dev, irq_adc, NULL, 279 stmpe_adc_isr, IRQF_ONESHOT, 280 "stmpe-adc", info); 281 if (ret < 0) { 282 dev_err(&pdev->dev, "failed requesting irq, irq = %d\n", 283 irq_adc); 284 return ret; 285 } 286 287 irq_temp = platform_get_irq_byname(pdev, "STMPE_TEMP_SENS"); 288 if (irq_temp >= 0) { 289 ret = devm_request_threaded_irq(&pdev->dev, irq_temp, NULL, 290 stmpe_adc_isr, IRQF_ONESHOT, 291 "stmpe-adc", info); 292 if (ret < 0) 293 dev_warn(&pdev->dev, "failed requesting irq for" 294 " temp sensor, irq = %d\n", irq_temp); 295 } 296 297 platform_set_drvdata(pdev, indio_dev); 298 299 indio_dev->name = dev_name(&pdev->dev); 300 indio_dev->dev.parent = &pdev->dev; 301 indio_dev->info = &stmpe_adc_iio_info; 302 indio_dev->modes = INDIO_DIRECT_MODE; 303 304 info->stmpe = dev_get_drvdata(pdev->dev.parent); 305 306 np = pdev->dev.of_node; 307 308 if (!np) 309 dev_err(&pdev->dev, "no device tree node found\n"); 310 311 of_property_read_u32(np, "st,norequest-mask", &norequest_mask); 312 313 for_each_clear_bit(i, (unsigned long *) &norequest_mask, 314 (STMPE_ADC_LAST_NR + 1)) { 315 stmpe_adc_voltage_chan(&info->stmpe_adc_iio_channels[num_chan], i); 316 num_chan++; 317 } 318 stmpe_adc_temp_chan(&info->stmpe_adc_iio_channels[num_chan], i); 319 num_chan++; 320 indio_dev->channels = info->stmpe_adc_iio_channels; 321 indio_dev->num_channels = num_chan; 322 323 ret = stmpe_adc_init_hw(info); 324 if (ret) 325 return ret; 326 327 stmpe_reg_write(info->stmpe, STMPE_REG_ADC_INT_EN, 328 ~(norequest_mask & 0xFF)); 329 330 stmpe_reg_write(info->stmpe, STMPE_REG_ADC_INT_STA, 331 ~(norequest_mask & 0xFF)); 332 333 return devm_iio_device_register(&pdev->dev, indio_dev); 334 } 335 336 static int __maybe_unused stmpe_adc_resume(struct device *dev) 337 { 338 struct iio_dev *indio_dev = dev_get_drvdata(dev); 339 struct stmpe_adc *info = iio_priv(indio_dev); 340 341 stmpe_adc_init_hw(info); 342 343 return 0; 344 } 345 346 static SIMPLE_DEV_PM_OPS(stmpe_adc_pm_ops, NULL, stmpe_adc_resume); 347 348 static struct platform_driver stmpe_adc_driver = { 349 .probe = stmpe_adc_probe, 350 .driver = { 351 .name = "stmpe-adc", 352 .pm = &stmpe_adc_pm_ops, 353 }, 354 }; 355 module_platform_driver(stmpe_adc_driver); 356 357 static const struct of_device_id stmpe_adc_ids[] = { 358 { .compatible = "st,stmpe-adc", }, 359 { }, 360 }; 361 MODULE_DEVICE_TABLE(of, stmpe_adc_ids); 362 363 MODULE_AUTHOR("Stefan Agner <stefan.agner@toradex.com>"); 364 MODULE_DESCRIPTION("STMPEXXX ADC driver"); 365 MODULE_LICENSE("GPL v2"); 366 MODULE_ALIAS("platform:stmpe-adc"); 367