1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (c) 2019 Nuvoton Technology corporation. 3 4 #include <linux/clk.h> 5 #include <linux/device.h> 6 #include <linux/mfd/syscon.h> 7 #include <linux/io.h> 8 #include <linux/iio/iio.h> 9 #include <linux/interrupt.h> 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/platform_device.h> 13 #include <linux/regmap.h> 14 #include <linux/regulator/consumer.h> 15 #include <linux/spinlock.h> 16 #include <linux/uaccess.h> 17 18 struct npcm_adc { 19 bool int_status; 20 u32 adc_sample_hz; 21 struct device *dev; 22 void __iomem *regs; 23 struct clk *adc_clk; 24 wait_queue_head_t wq; 25 struct regulator *vref; 26 struct regmap *rst_regmap; 27 }; 28 29 /* NPCM7xx reset module */ 30 #define NPCM7XX_IPSRST1_OFFSET 0x020 31 #define NPCM7XX_IPSRST1_ADC_RST BIT(27) 32 33 /* ADC registers */ 34 #define NPCM_ADCCON 0x00 35 #define NPCM_ADCDATA 0x04 36 37 /* ADCCON Register Bits */ 38 #define NPCM_ADCCON_ADC_INT_EN BIT(21) 39 #define NPCM_ADCCON_REFSEL BIT(19) 40 #define NPCM_ADCCON_ADC_INT_ST BIT(18) 41 #define NPCM_ADCCON_ADC_EN BIT(17) 42 #define NPCM_ADCCON_ADC_RST BIT(16) 43 #define NPCM_ADCCON_ADC_CONV BIT(13) 44 45 #define NPCM_ADCCON_CH_MASK GENMASK(27, 24) 46 #define NPCM_ADCCON_CH(x) ((x) << 24) 47 #define NPCM_ADCCON_DIV_SHIFT 1 48 #define NPCM_ADCCON_DIV_MASK GENMASK(8, 1) 49 #define NPCM_ADC_DATA_MASK(x) ((x) & GENMASK(9, 0)) 50 51 #define NPCM_ADC_ENABLE (NPCM_ADCCON_ADC_EN | NPCM_ADCCON_ADC_INT_EN) 52 53 /* ADC General Definition */ 54 #define NPCM_RESOLUTION_BITS 10 55 #define NPCM_INT_VREF_MV 2000 56 57 #define NPCM_ADC_CHAN(ch) { \ 58 .type = IIO_VOLTAGE, \ 59 .indexed = 1, \ 60 .channel = ch, \ 61 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 62 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 63 BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 64 } 65 66 static const struct iio_chan_spec npcm_adc_iio_channels[] = { 67 NPCM_ADC_CHAN(0), 68 NPCM_ADC_CHAN(1), 69 NPCM_ADC_CHAN(2), 70 NPCM_ADC_CHAN(3), 71 NPCM_ADC_CHAN(4), 72 NPCM_ADC_CHAN(5), 73 NPCM_ADC_CHAN(6), 74 NPCM_ADC_CHAN(7), 75 }; 76 77 static irqreturn_t npcm_adc_isr(int irq, void *data) 78 { 79 u32 regtemp; 80 struct iio_dev *indio_dev = data; 81 struct npcm_adc *info = iio_priv(indio_dev); 82 83 regtemp = ioread32(info->regs + NPCM_ADCCON); 84 if (regtemp & NPCM_ADCCON_ADC_INT_ST) { 85 iowrite32(regtemp, info->regs + NPCM_ADCCON); 86 wake_up_interruptible(&info->wq); 87 info->int_status = true; 88 } 89 90 return IRQ_HANDLED; 91 } 92 93 static int npcm_adc_read(struct npcm_adc *info, int *val, u8 channel) 94 { 95 int ret; 96 u32 regtemp; 97 98 /* Select ADC channel */ 99 regtemp = ioread32(info->regs + NPCM_ADCCON); 100 regtemp &= ~NPCM_ADCCON_CH_MASK; 101 info->int_status = false; 102 iowrite32(regtemp | NPCM_ADCCON_CH(channel) | 103 NPCM_ADCCON_ADC_CONV, info->regs + NPCM_ADCCON); 104 105 ret = wait_event_interruptible_timeout(info->wq, info->int_status, 106 msecs_to_jiffies(10)); 107 if (ret == 0) { 108 regtemp = ioread32(info->regs + NPCM_ADCCON); 109 if ((regtemp & NPCM_ADCCON_ADC_CONV) && info->rst_regmap) { 110 /* if conversion failed - reset ADC module */ 111 regmap_write(info->rst_regmap, NPCM7XX_IPSRST1_OFFSET, 112 NPCM7XX_IPSRST1_ADC_RST); 113 msleep(100); 114 regmap_write(info->rst_regmap, NPCM7XX_IPSRST1_OFFSET, 115 0x0); 116 msleep(100); 117 118 /* Enable ADC and start conversion module */ 119 iowrite32(NPCM_ADC_ENABLE | NPCM_ADCCON_ADC_CONV, 120 info->regs + NPCM_ADCCON); 121 dev_err(info->dev, "RESET ADC Complete\n"); 122 } 123 return -ETIMEDOUT; 124 } 125 if (ret < 0) 126 return ret; 127 128 *val = NPCM_ADC_DATA_MASK(ioread32(info->regs + NPCM_ADCDATA)); 129 130 return 0; 131 } 132 133 static int npcm_adc_read_raw(struct iio_dev *indio_dev, 134 struct iio_chan_spec const *chan, int *val, 135 int *val2, long mask) 136 { 137 int ret; 138 int vref_uv; 139 struct npcm_adc *info = iio_priv(indio_dev); 140 141 switch (mask) { 142 case IIO_CHAN_INFO_RAW: 143 mutex_lock(&indio_dev->mlock); 144 ret = npcm_adc_read(info, val, chan->channel); 145 mutex_unlock(&indio_dev->mlock); 146 if (ret) { 147 dev_err(info->dev, "NPCM ADC read failed\n"); 148 return ret; 149 } 150 return IIO_VAL_INT; 151 case IIO_CHAN_INFO_SCALE: 152 if (!IS_ERR(info->vref)) { 153 vref_uv = regulator_get_voltage(info->vref); 154 *val = vref_uv / 1000; 155 } else { 156 *val = NPCM_INT_VREF_MV; 157 } 158 *val2 = NPCM_RESOLUTION_BITS; 159 return IIO_VAL_FRACTIONAL_LOG2; 160 case IIO_CHAN_INFO_SAMP_FREQ: 161 *val = info->adc_sample_hz; 162 return IIO_VAL_INT; 163 default: 164 return -EINVAL; 165 } 166 167 return 0; 168 } 169 170 static const struct iio_info npcm_adc_iio_info = { 171 .read_raw = &npcm_adc_read_raw, 172 }; 173 174 static const struct of_device_id npcm_adc_match[] = { 175 { .compatible = "nuvoton,npcm750-adc", }, 176 { /* sentinel */ } 177 }; 178 MODULE_DEVICE_TABLE(of, npcm_adc_match); 179 180 static int npcm_adc_probe(struct platform_device *pdev) 181 { 182 int ret; 183 int irq; 184 u32 div; 185 u32 reg_con; 186 struct npcm_adc *info; 187 struct iio_dev *indio_dev; 188 struct device *dev = &pdev->dev; 189 struct device_node *np = pdev->dev.of_node; 190 191 indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*info)); 192 if (!indio_dev) 193 return -ENOMEM; 194 info = iio_priv(indio_dev); 195 196 info->dev = &pdev->dev; 197 198 info->regs = devm_platform_ioremap_resource(pdev, 0); 199 if (IS_ERR(info->regs)) 200 return PTR_ERR(info->regs); 201 202 info->adc_clk = devm_clk_get(&pdev->dev, NULL); 203 if (IS_ERR(info->adc_clk)) { 204 dev_warn(&pdev->dev, "ADC clock failed: can't read clk\n"); 205 return PTR_ERR(info->adc_clk); 206 } 207 208 /* calculate ADC clock sample rate */ 209 reg_con = ioread32(info->regs + NPCM_ADCCON); 210 div = reg_con & NPCM_ADCCON_DIV_MASK; 211 div = div >> NPCM_ADCCON_DIV_SHIFT; 212 info->adc_sample_hz = clk_get_rate(info->adc_clk) / ((div + 1) * 2); 213 214 if (of_device_is_compatible(np, "nuvoton,npcm750-adc")) { 215 info->rst_regmap = syscon_regmap_lookup_by_compatible 216 ("nuvoton,npcm750-rst"); 217 if (IS_ERR(info->rst_regmap)) { 218 dev_err(&pdev->dev, "Failed to find nuvoton,npcm750-rst\n"); 219 ret = PTR_ERR(info->rst_regmap); 220 goto err_disable_clk; 221 } 222 } 223 224 irq = platform_get_irq(pdev, 0); 225 if (irq <= 0) { 226 ret = -EINVAL; 227 goto err_disable_clk; 228 } 229 230 ret = devm_request_irq(&pdev->dev, irq, npcm_adc_isr, 0, 231 "NPCM_ADC", indio_dev); 232 if (ret < 0) { 233 dev_err(dev, "failed requesting interrupt\n"); 234 goto err_disable_clk; 235 } 236 237 reg_con = ioread32(info->regs + NPCM_ADCCON); 238 info->vref = devm_regulator_get_optional(&pdev->dev, "vref"); 239 if (!IS_ERR(info->vref)) { 240 ret = regulator_enable(info->vref); 241 if (ret) { 242 dev_err(&pdev->dev, "Can't enable ADC reference voltage\n"); 243 goto err_disable_clk; 244 } 245 246 iowrite32(reg_con & ~NPCM_ADCCON_REFSEL, 247 info->regs + NPCM_ADCCON); 248 } else { 249 /* 250 * Any error which is not ENODEV indicates the regulator 251 * has been specified and so is a failure case. 252 */ 253 if (PTR_ERR(info->vref) != -ENODEV) { 254 ret = PTR_ERR(info->vref); 255 goto err_disable_clk; 256 } 257 258 /* Use internal reference */ 259 iowrite32(reg_con | NPCM_ADCCON_REFSEL, 260 info->regs + NPCM_ADCCON); 261 } 262 263 init_waitqueue_head(&info->wq); 264 265 reg_con = ioread32(info->regs + NPCM_ADCCON); 266 reg_con |= NPCM_ADC_ENABLE; 267 268 /* Enable the ADC Module */ 269 iowrite32(reg_con, info->regs + NPCM_ADCCON); 270 271 /* Start ADC conversion */ 272 iowrite32(reg_con | NPCM_ADCCON_ADC_CONV, info->regs + NPCM_ADCCON); 273 274 platform_set_drvdata(pdev, indio_dev); 275 indio_dev->name = dev_name(&pdev->dev); 276 indio_dev->dev.parent = &pdev->dev; 277 indio_dev->info = &npcm_adc_iio_info; 278 indio_dev->modes = INDIO_DIRECT_MODE; 279 indio_dev->channels = npcm_adc_iio_channels; 280 indio_dev->num_channels = ARRAY_SIZE(npcm_adc_iio_channels); 281 282 ret = iio_device_register(indio_dev); 283 if (ret) { 284 dev_err(&pdev->dev, "Couldn't register the device.\n"); 285 goto err_iio_register; 286 } 287 288 pr_info("NPCM ADC driver probed\n"); 289 290 return 0; 291 292 err_iio_register: 293 iowrite32(reg_con & ~NPCM_ADCCON_ADC_EN, info->regs + NPCM_ADCCON); 294 if (!IS_ERR(info->vref)) 295 regulator_disable(info->vref); 296 err_disable_clk: 297 clk_disable_unprepare(info->adc_clk); 298 299 return ret; 300 } 301 302 static int npcm_adc_remove(struct platform_device *pdev) 303 { 304 struct iio_dev *indio_dev = platform_get_drvdata(pdev); 305 struct npcm_adc *info = iio_priv(indio_dev); 306 u32 regtemp; 307 308 iio_device_unregister(indio_dev); 309 310 regtemp = ioread32(info->regs + NPCM_ADCCON); 311 iowrite32(regtemp & ~NPCM_ADCCON_ADC_EN, info->regs + NPCM_ADCCON); 312 if (!IS_ERR(info->vref)) 313 regulator_disable(info->vref); 314 clk_disable_unprepare(info->adc_clk); 315 316 return 0; 317 } 318 319 static struct platform_driver npcm_adc_driver = { 320 .probe = npcm_adc_probe, 321 .remove = npcm_adc_remove, 322 .driver = { 323 .name = "npcm_adc", 324 .of_match_table = npcm_adc_match, 325 }, 326 }; 327 328 module_platform_driver(npcm_adc_driver); 329 330 MODULE_DESCRIPTION("Nuvoton NPCM ADC Driver"); 331 MODULE_AUTHOR("Tomer Maimon <tomer.maimon@nuvoton.com>"); 332 MODULE_LICENSE("GPL v2"); 333