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> 14c8b11de0SJosh Wu #include <linux/input.h> 150e589d5fSMaxime Ripard #include <linux/interrupt.h> 160e589d5fSMaxime Ripard #include <linux/jiffies.h> 170e589d5fSMaxime Ripard #include <linux/kernel.h> 180e589d5fSMaxime Ripard #include <linux/module.h> 19e364185fSMaxime Ripard #include <linux/of.h> 20e364185fSMaxime Ripard #include <linux/of_device.h> 210e589d5fSMaxime Ripard #include <linux/platform_device.h> 220e589d5fSMaxime Ripard #include <linux/sched.h> 230e589d5fSMaxime Ripard #include <linux/slab.h> 240e589d5fSMaxime Ripard #include <linux/wait.h> 250e589d5fSMaxime Ripard 260e589d5fSMaxime Ripard #include <linux/platform_data/at91_adc.h> 270e589d5fSMaxime Ripard 280e589d5fSMaxime Ripard #include <linux/iio/iio.h> 290e589d5fSMaxime Ripard #include <linux/iio/buffer.h> 300e589d5fSMaxime Ripard #include <linux/iio/trigger.h> 310e589d5fSMaxime Ripard #include <linux/iio/trigger_consumer.h> 3290032e4eSLars-Peter Clausen #include <linux/iio/triggered_buffer.h> 33bc3ae982SWenyou Yang #include <linux/pinctrl/consumer.h> 340e589d5fSMaxime Ripard 35bee20c4bSAlexandre Belloni /* Registers */ 36bee20c4bSAlexandre Belloni #define AT91_ADC_CR 0x00 /* Control Register */ 37bee20c4bSAlexandre Belloni #define AT91_ADC_SWRST (1 << 0) /* Software Reset */ 38bee20c4bSAlexandre Belloni #define AT91_ADC_START (1 << 1) /* Start Conversion */ 39bee20c4bSAlexandre Belloni 40bee20c4bSAlexandre Belloni #define AT91_ADC_MR 0x04 /* Mode Register */ 41bee20c4bSAlexandre Belloni #define AT91_ADC_TSAMOD (3 << 0) /* ADC mode */ 42bee20c4bSAlexandre Belloni #define AT91_ADC_TSAMOD_ADC_ONLY_MODE (0 << 0) /* ADC Mode */ 43bee20c4bSAlexandre Belloni #define AT91_ADC_TSAMOD_TS_ONLY_MODE (1 << 0) /* Touch Screen Only Mode */ 44bee20c4bSAlexandre Belloni #define AT91_ADC_TRGEN (1 << 0) /* Trigger Enable */ 45bee20c4bSAlexandre Belloni #define AT91_ADC_TRGSEL (7 << 1) /* Trigger Selection */ 46bee20c4bSAlexandre Belloni #define AT91_ADC_TRGSEL_TC0 (0 << 1) 47bee20c4bSAlexandre Belloni #define AT91_ADC_TRGSEL_TC1 (1 << 1) 48bee20c4bSAlexandre Belloni #define AT91_ADC_TRGSEL_TC2 (2 << 1) 49bee20c4bSAlexandre Belloni #define AT91_ADC_TRGSEL_EXTERNAL (6 << 1) 50bee20c4bSAlexandre Belloni #define AT91_ADC_LOWRES (1 << 4) /* Low Resolution */ 51bee20c4bSAlexandre Belloni #define AT91_ADC_SLEEP (1 << 5) /* Sleep Mode */ 52bee20c4bSAlexandre Belloni #define AT91_ADC_PENDET (1 << 6) /* Pen contact detection enable */ 53bee20c4bSAlexandre Belloni #define AT91_ADC_PRESCAL_9260 (0x3f << 8) /* Prescalar Rate Selection */ 54bee20c4bSAlexandre Belloni #define AT91_ADC_PRESCAL_9G45 (0xff << 8) 55bee20c4bSAlexandre Belloni #define AT91_ADC_PRESCAL_(x) ((x) << 8) 56bee20c4bSAlexandre Belloni #define AT91_ADC_STARTUP_9260 (0x1f << 16) /* Startup Up Time */ 57bee20c4bSAlexandre Belloni #define AT91_ADC_STARTUP_9G45 (0x7f << 16) 58bee20c4bSAlexandre Belloni #define AT91_ADC_STARTUP_9X5 (0xf << 16) 59bee20c4bSAlexandre Belloni #define AT91_ADC_STARTUP_(x) ((x) << 16) 60bee20c4bSAlexandre Belloni #define AT91_ADC_SHTIM (0xf << 24) /* Sample & Hold Time */ 61bee20c4bSAlexandre Belloni #define AT91_ADC_SHTIM_(x) ((x) << 24) 62bee20c4bSAlexandre Belloni #define AT91_ADC_PENDBC (0x0f << 28) /* Pen Debounce time */ 63bee20c4bSAlexandre Belloni #define AT91_ADC_PENDBC_(x) ((x) << 28) 64bee20c4bSAlexandre Belloni 65bee20c4bSAlexandre Belloni #define AT91_ADC_TSR 0x0C 66bee20c4bSAlexandre Belloni #define AT91_ADC_TSR_SHTIM (0xf << 24) /* Sample & Hold Time */ 67bee20c4bSAlexandre Belloni #define AT91_ADC_TSR_SHTIM_(x) ((x) << 24) 68bee20c4bSAlexandre Belloni 69bee20c4bSAlexandre Belloni #define AT91_ADC_CHER 0x10 /* Channel Enable Register */ 70bee20c4bSAlexandre Belloni #define AT91_ADC_CHDR 0x14 /* Channel Disable Register */ 71bee20c4bSAlexandre Belloni #define AT91_ADC_CHSR 0x18 /* Channel Status Register */ 72bee20c4bSAlexandre Belloni #define AT91_ADC_CH(n) (1 << (n)) /* Channel Number */ 73bee20c4bSAlexandre Belloni 74bee20c4bSAlexandre Belloni #define AT91_ADC_SR 0x1C /* Status Register */ 75bee20c4bSAlexandre Belloni #define AT91_ADC_EOC(n) (1 << (n)) /* End of Conversion on Channel N */ 76bee20c4bSAlexandre Belloni #define AT91_ADC_OVRE(n) (1 << ((n) + 8))/* Overrun Error on Channel N */ 77bee20c4bSAlexandre Belloni #define AT91_ADC_DRDY (1 << 16) /* Data Ready */ 78bee20c4bSAlexandre Belloni #define AT91_ADC_GOVRE (1 << 17) /* General Overrun Error */ 79bee20c4bSAlexandre Belloni #define AT91_ADC_ENDRX (1 << 18) /* End of RX Buffer */ 80bee20c4bSAlexandre Belloni #define AT91_ADC_RXFUFF (1 << 19) /* RX Buffer Full */ 81bee20c4bSAlexandre Belloni 82bee20c4bSAlexandre Belloni #define AT91_ADC_SR_9X5 0x30 /* Status Register for 9x5 */ 83bee20c4bSAlexandre Belloni #define AT91_ADC_SR_DRDY_9X5 (1 << 24) /* Data Ready */ 84bee20c4bSAlexandre Belloni 85bee20c4bSAlexandre Belloni #define AT91_ADC_LCDR 0x20 /* Last Converted Data Register */ 86bee20c4bSAlexandre Belloni #define AT91_ADC_LDATA (0x3ff) 87bee20c4bSAlexandre Belloni 88bee20c4bSAlexandre Belloni #define AT91_ADC_IER 0x24 /* Interrupt Enable Register */ 89bee20c4bSAlexandre Belloni #define AT91_ADC_IDR 0x28 /* Interrupt Disable Register */ 90bee20c4bSAlexandre Belloni #define AT91_ADC_IMR 0x2C /* Interrupt Mask Register */ 91bee20c4bSAlexandre Belloni #define AT91RL_ADC_IER_PEN (1 << 20) 92bee20c4bSAlexandre Belloni #define AT91RL_ADC_IER_NOPEN (1 << 21) 93bee20c4bSAlexandre Belloni #define AT91_ADC_IER_PEN (1 << 29) 94bee20c4bSAlexandre Belloni #define AT91_ADC_IER_NOPEN (1 << 30) 95bee20c4bSAlexandre Belloni #define AT91_ADC_IER_XRDY (1 << 20) 96bee20c4bSAlexandre Belloni #define AT91_ADC_IER_YRDY (1 << 21) 97bee20c4bSAlexandre Belloni #define AT91_ADC_IER_PRDY (1 << 22) 98bee20c4bSAlexandre Belloni #define AT91_ADC_ISR_PENS (1 << 31) 99bee20c4bSAlexandre Belloni 100bee20c4bSAlexandre Belloni #define AT91_ADC_CHR(n) (0x30 + ((n) * 4)) /* Channel Data Register N */ 101bee20c4bSAlexandre Belloni #define AT91_ADC_DATA (0x3ff) 102bee20c4bSAlexandre Belloni 103bee20c4bSAlexandre Belloni #define AT91_ADC_CDR0_9X5 (0x50) /* Channel Data Register 0 for 9X5 */ 104bee20c4bSAlexandre Belloni 105bee20c4bSAlexandre Belloni #define AT91_ADC_ACR 0x94 /* Analog Control Register */ 106bee20c4bSAlexandre Belloni #define AT91_ADC_ACR_PENDETSENS (0x3 << 0) /* pull-up resistor */ 107bee20c4bSAlexandre Belloni 108bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR 0xB0 109bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_TSMODE (3 << 0) /* Touch Screen Mode */ 110bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_TSMODE_NONE (0 << 0) 111bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_TSMODE_4WIRE_NO_PRESS (1 << 0) 112bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_TSMODE_4WIRE_PRESS (2 << 0) 113bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_TSMODE_5WIRE (3 << 0) 114bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_TSAV (3 << 4) /* Averages samples */ 115bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_TSAV_(x) ((x) << 4) 116bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_SCTIM (0x0f << 16) /* Switch closure time */ 117ede63aafSNicolas Ferre #define AT91_ADC_TSMR_SCTIM_(x) ((x) << 16) 118bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_PENDBC (0x0f << 28) /* Pen Debounce time */ 119bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_PENDBC_(x) ((x) << 28) 120bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_NOTSDMA (1 << 22) /* No Touchscreen DMA */ 121bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_PENDET_DIS (0 << 24) /* Pen contact detection disable */ 122bee20c4bSAlexandre Belloni #define AT91_ADC_TSMR_PENDET_ENA (1 << 24) /* Pen contact detection enable */ 123bee20c4bSAlexandre Belloni 124bee20c4bSAlexandre Belloni #define AT91_ADC_TSXPOSR 0xB4 125bee20c4bSAlexandre Belloni #define AT91_ADC_TSYPOSR 0xB8 126bee20c4bSAlexandre Belloni #define AT91_ADC_TSPRESSR 0xBC 127bee20c4bSAlexandre Belloni 128bee20c4bSAlexandre Belloni #define AT91_ADC_TRGR_9260 AT91_ADC_MR 129bee20c4bSAlexandre Belloni #define AT91_ADC_TRGR_9G45 0x08 130bee20c4bSAlexandre Belloni #define AT91_ADC_TRGR_9X5 0xC0 131bee20c4bSAlexandre Belloni 132bee20c4bSAlexandre Belloni /* Trigger Register bit field */ 133bee20c4bSAlexandre Belloni #define AT91_ADC_TRGR_TRGPER (0xffff << 16) 134bee20c4bSAlexandre Belloni #define AT91_ADC_TRGR_TRGPER_(x) ((x) << 16) 135bee20c4bSAlexandre Belloni #define AT91_ADC_TRGR_TRGMOD (0x7 << 0) 136bee20c4bSAlexandre Belloni #define AT91_ADC_TRGR_NONE (0 << 0) 137bee20c4bSAlexandre Belloni #define AT91_ADC_TRGR_MOD_PERIOD_TRIG (5 << 0) 1380e589d5fSMaxime Ripard 1390e589d5fSMaxime Ripard #define AT91_ADC_CHAN(st, ch) \ 1400e589d5fSMaxime Ripard (st->registers->channel_base + (ch * 4)) 1410e589d5fSMaxime Ripard #define at91_adc_readl(st, reg) \ 1420e589d5fSMaxime Ripard (readl_relaxed(st->reg_base + reg)) 1430e589d5fSMaxime Ripard #define at91_adc_writel(st, reg, val) \ 1440e589d5fSMaxime Ripard (writel_relaxed(val, st->reg_base + reg)) 1450e589d5fSMaxime Ripard 146c8b11de0SJosh Wu #define DRIVER_NAME "at91_adc" 147c8b11de0SJosh Wu #define MAX_POS_BITS 12 148c8b11de0SJosh Wu 149c8b11de0SJosh Wu #define TOUCH_SAMPLE_PERIOD_US 2000 /* 2ms */ 150c8b11de0SJosh Wu #define TOUCH_PEN_DETECT_DEBOUNCE_US 200 151c8b11de0SJosh Wu 15284882b06SAlexandre Belloni #define MAX_RLPOS_BITS 10 15384882b06SAlexandre Belloni #define TOUCH_SAMPLE_PERIOD_US_RL 10000 /* 10ms, the SoC can't keep up with 2ms */ 15484882b06SAlexandre Belloni #define TOUCH_SHTIM 0xa 155ede63aafSNicolas Ferre #define TOUCH_SCTIM_US 10 /* 10us for the Touchscreen Switches Closure Time */ 15684882b06SAlexandre Belloni 1572de0c019SAlexandre Belloni /** 1582de0c019SAlexandre Belloni * struct at91_adc_reg_desc - Various informations relative to registers 1592de0c019SAlexandre Belloni * @channel_base: Base offset for the channel data registers 1602de0c019SAlexandre Belloni * @drdy_mask: Mask of the DRDY field in the relevant registers 1612de0c019SAlexandre Belloni (Interruptions registers mostly) 1622de0c019SAlexandre Belloni * @status_register: Offset of the Interrupt Status Register 1632de0c019SAlexandre Belloni * @trigger_register: Offset of the Trigger setup register 1642de0c019SAlexandre Belloni * @mr_prescal_mask: Mask of the PRESCAL field in the adc MR register 1652de0c019SAlexandre Belloni * @mr_startup_mask: Mask of the STARTUP field in the adc MR register 1662de0c019SAlexandre Belloni */ 1672de0c019SAlexandre Belloni struct at91_adc_reg_desc { 1682de0c019SAlexandre Belloni u8 channel_base; 1692de0c019SAlexandre Belloni u32 drdy_mask; 1702de0c019SAlexandre Belloni u8 status_register; 1712de0c019SAlexandre Belloni u8 trigger_register; 1722de0c019SAlexandre Belloni u32 mr_prescal_mask; 1732de0c019SAlexandre Belloni u32 mr_startup_mask; 1742de0c019SAlexandre Belloni }; 1752de0c019SAlexandre Belloni 176e1811f97SJosh Wu struct at91_adc_caps { 177c8b11de0SJosh Wu bool has_ts; /* Support touch screen */ 178c8b11de0SJosh Wu bool has_tsmr; /* only at91sam9x5, sama5d3 have TSMR reg */ 179c8b11de0SJosh Wu /* 180c8b11de0SJosh Wu * Numbers of sampling data will be averaged. Can be 0~3. 181c8b11de0SJosh Wu * Hardware can average (2 ^ ts_filter_average) sample data. 182c8b11de0SJosh Wu */ 183c8b11de0SJosh Wu u8 ts_filter_average; 184c8b11de0SJosh Wu /* Pen Detection input pull-up resistor, can be 0~3 */ 185c8b11de0SJosh Wu u8 ts_pen_detect_sensitivity; 186c8b11de0SJosh Wu 187c4601666SJosh Wu /* startup time calculate function */ 1882ab5f39bSJan Leupold u32 (*calc_startup_ticks)(u32 startup_time, u32 adc_clk_khz); 189c4601666SJosh Wu 1902b6d598bSJosh Wu u8 num_channels; 191e1811f97SJosh Wu struct at91_adc_reg_desc registers; 192e1811f97SJosh Wu }; 193e1811f97SJosh Wu 1940e589d5fSMaxime Ripard struct at91_adc_state { 1950e589d5fSMaxime Ripard struct clk *adc_clk; 1960e589d5fSMaxime Ripard u16 *buffer; 1970e589d5fSMaxime Ripard unsigned long channels_mask; 1980e589d5fSMaxime Ripard struct clk *clk; 1990e589d5fSMaxime Ripard bool done; 2000e589d5fSMaxime Ripard int irq; 2010e589d5fSMaxime Ripard u16 last_value; 202d4f51956SLudovic Desroches int chnb; 2030e589d5fSMaxime Ripard struct mutex lock; 2040e589d5fSMaxime Ripard u8 num_channels; 2050e589d5fSMaxime Ripard void __iomem *reg_base; 2060e589d5fSMaxime Ripard struct at91_adc_reg_desc *registers; 2072ab5f39bSJan Leupold u32 startup_time; 208beca9e76SJean-Christophe PLAGNIOL-VILLARD u8 sample_hold_time; 209e748783cSJean-Christophe PLAGNIOL-VILLARD bool sleep_mode; 2100e589d5fSMaxime Ripard struct iio_trigger **trig; 2110e589d5fSMaxime Ripard struct at91_adc_trigger *trigger_list; 2120e589d5fSMaxime Ripard u32 trigger_number; 2130e589d5fSMaxime Ripard bool use_external; 2140e589d5fSMaxime Ripard u32 vref_mv; 21547be16b6SLudovic Desroches u32 res; /* resolution used for convertions */ 21647be16b6SLudovic Desroches bool low_res; /* the resolution corresponds to the lowest one */ 2170e589d5fSMaxime Ripard wait_queue_head_t wq_data_avail; 218e1811f97SJosh Wu struct at91_adc_caps *caps; 219c8b11de0SJosh Wu 220c8b11de0SJosh Wu /* 221c8b11de0SJosh Wu * Following ADC channels are shared by touchscreen: 222c8b11de0SJosh Wu * 223c8b11de0SJosh Wu * CH0 -- Touch screen XP/UL 224c8b11de0SJosh Wu * CH1 -- Touch screen XM/UR 225c8b11de0SJosh Wu * CH2 -- Touch screen YP/LL 226c8b11de0SJosh Wu * CH3 -- Touch screen YM/Sense 227c8b11de0SJosh Wu * CH4 -- Touch screen LR(5-wire only) 228c8b11de0SJosh Wu * 229c8b11de0SJosh Wu * The bitfields below represents the reserved channel in the 230c8b11de0SJosh Wu * touchscreen mode. 231c8b11de0SJosh Wu */ 232c8b11de0SJosh Wu #define CHAN_MASK_TOUCHSCREEN_4WIRE (0xf << 0) 233c8b11de0SJosh Wu #define CHAN_MASK_TOUCHSCREEN_5WIRE (0x1f << 0) 234c8b11de0SJosh Wu enum atmel_adc_ts_type touchscreen_type; 235c8b11de0SJosh Wu struct input_dev *ts_input; 236c8b11de0SJosh Wu 237c8b11de0SJosh Wu u16 ts_sample_period_val; 238c8b11de0SJosh Wu u32 ts_pressure_threshold; 23984882b06SAlexandre Belloni u16 ts_pendbc; 24084882b06SAlexandre Belloni 24184882b06SAlexandre Belloni bool ts_bufferedmeasure; 24284882b06SAlexandre Belloni u32 ts_prev_absx; 24384882b06SAlexandre Belloni u32 ts_prev_absy; 2440e589d5fSMaxime Ripard }; 2450e589d5fSMaxime Ripard 2460e589d5fSMaxime Ripard static irqreturn_t at91_adc_trigger_handler(int irq, void *p) 2470e589d5fSMaxime Ripard { 2480e589d5fSMaxime Ripard struct iio_poll_func *pf = p; 2490e589d5fSMaxime Ripard struct iio_dev *idev = pf->indio_dev; 2500e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 251aea835f2SEugen Hristev struct iio_chan_spec const *chan; 2520e589d5fSMaxime Ripard int i, j = 0; 2530e589d5fSMaxime Ripard 2540e589d5fSMaxime Ripard for (i = 0; i < idev->masklength; i++) { 2550e589d5fSMaxime Ripard if (!test_bit(i, idev->active_scan_mask)) 2560e589d5fSMaxime Ripard continue; 257aea835f2SEugen Hristev chan = idev->channels + i; 258aea835f2SEugen Hristev st->buffer[j] = at91_adc_readl(st, AT91_ADC_CHAN(st, chan->channel)); 2590e589d5fSMaxime Ripard j++; 2600e589d5fSMaxime Ripard } 2610e589d5fSMaxime Ripard 262e79cece0SLars-Peter Clausen iio_push_to_buffers_with_timestamp(idev, st->buffer, pf->timestamp); 2630e589d5fSMaxime Ripard 2640e589d5fSMaxime Ripard iio_trigger_notify_done(idev->trig); 2650e589d5fSMaxime Ripard 2660e589d5fSMaxime Ripard /* Needed to ACK the DRDY interruption */ 2670e589d5fSMaxime Ripard at91_adc_readl(st, AT91_ADC_LCDR); 2680e589d5fSMaxime Ripard 2690e589d5fSMaxime Ripard enable_irq(st->irq); 2700e589d5fSMaxime Ripard 2710e589d5fSMaxime Ripard return IRQ_HANDLED; 2720e589d5fSMaxime Ripard } 2730e589d5fSMaxime Ripard 274c8b11de0SJosh Wu /* Handler for classic adc channel eoc trigger */ 2753068ab20SJosh Wu static void handle_adc_eoc_trigger(int irq, struct iio_dev *idev) 2760e589d5fSMaxime Ripard { 2770e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 2780e589d5fSMaxime Ripard 2790e589d5fSMaxime Ripard if (iio_buffer_enabled(idev)) { 2800e589d5fSMaxime Ripard disable_irq_nosync(irq); 281398fd22bSPeter Meerwald iio_trigger_poll(idev->trig); 2820e589d5fSMaxime Ripard } else { 283d4f51956SLudovic Desroches st->last_value = at91_adc_readl(st, AT91_ADC_CHAN(st, st->chnb)); 284bc1b4532SEugen Hristev /* Needed to ACK the DRDY interruption */ 285bc1b4532SEugen Hristev at91_adc_readl(st, AT91_ADC_LCDR); 2860e589d5fSMaxime Ripard st->done = true; 2870e589d5fSMaxime Ripard wake_up_interruptible(&st->wq_data_avail); 2880e589d5fSMaxime Ripard } 289c8b11de0SJosh Wu } 290c8b11de0SJosh Wu 291c8b11de0SJosh Wu static int at91_ts_sample(struct at91_adc_state *st) 292c8b11de0SJosh Wu { 293c8b11de0SJosh Wu unsigned int xscale, yscale, reg, z1, z2; 294c8b11de0SJosh Wu unsigned int x, y, pres, xpos, ypos; 295c8b11de0SJosh Wu unsigned int rxp = 1; 296c8b11de0SJosh Wu unsigned int factor = 1000; 297c8b11de0SJosh Wu struct iio_dev *idev = iio_priv_to_dev(st); 298c8b11de0SJosh Wu 299c8b11de0SJosh Wu unsigned int xyz_mask_bits = st->res; 300c8b11de0SJosh Wu unsigned int xyz_mask = (1 << xyz_mask_bits) - 1; 301c8b11de0SJosh Wu 302c8b11de0SJosh Wu /* calculate position */ 303c8b11de0SJosh Wu /* x position = (x / xscale) * max, max = 2^MAX_POS_BITS - 1 */ 304c8b11de0SJosh Wu reg = at91_adc_readl(st, AT91_ADC_TSXPOSR); 305c8b11de0SJosh Wu xpos = reg & xyz_mask; 306c8b11de0SJosh Wu x = (xpos << MAX_POS_BITS) - xpos; 307c8b11de0SJosh Wu xscale = (reg >> 16) & xyz_mask; 308c8b11de0SJosh Wu if (xscale == 0) { 309c8b11de0SJosh Wu dev_err(&idev->dev, "Error: xscale == 0!\n"); 310c8b11de0SJosh Wu return -1; 311c8b11de0SJosh Wu } 312c8b11de0SJosh Wu x /= xscale; 313c8b11de0SJosh Wu 314c8b11de0SJosh Wu /* y position = (y / yscale) * max, max = 2^MAX_POS_BITS - 1 */ 315c8b11de0SJosh Wu reg = at91_adc_readl(st, AT91_ADC_TSYPOSR); 316c8b11de0SJosh Wu ypos = reg & xyz_mask; 317c8b11de0SJosh Wu y = (ypos << MAX_POS_BITS) - ypos; 318c8b11de0SJosh Wu yscale = (reg >> 16) & xyz_mask; 319c8b11de0SJosh Wu if (yscale == 0) { 320c8b11de0SJosh Wu dev_err(&idev->dev, "Error: yscale == 0!\n"); 321c8b11de0SJosh Wu return -1; 322c8b11de0SJosh Wu } 323c8b11de0SJosh Wu y /= yscale; 324c8b11de0SJosh Wu 325c8b11de0SJosh Wu /* calculate the pressure */ 326c8b11de0SJosh Wu reg = at91_adc_readl(st, AT91_ADC_TSPRESSR); 327c8b11de0SJosh Wu z1 = reg & xyz_mask; 328c8b11de0SJosh Wu z2 = (reg >> 16) & xyz_mask; 329c8b11de0SJosh Wu 330c8b11de0SJosh Wu if (z1 != 0) 331c8b11de0SJosh Wu pres = rxp * (x * factor / 1024) * (z2 * factor / z1 - factor) 332c8b11de0SJosh Wu / factor; 333c8b11de0SJosh Wu else 334c8b11de0SJosh Wu pres = st->ts_pressure_threshold; /* no pen contacted */ 335c8b11de0SJosh Wu 336c8b11de0SJosh Wu dev_dbg(&idev->dev, "xpos = %d, xscale = %d, ypos = %d, yscale = %d, z1 = %d, z2 = %d, press = %d\n", 337c8b11de0SJosh Wu xpos, xscale, ypos, yscale, z1, z2, pres); 338c8b11de0SJosh Wu 339c8b11de0SJosh Wu if (pres < st->ts_pressure_threshold) { 340c8b11de0SJosh Wu dev_dbg(&idev->dev, "x = %d, y = %d, pressure = %d\n", 341c8b11de0SJosh Wu x, y, pres / factor); 342c8b11de0SJosh Wu input_report_abs(st->ts_input, ABS_X, x); 343c8b11de0SJosh Wu input_report_abs(st->ts_input, ABS_Y, y); 344c8b11de0SJosh Wu input_report_abs(st->ts_input, ABS_PRESSURE, pres); 345c8b11de0SJosh Wu input_report_key(st->ts_input, BTN_TOUCH, 1); 346c8b11de0SJosh Wu input_sync(st->ts_input); 347c8b11de0SJosh Wu } else { 348c8b11de0SJosh Wu dev_dbg(&idev->dev, "pressure too low: not reporting\n"); 349c8b11de0SJosh Wu } 350c8b11de0SJosh Wu 351c8b11de0SJosh Wu return 0; 352c8b11de0SJosh Wu } 353c8b11de0SJosh Wu 35484882b06SAlexandre Belloni static irqreturn_t at91_adc_rl_interrupt(int irq, void *private) 35584882b06SAlexandre Belloni { 35684882b06SAlexandre Belloni struct iio_dev *idev = private; 35784882b06SAlexandre Belloni struct at91_adc_state *st = iio_priv(idev); 35884882b06SAlexandre Belloni u32 status = at91_adc_readl(st, st->registers->status_register); 35984882b06SAlexandre Belloni unsigned int reg; 36084882b06SAlexandre Belloni 36184882b06SAlexandre Belloni status &= at91_adc_readl(st, AT91_ADC_IMR); 362d4f51956SLudovic Desroches if (status & GENMASK(st->num_channels - 1, 0)) 36384882b06SAlexandre Belloni handle_adc_eoc_trigger(irq, idev); 36484882b06SAlexandre Belloni 36584882b06SAlexandre Belloni if (status & AT91RL_ADC_IER_PEN) { 36684882b06SAlexandre Belloni /* Disabling pen debounce is required to get a NOPEN irq */ 36784882b06SAlexandre Belloni reg = at91_adc_readl(st, AT91_ADC_MR); 36884882b06SAlexandre Belloni reg &= ~AT91_ADC_PENDBC; 36984882b06SAlexandre Belloni at91_adc_writel(st, AT91_ADC_MR, reg); 37084882b06SAlexandre Belloni 37184882b06SAlexandre Belloni at91_adc_writel(st, AT91_ADC_IDR, AT91RL_ADC_IER_PEN); 37284882b06SAlexandre Belloni at91_adc_writel(st, AT91_ADC_IER, AT91RL_ADC_IER_NOPEN 37384882b06SAlexandre Belloni | AT91_ADC_EOC(3)); 37484882b06SAlexandre Belloni /* Set up period trigger for sampling */ 37584882b06SAlexandre Belloni at91_adc_writel(st, st->registers->trigger_register, 37684882b06SAlexandre Belloni AT91_ADC_TRGR_MOD_PERIOD_TRIG | 37784882b06SAlexandre Belloni AT91_ADC_TRGR_TRGPER_(st->ts_sample_period_val)); 37884882b06SAlexandre Belloni } else if (status & AT91RL_ADC_IER_NOPEN) { 37984882b06SAlexandre Belloni reg = at91_adc_readl(st, AT91_ADC_MR); 38084882b06SAlexandre Belloni reg |= AT91_ADC_PENDBC_(st->ts_pendbc) & AT91_ADC_PENDBC; 38184882b06SAlexandre Belloni at91_adc_writel(st, AT91_ADC_MR, reg); 38284882b06SAlexandre Belloni at91_adc_writel(st, st->registers->trigger_register, 38384882b06SAlexandre Belloni AT91_ADC_TRGR_NONE); 38484882b06SAlexandre Belloni 38584882b06SAlexandre Belloni at91_adc_writel(st, AT91_ADC_IDR, AT91RL_ADC_IER_NOPEN 38684882b06SAlexandre Belloni | AT91_ADC_EOC(3)); 38784882b06SAlexandre Belloni at91_adc_writel(st, AT91_ADC_IER, AT91RL_ADC_IER_PEN); 38884882b06SAlexandre Belloni st->ts_bufferedmeasure = false; 38984882b06SAlexandre Belloni input_report_key(st->ts_input, BTN_TOUCH, 0); 39084882b06SAlexandre Belloni input_sync(st->ts_input); 391c2ab4474SAnders Darander } else if (status & AT91_ADC_EOC(3) && st->ts_input) { 392c2ab4474SAnders Darander /* Conversion finished and we've a touchscreen */ 39384882b06SAlexandre Belloni if (st->ts_bufferedmeasure) { 39484882b06SAlexandre Belloni /* 39584882b06SAlexandre Belloni * Last measurement is always discarded, since it can 39684882b06SAlexandre Belloni * be erroneous. 39784882b06SAlexandre Belloni * Always report previous measurement 39884882b06SAlexandre Belloni */ 39984882b06SAlexandre Belloni input_report_abs(st->ts_input, ABS_X, st->ts_prev_absx); 40084882b06SAlexandre Belloni input_report_abs(st->ts_input, ABS_Y, st->ts_prev_absy); 40184882b06SAlexandre Belloni input_report_key(st->ts_input, BTN_TOUCH, 1); 40284882b06SAlexandre Belloni input_sync(st->ts_input); 40384882b06SAlexandre Belloni } else 40484882b06SAlexandre Belloni st->ts_bufferedmeasure = true; 40584882b06SAlexandre Belloni 40684882b06SAlexandre Belloni /* Now make new measurement */ 40784882b06SAlexandre Belloni st->ts_prev_absx = at91_adc_readl(st, AT91_ADC_CHAN(st, 3)) 40884882b06SAlexandre Belloni << MAX_RLPOS_BITS; 40984882b06SAlexandre Belloni st->ts_prev_absx /= at91_adc_readl(st, AT91_ADC_CHAN(st, 2)); 41084882b06SAlexandre Belloni 41184882b06SAlexandre Belloni st->ts_prev_absy = at91_adc_readl(st, AT91_ADC_CHAN(st, 1)) 41284882b06SAlexandre Belloni << MAX_RLPOS_BITS; 41384882b06SAlexandre Belloni st->ts_prev_absy /= at91_adc_readl(st, AT91_ADC_CHAN(st, 0)); 41484882b06SAlexandre Belloni } 41584882b06SAlexandre Belloni 41684882b06SAlexandre Belloni return IRQ_HANDLED; 41784882b06SAlexandre Belloni } 41884882b06SAlexandre Belloni 41984882b06SAlexandre Belloni static irqreturn_t at91_adc_9x5_interrupt(int irq, void *private) 420c8b11de0SJosh Wu { 421c8b11de0SJosh Wu struct iio_dev *idev = private; 422c8b11de0SJosh Wu struct at91_adc_state *st = iio_priv(idev); 423c8b11de0SJosh Wu u32 status = at91_adc_readl(st, st->registers->status_register); 424c8b11de0SJosh Wu const uint32_t ts_data_irq_mask = 425c8b11de0SJosh Wu AT91_ADC_IER_XRDY | 426c8b11de0SJosh Wu AT91_ADC_IER_YRDY | 427c8b11de0SJosh Wu AT91_ADC_IER_PRDY; 428c8b11de0SJosh Wu 429d4f51956SLudovic Desroches if (status & GENMASK(st->num_channels - 1, 0)) 430c8b11de0SJosh Wu handle_adc_eoc_trigger(irq, idev); 431c8b11de0SJosh Wu 432c8b11de0SJosh Wu if (status & AT91_ADC_IER_PEN) { 433c8b11de0SJosh Wu at91_adc_writel(st, AT91_ADC_IDR, AT91_ADC_IER_PEN); 434c8b11de0SJosh Wu at91_adc_writel(st, AT91_ADC_IER, AT91_ADC_IER_NOPEN | 435c8b11de0SJosh Wu ts_data_irq_mask); 436c8b11de0SJosh Wu /* Set up period trigger for sampling */ 437c8b11de0SJosh Wu at91_adc_writel(st, st->registers->trigger_register, 438c8b11de0SJosh Wu AT91_ADC_TRGR_MOD_PERIOD_TRIG | 439c8b11de0SJosh Wu AT91_ADC_TRGR_TRGPER_(st->ts_sample_period_val)); 440c8b11de0SJosh Wu } else if (status & AT91_ADC_IER_NOPEN) { 441c8b11de0SJosh Wu at91_adc_writel(st, st->registers->trigger_register, 0); 442c8b11de0SJosh Wu at91_adc_writel(st, AT91_ADC_IDR, AT91_ADC_IER_NOPEN | 443c8b11de0SJosh Wu ts_data_irq_mask); 444c8b11de0SJosh Wu at91_adc_writel(st, AT91_ADC_IER, AT91_ADC_IER_PEN); 445c8b11de0SJosh Wu 446c8b11de0SJosh Wu input_report_key(st->ts_input, BTN_TOUCH, 0); 447c8b11de0SJosh Wu input_sync(st->ts_input); 448c8b11de0SJosh Wu } else if ((status & ts_data_irq_mask) == ts_data_irq_mask) { 449c8b11de0SJosh Wu /* Now all touchscreen data is ready */ 450c8b11de0SJosh Wu 451c8b11de0SJosh Wu if (status & AT91_ADC_ISR_PENS) { 452c8b11de0SJosh Wu /* validate data by pen contact */ 453c8b11de0SJosh Wu at91_ts_sample(st); 454c8b11de0SJosh Wu } else { 455c8b11de0SJosh Wu /* triggered by event that is no pen contact, just read 456c8b11de0SJosh Wu * them to clean the interrupt and discard all. 457c8b11de0SJosh Wu */ 458c8b11de0SJosh Wu at91_adc_readl(st, AT91_ADC_TSXPOSR); 459c8b11de0SJosh Wu at91_adc_readl(st, AT91_ADC_TSYPOSR); 460c8b11de0SJosh Wu at91_adc_readl(st, AT91_ADC_TSPRESSR); 461c8b11de0SJosh Wu } 462c8b11de0SJosh Wu } 4630e589d5fSMaxime Ripard 4640e589d5fSMaxime Ripard return IRQ_HANDLED; 4650e589d5fSMaxime Ripard } 4660e589d5fSMaxime Ripard 4670e589d5fSMaxime Ripard static int at91_adc_channel_init(struct iio_dev *idev) 4680e589d5fSMaxime Ripard { 4690e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 4700e589d5fSMaxime Ripard struct iio_chan_spec *chan_array, *timestamp; 4710e589d5fSMaxime Ripard int bit, idx = 0; 472c8b11de0SJosh Wu unsigned long rsvd_mask = 0; 473c8b11de0SJosh Wu 474c8b11de0SJosh Wu /* If touchscreen is enable, then reserve the adc channels */ 475c8b11de0SJosh Wu if (st->touchscreen_type == ATMEL_ADC_TOUCHSCREEN_4WIRE) 476c8b11de0SJosh Wu rsvd_mask = CHAN_MASK_TOUCHSCREEN_4WIRE; 477c8b11de0SJosh Wu else if (st->touchscreen_type == ATMEL_ADC_TOUCHSCREEN_5WIRE) 478c8b11de0SJosh Wu rsvd_mask = CHAN_MASK_TOUCHSCREEN_5WIRE; 479c8b11de0SJosh Wu 480c8b11de0SJosh Wu /* set up the channel mask to reserve touchscreen channels */ 481c8b11de0SJosh Wu st->channels_mask &= ~rsvd_mask; 4820e589d5fSMaxime Ripard 4830e589d5fSMaxime Ripard idev->num_channels = bitmap_weight(&st->channels_mask, 4840e589d5fSMaxime Ripard st->num_channels) + 1; 4850e589d5fSMaxime Ripard 4866b3aa313SAxel Lin chan_array = devm_kzalloc(&idev->dev, 4876b3aa313SAxel Lin ((idev->num_channels + 1) * 4886b3aa313SAxel Lin sizeof(struct iio_chan_spec)), 4896b3aa313SAxel Lin GFP_KERNEL); 4900e589d5fSMaxime Ripard 4910e589d5fSMaxime Ripard if (!chan_array) 4920e589d5fSMaxime Ripard return -ENOMEM; 4930e589d5fSMaxime Ripard 4940e589d5fSMaxime Ripard for_each_set_bit(bit, &st->channels_mask, st->num_channels) { 4950e589d5fSMaxime Ripard struct iio_chan_spec *chan = chan_array + idx; 4960e589d5fSMaxime Ripard 4970e589d5fSMaxime Ripard chan->type = IIO_VOLTAGE; 4980e589d5fSMaxime Ripard chan->indexed = 1; 4990e589d5fSMaxime Ripard chan->channel = bit; 5000e589d5fSMaxime Ripard chan->scan_index = idx; 5010e589d5fSMaxime Ripard chan->scan_type.sign = 'u'; 50247be16b6SLudovic Desroches chan->scan_type.realbits = st->res; 5030e589d5fSMaxime Ripard chan->scan_type.storagebits = 16; 50401bdab66SJonathan Cameron chan->info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE); 50501bdab66SJonathan Cameron chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW); 5060e589d5fSMaxime Ripard idx++; 5070e589d5fSMaxime Ripard } 5080e589d5fSMaxime Ripard timestamp = chan_array + idx; 5090e589d5fSMaxime Ripard 5100e589d5fSMaxime Ripard timestamp->type = IIO_TIMESTAMP; 5110e589d5fSMaxime Ripard timestamp->channel = -1; 5120e589d5fSMaxime Ripard timestamp->scan_index = idx; 5130e589d5fSMaxime Ripard timestamp->scan_type.sign = 's'; 5140e589d5fSMaxime Ripard timestamp->scan_type.realbits = 64; 5150e589d5fSMaxime Ripard timestamp->scan_type.storagebits = 64; 5160e589d5fSMaxime Ripard 5170e589d5fSMaxime Ripard idev->channels = chan_array; 5180e589d5fSMaxime Ripard return idev->num_channels; 5190e589d5fSMaxime Ripard } 5200e589d5fSMaxime Ripard 5214f3bcd87SDan Carpenter static int at91_adc_get_trigger_value_by_name(struct iio_dev *idev, 5220e589d5fSMaxime Ripard struct at91_adc_trigger *triggers, 5230e589d5fSMaxime Ripard const char *trigger_name) 5240e589d5fSMaxime Ripard { 5250e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 5260e589d5fSMaxime Ripard int i; 5270e589d5fSMaxime Ripard 5280e589d5fSMaxime Ripard for (i = 0; i < st->trigger_number; i++) { 5290e589d5fSMaxime Ripard char *name = kasprintf(GFP_KERNEL, 5300e589d5fSMaxime Ripard "%s-dev%d-%s", 5310e589d5fSMaxime Ripard idev->name, 5320e589d5fSMaxime Ripard idev->id, 5330e589d5fSMaxime Ripard triggers[i].name); 5340e589d5fSMaxime Ripard if (!name) 5350e589d5fSMaxime Ripard return -ENOMEM; 5360e589d5fSMaxime Ripard 5370e589d5fSMaxime Ripard if (strcmp(trigger_name, name) == 0) { 5380e589d5fSMaxime Ripard kfree(name); 5394f3bcd87SDan Carpenter if (triggers[i].value == 0) 5404f3bcd87SDan Carpenter return -EINVAL; 5414f3bcd87SDan Carpenter return triggers[i].value; 5420e589d5fSMaxime Ripard } 5430e589d5fSMaxime Ripard 5440e589d5fSMaxime Ripard kfree(name); 5450e589d5fSMaxime Ripard } 5460e589d5fSMaxime Ripard 5474f3bcd87SDan Carpenter return -EINVAL; 5480e589d5fSMaxime Ripard } 5490e589d5fSMaxime Ripard 5500e589d5fSMaxime Ripard static int at91_adc_configure_trigger(struct iio_trigger *trig, bool state) 5510e589d5fSMaxime Ripard { 5521e9663c6SLars-Peter Clausen struct iio_dev *idev = iio_trigger_get_drvdata(trig); 5530e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 5540e589d5fSMaxime Ripard struct at91_adc_reg_desc *reg = st->registers; 5550e589d5fSMaxime Ripard u32 status = at91_adc_readl(st, reg->trigger_register); 5564f3bcd87SDan Carpenter int value; 5570e589d5fSMaxime Ripard u8 bit; 5580e589d5fSMaxime Ripard 5590e589d5fSMaxime Ripard value = at91_adc_get_trigger_value_by_name(idev, 5600e589d5fSMaxime Ripard st->trigger_list, 5610e589d5fSMaxime Ripard idev->trig->name); 5624f3bcd87SDan Carpenter if (value < 0) 5634f3bcd87SDan Carpenter return value; 5640e589d5fSMaxime Ripard 5650e589d5fSMaxime Ripard if (state) { 5660e589d5fSMaxime Ripard st->buffer = kmalloc(idev->scan_bytes, GFP_KERNEL); 5670e589d5fSMaxime Ripard if (st->buffer == NULL) 5680e589d5fSMaxime Ripard return -ENOMEM; 5690e589d5fSMaxime Ripard 5700e589d5fSMaxime Ripard at91_adc_writel(st, reg->trigger_register, 5710e589d5fSMaxime Ripard status | value); 5720e589d5fSMaxime Ripard 57370dddeeeSOctavian Purdila for_each_set_bit(bit, idev->active_scan_mask, 5740e589d5fSMaxime Ripard st->num_channels) { 5750e589d5fSMaxime Ripard struct iio_chan_spec const *chan = idev->channels + bit; 5760e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_CHER, 5770e589d5fSMaxime Ripard AT91_ADC_CH(chan->channel)); 5780e589d5fSMaxime Ripard } 5790e589d5fSMaxime Ripard 5800e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_IER, reg->drdy_mask); 5810e589d5fSMaxime Ripard 5820e589d5fSMaxime Ripard } else { 5830e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_IDR, reg->drdy_mask); 5840e589d5fSMaxime Ripard 5850e589d5fSMaxime Ripard at91_adc_writel(st, reg->trigger_register, 5860e589d5fSMaxime Ripard status & ~value); 5870e589d5fSMaxime Ripard 58870dddeeeSOctavian Purdila for_each_set_bit(bit, idev->active_scan_mask, 5890e589d5fSMaxime Ripard st->num_channels) { 5900e589d5fSMaxime Ripard struct iio_chan_spec const *chan = idev->channels + bit; 5910e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_CHDR, 5920e589d5fSMaxime Ripard AT91_ADC_CH(chan->channel)); 5930e589d5fSMaxime Ripard } 5940e589d5fSMaxime Ripard kfree(st->buffer); 5950e589d5fSMaxime Ripard } 5960e589d5fSMaxime Ripard 5970e589d5fSMaxime Ripard return 0; 5980e589d5fSMaxime Ripard } 5990e589d5fSMaxime Ripard 6000e589d5fSMaxime Ripard static const struct iio_trigger_ops at91_adc_trigger_ops = { 6010e589d5fSMaxime Ripard .set_trigger_state = &at91_adc_configure_trigger, 6020e589d5fSMaxime Ripard }; 6030e589d5fSMaxime Ripard 6040e589d5fSMaxime Ripard static struct iio_trigger *at91_adc_allocate_trigger(struct iio_dev *idev, 6050e589d5fSMaxime Ripard struct at91_adc_trigger *trigger) 6060e589d5fSMaxime Ripard { 6070e589d5fSMaxime Ripard struct iio_trigger *trig; 6080e589d5fSMaxime Ripard int ret; 6090e589d5fSMaxime Ripard 6100e589d5fSMaxime Ripard trig = iio_trigger_alloc("%s-dev%d-%s", idev->name, 6110e589d5fSMaxime Ripard idev->id, trigger->name); 6120e589d5fSMaxime Ripard if (trig == NULL) 6130e589d5fSMaxime Ripard return NULL; 6140e589d5fSMaxime Ripard 6150e589d5fSMaxime Ripard trig->dev.parent = idev->dev.parent; 6161e9663c6SLars-Peter Clausen iio_trigger_set_drvdata(trig, idev); 6170e589d5fSMaxime Ripard trig->ops = &at91_adc_trigger_ops; 6180e589d5fSMaxime Ripard 6190e589d5fSMaxime Ripard ret = iio_trigger_register(trig); 6200e589d5fSMaxime Ripard if (ret) 6210e589d5fSMaxime Ripard return NULL; 6220e589d5fSMaxime Ripard 6230e589d5fSMaxime Ripard return trig; 6240e589d5fSMaxime Ripard } 6250e589d5fSMaxime Ripard 6260e589d5fSMaxime Ripard static int at91_adc_trigger_init(struct iio_dev *idev) 6270e589d5fSMaxime Ripard { 6280e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 6290e589d5fSMaxime Ripard int i, ret; 6300e589d5fSMaxime Ripard 631a86854d0SKees Cook st->trig = devm_kcalloc(&idev->dev, 632a86854d0SKees Cook st->trigger_number, sizeof(*st->trig), 6336b3aa313SAxel Lin GFP_KERNEL); 6340e589d5fSMaxime Ripard 6350e589d5fSMaxime Ripard if (st->trig == NULL) { 6360e589d5fSMaxime Ripard ret = -ENOMEM; 6370e589d5fSMaxime Ripard goto error_ret; 6380e589d5fSMaxime Ripard } 6390e589d5fSMaxime Ripard 6400e589d5fSMaxime Ripard for (i = 0; i < st->trigger_number; i++) { 6410e589d5fSMaxime Ripard if (st->trigger_list[i].is_external && !(st->use_external)) 6420e589d5fSMaxime Ripard continue; 6430e589d5fSMaxime Ripard 6440e589d5fSMaxime Ripard st->trig[i] = at91_adc_allocate_trigger(idev, 6450e589d5fSMaxime Ripard st->trigger_list + i); 6460e589d5fSMaxime Ripard if (st->trig[i] == NULL) { 6470e589d5fSMaxime Ripard dev_err(&idev->dev, 6480e589d5fSMaxime Ripard "Could not allocate trigger %d\n", i); 6490e589d5fSMaxime Ripard ret = -ENOMEM; 6500e589d5fSMaxime Ripard goto error_trigger; 6510e589d5fSMaxime Ripard } 6520e589d5fSMaxime Ripard } 6530e589d5fSMaxime Ripard 6540e589d5fSMaxime Ripard return 0; 6550e589d5fSMaxime Ripard 6560e589d5fSMaxime Ripard error_trigger: 6570e589d5fSMaxime Ripard for (i--; i >= 0; i--) { 6580e589d5fSMaxime Ripard iio_trigger_unregister(st->trig[i]); 6590e589d5fSMaxime Ripard iio_trigger_free(st->trig[i]); 6600e589d5fSMaxime Ripard } 6610e589d5fSMaxime Ripard error_ret: 6620e589d5fSMaxime Ripard return ret; 6630e589d5fSMaxime Ripard } 6640e589d5fSMaxime Ripard 6650e589d5fSMaxime Ripard static void at91_adc_trigger_remove(struct iio_dev *idev) 6660e589d5fSMaxime Ripard { 6670e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 6680e589d5fSMaxime Ripard int i; 6690e589d5fSMaxime Ripard 6700e589d5fSMaxime Ripard for (i = 0; i < st->trigger_number; i++) { 6710e589d5fSMaxime Ripard iio_trigger_unregister(st->trig[i]); 6720e589d5fSMaxime Ripard iio_trigger_free(st->trig[i]); 6730e589d5fSMaxime Ripard } 6740e589d5fSMaxime Ripard } 6750e589d5fSMaxime Ripard 6760e589d5fSMaxime Ripard static int at91_adc_buffer_init(struct iio_dev *idev) 6770e589d5fSMaxime Ripard { 67890032e4eSLars-Peter Clausen return iio_triggered_buffer_setup(idev, &iio_pollfunc_store_time, 67990032e4eSLars-Peter Clausen &at91_adc_trigger_handler, NULL); 6800e589d5fSMaxime Ripard } 6810e589d5fSMaxime Ripard 6820e589d5fSMaxime Ripard static void at91_adc_buffer_remove(struct iio_dev *idev) 6830e589d5fSMaxime Ripard { 68490032e4eSLars-Peter Clausen iio_triggered_buffer_cleanup(idev); 6850e589d5fSMaxime Ripard } 6860e589d5fSMaxime Ripard 6870e589d5fSMaxime Ripard static int at91_adc_read_raw(struct iio_dev *idev, 6880e589d5fSMaxime Ripard struct iio_chan_spec const *chan, 6890e589d5fSMaxime Ripard int *val, int *val2, long mask) 6900e589d5fSMaxime Ripard { 6910e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 6920e589d5fSMaxime Ripard int ret; 6930e589d5fSMaxime Ripard 6940e589d5fSMaxime Ripard switch (mask) { 6950e589d5fSMaxime Ripard case IIO_CHAN_INFO_RAW: 6960e589d5fSMaxime Ripard mutex_lock(&st->lock); 6970e589d5fSMaxime Ripard 698d4f51956SLudovic Desroches st->chnb = chan->channel; 6990e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_CHER, 7000e589d5fSMaxime Ripard AT91_ADC_CH(chan->channel)); 701d4f51956SLudovic Desroches at91_adc_writel(st, AT91_ADC_IER, BIT(chan->channel)); 7020e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_CR, AT91_ADC_START); 7030e589d5fSMaxime Ripard 7040e589d5fSMaxime Ripard ret = wait_event_interruptible_timeout(st->wq_data_avail, 7050e589d5fSMaxime Ripard st->done, 7060e589d5fSMaxime Ripard msecs_to_jiffies(1000)); 7070e589d5fSMaxime Ripard if (ret == 0) 70890e6dc7cSLars-Peter Clausen ret = -ETIMEDOUT; 70990e6dc7cSLars-Peter Clausen if (ret < 0) { 71090e6dc7cSLars-Peter Clausen mutex_unlock(&st->lock); 7110e589d5fSMaxime Ripard return ret; 71290e6dc7cSLars-Peter Clausen } 7130e589d5fSMaxime Ripard 7140e589d5fSMaxime Ripard *val = st->last_value; 7150e589d5fSMaxime Ripard 7160e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_CHDR, 7170e589d5fSMaxime Ripard AT91_ADC_CH(chan->channel)); 718d4f51956SLudovic Desroches at91_adc_writel(st, AT91_ADC_IDR, BIT(chan->channel)); 7190e589d5fSMaxime Ripard 7200e589d5fSMaxime Ripard st->last_value = 0; 7210e589d5fSMaxime Ripard st->done = false; 7220e589d5fSMaxime Ripard mutex_unlock(&st->lock); 7230e589d5fSMaxime Ripard return IIO_VAL_INT; 7240e589d5fSMaxime Ripard 7250e589d5fSMaxime Ripard case IIO_CHAN_INFO_SCALE: 726c45e561eSLars-Peter Clausen *val = st->vref_mv; 727c45e561eSLars-Peter Clausen *val2 = chan->scan_type.realbits; 728c45e561eSLars-Peter Clausen return IIO_VAL_FRACTIONAL_LOG2; 7290e589d5fSMaxime Ripard default: 7300e589d5fSMaxime Ripard break; 7310e589d5fSMaxime Ripard } 7320e589d5fSMaxime Ripard return -EINVAL; 7330e589d5fSMaxime Ripard } 7340e589d5fSMaxime Ripard 73547be16b6SLudovic Desroches static int at91_adc_of_get_resolution(struct at91_adc_state *st, 73647be16b6SLudovic Desroches struct platform_device *pdev) 73747be16b6SLudovic Desroches { 73847be16b6SLudovic Desroches struct iio_dev *idev = iio_priv_to_dev(st); 73947be16b6SLudovic Desroches struct device_node *np = pdev->dev.of_node; 74047be16b6SLudovic Desroches int count, i, ret = 0; 74147be16b6SLudovic Desroches char *res_name, *s; 74247be16b6SLudovic Desroches u32 *resolutions; 74347be16b6SLudovic Desroches 74447be16b6SLudovic Desroches count = of_property_count_strings(np, "atmel,adc-res-names"); 74547be16b6SLudovic Desroches if (count < 2) { 74647be16b6SLudovic Desroches dev_err(&idev->dev, "You must specified at least two resolution names for " 74747be16b6SLudovic Desroches "adc-res-names property in the DT\n"); 74847be16b6SLudovic Desroches return count; 74947be16b6SLudovic Desroches } 75047be16b6SLudovic Desroches 7513fba9b5fSNizam Haider resolutions = kmalloc_array(count, sizeof(*resolutions), GFP_KERNEL); 75247be16b6SLudovic Desroches if (!resolutions) 75347be16b6SLudovic Desroches return -ENOMEM; 75447be16b6SLudovic Desroches 75547be16b6SLudovic Desroches if (of_property_read_u32_array(np, "atmel,adc-res", resolutions, count)) { 75647be16b6SLudovic Desroches dev_err(&idev->dev, "Missing adc-res property in the DT.\n"); 75747be16b6SLudovic Desroches ret = -ENODEV; 75847be16b6SLudovic Desroches goto ret; 75947be16b6SLudovic Desroches } 76047be16b6SLudovic Desroches 76147be16b6SLudovic Desroches if (of_property_read_string(np, "atmel,adc-use-res", (const char **)&res_name)) 76247be16b6SLudovic Desroches res_name = "highres"; 76347be16b6SLudovic Desroches 76447be16b6SLudovic Desroches for (i = 0; i < count; i++) { 76547be16b6SLudovic Desroches if (of_property_read_string_index(np, "atmel,adc-res-names", i, (const char **)&s)) 76647be16b6SLudovic Desroches continue; 76747be16b6SLudovic Desroches 76847be16b6SLudovic Desroches if (strcmp(res_name, s)) 76947be16b6SLudovic Desroches continue; 77047be16b6SLudovic Desroches 77147be16b6SLudovic Desroches st->res = resolutions[i]; 77247be16b6SLudovic Desroches if (!strcmp(res_name, "lowres")) 77347be16b6SLudovic Desroches st->low_res = true; 77447be16b6SLudovic Desroches else 77547be16b6SLudovic Desroches st->low_res = false; 77647be16b6SLudovic Desroches 77747be16b6SLudovic Desroches dev_info(&idev->dev, "Resolution used: %u bits\n", st->res); 77847be16b6SLudovic Desroches goto ret; 77947be16b6SLudovic Desroches } 78047be16b6SLudovic Desroches 78147be16b6SLudovic Desroches dev_err(&idev->dev, "There is no resolution for %s\n", res_name); 78247be16b6SLudovic Desroches 78347be16b6SLudovic Desroches ret: 78447be16b6SLudovic Desroches kfree(resolutions); 78547be16b6SLudovic Desroches return ret; 78647be16b6SLudovic Desroches } 78747be16b6SLudovic Desroches 7882ab5f39bSJan Leupold static u32 calc_startup_ticks_9260(u32 startup_time, u32 adc_clk_khz) 789c4601666SJosh Wu { 790c4601666SJosh Wu /* 791c4601666SJosh Wu * Number of ticks needed to cover the startup time of the ADC 792c4601666SJosh Wu * as defined in the electrical characteristics of the board, 793c4601666SJosh Wu * divided by 8. The formula thus is : 794c4601666SJosh Wu * Startup Time = (ticks + 1) * 8 / ADC Clock 795c4601666SJosh Wu */ 796c4601666SJosh Wu return round_up((startup_time * adc_clk_khz / 1000) - 1, 8) / 8; 797c4601666SJosh Wu } 798c4601666SJosh Wu 7992ab5f39bSJan Leupold static u32 calc_startup_ticks_9x5(u32 startup_time, u32 adc_clk_khz) 800c4601666SJosh Wu { 801c4601666SJosh Wu /* 802c4601666SJosh Wu * For sama5d3x and at91sam9x5, the formula changes to: 803c4601666SJosh Wu * Startup Time = <lookup_table_value> / ADC Clock 804c4601666SJosh Wu */ 8055b4e17c9SColin Ian King static const int startup_lookup[] = { 806c4601666SJosh Wu 0, 8, 16, 24, 807c4601666SJosh Wu 64, 80, 96, 112, 808c4601666SJosh Wu 512, 576, 640, 704, 809c4601666SJosh Wu 768, 832, 896, 960 810c4601666SJosh Wu }; 811c4601666SJosh Wu int i, size = ARRAY_SIZE(startup_lookup); 812c4601666SJosh Wu unsigned int ticks; 813c4601666SJosh Wu 814c4601666SJosh Wu ticks = startup_time * adc_clk_khz / 1000; 815c4601666SJosh Wu for (i = 0; i < size; i++) 816c4601666SJosh Wu if (ticks < startup_lookup[i]) 817c4601666SJosh Wu break; 818c4601666SJosh Wu 819c4601666SJosh Wu ticks = i; 820c4601666SJosh Wu if (ticks == size) 821c4601666SJosh Wu /* Reach the end of lookup table */ 822c4601666SJosh Wu ticks = size - 1; 823c4601666SJosh Wu 824c4601666SJosh Wu return ticks; 825c4601666SJosh Wu } 826c4601666SJosh Wu 827e1811f97SJosh Wu static const struct of_device_id at91_adc_dt_ids[]; 828e1811f97SJosh Wu 829c8b11de0SJosh Wu static int at91_adc_probe_dt_ts(struct device_node *node, 830c8b11de0SJosh Wu struct at91_adc_state *st, struct device *dev) 831c8b11de0SJosh Wu { 832c8b11de0SJosh Wu int ret; 833c8b11de0SJosh Wu u32 prop; 834c8b11de0SJosh Wu 835c8b11de0SJosh Wu ret = of_property_read_u32(node, "atmel,adc-ts-wires", &prop); 836c8b11de0SJosh Wu if (ret) { 837c8b11de0SJosh Wu dev_info(dev, "ADC Touch screen is disabled.\n"); 838c8b11de0SJosh Wu return 0; 839c8b11de0SJosh Wu } 840c8b11de0SJosh Wu 841c8b11de0SJosh Wu switch (prop) { 842c8b11de0SJosh Wu case 4: 843c8b11de0SJosh Wu case 5: 844c8b11de0SJosh Wu st->touchscreen_type = prop; 845c8b11de0SJosh Wu break; 846c8b11de0SJosh Wu default: 847c8b11de0SJosh Wu dev_err(dev, "Unsupported number of touchscreen wires (%d). Should be 4 or 5.\n", prop); 848c8b11de0SJosh Wu return -EINVAL; 849c8b11de0SJosh Wu } 850c8b11de0SJosh Wu 85184882b06SAlexandre Belloni if (!st->caps->has_tsmr) 85284882b06SAlexandre Belloni return 0; 853c8b11de0SJosh Wu prop = 0; 854c8b11de0SJosh Wu of_property_read_u32(node, "atmel,adc-ts-pressure-threshold", &prop); 855c8b11de0SJosh Wu st->ts_pressure_threshold = prop; 856c8b11de0SJosh Wu if (st->ts_pressure_threshold) { 857c8b11de0SJosh Wu return 0; 858c8b11de0SJosh Wu } else { 859c8b11de0SJosh Wu dev_err(dev, "Invalid pressure threshold for the touchscreen\n"); 860c8b11de0SJosh Wu return -EINVAL; 861c8b11de0SJosh Wu } 862c8b11de0SJosh Wu } 863c8b11de0SJosh Wu 864e364185fSMaxime Ripard static int at91_adc_probe_dt(struct at91_adc_state *st, 865e364185fSMaxime Ripard struct platform_device *pdev) 866e364185fSMaxime Ripard { 867e364185fSMaxime Ripard struct iio_dev *idev = iio_priv_to_dev(st); 868e364185fSMaxime Ripard struct device_node *node = pdev->dev.of_node; 869e364185fSMaxime Ripard struct device_node *trig_node; 870e364185fSMaxime Ripard int i = 0, ret; 871e364185fSMaxime Ripard u32 prop; 872e364185fSMaxime Ripard 873e364185fSMaxime Ripard if (!node) 874e364185fSMaxime Ripard return -EINVAL; 875e364185fSMaxime Ripard 876e1811f97SJosh Wu st->caps = (struct at91_adc_caps *) 877e1811f97SJosh Wu of_match_device(at91_adc_dt_ids, &pdev->dev)->data; 878e1811f97SJosh Wu 879e364185fSMaxime Ripard st->use_external = of_property_read_bool(node, "atmel,adc-use-external-triggers"); 880e364185fSMaxime Ripard 881e364185fSMaxime Ripard if (of_property_read_u32(node, "atmel,adc-channels-used", &prop)) { 882e364185fSMaxime Ripard dev_err(&idev->dev, "Missing adc-channels-used property in the DT.\n"); 883e364185fSMaxime Ripard ret = -EINVAL; 884e364185fSMaxime Ripard goto error_ret; 885e364185fSMaxime Ripard } 886e364185fSMaxime Ripard st->channels_mask = prop; 887e364185fSMaxime Ripard 888e748783cSJean-Christophe PLAGNIOL-VILLARD st->sleep_mode = of_property_read_bool(node, "atmel,adc-sleep-mode"); 889e748783cSJean-Christophe PLAGNIOL-VILLARD 890e364185fSMaxime Ripard if (of_property_read_u32(node, "atmel,adc-startup-time", &prop)) { 891e364185fSMaxime Ripard dev_err(&idev->dev, "Missing adc-startup-time property in the DT.\n"); 892e364185fSMaxime Ripard ret = -EINVAL; 893e364185fSMaxime Ripard goto error_ret; 894e364185fSMaxime Ripard } 895e364185fSMaxime Ripard st->startup_time = prop; 896e364185fSMaxime Ripard 897beca9e76SJean-Christophe PLAGNIOL-VILLARD prop = 0; 898beca9e76SJean-Christophe PLAGNIOL-VILLARD of_property_read_u32(node, "atmel,adc-sample-hold-time", &prop); 899beca9e76SJean-Christophe PLAGNIOL-VILLARD st->sample_hold_time = prop; 900e364185fSMaxime Ripard 901e364185fSMaxime Ripard if (of_property_read_u32(node, "atmel,adc-vref", &prop)) { 902e364185fSMaxime Ripard dev_err(&idev->dev, "Missing adc-vref property in the DT.\n"); 903e364185fSMaxime Ripard ret = -EINVAL; 904e364185fSMaxime Ripard goto error_ret; 905e364185fSMaxime Ripard } 906e364185fSMaxime Ripard st->vref_mv = prop; 907e364185fSMaxime Ripard 90847be16b6SLudovic Desroches ret = at91_adc_of_get_resolution(st, pdev); 90947be16b6SLudovic Desroches if (ret) 91047be16b6SLudovic Desroches goto error_ret; 91147be16b6SLudovic Desroches 912e1811f97SJosh Wu st->registers = &st->caps->registers; 9132b6d598bSJosh Wu st->num_channels = st->caps->num_channels; 914e364185fSMaxime Ripard st->trigger_number = of_get_child_count(node); 915a86854d0SKees Cook st->trigger_list = devm_kcalloc(&idev->dev, 916a86854d0SKees Cook st->trigger_number, 9176b3aa313SAxel Lin sizeof(struct at91_adc_trigger), 9186b3aa313SAxel Lin GFP_KERNEL); 919e364185fSMaxime Ripard if (!st->trigger_list) { 920e364185fSMaxime Ripard dev_err(&idev->dev, "Could not allocate trigger list memory.\n"); 921e364185fSMaxime Ripard ret = -ENOMEM; 922e364185fSMaxime Ripard goto error_ret; 923e364185fSMaxime Ripard } 924e364185fSMaxime Ripard 925e364185fSMaxime Ripard for_each_child_of_node(node, trig_node) { 926e364185fSMaxime Ripard struct at91_adc_trigger *trig = st->trigger_list + i; 927e364185fSMaxime Ripard const char *name; 928e364185fSMaxime Ripard 929e364185fSMaxime Ripard if (of_property_read_string(trig_node, "trigger-name", &name)) { 930e364185fSMaxime Ripard dev_err(&idev->dev, "Missing trigger-name property in the DT.\n"); 931e364185fSMaxime Ripard ret = -EINVAL; 932e364185fSMaxime Ripard goto error_ret; 933e364185fSMaxime Ripard } 934e364185fSMaxime Ripard trig->name = name; 935e364185fSMaxime Ripard 936e364185fSMaxime Ripard if (of_property_read_u32(trig_node, "trigger-value", &prop)) { 937e364185fSMaxime Ripard dev_err(&idev->dev, "Missing trigger-value property in the DT.\n"); 938e364185fSMaxime Ripard ret = -EINVAL; 939e364185fSMaxime Ripard goto error_ret; 940e364185fSMaxime Ripard } 941e364185fSMaxime Ripard trig->value = prop; 942e364185fSMaxime Ripard trig->is_external = of_property_read_bool(trig_node, "trigger-external"); 943e364185fSMaxime Ripard i++; 944e364185fSMaxime Ripard } 945e364185fSMaxime Ripard 946c8b11de0SJosh Wu /* Check if touchscreen is supported. */ 947c8b11de0SJosh Wu if (st->caps->has_ts) 948c8b11de0SJosh Wu return at91_adc_probe_dt_ts(node, st, &idev->dev); 949c8b11de0SJosh Wu else 950c8b11de0SJosh Wu dev_info(&idev->dev, "not support touchscreen in the adc compatible string.\n"); 951c8b11de0SJosh Wu 952e364185fSMaxime Ripard return 0; 953e364185fSMaxime Ripard 954e364185fSMaxime Ripard error_ret: 955e364185fSMaxime Ripard return ret; 956e364185fSMaxime Ripard } 957e364185fSMaxime Ripard 9580e589d5fSMaxime Ripard static int at91_adc_probe_pdata(struct at91_adc_state *st, 9590e589d5fSMaxime Ripard struct platform_device *pdev) 9600e589d5fSMaxime Ripard { 9610e589d5fSMaxime Ripard struct at91_adc_data *pdata = pdev->dev.platform_data; 9620e589d5fSMaxime Ripard 9630e589d5fSMaxime Ripard if (!pdata) 9640e589d5fSMaxime Ripard return -EINVAL; 9650e589d5fSMaxime Ripard 966467a44b0SAlexandre Belloni st->caps = (struct at91_adc_caps *) 967467a44b0SAlexandre Belloni platform_get_device_id(pdev)->driver_data; 968467a44b0SAlexandre Belloni 9690e589d5fSMaxime Ripard st->use_external = pdata->use_external_triggers; 9700e589d5fSMaxime Ripard st->vref_mv = pdata->vref; 9710e589d5fSMaxime Ripard st->channels_mask = pdata->channels_used; 972467a44b0SAlexandre Belloni st->num_channels = st->caps->num_channels; 9730e589d5fSMaxime Ripard st->startup_time = pdata->startup_time; 9740e589d5fSMaxime Ripard st->trigger_number = pdata->trigger_number; 9750e589d5fSMaxime Ripard st->trigger_list = pdata->trigger_list; 976467a44b0SAlexandre Belloni st->registers = &st->caps->registers; 97784882b06SAlexandre Belloni st->touchscreen_type = pdata->touchscreen_type; 9780e589d5fSMaxime Ripard 9790e589d5fSMaxime Ripard return 0; 9800e589d5fSMaxime Ripard } 9810e589d5fSMaxime Ripard 9820e589d5fSMaxime Ripard static const struct iio_info at91_adc_info = { 9830e589d5fSMaxime Ripard .read_raw = &at91_adc_read_raw, 9840e589d5fSMaxime Ripard }; 9850e589d5fSMaxime Ripard 986c8b11de0SJosh Wu /* Touchscreen related functions */ 987c8b11de0SJosh Wu static int atmel_ts_open(struct input_dev *dev) 988c8b11de0SJosh Wu { 989c8b11de0SJosh Wu struct at91_adc_state *st = input_get_drvdata(dev); 990c8b11de0SJosh Wu 99184882b06SAlexandre Belloni if (st->caps->has_tsmr) 992c8b11de0SJosh Wu at91_adc_writel(st, AT91_ADC_IER, AT91_ADC_IER_PEN); 99384882b06SAlexandre Belloni else 99484882b06SAlexandre Belloni at91_adc_writel(st, AT91_ADC_IER, AT91RL_ADC_IER_PEN); 995c8b11de0SJosh Wu return 0; 996c8b11de0SJosh Wu } 997c8b11de0SJosh Wu 998c8b11de0SJosh Wu static void atmel_ts_close(struct input_dev *dev) 999c8b11de0SJosh Wu { 1000c8b11de0SJosh Wu struct at91_adc_state *st = input_get_drvdata(dev); 1001c8b11de0SJosh Wu 100284882b06SAlexandre Belloni if (st->caps->has_tsmr) 1003c8b11de0SJosh Wu at91_adc_writel(st, AT91_ADC_IDR, AT91_ADC_IER_PEN); 100484882b06SAlexandre Belloni else 100584882b06SAlexandre Belloni at91_adc_writel(st, AT91_ADC_IDR, AT91RL_ADC_IER_PEN); 1006c8b11de0SJosh Wu } 1007c8b11de0SJosh Wu 1008c8b11de0SJosh Wu static int at91_ts_hw_init(struct at91_adc_state *st, u32 adc_clk_khz) 1009c8b11de0SJosh Wu { 1010ede63aafSNicolas Ferre struct iio_dev *idev = iio_priv_to_dev(st); 101184882b06SAlexandre Belloni u32 reg = 0; 1012ede63aafSNicolas Ferre u32 tssctim = 0; 1013c8b11de0SJosh Wu int i = 0; 1014c8b11de0SJosh Wu 101584882b06SAlexandre Belloni /* a Pen Detect Debounce Time is necessary for the ADC Touch to avoid 101684882b06SAlexandre Belloni * pen detect noise. 101784882b06SAlexandre Belloni * The formula is : Pen Detect Debounce Time = (2 ^ pendbc) / ADCClock 101884882b06SAlexandre Belloni */ 101984882b06SAlexandre Belloni st->ts_pendbc = round_up(TOUCH_PEN_DETECT_DEBOUNCE_US * adc_clk_khz / 102084882b06SAlexandre Belloni 1000, 1); 102184882b06SAlexandre Belloni 102284882b06SAlexandre Belloni while (st->ts_pendbc >> ++i) 102384882b06SAlexandre Belloni ; /* Empty! Find the shift offset */ 102484882b06SAlexandre Belloni if (abs(st->ts_pendbc - (1 << i)) < abs(st->ts_pendbc - (1 << (i - 1)))) 102584882b06SAlexandre Belloni st->ts_pendbc = i; 102684882b06SAlexandre Belloni else 102784882b06SAlexandre Belloni st->ts_pendbc = i - 1; 102884882b06SAlexandre Belloni 102984882b06SAlexandre Belloni if (!st->caps->has_tsmr) { 103084882b06SAlexandre Belloni reg = at91_adc_readl(st, AT91_ADC_MR); 103184882b06SAlexandre Belloni reg |= AT91_ADC_TSAMOD_TS_ONLY_MODE | AT91_ADC_PENDET; 103284882b06SAlexandre Belloni 103384882b06SAlexandre Belloni reg |= AT91_ADC_PENDBC_(st->ts_pendbc) & AT91_ADC_PENDBC; 103484882b06SAlexandre Belloni at91_adc_writel(st, AT91_ADC_MR, reg); 103584882b06SAlexandre Belloni 103684882b06SAlexandre Belloni reg = AT91_ADC_TSR_SHTIM_(TOUCH_SHTIM) & AT91_ADC_TSR_SHTIM; 103784882b06SAlexandre Belloni at91_adc_writel(st, AT91_ADC_TSR, reg); 103884882b06SAlexandre Belloni 103984882b06SAlexandre Belloni st->ts_sample_period_val = round_up((TOUCH_SAMPLE_PERIOD_US_RL * 104084882b06SAlexandre Belloni adc_clk_khz / 1000) - 1, 1); 104184882b06SAlexandre Belloni 104284882b06SAlexandre Belloni return 0; 104384882b06SAlexandre Belloni } 104484882b06SAlexandre Belloni 1045ede63aafSNicolas Ferre /* Touchscreen Switches Closure time needed for allowing the value to 1046ede63aafSNicolas Ferre * stabilize. 1047ede63aafSNicolas Ferre * Switch Closure Time = (TSSCTIM * 4) ADCClock periods 1048ede63aafSNicolas Ferre */ 1049ede63aafSNicolas Ferre tssctim = DIV_ROUND_UP(TOUCH_SCTIM_US * adc_clk_khz / 1000, 4); 1050ede63aafSNicolas Ferre dev_dbg(&idev->dev, "adc_clk at: %d KHz, tssctim at: %d\n", 1051ede63aafSNicolas Ferre adc_clk_khz, tssctim); 1052ede63aafSNicolas Ferre 1053c8b11de0SJosh Wu if (st->touchscreen_type == ATMEL_ADC_TOUCHSCREEN_4WIRE) 1054c8b11de0SJosh Wu reg = AT91_ADC_TSMR_TSMODE_4WIRE_PRESS; 1055c8b11de0SJosh Wu else 1056c8b11de0SJosh Wu reg = AT91_ADC_TSMR_TSMODE_5WIRE; 1057c8b11de0SJosh Wu 1058ede63aafSNicolas Ferre reg |= AT91_ADC_TSMR_SCTIM_(tssctim) & AT91_ADC_TSMR_SCTIM; 1059c8b11de0SJosh Wu reg |= AT91_ADC_TSMR_TSAV_(st->caps->ts_filter_average) 1060c8b11de0SJosh Wu & AT91_ADC_TSMR_TSAV; 106184882b06SAlexandre Belloni reg |= AT91_ADC_TSMR_PENDBC_(st->ts_pendbc) & AT91_ADC_TSMR_PENDBC; 1062c8b11de0SJosh Wu reg |= AT91_ADC_TSMR_NOTSDMA; 1063c8b11de0SJosh Wu reg |= AT91_ADC_TSMR_PENDET_ENA; 106484882b06SAlexandre Belloni reg |= 0x03 << 8; /* TSFREQ, needs to be bigger than TSAV */ 1065c8b11de0SJosh Wu 1066c8b11de0SJosh Wu at91_adc_writel(st, AT91_ADC_TSMR, reg); 1067c8b11de0SJosh Wu 1068c8b11de0SJosh Wu /* Change adc internal resistor value for better pen detection, 1069c8b11de0SJosh Wu * default value is 100 kOhm. 1070c8b11de0SJosh Wu * 0 = 200 kOhm, 1 = 150 kOhm, 2 = 100 kOhm, 3 = 50 kOhm 1071c8b11de0SJosh Wu * option only available on ES2 and higher 1072c8b11de0SJosh Wu */ 1073c8b11de0SJosh Wu at91_adc_writel(st, AT91_ADC_ACR, st->caps->ts_pen_detect_sensitivity 1074c8b11de0SJosh Wu & AT91_ADC_ACR_PENDETSENS); 1075c8b11de0SJosh Wu 107684882b06SAlexandre Belloni /* Sample Period Time = (TRGPER + 1) / ADCClock */ 1077c8b11de0SJosh Wu st->ts_sample_period_val = round_up((TOUCH_SAMPLE_PERIOD_US * 1078c8b11de0SJosh Wu adc_clk_khz / 1000) - 1, 1); 1079c8b11de0SJosh Wu 1080c8b11de0SJosh Wu return 0; 1081c8b11de0SJosh Wu } 1082c8b11de0SJosh Wu 1083c8b11de0SJosh Wu static int at91_ts_register(struct at91_adc_state *st, 1084c8b11de0SJosh Wu struct platform_device *pdev) 1085c8b11de0SJosh Wu { 1086c8b11de0SJosh Wu struct input_dev *input; 1087c8b11de0SJosh Wu struct iio_dev *idev = iio_priv_to_dev(st); 1088c8b11de0SJosh Wu int ret; 1089c8b11de0SJosh Wu 1090c8b11de0SJosh Wu input = input_allocate_device(); 1091c8b11de0SJosh Wu if (!input) { 1092c8b11de0SJosh Wu dev_err(&idev->dev, "Failed to allocate TS device!\n"); 1093c8b11de0SJosh Wu return -ENOMEM; 1094c8b11de0SJosh Wu } 1095c8b11de0SJosh Wu 1096c8b11de0SJosh Wu input->name = DRIVER_NAME; 1097c8b11de0SJosh Wu input->id.bustype = BUS_HOST; 1098c8b11de0SJosh Wu input->dev.parent = &pdev->dev; 1099c8b11de0SJosh Wu input->open = atmel_ts_open; 1100c8b11de0SJosh Wu input->close = atmel_ts_close; 1101c8b11de0SJosh Wu 1102c8b11de0SJosh Wu __set_bit(EV_ABS, input->evbit); 1103c8b11de0SJosh Wu __set_bit(EV_KEY, input->evbit); 1104c8b11de0SJosh Wu __set_bit(BTN_TOUCH, input->keybit); 110584882b06SAlexandre Belloni if (st->caps->has_tsmr) { 110684882b06SAlexandre Belloni input_set_abs_params(input, ABS_X, 0, (1 << MAX_POS_BITS) - 1, 110784882b06SAlexandre Belloni 0, 0); 110884882b06SAlexandre Belloni input_set_abs_params(input, ABS_Y, 0, (1 << MAX_POS_BITS) - 1, 110984882b06SAlexandre Belloni 0, 0); 1110c8b11de0SJosh Wu input_set_abs_params(input, ABS_PRESSURE, 0, 0xffffff, 0, 0); 111184882b06SAlexandre Belloni } else { 111284882b06SAlexandre Belloni if (st->touchscreen_type != ATMEL_ADC_TOUCHSCREEN_4WIRE) { 111384882b06SAlexandre Belloni dev_err(&pdev->dev, 111484882b06SAlexandre Belloni "This touchscreen controller only support 4 wires\n"); 111584882b06SAlexandre Belloni ret = -EINVAL; 111684882b06SAlexandre Belloni goto err; 111784882b06SAlexandre Belloni } 111884882b06SAlexandre Belloni 111984882b06SAlexandre Belloni input_set_abs_params(input, ABS_X, 0, (1 << MAX_RLPOS_BITS) - 1, 112084882b06SAlexandre Belloni 0, 0); 112184882b06SAlexandre Belloni input_set_abs_params(input, ABS_Y, 0, (1 << MAX_RLPOS_BITS) - 1, 112284882b06SAlexandre Belloni 0, 0); 112384882b06SAlexandre Belloni } 1124c8b11de0SJosh Wu 1125c8b11de0SJosh Wu st->ts_input = input; 1126c8b11de0SJosh Wu input_set_drvdata(input, st); 1127c8b11de0SJosh Wu 1128c8b11de0SJosh Wu ret = input_register_device(input); 1129c8b11de0SJosh Wu if (ret) 113084882b06SAlexandre Belloni goto err; 1131c8b11de0SJosh Wu 1132c8b11de0SJosh Wu return ret; 113384882b06SAlexandre Belloni 113484882b06SAlexandre Belloni err: 113584882b06SAlexandre Belloni input_free_device(st->ts_input); 113684882b06SAlexandre Belloni return ret; 1137c8b11de0SJosh Wu } 1138c8b11de0SJosh Wu 1139c8b11de0SJosh Wu static void at91_ts_unregister(struct at91_adc_state *st) 1140c8b11de0SJosh Wu { 1141c8b11de0SJosh Wu input_unregister_device(st->ts_input); 1142c8b11de0SJosh Wu } 1143c8b11de0SJosh Wu 1144fc52692cSGreg Kroah-Hartman static int at91_adc_probe(struct platform_device *pdev) 11450e589d5fSMaxime Ripard { 1146db10e201SJosh Wu unsigned int prsc, mstrclk, ticks, adc_clk, adc_clk_khz, shtim; 11470e589d5fSMaxime Ripard int ret; 11480e589d5fSMaxime Ripard struct iio_dev *idev; 11490e589d5fSMaxime Ripard struct at91_adc_state *st; 11500e589d5fSMaxime Ripard struct resource *res; 1151e748783cSJean-Christophe PLAGNIOL-VILLARD u32 reg; 11520e589d5fSMaxime Ripard 1153f8837532SSachin Kamat idev = devm_iio_device_alloc(&pdev->dev, sizeof(struct at91_adc_state)); 1154f8837532SSachin Kamat if (!idev) 1155f8837532SSachin Kamat return -ENOMEM; 11560e589d5fSMaxime Ripard 11570e589d5fSMaxime Ripard st = iio_priv(idev); 11580e589d5fSMaxime Ripard 1159e364185fSMaxime Ripard if (pdev->dev.of_node) 1160e364185fSMaxime Ripard ret = at91_adc_probe_dt(st, pdev); 1161e364185fSMaxime Ripard else 11620e589d5fSMaxime Ripard ret = at91_adc_probe_pdata(st, pdev); 1163e364185fSMaxime Ripard 11640e589d5fSMaxime Ripard if (ret) { 11650e589d5fSMaxime Ripard dev_err(&pdev->dev, "No platform data available.\n"); 1166f8837532SSachin Kamat return -EINVAL; 11670e589d5fSMaxime Ripard } 11680e589d5fSMaxime Ripard 11690e589d5fSMaxime Ripard platform_set_drvdata(pdev, idev); 11700e589d5fSMaxime Ripard 11710e589d5fSMaxime Ripard idev->dev.parent = &pdev->dev; 11720e589d5fSMaxime Ripard idev->name = dev_name(&pdev->dev); 11730e589d5fSMaxime Ripard idev->modes = INDIO_DIRECT_MODE; 11740e589d5fSMaxime Ripard idev->info = &at91_adc_info; 11750e589d5fSMaxime Ripard 11760e589d5fSMaxime Ripard st->irq = platform_get_irq(pdev, 0); 11770e589d5fSMaxime Ripard if (st->irq < 0) { 11780e589d5fSMaxime Ripard dev_err(&pdev->dev, "No IRQ ID is designated\n"); 1179f8837532SSachin Kamat return -ENODEV; 11800e589d5fSMaxime Ripard } 11810e589d5fSMaxime Ripard 1182390d75c1SJulia Lawall res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 11830e589d5fSMaxime Ripard 11845fd98466SThierry Reding st->reg_base = devm_ioremap_resource(&pdev->dev, res); 1185c34812e4SVenkat Prashanth B U if (IS_ERR(st->reg_base)) 1186f8837532SSachin Kamat return PTR_ERR(st->reg_base); 1187c34812e4SVenkat Prashanth B U 11880e589d5fSMaxime Ripard 11890e589d5fSMaxime Ripard /* 11900e589d5fSMaxime Ripard * Disable all IRQs before setting up the handler 11910e589d5fSMaxime Ripard */ 11920e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_CR, AT91_ADC_SWRST); 11930e589d5fSMaxime Ripard at91_adc_writel(st, AT91_ADC_IDR, 0xFFFFFFFF); 119484882b06SAlexandre Belloni 119584882b06SAlexandre Belloni if (st->caps->has_tsmr) 119684882b06SAlexandre Belloni ret = request_irq(st->irq, at91_adc_9x5_interrupt, 0, 119784882b06SAlexandre Belloni pdev->dev.driver->name, idev); 119884882b06SAlexandre Belloni else 119984882b06SAlexandre Belloni ret = request_irq(st->irq, at91_adc_rl_interrupt, 0, 120084882b06SAlexandre Belloni pdev->dev.driver->name, idev); 12010e589d5fSMaxime Ripard if (ret) { 12020e589d5fSMaxime Ripard dev_err(&pdev->dev, "Failed to allocate IRQ.\n"); 1203f8837532SSachin Kamat return ret; 12040e589d5fSMaxime Ripard } 12050e589d5fSMaxime Ripard 1206390d75c1SJulia Lawall st->clk = devm_clk_get(&pdev->dev, "adc_clk"); 12070e589d5fSMaxime Ripard if (IS_ERR(st->clk)) { 12080e589d5fSMaxime Ripard dev_err(&pdev->dev, "Failed to get the clock.\n"); 12090e589d5fSMaxime Ripard ret = PTR_ERR(st->clk); 12100e589d5fSMaxime Ripard goto error_free_irq; 12110e589d5fSMaxime Ripard } 12120e589d5fSMaxime Ripard 121300062a9cSJulia Lawall ret = clk_prepare_enable(st->clk); 12140e589d5fSMaxime Ripard if (ret) { 121500062a9cSJulia Lawall dev_err(&pdev->dev, 121600062a9cSJulia Lawall "Could not prepare or enable the clock.\n"); 1217390d75c1SJulia Lawall goto error_free_irq; 12180e589d5fSMaxime Ripard } 12190e589d5fSMaxime Ripard 1220390d75c1SJulia Lawall st->adc_clk = devm_clk_get(&pdev->dev, "adc_op_clk"); 12210e589d5fSMaxime Ripard if (IS_ERR(st->adc_clk)) { 12220e589d5fSMaxime Ripard dev_err(&pdev->dev, "Failed to get the ADC clock.\n"); 1223f755bbbfSJulia Lawall ret = PTR_ERR(st->adc_clk); 12240e589d5fSMaxime Ripard goto error_disable_clk; 12250e589d5fSMaxime Ripard } 12260e589d5fSMaxime Ripard 122700062a9cSJulia Lawall ret = clk_prepare_enable(st->adc_clk); 12280e589d5fSMaxime Ripard if (ret) { 122900062a9cSJulia Lawall dev_err(&pdev->dev, 123000062a9cSJulia Lawall "Could not prepare or enable the ADC clock.\n"); 1231390d75c1SJulia Lawall goto error_disable_clk; 12320e589d5fSMaxime Ripard } 12330e589d5fSMaxime Ripard 12340e589d5fSMaxime Ripard /* 12350e589d5fSMaxime Ripard * Prescaler rate computation using the formula from the Atmel's 12360e589d5fSMaxime Ripard * datasheet : ADC Clock = MCK / ((Prescaler + 1) * 2), ADC Clock being 12370e589d5fSMaxime Ripard * specified by the electrical characteristics of the board. 12380e589d5fSMaxime Ripard */ 12390e589d5fSMaxime Ripard mstrclk = clk_get_rate(st->clk); 12400e589d5fSMaxime Ripard adc_clk = clk_get_rate(st->adc_clk); 1241db10e201SJosh Wu adc_clk_khz = adc_clk / 1000; 1242c8b11de0SJosh Wu 1243c8b11de0SJosh Wu dev_dbg(&pdev->dev, "Master clock is set as: %d Hz, adc_clk should set as: %d Hz\n", 1244c8b11de0SJosh Wu mstrclk, adc_clk); 1245c8b11de0SJosh Wu 12460e589d5fSMaxime Ripard prsc = (mstrclk / (2 * adc_clk)) - 1; 12470e589d5fSMaxime Ripard 12480e589d5fSMaxime Ripard if (!st->startup_time) { 12490e589d5fSMaxime Ripard dev_err(&pdev->dev, "No startup time available.\n"); 12500e589d5fSMaxime Ripard ret = -EINVAL; 12510e589d5fSMaxime Ripard goto error_disable_adc_clk; 12520e589d5fSMaxime Ripard } 1253c4601666SJosh Wu ticks = (*st->caps->calc_startup_ticks)(st->startup_time, adc_clk_khz); 12540e589d5fSMaxime Ripard 12550e589d5fSMaxime Ripard /* 1256beca9e76SJean-Christophe PLAGNIOL-VILLARD * a minimal Sample and Hold Time is necessary for the ADC to guarantee 1257beca9e76SJean-Christophe PLAGNIOL-VILLARD * the best converted final value between two channels selection 1258beca9e76SJean-Christophe PLAGNIOL-VILLARD * The formula thus is : Sample and Hold Time = (shtim + 1) / ADCClock 1259beca9e76SJean-Christophe PLAGNIOL-VILLARD */ 12608f32b6baSAlexandre Belloni if (st->sample_hold_time > 0) 12618f32b6baSAlexandre Belloni shtim = round_up((st->sample_hold_time * adc_clk_khz / 1000) 12628f32b6baSAlexandre Belloni - 1, 1); 12638f32b6baSAlexandre Belloni else 12648f32b6baSAlexandre Belloni shtim = 0; 1265beca9e76SJean-Christophe PLAGNIOL-VILLARD 12669120c0beSJosh Wu reg = AT91_ADC_PRESCAL_(prsc) & st->registers->mr_prescal_mask; 12679120c0beSJosh Wu reg |= AT91_ADC_STARTUP_(ticks) & st->registers->mr_startup_mask; 126847be16b6SLudovic Desroches if (st->low_res) 1269e748783cSJean-Christophe PLAGNIOL-VILLARD reg |= AT91_ADC_LOWRES; 1270e748783cSJean-Christophe PLAGNIOL-VILLARD if (st->sleep_mode) 1271e748783cSJean-Christophe PLAGNIOL-VILLARD reg |= AT91_ADC_SLEEP; 1272beca9e76SJean-Christophe PLAGNIOL-VILLARD reg |= AT91_ADC_SHTIM_(shtim) & AT91_ADC_SHTIM; 1273e748783cSJean-Christophe PLAGNIOL-VILLARD at91_adc_writel(st, AT91_ADC_MR, reg); 12740e589d5fSMaxime Ripard 12750e589d5fSMaxime Ripard /* Setup the ADC channels available on the board */ 12760e589d5fSMaxime Ripard ret = at91_adc_channel_init(idev); 12770e589d5fSMaxime Ripard if (ret < 0) { 12780e589d5fSMaxime Ripard dev_err(&pdev->dev, "Couldn't initialize the channels.\n"); 12790e589d5fSMaxime Ripard goto error_disable_adc_clk; 12800e589d5fSMaxime Ripard } 12810e589d5fSMaxime Ripard 12820e589d5fSMaxime Ripard init_waitqueue_head(&st->wq_data_avail); 12830e589d5fSMaxime Ripard mutex_init(&st->lock); 12840e589d5fSMaxime Ripard 1285c8b11de0SJosh Wu /* 1286c8b11de0SJosh Wu * Since touch screen will set trigger register as period trigger. So 1287c8b11de0SJosh Wu * when touch screen is enabled, then we have to disable hardware 1288c8b11de0SJosh Wu * trigger for classic adc. 1289c8b11de0SJosh Wu */ 1290c8b11de0SJosh Wu if (!st->touchscreen_type) { 12910e589d5fSMaxime Ripard ret = at91_adc_buffer_init(idev); 12920e589d5fSMaxime Ripard if (ret < 0) { 12930e589d5fSMaxime Ripard dev_err(&pdev->dev, "Couldn't initialize the buffer.\n"); 12940e589d5fSMaxime Ripard goto error_disable_adc_clk; 12950e589d5fSMaxime Ripard } 12960e589d5fSMaxime Ripard 12970e589d5fSMaxime Ripard ret = at91_adc_trigger_init(idev); 12980e589d5fSMaxime Ripard if (ret < 0) { 12990e589d5fSMaxime Ripard dev_err(&pdev->dev, "Couldn't setup the triggers.\n"); 1300c8b11de0SJosh Wu at91_adc_buffer_remove(idev); 1301c8b11de0SJosh Wu goto error_disable_adc_clk; 1302c8b11de0SJosh Wu } 1303c8b11de0SJosh Wu } else { 1304c8b11de0SJosh Wu ret = at91_ts_register(st, pdev); 1305c8b11de0SJosh Wu if (ret) 1306c8b11de0SJosh Wu goto error_disable_adc_clk; 1307c8b11de0SJosh Wu 1308c8b11de0SJosh Wu at91_ts_hw_init(st, adc_clk_khz); 13090e589d5fSMaxime Ripard } 13100e589d5fSMaxime Ripard 13110e589d5fSMaxime Ripard ret = iio_device_register(idev); 13120e589d5fSMaxime Ripard if (ret < 0) { 13130e589d5fSMaxime Ripard dev_err(&pdev->dev, "Couldn't register the device.\n"); 1314c8b11de0SJosh Wu goto error_iio_device_register; 13150e589d5fSMaxime Ripard } 13160e589d5fSMaxime Ripard 13170e589d5fSMaxime Ripard return 0; 13180e589d5fSMaxime Ripard 1319c8b11de0SJosh Wu error_iio_device_register: 1320c8b11de0SJosh Wu if (!st->touchscreen_type) { 13210e589d5fSMaxime Ripard at91_adc_trigger_remove(idev); 13220e589d5fSMaxime Ripard at91_adc_buffer_remove(idev); 1323c8b11de0SJosh Wu } else { 1324c8b11de0SJosh Wu at91_ts_unregister(st); 1325c8b11de0SJosh Wu } 13260e589d5fSMaxime Ripard error_disable_adc_clk: 132700062a9cSJulia Lawall clk_disable_unprepare(st->adc_clk); 13280e589d5fSMaxime Ripard error_disable_clk: 132900062a9cSJulia Lawall clk_disable_unprepare(st->clk); 13300e589d5fSMaxime Ripard error_free_irq: 13310e589d5fSMaxime Ripard free_irq(st->irq, idev); 13320e589d5fSMaxime Ripard return ret; 13330e589d5fSMaxime Ripard } 13340e589d5fSMaxime Ripard 1335fc52692cSGreg Kroah-Hartman static int at91_adc_remove(struct platform_device *pdev) 13360e589d5fSMaxime Ripard { 13370e589d5fSMaxime Ripard struct iio_dev *idev = platform_get_drvdata(pdev); 13380e589d5fSMaxime Ripard struct at91_adc_state *st = iio_priv(idev); 13390e589d5fSMaxime Ripard 13400e589d5fSMaxime Ripard iio_device_unregister(idev); 1341c8b11de0SJosh Wu if (!st->touchscreen_type) { 13420e589d5fSMaxime Ripard at91_adc_trigger_remove(idev); 13430e589d5fSMaxime Ripard at91_adc_buffer_remove(idev); 1344c8b11de0SJosh Wu } else { 1345c8b11de0SJosh Wu at91_ts_unregister(st); 1346c8b11de0SJosh Wu } 13470e589d5fSMaxime Ripard clk_disable_unprepare(st->adc_clk); 134800062a9cSJulia Lawall clk_disable_unprepare(st->clk); 13490e589d5fSMaxime Ripard free_irq(st->irq, idev); 13500e589d5fSMaxime Ripard 13510e589d5fSMaxime Ripard return 0; 13520e589d5fSMaxime Ripard } 13530e589d5fSMaxime Ripard 1354bc3ae982SWenyou Yang #ifdef CONFIG_PM_SLEEP 1355bc3ae982SWenyou Yang static int at91_adc_suspend(struct device *dev) 1356bc3ae982SWenyou Yang { 1357bc3ae982SWenyou Yang struct iio_dev *idev = platform_get_drvdata(to_platform_device(dev)); 1358bc3ae982SWenyou Yang struct at91_adc_state *st = iio_priv(idev); 1359bc3ae982SWenyou Yang 1360bc3ae982SWenyou Yang pinctrl_pm_select_sleep_state(dev); 1361bc3ae982SWenyou Yang clk_disable_unprepare(st->clk); 1362bc3ae982SWenyou Yang 1363bc3ae982SWenyou Yang return 0; 1364bc3ae982SWenyou Yang } 1365bc3ae982SWenyou Yang 1366bc3ae982SWenyou Yang static int at91_adc_resume(struct device *dev) 1367bc3ae982SWenyou Yang { 1368bc3ae982SWenyou Yang struct iio_dev *idev = platform_get_drvdata(to_platform_device(dev)); 1369bc3ae982SWenyou Yang struct at91_adc_state *st = iio_priv(idev); 1370bc3ae982SWenyou Yang 1371bc3ae982SWenyou Yang clk_prepare_enable(st->clk); 1372bc3ae982SWenyou Yang pinctrl_pm_select_default_state(dev); 1373bc3ae982SWenyou Yang 1374bc3ae982SWenyou Yang return 0; 1375bc3ae982SWenyou Yang } 1376bc3ae982SWenyou Yang #endif 1377bc3ae982SWenyou Yang 1378bc3ae982SWenyou Yang static SIMPLE_DEV_PM_OPS(at91_adc_pm_ops, at91_adc_suspend, at91_adc_resume); 1379bc3ae982SWenyou Yang 1380e1811f97SJosh Wu static struct at91_adc_caps at91sam9260_caps = { 1381c4601666SJosh Wu .calc_startup_ticks = calc_startup_ticks_9260, 13822b6d598bSJosh Wu .num_channels = 4, 1383e1811f97SJosh Wu .registers = { 1384e1811f97SJosh Wu .channel_base = AT91_ADC_CHR(0), 1385e1811f97SJosh Wu .drdy_mask = AT91_ADC_DRDY, 1386e1811f97SJosh Wu .status_register = AT91_ADC_SR, 1387e1811f97SJosh Wu .trigger_register = AT91_ADC_TRGR_9260, 13889120c0beSJosh Wu .mr_prescal_mask = AT91_ADC_PRESCAL_9260, 13899120c0beSJosh Wu .mr_startup_mask = AT91_ADC_STARTUP_9260, 1390e1811f97SJosh Wu }, 1391e1811f97SJosh Wu }; 1392e1811f97SJosh Wu 139365b1fdbaSAlexandre Belloni static struct at91_adc_caps at91sam9rl_caps = { 139465b1fdbaSAlexandre Belloni .has_ts = true, 139565b1fdbaSAlexandre Belloni .calc_startup_ticks = calc_startup_ticks_9260, /* same as 9260 */ 139665b1fdbaSAlexandre Belloni .num_channels = 6, 139765b1fdbaSAlexandre Belloni .registers = { 139865b1fdbaSAlexandre Belloni .channel_base = AT91_ADC_CHR(0), 139965b1fdbaSAlexandre Belloni .drdy_mask = AT91_ADC_DRDY, 140065b1fdbaSAlexandre Belloni .status_register = AT91_ADC_SR, 140165b1fdbaSAlexandre Belloni .trigger_register = AT91_ADC_TRGR_9G45, 140265b1fdbaSAlexandre Belloni .mr_prescal_mask = AT91_ADC_PRESCAL_9260, 140365b1fdbaSAlexandre Belloni .mr_startup_mask = AT91_ADC_STARTUP_9G45, 140465b1fdbaSAlexandre Belloni }, 140565b1fdbaSAlexandre Belloni }; 140665b1fdbaSAlexandre Belloni 1407e1811f97SJosh Wu static struct at91_adc_caps at91sam9g45_caps = { 1408c8b11de0SJosh Wu .has_ts = true, 1409c4601666SJosh Wu .calc_startup_ticks = calc_startup_ticks_9260, /* same as 9260 */ 14102b6d598bSJosh Wu .num_channels = 8, 1411e1811f97SJosh Wu .registers = { 1412e1811f97SJosh Wu .channel_base = AT91_ADC_CHR(0), 1413e1811f97SJosh Wu .drdy_mask = AT91_ADC_DRDY, 1414e1811f97SJosh Wu .status_register = AT91_ADC_SR, 1415e1811f97SJosh Wu .trigger_register = AT91_ADC_TRGR_9G45, 14169120c0beSJosh Wu .mr_prescal_mask = AT91_ADC_PRESCAL_9G45, 14179120c0beSJosh Wu .mr_startup_mask = AT91_ADC_STARTUP_9G45, 1418e1811f97SJosh Wu }, 1419e1811f97SJosh Wu }; 1420e1811f97SJosh Wu 1421e1811f97SJosh Wu static struct at91_adc_caps at91sam9x5_caps = { 1422c8b11de0SJosh Wu .has_ts = true, 1423c8b11de0SJosh Wu .has_tsmr = true, 1424c8b11de0SJosh Wu .ts_filter_average = 3, 1425c8b11de0SJosh Wu .ts_pen_detect_sensitivity = 2, 1426c4601666SJosh Wu .calc_startup_ticks = calc_startup_ticks_9x5, 14272b6d598bSJosh Wu .num_channels = 12, 1428e1811f97SJosh Wu .registers = { 1429e1811f97SJosh Wu .channel_base = AT91_ADC_CDR0_9X5, 1430e1811f97SJosh Wu .drdy_mask = AT91_ADC_SR_DRDY_9X5, 1431e1811f97SJosh Wu .status_register = AT91_ADC_SR_9X5, 1432e1811f97SJosh Wu .trigger_register = AT91_ADC_TRGR_9X5, 14339120c0beSJosh Wu /* prescal mask is same as 9G45 */ 14349120c0beSJosh Wu .mr_prescal_mask = AT91_ADC_PRESCAL_9G45, 14359120c0beSJosh Wu .mr_startup_mask = AT91_ADC_STARTUP_9X5, 1436e1811f97SJosh Wu }, 1437e1811f97SJosh Wu }; 1438e1811f97SJosh Wu 1439e364185fSMaxime Ripard static const struct of_device_id at91_adc_dt_ids[] = { 1440e1811f97SJosh Wu { .compatible = "atmel,at91sam9260-adc", .data = &at91sam9260_caps }, 144165b1fdbaSAlexandre Belloni { .compatible = "atmel,at91sam9rl-adc", .data = &at91sam9rl_caps }, 1442e1811f97SJosh Wu { .compatible = "atmel,at91sam9g45-adc", .data = &at91sam9g45_caps }, 1443e1811f97SJosh Wu { .compatible = "atmel,at91sam9x5-adc", .data = &at91sam9x5_caps }, 1444e364185fSMaxime Ripard {}, 1445e364185fSMaxime Ripard }; 1446e364185fSMaxime Ripard MODULE_DEVICE_TABLE(of, at91_adc_dt_ids); 1447467a44b0SAlexandre Belloni 1448467a44b0SAlexandre Belloni static const struct platform_device_id at91_adc_ids[] = { 1449467a44b0SAlexandre Belloni { 1450467a44b0SAlexandre Belloni .name = "at91sam9260-adc", 1451467a44b0SAlexandre Belloni .driver_data = (unsigned long)&at91sam9260_caps, 1452467a44b0SAlexandre Belloni }, { 145365b1fdbaSAlexandre Belloni .name = "at91sam9rl-adc", 145465b1fdbaSAlexandre Belloni .driver_data = (unsigned long)&at91sam9rl_caps, 145565b1fdbaSAlexandre Belloni }, { 1456467a44b0SAlexandre Belloni .name = "at91sam9g45-adc", 1457467a44b0SAlexandre Belloni .driver_data = (unsigned long)&at91sam9g45_caps, 1458467a44b0SAlexandre Belloni }, { 1459467a44b0SAlexandre Belloni .name = "at91sam9x5-adc", 1460467a44b0SAlexandre Belloni .driver_data = (unsigned long)&at91sam9x5_caps, 1461467a44b0SAlexandre Belloni }, { 1462467a44b0SAlexandre Belloni /* terminator */ 1463467a44b0SAlexandre Belloni } 1464467a44b0SAlexandre Belloni }; 1465467a44b0SAlexandre Belloni MODULE_DEVICE_TABLE(platform, at91_adc_ids); 1466e364185fSMaxime Ripard 14670e589d5fSMaxime Ripard static struct platform_driver at91_adc_driver = { 14680e589d5fSMaxime Ripard .probe = at91_adc_probe, 1469fc52692cSGreg Kroah-Hartman .remove = at91_adc_remove, 1470467a44b0SAlexandre Belloni .id_table = at91_adc_ids, 14710e589d5fSMaxime Ripard .driver = { 1472c8b11de0SJosh Wu .name = DRIVER_NAME, 1473e364185fSMaxime Ripard .of_match_table = of_match_ptr(at91_adc_dt_ids), 1474bc3ae982SWenyou Yang .pm = &at91_adc_pm_ops, 14750e589d5fSMaxime Ripard }, 14760e589d5fSMaxime Ripard }; 14770e589d5fSMaxime Ripard 14780e589d5fSMaxime Ripard module_platform_driver(at91_adc_driver); 14790e589d5fSMaxime Ripard 14800e589d5fSMaxime Ripard MODULE_LICENSE("GPL"); 14810e589d5fSMaxime Ripard MODULE_DESCRIPTION("Atmel AT91 ADC Driver"); 14820e589d5fSMaxime Ripard MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>"); 1483