drivers/iio/adc/at91-sama5d2_adc.c

   1 /*
   2  * Atmel ADC driver for SAMA5D2 devices and compatible.
   3  *
   4  * Copyright (C) 2015 Atmel,
   5  *               2015 Ludovic Desroches <ludovic.desroches@atmel.com>
   6  *
   7  * This software is licensed under the terms of the GNU General Public
   8  * License version 2, as published by the Free Software Foundation, and
   9  * may be copied, distributed, and modified under those terms.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <linux/bitops.h>
  18 #include <linux/clk.h>
  19 #include <linux/dma-mapping.h>
  20 #include <linux/dmaengine.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/io.h>
  23 #include <linux/module.h>
  24 #include <linux/of_device.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/sched.h>
  27 #include <linux/wait.h>
  28 #include <linux/iio/iio.h>
  29 #include <linux/iio/sysfs.h>
  30 #include <linux/iio/buffer.h>
  31 #include <linux/iio/trigger.h>
  32 #include <linux/iio/trigger_consumer.h>
  33 #include <linux/iio/triggered_buffer.h>
  34 #include <linux/pinctrl/consumer.h>
  35 #include <linux/regulator/consumer.h>
  36
  37 /* Control Register */
  38 #define AT91_SAMA5D2_CR         0x00
  39 /* Software Reset */
  40 #define AT91_SAMA5D2_CR_SWRST           BIT(0)
  41 /* Start Conversion */
  42 #define AT91_SAMA5D2_CR_START           BIT(1)
  43 /* Touchscreen Calibration */
  44 #define AT91_SAMA5D2_CR_TSCALIB         BIT(2)
  45 /* Comparison Restart */
  46 #define AT91_SAMA5D2_CR_CMPRST          BIT(4)
  47
  48 /* Mode Register */
  49 #define AT91_SAMA5D2_MR         0x04
  50 /* Trigger Selection */
  51 #define AT91_SAMA5D2_MR_TRGSEL(v)       ((v) << 1)
  52 /* ADTRG */
  53 #define AT91_SAMA5D2_MR_TRGSEL_TRIG0    0
  54 /* TIOA0 */
  55 #define AT91_SAMA5D2_MR_TRGSEL_TRIG1    1
  56 /* TIOA1 */
  57 #define AT91_SAMA5D2_MR_TRGSEL_TRIG2    2
  58 /* TIOA2 */
  59 #define AT91_SAMA5D2_MR_TRGSEL_TRIG3    3
  60 /* PWM event line 0 */
  61 #define AT91_SAMA5D2_MR_TRGSEL_TRIG4    4
  62 /* PWM event line 1 */
  63 #define AT91_SAMA5D2_MR_TRGSEL_TRIG5    5
  64 /* TIOA3 */
  65 #define AT91_SAMA5D2_MR_TRGSEL_TRIG6    6
  66 /* RTCOUT0 */
  67 #define AT91_SAMA5D2_MR_TRGSEL_TRIG7    7
  68 /* Sleep Mode */
  69 #define AT91_SAMA5D2_MR_SLEEP           BIT(5)
  70 /* Fast Wake Up */
  71 #define AT91_SAMA5D2_MR_FWUP            BIT(6)
  72 /* Prescaler Rate Selection */
  73 #define AT91_SAMA5D2_MR_PRESCAL(v)      ((v) << AT91_SAMA5D2_MR_PRESCAL_OFFSET)
  74 #define AT91_SAMA5D2_MR_PRESCAL_OFFSET  8
  75 #define AT91_SAMA5D2_MR_PRESCAL_MAX     0xff
  76 #define AT91_SAMA5D2_MR_PRESCAL_MASK    GENMASK(15, 8)
  77 /* Startup Time */
  78 #define AT91_SAMA5D2_MR_STARTUP(v)      ((v) << 16)
  79 #define AT91_SAMA5D2_MR_STARTUP_MASK    GENMASK(19, 16)
  80 /* Analog Change */
  81 #define AT91_SAMA5D2_MR_ANACH           BIT(23)
  82 /* Tracking Time */
  83 #define AT91_SAMA5D2_MR_TRACKTIM(v)     ((v) << 24)
  84 #define AT91_SAMA5D2_MR_TRACKTIM_MAX    0xf
  85 /* Transfer Time */
  86 #define AT91_SAMA5D2_MR_TRANSFER(v)     ((v) << 28)
  87 #define AT91_SAMA5D2_MR_TRANSFER_MAX    0x3
  88 /* Use Sequence Enable */
  89 #define AT91_SAMA5D2_MR_USEQ            BIT(31)
  90
  91 /* Channel Sequence Register 1 */
  92 #define AT91_SAMA5D2_SEQR1      0x08
  93 /* Channel Sequence Register 2 */
  94 #define AT91_SAMA5D2_SEQR2      0x0c
  95 /* Channel Enable Register */
  96 #define AT91_SAMA5D2_CHER       0x10
  97 /* Channel Disable Register */
  98 #define AT91_SAMA5D2_CHDR       0x14
  99 /* Channel Status Register */
 100 #define AT91_SAMA5D2_CHSR       0x18
 101 /* Last Converted Data Register */
 102 #define AT91_SAMA5D2_LCDR       0x20
 103 /* Interrupt Enable Register */
 104 #define AT91_SAMA5D2_IER        0x24
 105 /* Interrupt Enable Register - TS X measurement ready */
 106 #define AT91_SAMA5D2_IER_XRDY   BIT(20)
 107 /* Interrupt Enable Register - TS Y measurement ready */
 108 #define AT91_SAMA5D2_IER_YRDY   BIT(21)
 109 /* Interrupt Enable Register - TS pressure measurement ready */
 110 #define AT91_SAMA5D2_IER_PRDY   BIT(22)
 111 /* Interrupt Enable Register - general overrun error */
 112 #define AT91_SAMA5D2_IER_GOVRE BIT(25)
 113 /* Interrupt Enable Register - Pen detect */
 114 #define AT91_SAMA5D2_IER_PEN    BIT(29)
 115 /* Interrupt Enable Register - No pen detect */
 116 #define AT91_SAMA5D2_IER_NOPEN  BIT(30)
 117 /* Interrupt Disable Register */
 118 #define AT91_SAMA5D2_IDR        0x28
 119 /* Interrupt Mask Register */
 120 #define AT91_SAMA5D2_IMR        0x2c
 121 /* Interrupt Status Register */
 122 #define AT91_SAMA5D2_ISR        0x30
 123 /* Interrupt Status Register - Pen touching sense status */
 124 #define AT91_SAMA5D2_ISR_PENS   BIT(31)
 125 /* Last Channel Trigger Mode Register */
 126 #define AT91_SAMA5D2_LCTMR      0x34
 127 /* Last Channel Compare Window Register */
 128 #define AT91_SAMA5D2_LCCWR      0x38
 129 /* Overrun Status Register */
 130 #define AT91_SAMA5D2_OVER       0x3c
 131 /* Extended Mode Register */
 132 #define AT91_SAMA5D2_EMR        0x40
 133 /* Extended Mode Register - Oversampling rate */
 134 #define AT91_SAMA5D2_EMR_OSR(V)                 ((V) << 16)
 135 #define AT91_SAMA5D2_EMR_OSR_MASK               GENMASK(17, 16)
 136 #define AT91_SAMA5D2_EMR_OSR_1SAMPLES           0
 137 #define AT91_SAMA5D2_EMR_OSR_4SAMPLES           1
 138 #define AT91_SAMA5D2_EMR_OSR_16SAMPLES          2
 139
 140 /* Extended Mode Register - Averaging on single trigger event */
 141 #define AT91_SAMA5D2_EMR_ASTE(V)                ((V) << 20)
 142 /* Compare Window Register */
 143 #define AT91_SAMA5D2_CWR        0x44
 144 /* Channel Gain Register */
 145 #define AT91_SAMA5D2_CGR        0x48
 146
 147 /* Channel Offset Register */
 148 #define AT91_SAMA5D2_COR        0x4c
 149 #define AT91_SAMA5D2_COR_DIFF_OFFSET    16
 150
 151 /* Channel Data Register 0 */
 152 #define AT91_SAMA5D2_CDR0       0x50
 153 /* Analog Control Register */
 154 #define AT91_SAMA5D2_ACR        0x94
 155 /* Analog Control Register - Pen detect sensitivity mask */
 156 #define AT91_SAMA5D2_ACR_PENDETSENS_MASK        GENMASK(1, 0)
 157
 158 /* Touchscreen Mode Register */
 159 #define AT91_SAMA5D2_TSMR       0xb0
 160 /* Touchscreen Mode Register - No touch mode */
 161 #define AT91_SAMA5D2_TSMR_TSMODE_NONE           0
 162 /* Touchscreen Mode Register - 4 wire screen, no pressure measurement */
 163 #define AT91_SAMA5D2_TSMR_TSMODE_4WIRE_NO_PRESS 1
 164 /* Touchscreen Mode Register - 4 wire screen, pressure measurement */
 165 #define AT91_SAMA5D2_TSMR_TSMODE_4WIRE_PRESS    2
 166 /* Touchscreen Mode Register - 5 wire screen */
 167 #define AT91_SAMA5D2_TSMR_TSMODE_5WIRE          3
 168 /* Touchscreen Mode Register - Average samples mask */
 169 #define AT91_SAMA5D2_TSMR_TSAV_MASK             GENMASK(5, 4)
 170 /* Touchscreen Mode Register - Average samples */
 171 #define AT91_SAMA5D2_TSMR_TSAV(x)               ((x) << 4)
 172 /* Touchscreen Mode Register - Touch/trigger frequency ratio mask */
 173 #define AT91_SAMA5D2_TSMR_TSFREQ_MASK           GENMASK(11, 8)
 174 /* Touchscreen Mode Register - Touch/trigger frequency ratio */
 175 #define AT91_SAMA5D2_TSMR_TSFREQ(x)             ((x) << 8)
 176 /* Touchscreen Mode Register - Pen Debounce Time mask */
 177 #define AT91_SAMA5D2_TSMR_PENDBC_MASK           GENMASK(31, 28)
 178 /* Touchscreen Mode Register - Pen Debounce Time */
 179 #define AT91_SAMA5D2_TSMR_PENDBC(x)            ((x) << 28)
 180 /* Touchscreen Mode Register - No DMA for touch measurements */
 181 #define AT91_SAMA5D2_TSMR_NOTSDMA               BIT(22)
 182 /* Touchscreen Mode Register - Disable pen detection */
 183 #define AT91_SAMA5D2_TSMR_PENDET_DIS            (0 << 24)
 184 /* Touchscreen Mode Register - Enable pen detection */
 185 #define AT91_SAMA5D2_TSMR_PENDET_ENA            BIT(24)
 186
 187 /* Touchscreen X Position Register */
 188 #define AT91_SAMA5D2_XPOSR      0xb4
 189 /* Touchscreen Y Position Register */
 190 #define AT91_SAMA5D2_YPOSR      0xb8
 191 /* Touchscreen Pressure Register */
 192 #define AT91_SAMA5D2_PRESSR     0xbc
 193 /* Trigger Register */
 194 #define AT91_SAMA5D2_TRGR       0xc0
 195 /* Mask for TRGMOD field of TRGR register */
 196 #define AT91_SAMA5D2_TRGR_TRGMOD_MASK GENMASK(2, 0)
 197 /* No trigger, only software trigger can start conversions */
 198 #define AT91_SAMA5D2_TRGR_TRGMOD_NO_TRIGGER 0
 199 /* Trigger Mode external trigger rising edge */
 200 #define AT91_SAMA5D2_TRGR_TRGMOD_EXT_TRIG_RISE 1
 201 /* Trigger Mode external trigger falling edge */
 202 #define AT91_SAMA5D2_TRGR_TRGMOD_EXT_TRIG_FALL 2
 203 /* Trigger Mode external trigger any edge */
 204 #define AT91_SAMA5D2_TRGR_TRGMOD_EXT_TRIG_ANY 3
 205 /* Trigger Mode internal periodic */
 206 #define AT91_SAMA5D2_TRGR_TRGMOD_PERIODIC 5
 207 /* Trigger Mode - trigger period mask */
 208 #define AT91_SAMA5D2_TRGR_TRGPER_MASK           GENMASK(31, 16)
 209 /* Trigger Mode - trigger period */
 210 #define AT91_SAMA5D2_TRGR_TRGPER(x)             ((x) << 16)
 211
 212 /* Correction Select Register */
 213 #define AT91_SAMA5D2_COSR       0xd0
 214 /* Correction Value Register */
 215 #define AT91_SAMA5D2_CVR        0xd4
 216 /* Channel Error Correction Register */
 217 #define AT91_SAMA5D2_CECR       0xd8
 218 /* Write Protection Mode Register */
 219 #define AT91_SAMA5D2_WPMR       0xe4
 220 /* Write Protection Status Register */
 221 #define AT91_SAMA5D2_WPSR       0xe8
 222 /* Version Register */
 223 #define AT91_SAMA5D2_VERSION    0xfc
 224
 225 #define AT91_SAMA5D2_HW_TRIG_CNT 3
 226 #define AT91_SAMA5D2_SINGLE_CHAN_CNT 12
 227 #define AT91_SAMA5D2_DIFF_CHAN_CNT 6
 228
 229 #define AT91_SAMA5D2_TIMESTAMP_CHAN_IDX (AT91_SAMA5D2_SINGLE_CHAN_CNT + \
 230                                          AT91_SAMA5D2_DIFF_CHAN_CNT + 1)
 231
 232 #define AT91_SAMA5D2_TOUCH_X_CHAN_IDX (AT91_SAMA5D2_SINGLE_CHAN_CNT + \
 233                                          AT91_SAMA5D2_DIFF_CHAN_CNT * 2)
 234 #define AT91_SAMA5D2_TOUCH_Y_CHAN_IDX   (AT91_SAMA5D2_TOUCH_X_CHAN_IDX + 1)
 235 #define AT91_SAMA5D2_TOUCH_P_CHAN_IDX   (AT91_SAMA5D2_TOUCH_Y_CHAN_IDX + 1)
 236 #define AT91_SAMA5D2_MAX_CHAN_IDX       AT91_SAMA5D2_TOUCH_P_CHAN_IDX
 237
 238 #define AT91_SAMA5D2_TOUCH_SAMPLE_PERIOD_US          2000    /* 2ms */
 239 #define AT91_SAMA5D2_TOUCH_PEN_DETECT_DEBOUNCE_US    200
 240
 241 #define AT91_SAMA5D2_XYZ_MASK           GENMASK(11, 0)
 242
 243 #define AT91_SAMA5D2_MAX_POS_BITS                       12
 244
 245 /*
 246  * Maximum number of bytes to hold conversion from all channels
 247  * without the timestamp.
 248  */
 249 #define AT91_BUFFER_MAX_CONVERSION_BYTES ((AT91_SAMA5D2_SINGLE_CHAN_CNT + \
 250                                          AT91_SAMA5D2_DIFF_CHAN_CNT) * 2)
 251
 252 /* This total must also include the timestamp */
 253 #define AT91_BUFFER_MAX_BYTES (AT91_BUFFER_MAX_CONVERSION_BYTES + 8)
 254
 255 #define AT91_BUFFER_MAX_HWORDS (AT91_BUFFER_MAX_BYTES / 2)
 256
 257 #define AT91_HWFIFO_MAX_SIZE_STR        "128"
 258 #define AT91_HWFIFO_MAX_SIZE            128
 259
 260 /* Possible values for oversampling ratio */
 261 #define AT91_OSR_1SAMPLES               1
 262 #define AT91_OSR_4SAMPLES               4
 263 #define AT91_OSR_16SAMPLES              16
 264
 265 #define AT91_SAMA5D2_CHAN_SINGLE(num, addr)                             \
 266         {                                                               \
 267                 .type = IIO_VOLTAGE,                                    \
 268                 .channel = num,                                         \
 269                 .address = addr,                                        \
 270                 .scan_index = num,                                      \
 271                 .scan_type = {                                          \
 272                         .sign = 'u',                                    \
 273                         .realbits = 14,                                 \
 274                         .storagebits = 16,                              \
 275                 },                                                      \
 276                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
 277                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
 278                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ)|\
 279                                 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),  \
 280                 .datasheet_name = "CH"#num,                             \
 281                 .indexed = 1,                                           \
 282         }
 283
 284 #define AT91_SAMA5D2_CHAN_DIFF(num, num2, addr)                         \
 285         {                                                               \
 286                 .type = IIO_VOLTAGE,                                    \
 287                 .differential = 1,                                      \
 288                 .channel = num,                                         \
 289                 .channel2 = num2,                                       \
 290                 .address = addr,                                        \
 291                 .scan_index = num + AT91_SAMA5D2_SINGLE_CHAN_CNT,       \
 292                 .scan_type = {                                          \
 293                         .sign = 's',                                    \
 294                         .realbits = 14,                                 \
 295                         .storagebits = 16,                              \
 296                 },                                                      \
 297                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
 298                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
 299                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ)|\
 300                                 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),  \
 301                 .datasheet_name = "CH"#num"-CH"#num2,                   \
 302                 .indexed = 1,                                           \
 303         }
 304
 305 #define AT91_SAMA5D2_CHAN_TOUCH(num, name, mod)                         \
 306         {                                                               \
 307                 .type = IIO_POSITIONRELATIVE,                           \
 308                 .modified = 1,                                          \
 309                 .channel = num,                                         \
 310                 .channel2 = mod,                                        \
 311                 .scan_index = num,                                      \
 312                 .scan_type = {                                          \
 313                         .sign = 'u',                                    \
 314                         .realbits = 12,                                 \
 315                         .storagebits = 16,                              \
 316                 },                                                      \
 317                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
 318                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ)|\
 319                                 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),  \
 320                 .datasheet_name = name,                                 \
 321         }
 322 #define AT91_SAMA5D2_CHAN_PRESSURE(num, name)                           \
 323         {                                                               \
 324                 .type = IIO_PRESSURE,                                   \
 325                 .channel = num,                                         \
 326                 .scan_index = num,                                      \
 327                 .scan_type = {                                          \
 328                         .sign = 'u',                                    \
 329                         .realbits = 12,                                 \
 330                         .storagebits = 16,                              \
 331                 },                                                      \
 332                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
 333                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ)|\
 334                                 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),  \
 335                 .datasheet_name = name,                                 \
 336         }
 337
 338 #define at91_adc_readl(st, reg)         readl_relaxed(st->base + reg)
 339 #define at91_adc_writel(st, reg, val)   writel_relaxed(val, st->base + reg)
 340
 341 struct at91_adc_soc_info {
 342         unsigned                        startup_time;
 343         unsigned                        min_sample_rate;
 344         unsigned                        max_sample_rate;
 345 };
 346
 347 struct at91_adc_trigger {
 348         char                            *name;
 349         unsigned int                    trgmod_value;
 350         unsigned int                    edge_type;
 351         bool                            hw_trig;
 352 };
 353
 354 /**
 355  * at91_adc_dma - at91-sama5d2 dma information struct
 356  * @dma_chan:           the dma channel acquired
 357  * @rx_buf:             dma coherent allocated area
 358  * @rx_dma_buf:         dma handler for the buffer
 359  * @phys_addr:          physical address of the ADC base register
 360  * @buf_idx:            index inside the dma buffer where reading was last done
 361  * @rx_buf_sz:          size of buffer used by DMA operation
 362  * @watermark:          number of conversions to copy before DMA triggers irq
 363  * @dma_ts:             hold the start timestamp of dma operation
 364  */
 365 struct at91_adc_dma {
 366         struct dma_chan                 *dma_chan;
 367         u8                              *rx_buf;
 368         dma_addr_t                      rx_dma_buf;
 369         phys_addr_t                     phys_addr;
 370         int                             buf_idx;
 371         int                             rx_buf_sz;
 372         int                             watermark;
 373         s64                             dma_ts;
 374 };
 375
 376 /**
 377  * at91_adc_touch - at91-sama5d2 touchscreen information struct
 378  * @sample_period_val:          the value for periodic trigger interval
 379  * @touching:                   is the pen touching the screen or not
 380  * @x_pos:                      temporary placeholder for pressure computation
 381  * @channels_bitmask:           bitmask with the touchscreen channels enabled
 382  * @workq:                      workqueue for buffer data pushing
 383  */
 384 struct at91_adc_touch {
 385         u16                             sample_period_val;
 386         bool                            touching;
 387         u16                             x_pos;
 388         unsigned long                   channels_bitmask;
 389         struct work_struct              workq;
 390 };
 391
 392 struct at91_adc_state {
 393         void __iomem                    *base;
 394         int                             irq;
 395         struct clk                      *per_clk;
 396         struct regulator                *reg;
 397         struct regulator                *vref;
 398         int                             vref_uv;
 399         unsigned int                    current_sample_rate;
 400         struct iio_trigger              *trig;
 401         const struct at91_adc_trigger   *selected_trig;
 402         const struct iio_chan_spec      *chan;
 403         bool                            conversion_done;
 404         u32                             conversion_value;
 405         unsigned int                    oversampling_ratio;
 406         struct at91_adc_soc_info        soc_info;
 407         wait_queue_head_t               wq_data_available;
 408         struct at91_adc_dma             dma_st;
 409         struct at91_adc_touch           touch_st;
 410         u16                             buffer[AT91_BUFFER_MAX_HWORDS];
 411         /*
 412          * lock to prevent concurrent 'single conversion' requests through
 413          * sysfs.
 414          */
 415         struct mutex                    lock;
 416 };
 417
 418 static const struct at91_adc_trigger at91_adc_trigger_list[] = {
 419         {
 420                 .name = "external_rising",
 421                 .trgmod_value = AT91_SAMA5D2_TRGR_TRGMOD_EXT_TRIG_RISE,
 422                 .edge_type = IRQ_TYPE_EDGE_RISING,
 423                 .hw_trig = true,
 424         },
 425         {
 426                 .name = "external_falling",
 427                 .trgmod_value = AT91_SAMA5D2_TRGR_TRGMOD_EXT_TRIG_FALL,
 428                 .edge_type = IRQ_TYPE_EDGE_FALLING,
 429                 .hw_trig = true,
 430         },
 431         {
 432                 .name = "external_any",
 433                 .trgmod_value = AT91_SAMA5D2_TRGR_TRGMOD_EXT_TRIG_ANY,
 434                 .edge_type = IRQ_TYPE_EDGE_BOTH,
 435                 .hw_trig = true,
 436         },
 437         {
 438                 .name = "software",
 439                 .trgmod_value = AT91_SAMA5D2_TRGR_TRGMOD_NO_TRIGGER,
 440                 .edge_type = IRQ_TYPE_NONE,
 441                 .hw_trig = false,
 442         },
 443 };
 444
 445 static const struct iio_chan_spec at91_adc_channels[] = {
 446         AT91_SAMA5D2_CHAN_SINGLE(0, 0x50),
 447         AT91_SAMA5D2_CHAN_SINGLE(1, 0x54),
 448         AT91_SAMA5D2_CHAN_SINGLE(2, 0x58),
 449         AT91_SAMA5D2_CHAN_SINGLE(3, 0x5c),
 450         AT91_SAMA5D2_CHAN_SINGLE(4, 0x60),
 451         AT91_SAMA5D2_CHAN_SINGLE(5, 0x64),
 452         AT91_SAMA5D2_CHAN_SINGLE(6, 0x68),
 453         AT91_SAMA5D2_CHAN_SINGLE(7, 0x6c),
 454         AT91_SAMA5D2_CHAN_SINGLE(8, 0x70),
 455         AT91_SAMA5D2_CHAN_SINGLE(9, 0x74),
 456         AT91_SAMA5D2_CHAN_SINGLE(10, 0x78),
 457         AT91_SAMA5D2_CHAN_SINGLE(11, 0x7c),
 458         AT91_SAMA5D2_CHAN_DIFF(0, 1, 0x50),
 459         AT91_SAMA5D2_CHAN_DIFF(2, 3, 0x58),
 460         AT91_SAMA5D2_CHAN_DIFF(4, 5, 0x60),
 461         AT91_SAMA5D2_CHAN_DIFF(6, 7, 0x68),
 462         AT91_SAMA5D2_CHAN_DIFF(8, 9, 0x70),
 463         AT91_SAMA5D2_CHAN_DIFF(10, 11, 0x78),
 464         IIO_CHAN_SOFT_TIMESTAMP(AT91_SAMA5D2_TIMESTAMP_CHAN_IDX),
 465         AT91_SAMA5D2_CHAN_TOUCH(AT91_SAMA5D2_TOUCH_X_CHAN_IDX, "x", IIO_MOD_X),
 466         AT91_SAMA5D2_CHAN_TOUCH(AT91_SAMA5D2_TOUCH_Y_CHAN_IDX, "y", IIO_MOD_Y),
 467         AT91_SAMA5D2_CHAN_PRESSURE(AT91_SAMA5D2_TOUCH_P_CHAN_IDX, "pressure"),
 468 };
 469
 470 static int at91_adc_chan_xlate(struct iio_dev *indio_dev, int chan)
 471 {
 472         int i;
 473
 474         for (i = 0; i < indio_dev->num_channels; i++) {
 475                 if (indio_dev->channels[i].scan_index == chan)
 476                         return i;
 477         }
 478         return -EINVAL;
 479 }
 480
 481 static inline struct iio_chan_spec const *
 482 at91_adc_chan_get(struct iio_dev *indio_dev, int chan)
 483 {
 484         int index = at91_adc_chan_xlate(indio_dev, chan);
 485
 486         if (index < 0)
 487                 return NULL;
 488         return indio_dev->channels + index;
 489 }
 490
 491 static inline int at91_adc_of_xlate(struct iio_dev *indio_dev,
 492                                     const struct of_phandle_args *iiospec)
 493 {
 494         return at91_adc_chan_xlate(indio_dev, iiospec->args[0]);
 495 }
 496
 497 static void at91_adc_config_emr(struct at91_adc_state *st)
 498 {
 499         /* configure the extended mode register */
 500         unsigned int emr = at91_adc_readl(st, AT91_SAMA5D2_EMR);
 501
 502         /* select oversampling per single trigger event */
 503         emr |= AT91_SAMA5D2_EMR_ASTE(1);
 504
 505         /* delete leftover content if it's the case */
 506         emr &= ~AT91_SAMA5D2_EMR_OSR_MASK;
 507
 508         /* select oversampling ratio from configuration */
 509         switch (st->oversampling_ratio) {
 510         case AT91_OSR_1SAMPLES:
 511                 emr |= AT91_SAMA5D2_EMR_OSR(AT91_SAMA5D2_EMR_OSR_1SAMPLES) &
 512                        AT91_SAMA5D2_EMR_OSR_MASK;
 513                 break;
 514         case AT91_OSR_4SAMPLES:
 515                 emr |= AT91_SAMA5D2_EMR_OSR(AT91_SAMA5D2_EMR_OSR_4SAMPLES) &
 516                        AT91_SAMA5D2_EMR_OSR_MASK;
 517                 break;
 518         case AT91_OSR_16SAMPLES:
 519                 emr |= AT91_SAMA5D2_EMR_OSR(AT91_SAMA5D2_EMR_OSR_16SAMPLES) &
 520                        AT91_SAMA5D2_EMR_OSR_MASK;
 521                 break;
 522         }
 523
 524         at91_adc_writel(st, AT91_SAMA5D2_EMR, emr);
 525 }
 526
 527 static int at91_adc_adjust_val_osr(struct at91_adc_state *st, int *val)
 528 {
 529         if (st->oversampling_ratio == AT91_OSR_1SAMPLES) {
 530                 /*
 531                  * in this case we only have 12 bits of real data, but channel
 532                  * is registered as 14 bits, so shift left two bits
 533                  */
 534                 *val <<= 2;
 535         } else if (st->oversampling_ratio == AT91_OSR_4SAMPLES) {
 536                 /*
 537                  * in this case we have 13 bits of real data, but channel
 538                  * is registered as 14 bits, so left shift one bit
 539                  */
 540                 *val <<= 1;
 541         }
 542
 543         return IIO_VAL_INT;
 544 }
 545
 546 static void at91_adc_adjust_val_osr_array(struct at91_adc_state *st, void *buf,
 547                                           int len)
 548 {
 549         int i = 0, val;
 550         u16 *buf_u16 = (u16 *) buf;
 551
 552         /*
 553          * We are converting each two bytes (each sample).
 554          * First convert the byte based array to u16, and convert each sample
 555          * separately.
 556          * Each value is two bytes in an array of chars, so to not shift
 557          * more than we need, save the value separately.
 558          * len is in bytes, so divide by two to get number of samples.
 559          */
 560         while (i < len / 2) {
 561                 val = buf_u16[i];
 562                 at91_adc_adjust_val_osr(st, &val);
 563                 buf_u16[i] = val;
 564                 i++;
 565         }
 566 }
 567
 568 static int at91_adc_configure_touch(struct at91_adc_state *st, bool state)
 569 {
 570         u32 clk_khz = st->current_sample_rate / 1000;
 571         int i = 0;
 572         u16 pendbc;
 573         u32 tsmr, acr;
 574
 575         if (!state) {
 576                 /* disabling touch IRQs and setting mode to no touch enabled */
 577                 at91_adc_writel(st, AT91_SAMA5D2_IDR,
 578                                 AT91_SAMA5D2_IER_PEN | AT91_SAMA5D2_IER_NOPEN);
 579                 at91_adc_writel(st, AT91_SAMA5D2_TSMR, 0);
 580                 return 0;
 581         }
 582         /*
 583          * debounce time is in microseconds, we need it in milliseconds to
 584          * multiply with kilohertz, so, divide by 1000, but after the multiply.
 585          * round up to make sure pendbc is at least 1
 586          */
 587         pendbc = round_up(AT91_SAMA5D2_TOUCH_PEN_DETECT_DEBOUNCE_US *
 588                           clk_khz / 1000, 1);
 589
 590         /* get the required exponent */
 591         while (pendbc >> i++)
 592                 ;
 593
 594         pendbc = i;
 595
 596         tsmr = AT91_SAMA5D2_TSMR_TSMODE_4WIRE_PRESS;
 597
 598         tsmr |= AT91_SAMA5D2_TSMR_TSAV(2) & AT91_SAMA5D2_TSMR_TSAV_MASK;
 599         tsmr |= AT91_SAMA5D2_TSMR_PENDBC(pendbc) &
 600                 AT91_SAMA5D2_TSMR_PENDBC_MASK;
 601         tsmr |= AT91_SAMA5D2_TSMR_NOTSDMA;
 602         tsmr |= AT91_SAMA5D2_TSMR_PENDET_ENA;
 603         tsmr |= AT91_SAMA5D2_TSMR_TSFREQ(2) & AT91_SAMA5D2_TSMR_TSFREQ_MASK;
 604
 605         at91_adc_writel(st, AT91_SAMA5D2_TSMR, tsmr);
 606
 607         acr =  at91_adc_readl(st, AT91_SAMA5D2_ACR);
 608         acr &= ~AT91_SAMA5D2_ACR_PENDETSENS_MASK;
 609         acr |= 0x02 & AT91_SAMA5D2_ACR_PENDETSENS_MASK;
 610         at91_adc_writel(st, AT91_SAMA5D2_ACR, acr);
 611
 612         /* Sample Period Time = (TRGPER + 1) / ADCClock */
 613         st->touch_st.sample_period_val =
 614                                  round_up((AT91_SAMA5D2_TOUCH_SAMPLE_PERIOD_US *
 615                                  clk_khz / 1000) - 1, 1);
 616         /* enable pen detect IRQ */
 617         at91_adc_writel(st, AT91_SAMA5D2_IER, AT91_SAMA5D2_IER_PEN);
 618
 619         return 0;
 620 }
 621
 622 static u16 at91_adc_touch_pos(struct at91_adc_state *st, int reg)
 623 {
 624         u32 val;
 625         u32 scale, result, pos;
 626
 627         /*
 628          * to obtain the actual position we must divide by scale
 629          * and multiply with max, where
 630          * max = 2^AT91_SAMA5D2_MAX_POS_BITS - 1
 631          */
 632         /* first half of register is the x or y, second half is the scale */
 633         val = at91_adc_readl(st, reg);
 634         if (!val)
 635                 dev_dbg(&iio_priv_to_dev(st)->dev, "pos is 0\n");
 636
 637         pos = val & AT91_SAMA5D2_XYZ_MASK;
 638         result = (pos << AT91_SAMA5D2_MAX_POS_BITS) - pos;
 639         scale = (val >> 16) & AT91_SAMA5D2_XYZ_MASK;
 640         if (scale == 0) {
 641                 dev_err(&iio_priv_to_dev(st)->dev, "scale is 0\n");
 642                 return 0;
 643         }
 644         result /= scale;
 645
 646         return result;
 647 }
 648
 649 static u16 at91_adc_touch_x_pos(struct at91_adc_state *st)
 650 {
 651         st->touch_st.x_pos = at91_adc_touch_pos(st, AT91_SAMA5D2_XPOSR);
 652         return st->touch_st.x_pos;
 653 }
 654
 655 static u16 at91_adc_touch_y_pos(struct at91_adc_state *st)
 656 {
 657         return at91_adc_touch_pos(st, AT91_SAMA5D2_YPOSR);
 658 }
 659
 660 static u16 at91_adc_touch_pressure(struct at91_adc_state *st)
 661 {
 662         u32 val;
 663         u32 z1, z2;
 664         u32 pres;
 665         u32 rxp = 1;
 666         u32 factor = 1000;
 667
 668         /* calculate the pressure */
 669         val = at91_adc_readl(st, AT91_SAMA5D2_PRESSR);
 670         z1 = val & AT91_SAMA5D2_XYZ_MASK;
 671         z2 = (val >> 16) & AT91_SAMA5D2_XYZ_MASK;
 672
 673         if (z1 != 0)
 674                 pres = rxp * (st->touch_st.x_pos * factor / 1024) *
 675                         (z2 * factor / z1 - factor) /
 676                         factor;
 677         else
 678                 pres = 0xFFFF;       /* no pen contact */
 679
 680         /*
 681          * The pressure from device grows down, minimum is 0xFFFF, maximum 0x0.
 682          * We compute it this way, but let's return it in the expected way,
 683          * growing from 0 to 0xFFFF.
 684          */
 685         return 0xFFFF - pres;
 686 }
 687
 688 static int at91_adc_read_position(struct at91_adc_state *st, int chan, u16 *val)
 689 {
 690         *val = 0;
 691         if (!st->touch_st.touching)
 692                 return -ENODATA;
 693         if (chan == AT91_SAMA5D2_TOUCH_X_CHAN_IDX)
 694                 *val = at91_adc_touch_x_pos(st);
 695         else if (chan == AT91_SAMA5D2_TOUCH_Y_CHAN_IDX)
 696                 *val = at91_adc_touch_y_pos(st);
 697         else
 698                 return -ENODATA;
 699
 700         return IIO_VAL_INT;
 701 }
 702
 703 static int at91_adc_read_pressure(struct at91_adc_state *st, int chan, u16 *val)
 704 {
 705         *val = 0;
 706         if (!st->touch_st.touching)
 707                 return -ENODATA;
 708         if (chan == AT91_SAMA5D2_TOUCH_P_CHAN_IDX)
 709                 *val = at91_adc_touch_pressure(st);
 710         else
 711                 return -ENODATA;
 712
 713         return IIO_VAL_INT;
 714 }
 715
 716 static int at91_adc_configure_trigger(struct iio_trigger *trig, bool state)
 717 {
 718         struct iio_dev *indio = iio_trigger_get_drvdata(trig);
 719         struct at91_adc_state *st = iio_priv(indio);
 720         u32 status = at91_adc_readl(st, AT91_SAMA5D2_TRGR);
 721         u8 bit;
 722
 723         /* clear TRGMOD */
 724         status &= ~AT91_SAMA5D2_TRGR_TRGMOD_MASK;
 725
 726         if (state)
 727                 status |= st->selected_trig->trgmod_value;
 728
 729         /* set/unset hw trigger */
 730         at91_adc_writel(st, AT91_SAMA5D2_TRGR, status);
 731
 732         for_each_set_bit(bit, indio->active_scan_mask, indio->num_channels) {
 733                 struct iio_chan_spec const *chan = at91_adc_chan_get(indio, bit);
 734                 u32 cor;
 735
 736                 if (!chan)
 737                         continue;
 738                 /* these channel types cannot be handled by this trigger */
 739                 if (chan->type == IIO_POSITIONRELATIVE ||
 740                     chan->type == IIO_PRESSURE)
 741                         continue;
 742
 743                 if (state) {
 744                         cor = at91_adc_readl(st, AT91_SAMA5D2_COR);
 745
 746                         if (chan->differential)
 747                                 cor |= (BIT(chan->channel) |
 748                                         BIT(chan->channel2)) <<
 749                                         AT91_SAMA5D2_COR_DIFF_OFFSET;
 750                         else
 751                                 cor &= ~(BIT(chan->channel) <<
 752                                        AT91_SAMA5D2_COR_DIFF_OFFSET);
 753
 754                         at91_adc_writel(st, AT91_SAMA5D2_COR, cor);
 755                 }
 756
 757                 if (state) {
 758                         at91_adc_writel(st, AT91_SAMA5D2_CHER,
 759                                         BIT(chan->channel));
 760                         /* enable irq only if not using DMA */
 761                         if (!st->dma_st.dma_chan) {
 762                                 at91_adc_writel(st, AT91_SAMA5D2_IER,
 763                                                 BIT(chan->channel));
 764                         }
 765                 } else {
 766                         /* disable irq only if not using DMA */
 767                         if (!st->dma_st.dma_chan) {
 768                                 at91_adc_writel(st, AT91_SAMA5D2_IDR,
 769                                                 BIT(chan->channel));
 770                         }
 771                         at91_adc_writel(st, AT91_SAMA5D2_CHDR,
 772                                         BIT(chan->channel));
 773                 }
 774         }
 775
 776         return 0;
 777 }
 778
 779 static int at91_adc_reenable_trigger(struct iio_trigger *trig)
 780 {
 781         struct iio_dev *indio = iio_trigger_get_drvdata(trig);
 782         struct at91_adc_state *st = iio_priv(indio);
 783
 784         /* if we are using DMA, we must not reenable irq after each trigger */
 785         if (st->dma_st.dma_chan)
 786                 return 0;
 787
 788         enable_irq(st->irq);
 789
 790         /* Needed to ACK the DRDY interruption */
 791         at91_adc_readl(st, AT91_SAMA5D2_LCDR);
 792         return 0;
 793 }
 794
 795 static const struct iio_trigger_ops at91_adc_trigger_ops = {
 796         .set_trigger_state = &at91_adc_configure_trigger,
 797         .try_reenable = &at91_adc_reenable_trigger,
 798         .validate_device = iio_trigger_validate_own_device,
 799 };
 800
 801 static int at91_adc_dma_size_done(struct at91_adc_state *st)
 802 {
 803         struct dma_tx_state state;
 804         enum dma_status status;
 805         int i, size;
 806
 807         status = dmaengine_tx_status(st->dma_st.dma_chan,
 808                                      st->dma_st.dma_chan->cookie,
 809                                      &state);
 810         if (status != DMA_IN_PROGRESS)
 811                 return 0;
 812
 813         /* Transferred length is size in bytes from end of buffer */
 814         i = st->dma_st.rx_buf_sz - state.residue;
 815
 816         /* Return available bytes */
 817         if (i >= st->dma_st.buf_idx)
 818                 size = i - st->dma_st.buf_idx;
 819         else
 820                 size = st->dma_st.rx_buf_sz + i - st->dma_st.buf_idx;
 821         return size;
 822 }
 823
 824 static void at91_dma_buffer_done(void *data)
 825 {
 826         struct iio_dev *indio_dev = data;
 827
 828         iio_trigger_poll_chained(indio_dev->trig);
 829 }
 830
 831 static int at91_adc_dma_start(struct iio_dev *indio_dev)
 832 {
 833         struct at91_adc_state *st = iio_priv(indio_dev);
 834         struct dma_async_tx_descriptor *desc;
 835         dma_cookie_t cookie;
 836         int ret;
 837         u8 bit;
 838
 839         if (!st->dma_st.dma_chan)
 840                 return 0;
 841
 842         /* we start a new DMA, so set buffer index to start */
 843         st->dma_st.buf_idx = 0;
 844
 845         /*
 846          * compute buffer size w.r.t. watermark and enabled channels.
 847          * scan_bytes is aligned so we need an exact size for DMA
 848          */
 849         st->dma_st.rx_buf_sz = 0;
 850
 851         for_each_set_bit(bit, indio_dev->active_scan_mask,
 852                          indio_dev->num_channels) {
 853                 struct iio_chan_spec const *chan =
 854                                          at91_adc_chan_get(indio_dev, bit);
 855
 856                 if (!chan)
 857                         continue;
 858
 859                 st->dma_st.rx_buf_sz += chan->scan_type.storagebits / 8;
 860         }
 861         st->dma_st.rx_buf_sz *= st->dma_st.watermark;
 862
 863         /* Prepare a DMA cyclic transaction */
 864         desc = dmaengine_prep_dma_cyclic(st->dma_st.dma_chan,
 865                                          st->dma_st.rx_dma_buf,
 866                                          st->dma_st.rx_buf_sz,
 867                                          st->dma_st.rx_buf_sz / 2,
 868                                          DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT);
 869
 870         if (!desc) {
 871                 dev_err(&indio_dev->dev, "cannot prepare DMA cyclic\n");
 872                 return -EBUSY;
 873         }
 874
 875         desc->callback = at91_dma_buffer_done;
 876         desc->callback_param = indio_dev;
 877
 878         cookie = dmaengine_submit(desc);
 879         ret = dma_submit_error(cookie);
 880         if (ret) {
 881                 dev_err(&indio_dev->dev, "cannot submit DMA cyclic\n");
 882                 dmaengine_terminate_async(st->dma_st.dma_chan);
 883                 return ret;
 884         }
 885
 886         /* enable general overrun error signaling */
 887         at91_adc_writel(st, AT91_SAMA5D2_IER, AT91_SAMA5D2_IER_GOVRE);
 888         /* Issue pending DMA requests */
 889         dma_async_issue_pending(st->dma_st.dma_chan);
 890
 891         /* consider current time as DMA start time for timestamps */
 892         st->dma_st.dma_ts = iio_get_time_ns(indio_dev);
 893
 894         dev_dbg(&indio_dev->dev, "DMA cyclic started\n");
 895
 896         return 0;
 897 }
 898
 899 static int at91_adc_buffer_postenable(struct iio_dev *indio_dev)
 900 {
 901         int ret;
 902         struct at91_adc_state *st = iio_priv(indio_dev);
 903
 904         /* check if we are enabling triggered buffer or the touchscreen */
 905         if (bitmap_subset(indio_dev->active_scan_mask,
 906                           &st->touch_st.channels_bitmask,
 907                           AT91_SAMA5D2_MAX_CHAN_IDX + 1)) {
 908                 /* touchscreen enabling */
 909                 return at91_adc_configure_touch(st, true);
 910         }
 911         /* if we are not in triggered mode, we cannot enable the buffer. */
 912         if (!(indio_dev->currentmode & INDIO_ALL_TRIGGERED_MODES))
 913                 return -EINVAL;
 914
 915         /* we continue with the triggered buffer */
 916         ret = at91_adc_dma_start(indio_dev);
 917         if (ret) {
 918                 dev_err(&indio_dev->dev, "buffer postenable failed\n");
 919                 return ret;
 920         }
 921
 922         return iio_triggered_buffer_postenable(indio_dev);
 923 }
 924
 925 static int at91_adc_buffer_predisable(struct iio_dev *indio_dev)
 926 {
 927         struct at91_adc_state *st = iio_priv(indio_dev);
 928         int ret;
 929         u8 bit;
 930
 931         /* check if we are disabling triggered buffer or the touchscreen */
 932         if (bitmap_subset(indio_dev->active_scan_mask,
 933                           &st->touch_st.channels_bitmask,
 934                           AT91_SAMA5D2_MAX_CHAN_IDX + 1)) {
 935                 /* touchscreen disable */
 936                 return at91_adc_configure_touch(st, false);
 937         }
 938         /* if we are not in triggered mode, nothing to do here */
 939         if (!(indio_dev->currentmode & INDIO_ALL_TRIGGERED_MODES))
 940                 return -EINVAL;
 941
 942         /* continue with the triggered buffer */
 943         ret = iio_triggered_buffer_predisable(indio_dev);
 944         if (ret < 0)
 945                 dev_err(&indio_dev->dev, "buffer predisable failed\n");
 946
 947         if (!st->dma_st.dma_chan)
 948                 return ret;
 949
 950         /* if we are using DMA we must clear registers and end DMA */
 951         dmaengine_terminate_sync(st->dma_st.dma_chan);
 952
 953         /*
 954          * For each enabled channel we must read the last converted value
 955          * to clear EOC status and not get a possible interrupt later.
 956          * This value is being read by DMA from LCDR anyway
 957          */
 958         for_each_set_bit(bit, indio_dev->active_scan_mask,
 959                          indio_dev->num_channels) {
 960                 struct iio_chan_spec const *chan =
 961                                         at91_adc_chan_get(indio_dev, bit);
 962
 963                 if (!chan)
 964                         continue;
 965                 /* these channel types are virtual, no need to do anything */
 966                 if (chan->type == IIO_POSITIONRELATIVE ||
 967                     chan->type == IIO_PRESSURE)
 968                         continue;
 969                 if (st->dma_st.dma_chan)
 970                         at91_adc_readl(st, chan->address);
 971         }
 972
 973         /* read overflow register to clear possible overflow status */
 974         at91_adc_readl(st, AT91_SAMA5D2_OVER);
 975         return ret;
 976 }
 977
 978 static const struct iio_buffer_setup_ops at91_buffer_setup_ops = {
 979         .postenable = &at91_adc_buffer_postenable,
 980         .predisable = &at91_adc_buffer_predisable,
 981 };
 982
 983 static struct iio_trigger *at91_adc_allocate_trigger(struct iio_dev *indio,
 984                                                      char *trigger_name)
 985 {
 986         struct iio_trigger *trig;
 987         int ret;
 988
 989         trig = devm_iio_trigger_alloc(&indio->dev, "%s-dev%d-%s", indio->name,
 990                                       indio->id, trigger_name);
 991         if (!trig)
 992                 return ERR_PTR(-ENOMEM);
 993
 994         trig->dev.parent = indio->dev.parent;
 995         iio_trigger_set_drvdata(trig, indio);
 996         trig->ops = &at91_adc_trigger_ops;
 997
 998         ret = devm_iio_trigger_register(&indio->dev, trig);
 999         if (ret)
1000                 return ERR_PTR(ret);
1001
1002         return trig;
1003 }
1004
1005 static int at91_adc_trigger_init(struct iio_dev *indio)
1006 {
1007         struct at91_adc_state *st = iio_priv(indio);
1008
1009         st->trig = at91_adc_allocate_trigger(indio, st->selected_trig->name);
1010         if (IS_ERR(st->trig)) {
1011                 dev_err(&indio->dev,
1012                         "could not allocate trigger\n");
1013                 return PTR_ERR(st->trig);
1014         }
1015
1016         return 0;
1017 }
1018
1019 static void at91_adc_trigger_handler_nodma(struct iio_dev *indio_dev,
1020                                            struct iio_poll_func *pf)
1021 {
1022         struct at91_adc_state *st = iio_priv(indio_dev);
1023         int i = 0;
1024         int val;
1025         u8 bit;
1026
1027         for_each_set_bit(bit, indio_dev->active_scan_mask,
1028                          indio_dev->num_channels) {
1029                 struct iio_chan_spec const *chan =
1030                                         at91_adc_chan_get(indio_dev, bit);
1031
1032                 if (!chan)
1033                         continue;
1034                 /*
1035                  * Our external trigger only supports the voltage channels.
1036                  * In case someone requested a different type of channel
1037                  * just put zeroes to buffer.
1038                  * This should not happen because we check the scan mode
1039                  * and scan mask when we enable the buffer, and we don't allow
1040                  * the buffer to start with a mixed mask (voltage and something
1041                  * else).
1042                  * Thus, emit a warning.
1043                  */
1044                 if (chan->type == IIO_VOLTAGE) {
1045                         val = at91_adc_readl(st, chan->address);
1046                         at91_adc_adjust_val_osr(st, &val);
1047                         st->buffer[i] = val;
1048                 } else {
1049                         st->buffer[i] = 0;
1050                         WARN(true, "This trigger cannot handle this type of channel");
1051                 }
1052                 i++;
1053         }
1054         iio_push_to_buffers_with_timestamp(indio_dev, st->buffer,
1055                                            pf->timestamp);
1056 }
1057
1058 static void at91_adc_trigger_handler_dma(struct iio_dev *indio_dev)
1059 {
1060         struct at91_adc_state *st = iio_priv(indio_dev);
1061         int transferred_len = at91_adc_dma_size_done(st);
1062         s64 ns = iio_get_time_ns(indio_dev);
1063         s64 interval;
1064         int sample_index = 0, sample_count, sample_size;
1065
1066         u32 status = at91_adc_readl(st, AT91_SAMA5D2_ISR);
1067         /* if we reached this point, we cannot sample faster */
1068         if (status & AT91_SAMA5D2_IER_GOVRE)
1069                 pr_info_ratelimited("%s: conversion overrun detected\n",
1070                                     indio_dev->name);
1071
1072         sample_size = div_s64(st->dma_st.rx_buf_sz, st->dma_st.watermark);
1073
1074         sample_count = div_s64(transferred_len, sample_size);
1075
1076         /*
1077          * interval between samples is total time since last transfer handling
1078          * divided by the number of samples (total size divided by sample size)
1079          */
1080         interval = div_s64((ns - st->dma_st.dma_ts), sample_count);
1081
1082         while (transferred_len >= sample_size) {
1083                 /*
1084                  * for all the values in the current sample,
1085                  * adjust the values inside the buffer for oversampling
1086                  */
1087                 at91_adc_adjust_val_osr_array(st,
1088                                         &st->dma_st.rx_buf[st->dma_st.buf_idx],
1089                                         sample_size);
1090
1091                 iio_push_to_buffers_with_timestamp(indio_dev,
1092                                 (st->dma_st.rx_buf + st->dma_st.buf_idx),
1093                                 (st->dma_st.dma_ts + interval * sample_index));
1094                 /* adjust remaining length */
1095                 transferred_len -= sample_size;
1096                 /* adjust buffer index */
1097                 st->dma_st.buf_idx += sample_size;
1098                 /* in case of reaching end of buffer, reset index */
1099                 if (st->dma_st.buf_idx >= st->dma_st.rx_buf_sz)
1100                         st->dma_st.buf_idx = 0;
1101                 sample_index++;
1102         }
1103         /* adjust saved time for next transfer handling */
1104         st->dma_st.dma_ts = iio_get_time_ns(indio_dev);
1105 }
1106
1107 static irqreturn_t at91_adc_trigger_handler(int irq, void *p)
1108 {
1109         struct iio_poll_func *pf = p;
1110         struct iio_dev *indio_dev = pf->indio_dev;
1111         struct at91_adc_state *st = iio_priv(indio_dev);
1112
1113         if (st->dma_st.dma_chan)
1114                 at91_adc_trigger_handler_dma(indio_dev);
1115         else
1116                 at91_adc_trigger_handler_nodma(indio_dev, pf);
1117
1118         iio_trigger_notify_done(indio_dev->trig);
1119
1120         return IRQ_HANDLED;
1121 }
1122
1123 static int at91_adc_buffer_init(struct iio_dev *indio)
1124 {
1125         struct at91_adc_state *st = iio_priv(indio);
1126
1127         if (st->selected_trig->hw_trig) {
1128                 return devm_iio_triggered_buffer_setup(&indio->dev, indio,
1129                         &iio_pollfunc_store_time,
1130                         &at91_adc_trigger_handler, &at91_buffer_setup_ops);
1131         }
1132         /*
1133          * we need to prepare the buffer ops in case we will get
1134          * another buffer attached (like a callback buffer for the touchscreen)
1135          */
1136         indio->setup_ops = &at91_buffer_setup_ops;
1137
1138         return 0;
1139 }
1140
1141 static unsigned at91_adc_startup_time(unsigned startup_time_min,
1142                                       unsigned adc_clk_khz)
1143 {
1144         static const unsigned int startup_lookup[] = {
1145                   0,   8,  16,  24,
1146                  64,  80,  96, 112,
1147                 512, 576, 640, 704,
1148                 768, 832, 896, 960
1149                 };
1150         unsigned ticks_min, i;
1151
1152         /*
1153          * Since the adc frequency is checked before, there is no reason
1154          * to not meet the startup time constraint.
1155          */
1156
1157         ticks_min = startup_time_min * adc_clk_khz / 1000;
1158         for (i = 0; i < ARRAY_SIZE(startup_lookup); i++)
1159                 if (startup_lookup[i] > ticks_min)
1160                         break;
1161
1162         return i;
1163 }
1164
1165 static void at91_adc_setup_samp_freq(struct at91_adc_state *st, unsigned freq)
1166 {
1167         struct iio_dev *indio_dev = iio_priv_to_dev(st);
1168         unsigned f_per, prescal, startup, mr;
1169
1170         f_per = clk_get_rate(st->per_clk);
1171         prescal = (f_per / (2 * freq)) - 1;
1172
1173         startup = at91_adc_startup_time(st->soc_info.startup_time,
1174                                         freq / 1000);
1175
1176         mr = at91_adc_readl(st, AT91_SAMA5D2_MR);
1177         mr &= ~(AT91_SAMA5D2_MR_STARTUP_MASK | AT91_SAMA5D2_MR_PRESCAL_MASK);
1178         mr |= AT91_SAMA5D2_MR_STARTUP(startup);
1179         mr |= AT91_SAMA5D2_MR_PRESCAL(prescal);
1180         at91_adc_writel(st, AT91_SAMA5D2_MR, mr);
1181
1182         dev_dbg(&indio_dev->dev, "freq: %u, startup: %u, prescal: %u\n",
1183                 freq, startup, prescal);
1184         st->current_sample_rate = freq;
1185 }
1186
1187 static inline unsigned at91_adc_get_sample_freq(struct at91_adc_state *st)
1188 {
1189         return st->current_sample_rate;
1190 }
1191
1192 static void at91_adc_touch_data_handler(struct iio_dev *indio_dev)
1193 {
1194         struct at91_adc_state *st = iio_priv(indio_dev);
1195         u8 bit;
1196         u16 val;
1197         int i = 0;
1198
1199         for_each_set_bit(bit, indio_dev->active_scan_mask,
1200                          AT91_SAMA5D2_MAX_CHAN_IDX + 1) {
1201                 struct iio_chan_spec const *chan =
1202                                          at91_adc_chan_get(indio_dev, bit);
1203
1204                 if (chan->type == IIO_POSITIONRELATIVE)
1205                         at91_adc_read_position(st, chan->channel, &val);
1206                 else if (chan->type == IIO_PRESSURE)
1207                         at91_adc_read_pressure(st, chan->channel, &val);
1208                 else
1209                         continue;
1210                 st->buffer[i] = val;
1211                 i++;
1212         }
1213         /*
1214          * Schedule work to push to buffers.
1215          * This is intended to push to the callback buffer that another driver
1216          * registered. We are still in a handler from our IRQ. If we push
1217          * directly, it means the other driver has it's callback called
1218          * from our IRQ context. Which is something we better avoid.
1219          * Let's schedule it after our IRQ is completed.
1220          */
1221         schedule_work(&st->touch_st.workq);
1222 }
1223
1224 static void at91_adc_pen_detect_interrupt(struct at91_adc_state *st)
1225 {
1226         at91_adc_writel(st, AT91_SAMA5D2_IDR, AT91_SAMA5D2_IER_PEN);
1227         at91_adc_writel(st, AT91_SAMA5D2_IER, AT91_SAMA5D2_IER_NOPEN |
1228                         AT91_SAMA5D2_IER_XRDY | AT91_SAMA5D2_IER_YRDY |
1229                         AT91_SAMA5D2_IER_PRDY);
1230         at91_adc_writel(st, AT91_SAMA5D2_TRGR,
1231                         AT91_SAMA5D2_TRGR_TRGMOD_PERIODIC |
1232                         AT91_SAMA5D2_TRGR_TRGPER(st->touch_st.sample_period_val));
1233         st->touch_st.touching = true;
1234 }
1235
1236 static void at91_adc_no_pen_detect_interrupt(struct at91_adc_state *st)
1237 {
1238         struct iio_dev *indio_dev = iio_priv_to_dev(st);
1239
1240         at91_adc_writel(st, AT91_SAMA5D2_TRGR,
1241                         AT91_SAMA5D2_TRGR_TRGMOD_NO_TRIGGER);
1242         at91_adc_writel(st, AT91_SAMA5D2_IDR, AT91_SAMA5D2_IER_NOPEN |
1243                         AT91_SAMA5D2_IER_XRDY | AT91_SAMA5D2_IER_YRDY |
1244                         AT91_SAMA5D2_IER_PRDY);
1245         st->touch_st.touching = false;
1246
1247         at91_adc_touch_data_handler(indio_dev);
1248
1249         at91_adc_writel(st, AT91_SAMA5D2_IER, AT91_SAMA5D2_IER_PEN);
1250 }
1251
1252 static void at91_adc_workq_handler(struct work_struct *workq)
1253 {
1254         struct at91_adc_touch *touch_st = container_of(workq,
1255                                         struct at91_adc_touch, workq);
1256         struct at91_adc_state *st = container_of(touch_st,
1257                                         struct at91_adc_state, touch_st);
1258         struct iio_dev *indio_dev = iio_priv_to_dev(st);
1259
1260         iio_push_to_buffers(indio_dev, st->buffer);
1261 }
1262
1263 static irqreturn_t at91_adc_interrupt(int irq, void *private)
1264 {
1265         struct iio_dev *indio = private;
1266         struct at91_adc_state *st = iio_priv(indio);
1267         u32 status = at91_adc_readl(st, AT91_SAMA5D2_ISR);
1268         u32 imr = at91_adc_readl(st, AT91_SAMA5D2_IMR);
1269         u32 rdy_mask = AT91_SAMA5D2_IER_XRDY | AT91_SAMA5D2_IER_YRDY |
1270                         AT91_SAMA5D2_IER_PRDY;
1271
1272         if (!(status & imr))
1273                 return IRQ_NONE;
1274         if (status & AT91_SAMA5D2_IER_PEN) {
1275                 /* pen detected IRQ */
1276                 at91_adc_pen_detect_interrupt(st);
1277         } else if ((status & AT91_SAMA5D2_IER_NOPEN)) {
1278                 /* nopen detected IRQ */
1279                 at91_adc_no_pen_detect_interrupt(st);
1280         } else if ((status & AT91_SAMA5D2_ISR_PENS) &&
1281                    ((status & rdy_mask) == rdy_mask)) {
1282                 /* periodic trigger IRQ - during pen sense */
1283                 at91_adc_touch_data_handler(indio);
1284         } else if (status & AT91_SAMA5D2_ISR_PENS) {
1285                 /*
1286                  * touching, but the measurements are not ready yet.
1287                  * read and ignore.
1288                  */
1289                 status = at91_adc_readl(st, AT91_SAMA5D2_XPOSR);
1290                 status = at91_adc_readl(st, AT91_SAMA5D2_YPOSR);
1291                 status = at91_adc_readl(st, AT91_SAMA5D2_PRESSR);
1292         } else if (iio_buffer_enabled(indio) && !st->dma_st.dma_chan) {
1293                 /* triggered buffer without DMA */
1294                 disable_irq_nosync(irq);
1295                 iio_trigger_poll(indio->trig);
1296         } else if (iio_buffer_enabled(indio) && st->dma_st.dma_chan) {
1297                 /* triggered buffer with DMA - should not happen */
1298                 disable_irq_nosync(irq);
1299                 WARN(true, "Unexpected irq occurred\n");
1300         } else if (!iio_buffer_enabled(indio)) {
1301                 /* software requested conversion */
1302                 st->conversion_value = at91_adc_readl(st, st->chan->address);
1303                 st->conversion_done = true;
1304                 wake_up_interruptible(&st->wq_data_available);
1305         }
1306         return IRQ_HANDLED;
1307 }
1308
1309 static int at91_adc_read_info_raw(struct iio_dev *indio_dev,
1310                                   struct iio_chan_spec const *chan, int *val)
1311 {
1312         struct at91_adc_state *st = iio_priv(indio_dev);
1313         u32 cor = 0;
1314         u16 tmp_val;
1315         int ret;
1316
1317         /*
1318          * Keep in mind that we cannot use software trigger or touchscreen
1319          * if external trigger is enabled
1320          */
1321         if (chan->type == IIO_POSITIONRELATIVE) {
1322                 ret = iio_device_claim_direct_mode(indio_dev);
1323                 if (ret)
1324                         return ret;
1325                 mutex_lock(&st->lock);
1326
1327                 ret = at91_adc_read_position(st, chan->channel,
1328                                              &tmp_val);
1329                 *val = tmp_val;
1330                 mutex_unlock(&st->lock);
1331                 iio_device_release_direct_mode(indio_dev);
1332                 if (ret > 0)
1333                         ret = at91_adc_adjust_val_osr(st, val);
1334
1335                 return ret;
1336         }
1337         if (chan->type == IIO_PRESSURE) {
1338                 ret = iio_device_claim_direct_mode(indio_dev);
1339                 if (ret)
1340                         return ret;
1341                 mutex_lock(&st->lock);
1342
1343                 ret = at91_adc_read_pressure(st, chan->channel,
1344                                              &tmp_val);
1345                 *val = tmp_val;
1346                 mutex_unlock(&st->lock);
1347                 iio_device_release_direct_mode(indio_dev);
1348                 if (ret > 0)
1349                         ret = at91_adc_adjust_val_osr(st, val);
1350
1351                 return ret;
1352         }
1353
1354         /* in this case we have a voltage channel */
1355
1356         ret = iio_device_claim_direct_mode(indio_dev);
1357         if (ret)
1358                 return ret;
1359         mutex_lock(&st->lock);
1360
1361         st->chan = chan;
1362
1363         if (chan->differential)
1364                 cor = (BIT(chan->channel) | BIT(chan->channel2)) <<
1365                       AT91_SAMA5D2_COR_DIFF_OFFSET;
1366
1367         at91_adc_writel(st, AT91_SAMA5D2_COR, cor);
1368         at91_adc_writel(st, AT91_SAMA5D2_CHER, BIT(chan->channel));
1369         at91_adc_writel(st, AT91_SAMA5D2_IER, BIT(chan->channel));
1370         at91_adc_writel(st, AT91_SAMA5D2_CR, AT91_SAMA5D2_CR_START);
1371
1372         ret = wait_event_interruptible_timeout(st->wq_data_available,
1373                                                st->conversion_done,
1374                                                msecs_to_jiffies(1000));
1375         if (ret == 0)
1376                 ret = -ETIMEDOUT;
1377
1378         if (ret > 0) {
1379                 *val = st->conversion_value;
1380                 ret = at91_adc_adjust_val_osr(st, val);
1381                 if (chan->scan_type.sign == 's')
1382                         *val = sign_extend32(*val,
1383                                              chan->scan_type.realbits - 1);
1384                 st->conversion_done = false;
1385         }
1386
1387         at91_adc_writel(st, AT91_SAMA5D2_IDR, BIT(chan->channel));
1388         at91_adc_writel(st, AT91_SAMA5D2_CHDR, BIT(chan->channel));
1389
1390         /* Needed to ACK the DRDY interruption */
1391         at91_adc_readl(st, AT91_SAMA5D2_LCDR);
1392
1393         mutex_unlock(&st->lock);
1394
1395         iio_device_release_direct_mode(indio_dev);
1396         return ret;
1397 }
1398
1399 static int at91_adc_read_raw(struct iio_dev *indio_dev,
1400                              struct iio_chan_spec const *chan,
1401                              int *val, int *val2, long mask)
1402 {
1403         struct at91_adc_state *st = iio_priv(indio_dev);
1404
1405         switch (mask) {
1406         case IIO_CHAN_INFO_RAW:
1407                 return at91_adc_read_info_raw(indio_dev, chan, val);
1408         case IIO_CHAN_INFO_SCALE:
1409                 *val = st->vref_uv / 1000;
1410                 if (chan->differential)
1411                         *val *= 2;
1412                 *val2 = chan->scan_type.realbits;
1413                 return IIO_VAL_FRACTIONAL_LOG2;
1414
1415         case IIO_CHAN_INFO_SAMP_FREQ:
1416                 *val = at91_adc_get_sample_freq(st);
1417                 return IIO_VAL_INT;
1418
1419         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
1420                 *val = st->oversampling_ratio;
1421                 return IIO_VAL_INT;
1422
1423         default:
1424                 return -EINVAL;
1425         }
1426 }
1427
1428 static int at91_adc_write_raw(struct iio_dev *indio_dev,
1429                               struct iio_chan_spec const *chan,
1430                               int val, int val2, long mask)
1431 {
1432         struct at91_adc_state *st = iio_priv(indio_dev);
1433
1434         switch (mask) {
1435         case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
1436                 if ((val != AT91_OSR_1SAMPLES) && (val != AT91_OSR_4SAMPLES) &&
1437                     (val != AT91_OSR_16SAMPLES))
1438                         return -EINVAL;
1439                 /* if no change, optimize out */
1440                 if (val == st->oversampling_ratio)
1441                         return 0;
1442                 st->oversampling_ratio = val;
1443                 /* update ratio */
1444                 at91_adc_config_emr(st);
1445                 return 0;
1446         case IIO_CHAN_INFO_SAMP_FREQ:
1447                 if (val < st->soc_info.min_sample_rate ||
1448                     val > st->soc_info.max_sample_rate)
1449                         return -EINVAL;
1450
1451                 at91_adc_setup_samp_freq(st, val);
1452                 return 0;
1453         default:
1454                 return -EINVAL;
1455         };
1456 }
1457
1458 static void at91_adc_dma_init(struct platform_device *pdev)
1459 {
1460         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
1461         struct at91_adc_state *st = iio_priv(indio_dev);
1462         struct dma_slave_config config = {0};
1463         /*
1464          * We make the buffer double the size of the fifo,
1465          * such that DMA uses one half of the buffer (full fifo size)
1466          * and the software uses the other half to read/write.
1467          */
1468         unsigned int pages = DIV_ROUND_UP(AT91_HWFIFO_MAX_SIZE *
1469                                           AT91_BUFFER_MAX_CONVERSION_BYTES * 2,
1470                                           PAGE_SIZE);
1471
1472         if (st->dma_st.dma_chan)
1473                 return;
1474
1475         st->dma_st.dma_chan = dma_request_slave_channel(&pdev->dev, "rx");
1476
1477         if (!st->dma_st.dma_chan)  {
1478                 dev_info(&pdev->dev, "can't get DMA channel\n");
1479                 goto dma_exit;
1480         }
1481
1482         st->dma_st.rx_buf = dma_alloc_coherent(st->dma_st.dma_chan->device->dev,
1483                                                pages * PAGE_SIZE,
1484                                                &st->dma_st.rx_dma_buf,
1485                                                GFP_KERNEL);
1486         if (!st->dma_st.rx_buf) {
1487                 dev_info(&pdev->dev, "can't allocate coherent DMA area\n");
1488                 goto dma_chan_disable;
1489         }
1490
1491         /* Configure DMA channel to read data register */
1492         config.direction = DMA_DEV_TO_MEM;
1493         config.src_addr = (phys_addr_t)(st->dma_st.phys_addr
1494                           + AT91_SAMA5D2_LCDR);
1495         config.src_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
1496         config.src_maxburst = 1;
1497         config.dst_maxburst = 1;
1498
1499         if (dmaengine_slave_config(st->dma_st.dma_chan, &config)) {
1500                 dev_info(&pdev->dev, "can't configure DMA slave\n");
1501                 goto dma_free_area;
1502         }
1503
1504         dev_info(&pdev->dev, "using %s for rx DMA transfers\n",
1505                  dma_chan_name(st->dma_st.dma_chan));
1506
1507         return;
1508
1509 dma_free_area:
1510         dma_free_coherent(st->dma_st.dma_chan->device->dev, pages * PAGE_SIZE,
1511                           st->dma_st.rx_buf, st->dma_st.rx_dma_buf);
1512 dma_chan_disable:
1513         dma_release_channel(st->dma_st.dma_chan);
1514         st->dma_st.dma_chan = 0;
1515 dma_exit:
1516         dev_info(&pdev->dev, "continuing without DMA support\n");
1517 }
1518
1519 static void at91_adc_dma_disable(struct platform_device *pdev)
1520 {
1521         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
1522         struct at91_adc_state *st = iio_priv(indio_dev);
1523         unsigned int pages = DIV_ROUND_UP(AT91_HWFIFO_MAX_SIZE *
1524                                           AT91_BUFFER_MAX_CONVERSION_BYTES * 2,
1525                                           PAGE_SIZE);
1526
1527         /* if we are not using DMA, just return */
1528         if (!st->dma_st.dma_chan)
1529                 return;
1530
1531         /* wait for all transactions to be terminated first*/
1532         dmaengine_terminate_sync(st->dma_st.dma_chan);
1533
1534         dma_free_coherent(st->dma_st.dma_chan->device->dev, pages * PAGE_SIZE,
1535                           st->dma_st.rx_buf, st->dma_st.rx_dma_buf);
1536         dma_release_channel(st->dma_st.dma_chan);
1537         st->dma_st.dma_chan = 0;
1538
1539         dev_info(&pdev->dev, "continuing without DMA support\n");
1540 }
1541
1542 static int at91_adc_set_watermark(struct iio_dev *indio_dev, unsigned int val)
1543 {
1544         struct at91_adc_state *st = iio_priv(indio_dev);
1545
1546         if (val > AT91_HWFIFO_MAX_SIZE)
1547                 return -EINVAL;
1548
1549         if (!st->selected_trig->hw_trig) {
1550                 dev_dbg(&indio_dev->dev, "we need hw trigger for DMA\n");
1551                 return 0;
1552         }
1553
1554         dev_dbg(&indio_dev->dev, "new watermark is %u\n", val);
1555         st->dma_st.watermark = val;
1556
1557         /*
1558          * The logic here is: if we have watermark 1, it means we do
1559          * each conversion with it's own IRQ, thus we don't need DMA.
1560          * If the watermark is higher, we do DMA to do all the transfers in bulk
1561          */
1562
1563         if (val == 1)
1564                 at91_adc_dma_disable(to_platform_device(&indio_dev->dev));
1565         else if (val > 1)
1566                 at91_adc_dma_init(to_platform_device(&indio_dev->dev));
1567
1568         return 0;
1569 }
1570
1571 static int at91_adc_update_scan_mode(struct iio_dev *indio_dev,
1572                                      const unsigned long *scan_mask)
1573 {
1574         struct at91_adc_state *st = iio_priv(indio_dev);
1575
1576         if (bitmap_subset(scan_mask, &st->touch_st.channels_bitmask,
1577                           AT91_SAMA5D2_MAX_CHAN_IDX + 1))
1578                 return 0;
1579         /*
1580          * if the new bitmap is a combination of touchscreen and regular
1581          * channels, then we are not fine
1582          */
1583         if (bitmap_intersects(&st->touch_st.channels_bitmask, scan_mask,
1584                               AT91_SAMA5D2_MAX_CHAN_IDX + 1))
1585                 return -EINVAL;
1586         return 0;
1587 }
1588
1589 static void at91_adc_hw_init(struct at91_adc_state *st)
1590 {
1591         at91_adc_writel(st, AT91_SAMA5D2_CR, AT91_SAMA5D2_CR_SWRST);
1592         at91_adc_writel(st, AT91_SAMA5D2_IDR, 0xffffffff);
1593         /*
1594          * Transfer field must be set to 2 according to the datasheet and
1595          * allows different analog settings for each channel.
1596          */
1597         at91_adc_writel(st, AT91_SAMA5D2_MR,
1598                         AT91_SAMA5D2_MR_TRANSFER(2) | AT91_SAMA5D2_MR_ANACH);
1599
1600         at91_adc_setup_samp_freq(st, st->soc_info.min_sample_rate);
1601
1602         /* configure extended mode register */
1603         at91_adc_config_emr(st);
1604 }
1605
1606 static ssize_t at91_adc_get_fifo_state(struct device *dev,
1607                                        struct device_attribute *attr, char *buf)
1608 {
1609         struct iio_dev *indio_dev =
1610                         platform_get_drvdata(to_platform_device(dev));
1611         struct at91_adc_state *st = iio_priv(indio_dev);
1612
1613         return scnprintf(buf, PAGE_SIZE, "%d\n", !!st->dma_st.dma_chan);
1614 }
1615
1616 static ssize_t at91_adc_get_watermark(struct device *dev,
1617                                       struct device_attribute *attr, char *buf)
1618 {
1619         struct iio_dev *indio_dev =
1620                         platform_get_drvdata(to_platform_device(dev));
1621         struct at91_adc_state *st = iio_priv(indio_dev);
1622
1623         return scnprintf(buf, PAGE_SIZE, "%d\n", st->dma_st.watermark);
1624 }
1625
1626 static IIO_DEVICE_ATTR(hwfifo_enabled, 0444,
1627                        at91_adc_get_fifo_state, NULL, 0);
1628 static IIO_DEVICE_ATTR(hwfifo_watermark, 0444,
1629                        at91_adc_get_watermark, NULL, 0);
1630
1631 static IIO_CONST_ATTR(hwfifo_watermark_min, "2");
1632 static IIO_CONST_ATTR(hwfifo_watermark_max, AT91_HWFIFO_MAX_SIZE_STR);
1633
1634 static IIO_CONST_ATTR(oversampling_ratio_available,
1635                       __stringify(AT91_OSR_1SAMPLES) " "
1636                       __stringify(AT91_OSR_4SAMPLES) " "
1637                       __stringify(AT91_OSR_16SAMPLES));
1638
1639 static struct attribute *at91_adc_attributes[] = {
1640         &iio_const_attr_oversampling_ratio_available.dev_attr.attr,
1641         NULL,
1642 };
1643
1644 static const struct attribute_group at91_adc_attribute_group = {
1645         .attrs = at91_adc_attributes,
1646 };
1647
1648 static const struct attribute *at91_adc_fifo_attributes[] = {
1649         &iio_const_attr_hwfifo_watermark_min.dev_attr.attr,
1650         &iio_const_attr_hwfifo_watermark_max.dev_attr.attr,
1651         &iio_dev_attr_hwfifo_watermark.dev_attr.attr,
1652         &iio_dev_attr_hwfifo_enabled.dev_attr.attr,
1653         NULL,
1654 };
1655
1656 static const struct iio_info at91_adc_info = {
1657         .attrs = &at91_adc_attribute_group,
1658         .read_raw = &at91_adc_read_raw,
1659         .write_raw = &at91_adc_write_raw,
1660         .update_scan_mode = &at91_adc_update_scan_mode,
1661         .of_xlate = &at91_adc_of_xlate,
1662         .hwfifo_set_watermark = &at91_adc_set_watermark,
1663 };
1664
1665 static int at91_adc_probe(struct platform_device *pdev)
1666 {
1667         struct iio_dev *indio_dev;
1668         struct at91_adc_state *st;
1669         struct resource *res;
1670         int ret, i;
1671         u32 edge_type = IRQ_TYPE_NONE;
1672
1673         indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*st));
1674         if (!indio_dev)
1675                 return -ENOMEM;
1676
1677         indio_dev->dev.parent = &pdev->dev;
1678         indio_dev->name = dev_name(&pdev->dev);
1679         indio_dev->modes = INDIO_DIRECT_MODE | INDIO_BUFFER_SOFTWARE;
1680         indio_dev->info = &at91_adc_info;
1681         indio_dev->channels = at91_adc_channels;
1682         indio_dev->num_channels = ARRAY_SIZE(at91_adc_channels);
1683
1684         st = iio_priv(indio_dev);
1685
1686         bitmap_set(&st->touch_st.channels_bitmask,
1687                    AT91_SAMA5D2_TOUCH_X_CHAN_IDX, 1);
1688         bitmap_set(&st->touch_st.channels_bitmask,
1689                    AT91_SAMA5D2_TOUCH_Y_CHAN_IDX, 1);
1690         bitmap_set(&st->touch_st.channels_bitmask,
1691                    AT91_SAMA5D2_TOUCH_P_CHAN_IDX, 1);
1692
1693         st->oversampling_ratio = AT91_OSR_1SAMPLES;
1694
1695         ret = of_property_read_u32(pdev->dev.of_node,
1696                                    "atmel,min-sample-rate-hz",
1697                                    &st->soc_info.min_sample_rate);
1698         if (ret) {
1699                 dev_err(&pdev->dev,
1700                         "invalid or missing value for atmel,min-sample-rate-hz\n");
1701                 return ret;
1702         }
1703
1704         ret = of_property_read_u32(pdev->dev.of_node,
1705                                    "atmel,max-sample-rate-hz",
1706                                    &st->soc_info.max_sample_rate);
1707         if (ret) {
1708                 dev_err(&pdev->dev,
1709                         "invalid or missing value for atmel,max-sample-rate-hz\n");
1710                 return ret;
1711         }
1712
1713         ret = of_property_read_u32(pdev->dev.of_node, "atmel,startup-time-ms",
1714                                    &st->soc_info.startup_time);
1715         if (ret) {
1716                 dev_err(&pdev->dev,
1717                         "invalid or missing value for atmel,startup-time-ms\n");
1718                 return ret;
1719         }
1720
1721         ret = of_property_read_u32(pdev->dev.of_node,
1722                                    "atmel,trigger-edge-type", &edge_type);
1723         if (ret) {
1724                 dev_dbg(&pdev->dev,
1725                         "atmel,trigger-edge-type not specified, only software trigger available\n");
1726         }
1727
1728         st->selected_trig = NULL;
1729
1730         /* find the right trigger, or no trigger at all */
1731         for (i = 0; i < AT91_SAMA5D2_HW_TRIG_CNT + 1; i++)
1732                 if (at91_adc_trigger_list[i].edge_type == edge_type) {
1733                         st->selected_trig = &at91_adc_trigger_list[i];
1734                         break;
1735                 }
1736
1737         if (!st->selected_trig) {
1738                 dev_err(&pdev->dev, "invalid external trigger edge value\n");
1739                 return -EINVAL;
1740         }
1741
1742         init_waitqueue_head(&st->wq_data_available);
1743         mutex_init(&st->lock);
1744         INIT_WORK(&st->touch_st.workq, at91_adc_workq_handler);
1745
1746         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1747         if (!res)
1748                 return -EINVAL;
1749
1750         /* if we plan to use DMA, we need the physical address of the regs */
1751         st->dma_st.phys_addr = res->start;
1752
1753         st->base = devm_ioremap_resource(&pdev->dev, res);
1754         if (IS_ERR(st->base))
1755                 return PTR_ERR(st->base);
1756
1757         st->irq = platform_get_irq(pdev, 0);
1758         if (st->irq <= 0) {
1759                 if (!st->irq)
1760                         st->irq = -ENXIO;
1761
1762                 return st->irq;
1763         }
1764
1765         st->per_clk = devm_clk_get(&pdev->dev, "adc_clk");
1766         if (IS_ERR(st->per_clk))
1767                 return PTR_ERR(st->per_clk);
1768
1769         st->reg = devm_regulator_get(&pdev->dev, "vddana");
1770         if (IS_ERR(st->reg))
1771                 return PTR_ERR(st->reg);
1772
1773         st->vref = devm_regulator_get(&pdev->dev, "vref");
1774         if (IS_ERR(st->vref))
1775                 return PTR_ERR(st->vref);
1776
1777         ret = devm_request_irq(&pdev->dev, st->irq, at91_adc_interrupt, 0,
1778                                pdev->dev.driver->name, indio_dev);
1779         if (ret)
1780                 return ret;
1781
1782         ret = regulator_enable(st->reg);
1783         if (ret)
1784                 return ret;
1785
1786         ret = regulator_enable(st->vref);
1787         if (ret)
1788                 goto reg_disable;
1789
1790         st->vref_uv = regulator_get_voltage(st->vref);
1791         if (st->vref_uv <= 0) {
1792                 ret = -EINVAL;
1793                 goto vref_disable;
1794         }
1795
1796         at91_adc_hw_init(st);
1797
1798         ret = clk_prepare_enable(st->per_clk);
1799         if (ret)
1800                 goto vref_disable;
1801
1802         platform_set_drvdata(pdev, indio_dev);
1803
1804         ret = at91_adc_buffer_init(indio_dev);
1805         if (ret < 0) {
1806                 dev_err(&pdev->dev, "couldn't initialize the buffer.\n");
1807                 goto per_clk_disable_unprepare;
1808         }
1809
1810         if (st->selected_trig->hw_trig) {
1811                 ret = at91_adc_trigger_init(indio_dev);
1812                 if (ret < 0) {
1813                         dev_err(&pdev->dev, "couldn't setup the triggers.\n");
1814                         goto per_clk_disable_unprepare;
1815                 }
1816                 /*
1817                  * Initially the iio buffer has a length of 2 and
1818                  * a watermark of 1
1819                  */
1820                 st->dma_st.watermark = 1;
1821
1822                 iio_buffer_set_attrs(indio_dev->buffer,
1823                                      at91_adc_fifo_attributes);
1824         }
1825
1826         if (dma_coerce_mask_and_coherent(&indio_dev->dev, DMA_BIT_MASK(32)))
1827                 dev_info(&pdev->dev, "cannot set DMA mask to 32-bit\n");
1828
1829         ret = iio_device_register(indio_dev);
1830         if (ret < 0)
1831                 goto dma_disable;
1832
1833         if (st->selected_trig->hw_trig)
1834                 dev_info(&pdev->dev, "setting up trigger as %s\n",
1835                          st->selected_trig->name);
1836
1837         dev_info(&pdev->dev, "version: %x\n",
1838                  readl_relaxed(st->base + AT91_SAMA5D2_VERSION));
1839
1840         return 0;
1841
1842 dma_disable:
1843         at91_adc_dma_disable(pdev);
1844 per_clk_disable_unprepare:
1845         clk_disable_unprepare(st->per_clk);
1846 vref_disable:
1847         regulator_disable(st->vref);
1848 reg_disable:
1849         regulator_disable(st->reg);
1850         return ret;
1851 }
1852
1853 static int at91_adc_remove(struct platform_device *pdev)
1854 {
1855         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
1856         struct at91_adc_state *st = iio_priv(indio_dev);
1857
1858         iio_device_unregister(indio_dev);
1859
1860         at91_adc_dma_disable(pdev);
1861
1862         clk_disable_unprepare(st->per_clk);
1863
1864         regulator_disable(st->vref);
1865         regulator_disable(st->reg);
1866
1867         return 0;
1868 }
1869
1870 static __maybe_unused int at91_adc_suspend(struct device *dev)
1871 {
1872         struct iio_dev *indio_dev =
1873                         platform_get_drvdata(to_platform_device(dev));
1874         struct at91_adc_state *st = iio_priv(indio_dev);
1875
1876         /*
1877          * Do a sofware reset of the ADC before we go to suspend.
1878          * this will ensure that all pins are free from being muxed by the ADC
1879          * and can be used by for other devices.
1880          * Otherwise, ADC will hog them and we can't go to suspend mode.
1881          */
1882         at91_adc_writel(st, AT91_SAMA5D2_CR, AT91_SAMA5D2_CR_SWRST);
1883
1884         clk_disable_unprepare(st->per_clk);
1885         regulator_disable(st->vref);
1886         regulator_disable(st->reg);
1887
1888         return pinctrl_pm_select_sleep_state(dev);
1889 }
1890
1891 static __maybe_unused int at91_adc_resume(struct device *dev)
1892 {
1893         struct iio_dev *indio_dev =
1894                         platform_get_drvdata(to_platform_device(dev));
1895         struct at91_adc_state *st = iio_priv(indio_dev);
1896         int ret;
1897
1898         ret = pinctrl_pm_select_default_state(dev);
1899         if (ret)
1900                 goto resume_failed;
1901
1902         ret = regulator_enable(st->reg);
1903         if (ret)
1904                 goto resume_failed;
1905
1906         ret = regulator_enable(st->vref);
1907         if (ret)
1908                 goto reg_disable_resume;
1909
1910         ret = clk_prepare_enable(st->per_clk);
1911         if (ret)
1912                 goto vref_disable_resume;
1913
1914         at91_adc_hw_init(st);
1915
1916         /* reconfiguring trigger hardware state */
1917         if (!iio_buffer_enabled(indio_dev))
1918                 return 0;
1919
1920         /* check if we are enabling triggered buffer or the touchscreen */
1921         if (bitmap_subset(indio_dev->active_scan_mask,
1922                           &st->touch_st.channels_bitmask,
1923                           AT91_SAMA5D2_MAX_CHAN_IDX + 1)) {
1924                 /* touchscreen enabling */
1925                 return at91_adc_configure_touch(st, true);
1926         } else {
1927                 return at91_adc_configure_trigger(st->trig, true);
1928         }
1929
1930         /* not needed but more explicit */
1931         return 0;
1932
1933 vref_disable_resume:
1934         regulator_disable(st->vref);
1935 reg_disable_resume:
1936         regulator_disable(st->reg);
1937 resume_failed:
1938         dev_err(&indio_dev->dev, "failed to resume\n");
1939         return ret;
1940 }
1941
1942 static SIMPLE_DEV_PM_OPS(at91_adc_pm_ops, at91_adc_suspend, at91_adc_resume);
1943
1944 static const struct of_device_id at91_adc_dt_match[] = {
1945         {
1946                 .compatible = "atmel,sama5d2-adc",
1947         }, {
1948                 /* sentinel */
1949         }
1950 };
1951 MODULE_DEVICE_TABLE(of, at91_adc_dt_match);
1952
1953 static struct platform_driver at91_adc_driver = {
1954         .probe = at91_adc_probe,
1955         .remove = at91_adc_remove,
1956         .driver = {
1957                 .name = "at91-sama5d2_adc",
1958                 .of_match_table = at91_adc_dt_match,
1959                 .pm = &at91_adc_pm_ops,
1960         },
1961 };
1962 module_platform_driver(at91_adc_driver)
1963
1964 MODULE_AUTHOR("Ludovic Desroches <ludovic.desroches@atmel.com>");
1965 MODULE_DESCRIPTION("Atmel AT91 SAMA5D2 ADC");
1966 MODULE_LICENSE("GPL v2");