10e589d5fSMaxime Ripard /* 20e589d5fSMaxime Ripard * Driver for the ADC present in the Atmel AT91 evaluation boards. 30e589d5fSMaxime Ripard * 40e589d5fSMaxime Ripard * Copyright 2011 Free Electrons 50e589d5fSMaxime Ripard * 60e589d5fSMaxime Ripard * Licensed under the GPLv2 or later. 70e589d5fSMaxime Ripard */ 80e589d5fSMaxime Ripard 90e589d5fSMaxime Ripard #include <linux/bitmap.h> 100e589d5fSMaxime Ripard #include <linux/bitops.h> 110e589d5fSMaxime Ripard #include <linux/clk.h> 120e589d5fSMaxime Ripard #include <linux/err.h> 130e589d5fSMaxime Ripard #include <linux/io.h> 140e589d5fSMaxime Ripard #include <linux/interrupt.h> 150e589d5fSMaxime Ripard #include <linux/jiffies.h> 160e589d5fSMaxime Ripard #include <linux/kernel.h> 170e589d5fSMaxime Ripard #include <linux/module.h> 18e364185fSMaxime Ripard #include <linux/of.h> 19e364185fSMaxime Ripard #include <linux/of_device.h> 200e589d5fSMaxime Ripard #include <linux/platform_device.h> 210e589d5fSMaxime Ripard #include <linux/sched.h> 220e589d5fSMaxime Ripard #include <linux/slab.h> 230e589d5fSMaxime Ripard #include <linux/wait.h> 240e589d5fSMaxime Ripard 250e589d5fSMaxime Ripard #include <linux/platform_data/at91_adc.h> 260e589d5fSMaxime Ripard 270e589d5fSMaxime Ripard #include <linux/iio/iio.h> 280e589d5fSMaxime Ripard #include <linux/iio/buffer.h> 290e589d5fSMaxime Ripard #include <linux/iio/trigger.h> 300e589d5fSMaxime Ripard #include <linux/iio/trigger_consumer.h> 3190032e4eSLars-Peter Clausen #include <linux/iio/triggered_buffer.h> 320e589d5fSMaxime Ripard 330e589d5fSMaxime Ripard #include <mach/at91_adc.h> 340e589d5fSMaxime Ripard 350e589d5fSMaxime Ripard #define AT91_ADC_CHAN(st, ch) \ 360e589d5fSMaxime Ripard (st->registers->channel_base + (ch * 4)) 370e589d5fSMaxime Ripard #define at91_adc_readl(st, reg) \ 380e589d5fSMaxime Ripard (readl_relaxed(st->reg_base + reg)) 390e589d5fSMaxime Ripard #define at91_adc_writel(st, reg, val) \ 400e589d5fSMaxime Ripard (writel_relaxed(val, st->reg_base + reg)) 410e589d5fSMaxime Ripard 420e589d5fSMaxime Ripard struct at91_adc_state { 430e589d5fSMaxime Ripard struct clk *adc_clk; 440e589d5fSMaxime Ripard u16 *buffer; 450e589d5fSMaxime Ripard unsigned long channels_mask; 460e589d5fSMaxime Ripard struct clk *clk; 470e589d5fSMaxime Ripard bool done; 480e589d5fSMaxime Ripard int irq; 490e589d5fSMaxime Ripard u16 last_value; 500e589d5fSMaxime Ripard struct mutex lock; 510e589d5fSMaxime Ripard u8 num_channels; 520e589d5fSMaxime Ripard void __iomem *reg_base; 530e589d5fSMaxime Ripard struct at91_adc_reg_desc *registers; 540e589d5fSMaxime Ripard u8 startup_time; 55beca9e76SJean-Christophe PLAGNIOL-VILLARD u8 sample_hold_time; 56e748783cSJean-Christophe PLAGNIOL-VILLARD bool sleep_mode; 570e589d5fSMaxime Ripard struct iio_trigger **trig; 580e589d5fSMaxime Ripard struct at91_adc_trigger *trigger_list; 590e589d5fSMaxime Ripard u32 trigger_number; 600e589d5fSMaxime Ripard bool use_external; 610e589d5fSMaxime Ripard u32 vref_mv; 6247be16b6SLudovic Desroches u32 res; /* resolution used for convertions */ 6347be16b6SLudovic Desroches bool low_res; /* the resolution corresponds to the lowest one */ 640e589d5fSMaxime Ripard wait_queue_head_t wq_data_avail; 650e589d5fSMaxime Ripard }; 660e589d5fSMaxime Ripard 670e589d5fSMaxime Ripard static irqreturn_t at91_adc_trigger_handler(int irq, void *p) 680e589d5fSMaxime Ripard { 690e589d5fSMaxime Ripard struct iio_poll_func *pf = p; 700e589d5fSMaxime Ripard struct iio_dev *idev = pf->indio_dev; 710e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 720e589d5fSMaxime Ripard int i, j = 0; 730e589d5fSMaxime Ripard 740e589d5fSMaxime Ripard for (i = 0; i < idev->masklength; i++) { 750e589d5fSMaxime Ripard if (!test_bit(i, idev->active_scan_mask)) 760e589d5fSMaxime Ripard continue; 770e589d5fSMaxime Ripard st->buffer[j] = at91_adc_readl(st, AT91_ADC_CHAN(st, i)); 780e589d5fSMaxime Ripard j++; 790e589d5fSMaxime Ripard } 800e589d5fSMaxime Ripard 810e589d5fSMaxime Ripard if (idev->scan_timestamp) { 820e589d5fSMaxime Ripard s64 *timestamp = (s64 *)((u8 *)st->buffer + 830e589d5fSMaxime Ripard ALIGN(j, sizeof(s64))); 840e589d5fSMaxime Ripard *timestamp = pf->timestamp; 850e589d5fSMaxime Ripard } 860e589d5fSMaxime Ripard 8711679767SJean-Christophe PLAGNIOL-VILLARD iio_push_to_buffers(idev, (u8 *)st->buffer); 880e589d5fSMaxime Ripard 890e589d5fSMaxime Ripard iio_trigger_notify_done(idev->trig); 900e589d5fSMaxime Ripard 910e589d5fSMaxime Ripard /* Needed to ACK the DRDY interruption */ 920e589d5fSMaxime Ripard at91_adc_readl(st, AT91_ADC_LCDR); 930e589d5fSMaxime Ripard 940e589d5fSMaxime Ripard enable_irq(st->irq); 950e589d5fSMaxime Ripard 960e589d5fSMaxime Ripard return IRQ_HANDLED; 970e589d5fSMaxime Ripard } 980e589d5fSMaxime Ripard 990e589d5fSMaxime Ripard static irqreturn_t at91_adc_eoc_trigger(int irq, void *private) 1000e589d5fSMaxime Ripard { 1010e589d5fSMaxime Ripard struct iio_dev *idev = private; 1020e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 1030e589d5fSMaxime Ripard u32 status = at91_adc_readl(st, st->registers->status_register); 1040e589d5fSMaxime Ripard 1050e589d5fSMaxime Ripard if (!(status & st->registers->drdy_mask)) 1060e589d5fSMaxime Ripard return IRQ_HANDLED; 1070e589d5fSMaxime Ripard 1080e589d5fSMaxime Ripard if (iio_buffer_enabled(idev)) { 1090e589d5fSMaxime Ripard disable_irq_nosync(irq); 1100e589d5fSMaxime Ripard iio_trigger_poll(idev->trig, iio_get_time_ns()); 1110e589d5fSMaxime Ripard } else { 1120e589d5fSMaxime Ripard st->last_value = at91_adc_readl(st, AT91_ADC_LCDR); 1130e589d5fSMaxime Ripard st->done = true; 1140e589d5fSMaxime Ripard wake_up_interruptible(&st->wq_data_avail); 1150e589d5fSMaxime Ripard } 1160e589d5fSMaxime Ripard 1170e589d5fSMaxime Ripard return IRQ_HANDLED; 1180e589d5fSMaxime Ripard } 1190e589d5fSMaxime Ripard 1200e589d5fSMaxime Ripard static int at91_adc_channel_init(struct iio_dev *idev) 1210e589d5fSMaxime Ripard { 1220e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 1230e589d5fSMaxime Ripard struct iio_chan_spec *chan_array, *timestamp; 1240e589d5fSMaxime Ripard int bit, idx = 0; 1250e589d5fSMaxime Ripard 1260e589d5fSMaxime Ripard idev->num_channels = bitmap_weight(&st->channels_mask, 1270e589d5fSMaxime Ripard st->num_channels) + 1; 1280e589d5fSMaxime Ripard 1296b3aa313SAxel Lin chan_array = devm_kzalloc(&idev->dev, 1306b3aa313SAxel Lin ((idev->num_channels + 1) * 1316b3aa313SAxel Lin sizeof(struct iio_chan_spec)), 1326b3aa313SAxel Lin GFP_KERNEL); 1330e589d5fSMaxime Ripard 1340e589d5fSMaxime Ripard if (!chan_array) 1350e589d5fSMaxime Ripard return -ENOMEM; 1360e589d5fSMaxime Ripard 1370e589d5fSMaxime Ripard for_each_set_bit(bit, &st->channels_mask, st->num_channels) { 1380e589d5fSMaxime Ripard struct iio_chan_spec *chan = chan_array + idx; 1390e589d5fSMaxime Ripard 1400e589d5fSMaxime Ripard chan->type = IIO_VOLTAGE; 1410e589d5fSMaxime Ripard chan->indexed = 1; 1420e589d5fSMaxime Ripard chan->channel = bit; 1430e589d5fSMaxime Ripard chan->scan_index = idx; 1440e589d5fSMaxime Ripard chan->scan_type.sign = 'u'; 14547be16b6SLudovic Desroches chan->scan_type.realbits = st->res; 1460e589d5fSMaxime Ripard chan->scan_type.storagebits = 16; 14701bdab66SJonathan Cameron chan->info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE); 14801bdab66SJonathan Cameron chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW); 1490e589d5fSMaxime Ripard idx++; 1500e589d5fSMaxime Ripard } 1510e589d5fSMaxime Ripard timestamp = chan_array + idx; 1520e589d5fSMaxime Ripard 1530e589d5fSMaxime Ripard timestamp->type = IIO_TIMESTAMP; 1540e589d5fSMaxime Ripard timestamp->channel = -1; 1550e589d5fSMaxime Ripard timestamp->scan_index = idx; 1560e589d5fSMaxime Ripard timestamp->scan_type.sign = 's'; 1570e589d5fSMaxime Ripard timestamp->scan_type.realbits = 64; 1580e589d5fSMaxime Ripard timestamp->scan_type.storagebits = 64; 1590e589d5fSMaxime Ripard 1600e589d5fSMaxime Ripard idev->channels = chan_array; 1610e589d5fSMaxime Ripard return idev->num_channels; 1620e589d5fSMaxime Ripard } 1630e589d5fSMaxime Ripard 1640e589d5fSMaxime Ripard static u8 at91_adc_get_trigger_value_by_name(struct iio_dev *idev, 1650e589d5fSMaxime Ripard struct at91_adc_trigger *triggers, 1660e589d5fSMaxime Ripard const char *trigger_name) 1670e589d5fSMaxime Ripard { 1680e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 1690e589d5fSMaxime Ripard u8 value = 0; 1700e589d5fSMaxime Ripard int i; 1710e589d5fSMaxime Ripard 1720e589d5fSMaxime Ripard for (i = 0; i < st->trigger_number; i++) { 1730e589d5fSMaxime Ripard char *name = kasprintf(GFP_KERNEL, 1740e589d5fSMaxime Ripard "%s-dev%d-%s", 1750e589d5fSMaxime Ripard idev->name, 1760e589d5fSMaxime Ripard idev->id, 1770e589d5fSMaxime Ripard triggers[i].name); 1780e589d5fSMaxime Ripard if (!name) 1790e589d5fSMaxime Ripard return -ENOMEM; 1800e589d5fSMaxime Ripard 1810e589d5fSMaxime Ripard if (strcmp(trigger_name, name) == 0) { 1820e589d5fSMaxime Ripard value = triggers[i].value; 1830e589d5fSMaxime Ripard kfree(name); 1840e589d5fSMaxime Ripard break; 1850e589d5fSMaxime Ripard } 1860e589d5fSMaxime Ripard 1870e589d5fSMaxime Ripard kfree(name); 1880e589d5fSMaxime Ripard } 1890e589d5fSMaxime Ripard 1900e589d5fSMaxime Ripard return value; 1910e589d5fSMaxime Ripard } 1920e589d5fSMaxime Ripard 1930e589d5fSMaxime Ripard static int at91_adc_configure_trigger(struct iio_trigger *trig, bool state) 1940e589d5fSMaxime Ripard { 1951e9663c6SLars-Peter Clausen struct iio_dev *idev = iio_trigger_get_drvdata(trig); 1960e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 1970e589d5fSMaxime Ripard struct iio_buffer *buffer = idev->buffer; 1980e589d5fSMaxime Ripard struct at91_adc_reg_desc *reg = st->registers; 1990e589d5fSMaxime Ripard u32 status = at91_adc_readl(st, reg->trigger_register); 2000e589d5fSMaxime Ripard u8 value; 2010e589d5fSMaxime Ripard u8 bit; 2020e589d5fSMaxime Ripard 2030e589d5fSMaxime Ripard value = at91_adc_get_trigger_value_by_name(idev, 2040e589d5fSMaxime Ripard st->trigger_list, 2050e589d5fSMaxime Ripard idev->trig->name); 2060e589d5fSMaxime Ripard if (value == 0) 2070e589d5fSMaxime Ripard return -EINVAL; 2080e589d5fSMaxime Ripard 2090e589d5fSMaxime Ripard if (state) { 2100e589d5fSMaxime Ripard st->buffer = kmalloc(idev->scan_bytes, GFP_KERNEL); 2110e589d5fSMaxime Ripard if (st->buffer == NULL) 2120e589d5fSMaxime Ripard return -ENOMEM; 2130e589d5fSMaxime Ripard 2140e589d5fSMaxime Ripard at91_adc_writel(st, reg->trigger_register, 2150e589d5fSMaxime Ripard status | value); 2160e589d5fSMaxime Ripard 2170e589d5fSMaxime Ripard for_each_set_bit(bit, buffer->scan_mask, 2180e589d5fSMaxime Ripard st->num_channels) { 2190e589d5fSMaxime Ripard struct iio_chan_spec const *chan = idev->channels + bit; 2200e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_CHER, 2210e589d5fSMaxime Ripard AT91_ADC_CH(chan->channel)); 2220e589d5fSMaxime Ripard } 2230e589d5fSMaxime Ripard 2240e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_IER, reg->drdy_mask); 2250e589d5fSMaxime Ripard 2260e589d5fSMaxime Ripard } else { 2270e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_IDR, reg->drdy_mask); 2280e589d5fSMaxime Ripard 2290e589d5fSMaxime Ripard at91_adc_writel(st, reg->trigger_register, 2300e589d5fSMaxime Ripard status & ~value); 2310e589d5fSMaxime Ripard 2320e589d5fSMaxime Ripard for_each_set_bit(bit, buffer->scan_mask, 2330e589d5fSMaxime Ripard st->num_channels) { 2340e589d5fSMaxime Ripard struct iio_chan_spec const *chan = idev->channels + bit; 2350e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_CHDR, 2360e589d5fSMaxime Ripard AT91_ADC_CH(chan->channel)); 2370e589d5fSMaxime Ripard } 2380e589d5fSMaxime Ripard kfree(st->buffer); 2390e589d5fSMaxime Ripard } 2400e589d5fSMaxime Ripard 2410e589d5fSMaxime Ripard return 0; 2420e589d5fSMaxime Ripard } 2430e589d5fSMaxime Ripard 2440e589d5fSMaxime Ripard static const struct iio_trigger_ops at91_adc_trigger_ops = { 2450e589d5fSMaxime Ripard .owner = THIS_MODULE, 2460e589d5fSMaxime Ripard .set_trigger_state = &at91_adc_configure_trigger, 2470e589d5fSMaxime Ripard }; 2480e589d5fSMaxime Ripard 2490e589d5fSMaxime Ripard static struct iio_trigger *at91_adc_allocate_trigger(struct iio_dev *idev, 2500e589d5fSMaxime Ripard struct at91_adc_trigger *trigger) 2510e589d5fSMaxime Ripard { 2520e589d5fSMaxime Ripard struct iio_trigger *trig; 2530e589d5fSMaxime Ripard int ret; 2540e589d5fSMaxime Ripard 2550e589d5fSMaxime Ripard trig = iio_trigger_alloc("%s-dev%d-%s", idev->name, 2560e589d5fSMaxime Ripard idev->id, trigger->name); 2570e589d5fSMaxime Ripard if (trig == NULL) 2580e589d5fSMaxime Ripard return NULL; 2590e589d5fSMaxime Ripard 2600e589d5fSMaxime Ripard trig->dev.parent = idev->dev.parent; 2611e9663c6SLars-Peter Clausen iio_trigger_set_drvdata(trig, idev); 2620e589d5fSMaxime Ripard trig->ops = &at91_adc_trigger_ops; 2630e589d5fSMaxime Ripard 2640e589d5fSMaxime Ripard ret = iio_trigger_register(trig); 2650e589d5fSMaxime Ripard if (ret) 2660e589d5fSMaxime Ripard return NULL; 2670e589d5fSMaxime Ripard 2680e589d5fSMaxime Ripard return trig; 2690e589d5fSMaxime Ripard } 2700e589d5fSMaxime Ripard 2710e589d5fSMaxime Ripard static int at91_adc_trigger_init(struct iio_dev *idev) 2720e589d5fSMaxime Ripard { 2730e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 2740e589d5fSMaxime Ripard int i, ret; 2750e589d5fSMaxime Ripard 2766b3aa313SAxel Lin st->trig = devm_kzalloc(&idev->dev, 2776b3aa313SAxel Lin st->trigger_number * sizeof(st->trig), 2786b3aa313SAxel Lin GFP_KERNEL); 2790e589d5fSMaxime Ripard 2800e589d5fSMaxime Ripard if (st->trig == NULL) { 2810e589d5fSMaxime Ripard ret = -ENOMEM; 2820e589d5fSMaxime Ripard goto error_ret; 2830e589d5fSMaxime Ripard } 2840e589d5fSMaxime Ripard 2850e589d5fSMaxime Ripard for (i = 0; i < st->trigger_number; i++) { 2860e589d5fSMaxime Ripard if (st->trigger_list[i].is_external && !(st->use_external)) 2870e589d5fSMaxime Ripard continue; 2880e589d5fSMaxime Ripard 2890e589d5fSMaxime Ripard st->trig[i] = at91_adc_allocate_trigger(idev, 2900e589d5fSMaxime Ripard st->trigger_list + i); 2910e589d5fSMaxime Ripard if (st->trig[i] == NULL) { 2920e589d5fSMaxime Ripard dev_err(&idev->dev, 2930e589d5fSMaxime Ripard "Could not allocate trigger %d\n", i); 2940e589d5fSMaxime Ripard ret = -ENOMEM; 2950e589d5fSMaxime Ripard goto error_trigger; 2960e589d5fSMaxime Ripard } 2970e589d5fSMaxime Ripard } 2980e589d5fSMaxime Ripard 2990e589d5fSMaxime Ripard return 0; 3000e589d5fSMaxime Ripard 3010e589d5fSMaxime Ripard error_trigger: 3020e589d5fSMaxime Ripard for (i--; i >= 0; i--) { 3030e589d5fSMaxime Ripard iio_trigger_unregister(st->trig[i]); 3040e589d5fSMaxime Ripard iio_trigger_free(st->trig[i]); 3050e589d5fSMaxime Ripard } 3060e589d5fSMaxime Ripard error_ret: 3070e589d5fSMaxime Ripard return ret; 3080e589d5fSMaxime Ripard } 3090e589d5fSMaxime Ripard 3100e589d5fSMaxime Ripard static void at91_adc_trigger_remove(struct iio_dev *idev) 3110e589d5fSMaxime Ripard { 3120e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 3130e589d5fSMaxime Ripard int i; 3140e589d5fSMaxime Ripard 3150e589d5fSMaxime Ripard for (i = 0; i < st->trigger_number; i++) { 3160e589d5fSMaxime Ripard iio_trigger_unregister(st->trig[i]); 3170e589d5fSMaxime Ripard iio_trigger_free(st->trig[i]); 3180e589d5fSMaxime Ripard } 3190e589d5fSMaxime Ripard } 3200e589d5fSMaxime Ripard 3210e589d5fSMaxime Ripard static int at91_adc_buffer_init(struct iio_dev *idev) 3220e589d5fSMaxime Ripard { 32390032e4eSLars-Peter Clausen return iio_triggered_buffer_setup(idev, &iio_pollfunc_store_time, 32490032e4eSLars-Peter Clausen &at91_adc_trigger_handler, NULL); 3250e589d5fSMaxime Ripard } 3260e589d5fSMaxime Ripard 3270e589d5fSMaxime Ripard static void at91_adc_buffer_remove(struct iio_dev *idev) 3280e589d5fSMaxime Ripard { 32990032e4eSLars-Peter Clausen iio_triggered_buffer_cleanup(idev); 3300e589d5fSMaxime Ripard } 3310e589d5fSMaxime Ripard 3320e589d5fSMaxime Ripard static int at91_adc_read_raw(struct iio_dev *idev, 3330e589d5fSMaxime Ripard struct iio_chan_spec const *chan, 3340e589d5fSMaxime Ripard int *val, int *val2, long mask) 3350e589d5fSMaxime Ripard { 3360e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 3370e589d5fSMaxime Ripard int ret; 3380e589d5fSMaxime Ripard 3390e589d5fSMaxime Ripard switch (mask) { 3400e589d5fSMaxime Ripard case IIO_CHAN_INFO_RAW: 3410e589d5fSMaxime Ripard mutex_lock(&st->lock); 3420e589d5fSMaxime Ripard 3430e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_CHER, 3440e589d5fSMaxime Ripard AT91_ADC_CH(chan->channel)); 3450e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_IER, st->registers->drdy_mask); 3460e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_CR, AT91_ADC_START); 3470e589d5fSMaxime Ripard 3480e589d5fSMaxime Ripard ret = wait_event_interruptible_timeout(st->wq_data_avail, 3490e589d5fSMaxime Ripard st->done, 3500e589d5fSMaxime Ripard msecs_to_jiffies(1000)); 3510e589d5fSMaxime Ripard if (ret == 0) 35290e6dc7cSLars-Peter Clausen ret = -ETIMEDOUT; 35390e6dc7cSLars-Peter Clausen if (ret < 0) { 35490e6dc7cSLars-Peter Clausen mutex_unlock(&st->lock); 3550e589d5fSMaxime Ripard return ret; 35690e6dc7cSLars-Peter Clausen } 3570e589d5fSMaxime Ripard 3580e589d5fSMaxime Ripard *val = st->last_value; 3590e589d5fSMaxime Ripard 3600e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_CHDR, 3610e589d5fSMaxime Ripard AT91_ADC_CH(chan->channel)); 3620e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_IDR, st->registers->drdy_mask); 3630e589d5fSMaxime Ripard 3640e589d5fSMaxime Ripard st->last_value = 0; 3650e589d5fSMaxime Ripard st->done = false; 3660e589d5fSMaxime Ripard mutex_unlock(&st->lock); 3670e589d5fSMaxime Ripard return IIO_VAL_INT; 3680e589d5fSMaxime Ripard 3690e589d5fSMaxime Ripard case IIO_CHAN_INFO_SCALE: 3700e589d5fSMaxime Ripard *val = (st->vref_mv * 1000) >> chan->scan_type.realbits; 3710e589d5fSMaxime Ripard *val2 = 0; 3720e589d5fSMaxime Ripard return IIO_VAL_INT_PLUS_MICRO; 3730e589d5fSMaxime Ripard default: 3740e589d5fSMaxime Ripard break; 3750e589d5fSMaxime Ripard } 3760e589d5fSMaxime Ripard return -EINVAL; 3770e589d5fSMaxime Ripard } 3780e589d5fSMaxime Ripard 37947be16b6SLudovic Desroches static int at91_adc_of_get_resolution(struct at91_adc_state *st, 38047be16b6SLudovic Desroches struct platform_device *pdev) 38147be16b6SLudovic Desroches { 38247be16b6SLudovic Desroches struct iio_dev *idev = iio_priv_to_dev(st); 38347be16b6SLudovic Desroches struct device_node *np = pdev->dev.of_node; 38447be16b6SLudovic Desroches int count, i, ret = 0; 38547be16b6SLudovic Desroches char *res_name, *s; 38647be16b6SLudovic Desroches u32 *resolutions; 38747be16b6SLudovic Desroches 38847be16b6SLudovic Desroches count = of_property_count_strings(np, "atmel,adc-res-names"); 38947be16b6SLudovic Desroches if (count < 2) { 39047be16b6SLudovic Desroches dev_err(&idev->dev, "You must specified at least two resolution names for " 39147be16b6SLudovic Desroches "adc-res-names property in the DT\n"); 39247be16b6SLudovic Desroches return count; 39347be16b6SLudovic Desroches } 39447be16b6SLudovic Desroches 39547be16b6SLudovic Desroches resolutions = kmalloc(count * sizeof(*resolutions), GFP_KERNEL); 39647be16b6SLudovic Desroches if (!resolutions) 39747be16b6SLudovic Desroches return -ENOMEM; 39847be16b6SLudovic Desroches 39947be16b6SLudovic Desroches if (of_property_read_u32_array(np, "atmel,adc-res", resolutions, count)) { 40047be16b6SLudovic Desroches dev_err(&idev->dev, "Missing adc-res property in the DT.\n"); 40147be16b6SLudovic Desroches ret = -ENODEV; 40247be16b6SLudovic Desroches goto ret; 40347be16b6SLudovic Desroches } 40447be16b6SLudovic Desroches 40547be16b6SLudovic Desroches if (of_property_read_string(np, "atmel,adc-use-res", (const char **)&res_name)) 40647be16b6SLudovic Desroches res_name = "highres"; 40747be16b6SLudovic Desroches 40847be16b6SLudovic Desroches for (i = 0; i < count; i++) { 40947be16b6SLudovic Desroches if (of_property_read_string_index(np, "atmel,adc-res-names", i, (const char **)&s)) 41047be16b6SLudovic Desroches continue; 41147be16b6SLudovic Desroches 41247be16b6SLudovic Desroches if (strcmp(res_name, s)) 41347be16b6SLudovic Desroches continue; 41447be16b6SLudovic Desroches 41547be16b6SLudovic Desroches st->res = resolutions[i]; 41647be16b6SLudovic Desroches if (!strcmp(res_name, "lowres")) 41747be16b6SLudovic Desroches st->low_res = true; 41847be16b6SLudovic Desroches else 41947be16b6SLudovic Desroches st->low_res = false; 42047be16b6SLudovic Desroches 42147be16b6SLudovic Desroches dev_info(&idev->dev, "Resolution used: %u bits\n", st->res); 42247be16b6SLudovic Desroches goto ret; 42347be16b6SLudovic Desroches } 42447be16b6SLudovic Desroches 42547be16b6SLudovic Desroches dev_err(&idev->dev, "There is no resolution for %s\n", res_name); 42647be16b6SLudovic Desroches 42747be16b6SLudovic Desroches ret: 42847be16b6SLudovic Desroches kfree(resolutions); 42947be16b6SLudovic Desroches return ret; 43047be16b6SLudovic Desroches } 43147be16b6SLudovic Desroches 432e364185fSMaxime Ripard static int at91_adc_probe_dt(struct at91_adc_state *st, 433e364185fSMaxime Ripard struct platform_device *pdev) 434e364185fSMaxime Ripard { 435e364185fSMaxime Ripard struct iio_dev *idev = iio_priv_to_dev(st); 436e364185fSMaxime Ripard struct device_node *node = pdev->dev.of_node; 437e364185fSMaxime Ripard struct device_node *trig_node; 438e364185fSMaxime Ripard int i = 0, ret; 439e364185fSMaxime Ripard u32 prop; 440e364185fSMaxime Ripard 441e364185fSMaxime Ripard if (!node) 442e364185fSMaxime Ripard return -EINVAL; 443e364185fSMaxime Ripard 444e364185fSMaxime Ripard st->use_external = of_property_read_bool(node, "atmel,adc-use-external-triggers"); 445e364185fSMaxime Ripard 446e364185fSMaxime Ripard if (of_property_read_u32(node, "atmel,adc-channels-used", &prop)) { 447e364185fSMaxime Ripard dev_err(&idev->dev, "Missing adc-channels-used property in the DT.\n"); 448e364185fSMaxime Ripard ret = -EINVAL; 449e364185fSMaxime Ripard goto error_ret; 450e364185fSMaxime Ripard } 451e364185fSMaxime Ripard st->channels_mask = prop; 452e364185fSMaxime Ripard 453e364185fSMaxime Ripard if (of_property_read_u32(node, "atmel,adc-num-channels", &prop)) { 454e364185fSMaxime Ripard dev_err(&idev->dev, "Missing adc-num-channels property in the DT.\n"); 455e364185fSMaxime Ripard ret = -EINVAL; 456e364185fSMaxime Ripard goto error_ret; 457e364185fSMaxime Ripard } 458e364185fSMaxime Ripard st->num_channels = prop; 459e364185fSMaxime Ripard 460e748783cSJean-Christophe PLAGNIOL-VILLARD st->sleep_mode = of_property_read_bool(node, "atmel,adc-sleep-mode"); 461e748783cSJean-Christophe PLAGNIOL-VILLARD 462e364185fSMaxime Ripard if (of_property_read_u32(node, "atmel,adc-startup-time", &prop)) { 463e364185fSMaxime Ripard dev_err(&idev->dev, "Missing adc-startup-time property in the DT.\n"); 464e364185fSMaxime Ripard ret = -EINVAL; 465e364185fSMaxime Ripard goto error_ret; 466e364185fSMaxime Ripard } 467e364185fSMaxime Ripard st->startup_time = prop; 468e364185fSMaxime Ripard 469beca9e76SJean-Christophe PLAGNIOL-VILLARD prop = 0; 470beca9e76SJean-Christophe PLAGNIOL-VILLARD of_property_read_u32(node, "atmel,adc-sample-hold-time", &prop); 471beca9e76SJean-Christophe PLAGNIOL-VILLARD st->sample_hold_time = prop; 472e364185fSMaxime Ripard 473e364185fSMaxime Ripard if (of_property_read_u32(node, "atmel,adc-vref", &prop)) { 474e364185fSMaxime Ripard dev_err(&idev->dev, "Missing adc-vref property in the DT.\n"); 475e364185fSMaxime Ripard ret = -EINVAL; 476e364185fSMaxime Ripard goto error_ret; 477e364185fSMaxime Ripard } 478e364185fSMaxime Ripard st->vref_mv = prop; 479e364185fSMaxime Ripard 48047be16b6SLudovic Desroches ret = at91_adc_of_get_resolution(st, pdev); 48147be16b6SLudovic Desroches if (ret) 48247be16b6SLudovic Desroches goto error_ret; 48347be16b6SLudovic Desroches 484e364185fSMaxime Ripard st->registers = devm_kzalloc(&idev->dev, 485e364185fSMaxime Ripard sizeof(struct at91_adc_reg_desc), 486e364185fSMaxime Ripard GFP_KERNEL); 487e364185fSMaxime Ripard if (!st->registers) { 488e364185fSMaxime Ripard dev_err(&idev->dev, "Could not allocate register memory.\n"); 489e364185fSMaxime Ripard ret = -ENOMEM; 490e364185fSMaxime Ripard goto error_ret; 491e364185fSMaxime Ripard } 492e364185fSMaxime Ripard 493e364185fSMaxime Ripard if (of_property_read_u32(node, "atmel,adc-channel-base", &prop)) { 494e364185fSMaxime Ripard dev_err(&idev->dev, "Missing adc-channel-base property in the DT.\n"); 495e364185fSMaxime Ripard ret = -EINVAL; 496e364185fSMaxime Ripard goto error_ret; 497e364185fSMaxime Ripard } 498e364185fSMaxime Ripard st->registers->channel_base = prop; 499e364185fSMaxime Ripard 500e364185fSMaxime Ripard if (of_property_read_u32(node, "atmel,adc-drdy-mask", &prop)) { 501e364185fSMaxime Ripard dev_err(&idev->dev, "Missing adc-drdy-mask property in the DT.\n"); 502e364185fSMaxime Ripard ret = -EINVAL; 503e364185fSMaxime Ripard goto error_ret; 504e364185fSMaxime Ripard } 505e364185fSMaxime Ripard st->registers->drdy_mask = prop; 506e364185fSMaxime Ripard 507e364185fSMaxime Ripard if (of_property_read_u32(node, "atmel,adc-status-register", &prop)) { 508e364185fSMaxime Ripard dev_err(&idev->dev, "Missing adc-status-register property in the DT.\n"); 509e364185fSMaxime Ripard ret = -EINVAL; 510e364185fSMaxime Ripard goto error_ret; 511e364185fSMaxime Ripard } 512e364185fSMaxime Ripard st->registers->status_register = prop; 513e364185fSMaxime Ripard 514e364185fSMaxime Ripard if (of_property_read_u32(node, "atmel,adc-trigger-register", &prop)) { 515e364185fSMaxime Ripard dev_err(&idev->dev, "Missing adc-trigger-register property in the DT.\n"); 516e364185fSMaxime Ripard ret = -EINVAL; 517e364185fSMaxime Ripard goto error_ret; 518e364185fSMaxime Ripard } 519e364185fSMaxime Ripard st->registers->trigger_register = prop; 520e364185fSMaxime Ripard 521e364185fSMaxime Ripard st->trigger_number = of_get_child_count(node); 5226b3aa313SAxel Lin st->trigger_list = devm_kzalloc(&idev->dev, st->trigger_number * 5236b3aa313SAxel Lin sizeof(struct at91_adc_trigger), 5246b3aa313SAxel Lin GFP_KERNEL); 525e364185fSMaxime Ripard if (!st->trigger_list) { 526e364185fSMaxime Ripard dev_err(&idev->dev, "Could not allocate trigger list memory.\n"); 527e364185fSMaxime Ripard ret = -ENOMEM; 528e364185fSMaxime Ripard goto error_ret; 529e364185fSMaxime Ripard } 530e364185fSMaxime Ripard 531e364185fSMaxime Ripard for_each_child_of_node(node, trig_node) { 532e364185fSMaxime Ripard struct at91_adc_trigger *trig = st->trigger_list + i; 533e364185fSMaxime Ripard const char *name; 534e364185fSMaxime Ripard 535e364185fSMaxime Ripard if (of_property_read_string(trig_node, "trigger-name", &name)) { 536e364185fSMaxime Ripard dev_err(&idev->dev, "Missing trigger-name property in the DT.\n"); 537e364185fSMaxime Ripard ret = -EINVAL; 538e364185fSMaxime Ripard goto error_ret; 539e364185fSMaxime Ripard } 540e364185fSMaxime Ripard trig->name = name; 541e364185fSMaxime Ripard 542e364185fSMaxime Ripard if (of_property_read_u32(trig_node, "trigger-value", &prop)) { 543e364185fSMaxime Ripard dev_err(&idev->dev, "Missing trigger-value property in the DT.\n"); 544e364185fSMaxime Ripard ret = -EINVAL; 545e364185fSMaxime Ripard goto error_ret; 546e364185fSMaxime Ripard } 547e364185fSMaxime Ripard trig->value = prop; 548e364185fSMaxime Ripard trig->is_external = of_property_read_bool(trig_node, "trigger-external"); 549e364185fSMaxime Ripard i++; 550e364185fSMaxime Ripard } 551e364185fSMaxime Ripard 552e364185fSMaxime Ripard return 0; 553e364185fSMaxime Ripard 554e364185fSMaxime Ripard error_ret: 555e364185fSMaxime Ripard return ret; 556e364185fSMaxime Ripard } 557e364185fSMaxime Ripard 5580e589d5fSMaxime Ripard static int at91_adc_probe_pdata(struct at91_adc_state *st, 5590e589d5fSMaxime Ripard struct platform_device *pdev) 5600e589d5fSMaxime Ripard { 5610e589d5fSMaxime Ripard struct at91_adc_data *pdata = pdev->dev.platform_data; 5620e589d5fSMaxime Ripard 5630e589d5fSMaxime Ripard if (!pdata) 5640e589d5fSMaxime Ripard return -EINVAL; 5650e589d5fSMaxime Ripard 5660e589d5fSMaxime Ripard st->use_external = pdata->use_external_triggers; 5670e589d5fSMaxime Ripard st->vref_mv = pdata->vref; 5680e589d5fSMaxime Ripard st->channels_mask = pdata->channels_used; 5690e589d5fSMaxime Ripard st->num_channels = pdata->num_channels; 5700e589d5fSMaxime Ripard st->startup_time = pdata->startup_time; 5710e589d5fSMaxime Ripard st->trigger_number = pdata->trigger_number; 5720e589d5fSMaxime Ripard st->trigger_list = pdata->trigger_list; 5730e589d5fSMaxime Ripard st->registers = pdata->registers; 5740e589d5fSMaxime Ripard 5750e589d5fSMaxime Ripard return 0; 5760e589d5fSMaxime Ripard } 5770e589d5fSMaxime Ripard 5780e589d5fSMaxime Ripard static const struct iio_info at91_adc_info = { 5790e589d5fSMaxime Ripard .driver_module = THIS_MODULE, 5800e589d5fSMaxime Ripard .read_raw = &at91_adc_read_raw, 5810e589d5fSMaxime Ripard }; 5820e589d5fSMaxime Ripard 583fc52692cSGreg Kroah-Hartman static int at91_adc_probe(struct platform_device *pdev) 5840e589d5fSMaxime Ripard { 585beca9e76SJean-Christophe PLAGNIOL-VILLARD unsigned int prsc, mstrclk, ticks, adc_clk, shtim; 5860e589d5fSMaxime Ripard int ret; 5870e589d5fSMaxime Ripard struct iio_dev *idev; 5880e589d5fSMaxime Ripard struct at91_adc_state *st; 5890e589d5fSMaxime Ripard struct resource *res; 590e748783cSJean-Christophe PLAGNIOL-VILLARD u32 reg; 5910e589d5fSMaxime Ripard 592f8837532SSachin Kamat idev = devm_iio_device_alloc(&pdev->dev, sizeof(struct at91_adc_state)); 593f8837532SSachin Kamat if (!idev) 594f8837532SSachin Kamat return -ENOMEM; 5950e589d5fSMaxime Ripard 5960e589d5fSMaxime Ripard st = iio_priv(idev); 5970e589d5fSMaxime Ripard 598e364185fSMaxime Ripard if (pdev->dev.of_node) 599e364185fSMaxime Ripard ret = at91_adc_probe_dt(st, pdev); 600e364185fSMaxime Ripard else 6010e589d5fSMaxime Ripard ret = at91_adc_probe_pdata(st, pdev); 602e364185fSMaxime Ripard 6030e589d5fSMaxime Ripard if (ret) { 6040e589d5fSMaxime Ripard dev_err(&pdev->dev, "No platform data available.\n"); 605f8837532SSachin Kamat return -EINVAL; 6060e589d5fSMaxime Ripard } 6070e589d5fSMaxime Ripard 6080e589d5fSMaxime Ripard platform_set_drvdata(pdev, idev); 6090e589d5fSMaxime Ripard 6100e589d5fSMaxime Ripard idev->dev.parent = &pdev->dev; 6110e589d5fSMaxime Ripard idev->name = dev_name(&pdev->dev); 6120e589d5fSMaxime Ripard idev->modes = INDIO_DIRECT_MODE; 6130e589d5fSMaxime Ripard idev->info = &at91_adc_info; 6140e589d5fSMaxime Ripard 6150e589d5fSMaxime Ripard st->irq = platform_get_irq(pdev, 0); 6160e589d5fSMaxime Ripard if (st->irq < 0) { 6170e589d5fSMaxime Ripard dev_err(&pdev->dev, "No IRQ ID is designated\n"); 618f8837532SSachin Kamat return -ENODEV; 6190e589d5fSMaxime Ripard } 6200e589d5fSMaxime Ripard 621390d75c1SJulia Lawall res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 6220e589d5fSMaxime Ripard 6235fd98466SThierry Reding st->reg_base = devm_ioremap_resource(&pdev->dev, res); 6245fd98466SThierry Reding if (IS_ERR(st->reg_base)) { 625f8837532SSachin Kamat return PTR_ERR(st->reg_base); 6260e589d5fSMaxime Ripard } 6270e589d5fSMaxime Ripard 6280e589d5fSMaxime Ripard /* 6290e589d5fSMaxime Ripard * Disable all IRQs before setting up the handler 6300e589d5fSMaxime Ripard */ 6310e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_CR, AT91_ADC_SWRST); 6320e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_IDR, 0xFFFFFFFF); 6330e589d5fSMaxime Ripard ret = request_irq(st->irq, 6340e589d5fSMaxime Ripard at91_adc_eoc_trigger, 6350e589d5fSMaxime Ripard 0, 6360e589d5fSMaxime Ripard pdev->dev.driver->name, 6370e589d5fSMaxime Ripard idev); 6380e589d5fSMaxime Ripard if (ret) { 6390e589d5fSMaxime Ripard dev_err(&pdev->dev, "Failed to allocate IRQ.\n"); 640f8837532SSachin Kamat return ret; 6410e589d5fSMaxime Ripard } 6420e589d5fSMaxime Ripard 643390d75c1SJulia Lawall st->clk = devm_clk_get(&pdev->dev, "adc_clk"); 6440e589d5fSMaxime Ripard if (IS_ERR(st->clk)) { 6450e589d5fSMaxime Ripard dev_err(&pdev->dev, "Failed to get the clock.\n"); 6460e589d5fSMaxime Ripard ret = PTR_ERR(st->clk); 6470e589d5fSMaxime Ripard goto error_free_irq; 6480e589d5fSMaxime Ripard } 6490e589d5fSMaxime Ripard 65000062a9cSJulia Lawall ret = clk_prepare_enable(st->clk); 6510e589d5fSMaxime Ripard if (ret) { 65200062a9cSJulia Lawall dev_err(&pdev->dev, 65300062a9cSJulia Lawall "Could not prepare or enable the clock.\n"); 654390d75c1SJulia Lawall goto error_free_irq; 6550e589d5fSMaxime Ripard } 6560e589d5fSMaxime Ripard 657390d75c1SJulia Lawall st->adc_clk = devm_clk_get(&pdev->dev, "adc_op_clk"); 6580e589d5fSMaxime Ripard if (IS_ERR(st->adc_clk)) { 6590e589d5fSMaxime Ripard dev_err(&pdev->dev, "Failed to get the ADC clock.\n"); 660f755bbbfSJulia Lawall ret = PTR_ERR(st->adc_clk); 6610e589d5fSMaxime Ripard goto error_disable_clk; 6620e589d5fSMaxime Ripard } 6630e589d5fSMaxime Ripard 66400062a9cSJulia Lawall ret = clk_prepare_enable(st->adc_clk); 6650e589d5fSMaxime Ripard if (ret) { 66600062a9cSJulia Lawall dev_err(&pdev->dev, 66700062a9cSJulia Lawall "Could not prepare or enable the ADC clock.\n"); 668390d75c1SJulia Lawall goto error_disable_clk; 6690e589d5fSMaxime Ripard } 6700e589d5fSMaxime Ripard 6710e589d5fSMaxime Ripard /* 6720e589d5fSMaxime Ripard * Prescaler rate computation using the formula from the Atmel's 6730e589d5fSMaxime Ripard * datasheet : ADC Clock = MCK / ((Prescaler + 1) * 2), ADC Clock being 6740e589d5fSMaxime Ripard * specified by the electrical characteristics of the board. 6750e589d5fSMaxime Ripard */ 6760e589d5fSMaxime Ripard mstrclk = clk_get_rate(st->clk); 6770e589d5fSMaxime Ripard adc_clk = clk_get_rate(st->adc_clk); 6780e589d5fSMaxime Ripard prsc = (mstrclk / (2 * adc_clk)) - 1; 6790e589d5fSMaxime Ripard 6800e589d5fSMaxime Ripard if (!st->startup_time) { 6810e589d5fSMaxime Ripard dev_err(&pdev->dev, "No startup time available.\n"); 6820e589d5fSMaxime Ripard ret = -EINVAL; 6830e589d5fSMaxime Ripard goto error_disable_adc_clk; 6840e589d5fSMaxime Ripard } 6850e589d5fSMaxime Ripard 6860e589d5fSMaxime Ripard /* 6870e589d5fSMaxime Ripard * Number of ticks needed to cover the startup time of the ADC as 6880e589d5fSMaxime Ripard * defined in the electrical characteristics of the board, divided by 8. 6890e589d5fSMaxime Ripard * The formula thus is : Startup Time = (ticks + 1) * 8 / ADC Clock 6900e589d5fSMaxime Ripard */ 6910e589d5fSMaxime Ripard ticks = round_up((st->startup_time * adc_clk / 6920e589d5fSMaxime Ripard 1000000) - 1, 8) / 8; 693beca9e76SJean-Christophe PLAGNIOL-VILLARD /* 694beca9e76SJean-Christophe PLAGNIOL-VILLARD * a minimal Sample and Hold Time is necessary for the ADC to guarantee 695beca9e76SJean-Christophe PLAGNIOL-VILLARD * the best converted final value between two channels selection 696beca9e76SJean-Christophe PLAGNIOL-VILLARD * The formula thus is : Sample and Hold Time = (shtim + 1) / ADCClock 697beca9e76SJean-Christophe PLAGNIOL-VILLARD */ 698beca9e76SJean-Christophe PLAGNIOL-VILLARD shtim = round_up((st->sample_hold_time * adc_clk / 699beca9e76SJean-Christophe PLAGNIOL-VILLARD 1000000) - 1, 1); 700beca9e76SJean-Christophe PLAGNIOL-VILLARD 701e748783cSJean-Christophe PLAGNIOL-VILLARD reg = AT91_ADC_PRESCAL_(prsc) & AT91_ADC_PRESCAL; 702e748783cSJean-Christophe PLAGNIOL-VILLARD reg |= AT91_ADC_STARTUP_(ticks) & AT91_ADC_STARTUP; 70347be16b6SLudovic Desroches if (st->low_res) 704e748783cSJean-Christophe PLAGNIOL-VILLARD reg |= AT91_ADC_LOWRES; 705e748783cSJean-Christophe PLAGNIOL-VILLARD if (st->sleep_mode) 706e748783cSJean-Christophe PLAGNIOL-VILLARD reg |= AT91_ADC_SLEEP; 707beca9e76SJean-Christophe PLAGNIOL-VILLARD reg |= AT91_ADC_SHTIM_(shtim) & AT91_ADC_SHTIM; 708e748783cSJean-Christophe PLAGNIOL-VILLARD at91_adc_writel(st, AT91_ADC_MR, reg); 7090e589d5fSMaxime Ripard 7100e589d5fSMaxime Ripard /* Setup the ADC channels available on the board */ 7110e589d5fSMaxime Ripard ret = at91_adc_channel_init(idev); 7120e589d5fSMaxime Ripard if (ret < 0) { 7130e589d5fSMaxime Ripard dev_err(&pdev->dev, "Couldn't initialize the channels.\n"); 7140e589d5fSMaxime Ripard goto error_disable_adc_clk; 7150e589d5fSMaxime Ripard } 7160e589d5fSMaxime Ripard 7170e589d5fSMaxime Ripard init_waitqueue_head(&st->wq_data_avail); 7180e589d5fSMaxime Ripard mutex_init(&st->lock); 7190e589d5fSMaxime Ripard 7200e589d5fSMaxime Ripard ret = at91_adc_buffer_init(idev); 7210e589d5fSMaxime Ripard if (ret < 0) { 7220e589d5fSMaxime Ripard dev_err(&pdev->dev, "Couldn't initialize the buffer.\n"); 7230e589d5fSMaxime Ripard goto error_disable_adc_clk; 7240e589d5fSMaxime Ripard } 7250e589d5fSMaxime Ripard 7260e589d5fSMaxime Ripard ret = at91_adc_trigger_init(idev); 7270e589d5fSMaxime Ripard if (ret < 0) { 7280e589d5fSMaxime Ripard dev_err(&pdev->dev, "Couldn't setup the triggers.\n"); 7290e589d5fSMaxime Ripard goto error_unregister_buffer; 7300e589d5fSMaxime Ripard } 7310e589d5fSMaxime Ripard 7320e589d5fSMaxime Ripard ret = iio_device_register(idev); 7330e589d5fSMaxime Ripard if (ret < 0) { 7340e589d5fSMaxime Ripard dev_err(&pdev->dev, "Couldn't register the device.\n"); 7350e589d5fSMaxime Ripard goto error_remove_triggers; 7360e589d5fSMaxime Ripard } 7370e589d5fSMaxime Ripard 7380e589d5fSMaxime Ripard return 0; 7390e589d5fSMaxime Ripard 7400e589d5fSMaxime Ripard error_remove_triggers: 7410e589d5fSMaxime Ripard at91_adc_trigger_remove(idev); 7420e589d5fSMaxime Ripard error_unregister_buffer: 7430e589d5fSMaxime Ripard at91_adc_buffer_remove(idev); 7440e589d5fSMaxime Ripard error_disable_adc_clk: 74500062a9cSJulia Lawall clk_disable_unprepare(st->adc_clk); 7460e589d5fSMaxime Ripard error_disable_clk: 74700062a9cSJulia Lawall clk_disable_unprepare(st->clk); 7480e589d5fSMaxime Ripard error_free_irq: 7490e589d5fSMaxime Ripard free_irq(st->irq, idev); 7500e589d5fSMaxime Ripard return ret; 7510e589d5fSMaxime Ripard } 7520e589d5fSMaxime Ripard 753fc52692cSGreg Kroah-Hartman static int at91_adc_remove(struct platform_device *pdev) 7540e589d5fSMaxime Ripard { 7550e589d5fSMaxime Ripard struct iio_dev *idev = platform_get_drvdata(pdev); 7560e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 7570e589d5fSMaxime Ripard 7580e589d5fSMaxime Ripard iio_device_unregister(idev); 7590e589d5fSMaxime Ripard at91_adc_trigger_remove(idev); 7600e589d5fSMaxime Ripard at91_adc_buffer_remove(idev); 7610e589d5fSMaxime Ripard clk_disable_unprepare(st->adc_clk); 76200062a9cSJulia Lawall clk_disable_unprepare(st->clk); 7630e589d5fSMaxime Ripard free_irq(st->irq, idev); 7640e589d5fSMaxime Ripard 7650e589d5fSMaxime Ripard return 0; 7660e589d5fSMaxime Ripard } 7670e589d5fSMaxime Ripard 76800738ff6SSachin Kamat #ifdef CONFIG_OF 769e364185fSMaxime Ripard static const struct of_device_id at91_adc_dt_ids[] = { 770e364185fSMaxime Ripard { .compatible = "atmel,at91sam9260-adc" }, 771e364185fSMaxime Ripard {}, 772e364185fSMaxime Ripard }; 773e364185fSMaxime Ripard MODULE_DEVICE_TABLE(of, at91_adc_dt_ids); 77400738ff6SSachin Kamat #endif 775e364185fSMaxime Ripard 7760e589d5fSMaxime Ripard static struct platform_driver at91_adc_driver = { 7770e589d5fSMaxime Ripard .probe = at91_adc_probe, 778fc52692cSGreg Kroah-Hartman .remove = at91_adc_remove, 7790e589d5fSMaxime Ripard .driver = { 7800e589d5fSMaxime Ripard .name = "at91_adc", 781e364185fSMaxime Ripard .of_match_table = of_match_ptr(at91_adc_dt_ids), 7820e589d5fSMaxime Ripard }, 7830e589d5fSMaxime Ripard }; 7840e589d5fSMaxime Ripard 7850e589d5fSMaxime Ripard module_platform_driver(at91_adc_driver); 7860e589d5fSMaxime Ripard 7870e589d5fSMaxime Ripard MODULE_LICENSE("GPL"); 7880e589d5fSMaxime Ripard MODULE_DESCRIPTION("Atmel AT91 ADC Driver"); 7890e589d5fSMaxime Ripard MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>"); 790