drivers/iio/adc/xilinx-ams.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Xilinx AMS driver
   4  *
   5  *  Copyright (C) 2021 Xilinx, Inc.
   6  *
   7  *  Manish Narani <mnarani@xilinx.com>
   8  *  Rajnikant Bhojani <rajnikant.bhojani@xilinx.com>
   9  */
  10
  11 #include <linux/bits.h>
  12 #include <linux/bitfield.h>
  13 #include <linux/clk.h>
  14 #include <linux/delay.h>
  15 #include <linux/devm-helpers.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/io.h>
  18 #include <linux/iopoll.h>
  19 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/mod_devicetable.h>
  22 #include <linux/overflow.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/property.h>
  25 #include <linux/slab.h>
  26
  27 #include <linux/iio/events.h>
  28 #include <linux/iio/iio.h>
  29
  30 /* AMS registers definitions */
  31 #define AMS_ISR_0                       0x010
  32 #define AMS_ISR_1                       0x014
  33 #define AMS_IER_0                       0x020
  34 #define AMS_IER_1                       0x024
  35 #define AMS_IDR_0                       0x028
  36 #define AMS_IDR_1                       0x02C
  37 #define AMS_PS_CSTS                     0x040
  38 #define AMS_PL_CSTS                     0x044
  39
  40 #define AMS_VCC_PSPLL0                  0x060
  41 #define AMS_VCC_PSPLL3                  0x06C
  42 #define AMS_VCCINT                      0x078
  43 #define AMS_VCCBRAM                     0x07C
  44 #define AMS_VCCAUX                      0x080
  45 #define AMS_PSDDRPLL                    0x084
  46 #define AMS_PSINTFPDDR                  0x09C
  47
  48 #define AMS_VCC_PSPLL0_CH               48
  49 #define AMS_VCC_PSPLL3_CH               51
  50 #define AMS_VCCINT_CH                   54
  51 #define AMS_VCCBRAM_CH                  55
  52 #define AMS_VCCAUX_CH                   56
  53 #define AMS_PSDDRPLL_CH                 57
  54 #define AMS_PSINTFPDDR_CH               63
  55
  56 #define AMS_REG_CONFIG0                 0x100
  57 #define AMS_REG_CONFIG1                 0x104
  58 #define AMS_REG_CONFIG3                 0x10C
  59 #define AMS_REG_CONFIG4                 0x110
  60 #define AMS_REG_SEQ_CH0                 0x120
  61 #define AMS_REG_SEQ_CH1                 0x124
  62 #define AMS_REG_SEQ_CH2                 0x118
  63
  64 #define AMS_VUSER0_MASK                 BIT(0)
  65 #define AMS_VUSER1_MASK                 BIT(1)
  66 #define AMS_VUSER2_MASK                 BIT(2)
  67 #define AMS_VUSER3_MASK                 BIT(3)
  68
  69 #define AMS_TEMP                        0x000
  70 #define AMS_SUPPLY1                     0x004
  71 #define AMS_SUPPLY2                     0x008
  72 #define AMS_VP_VN                       0x00C
  73 #define AMS_VREFP                       0x010
  74 #define AMS_VREFN                       0x014
  75 #define AMS_SUPPLY3                     0x018
  76 #define AMS_SUPPLY4                     0x034
  77 #define AMS_SUPPLY5                     0x038
  78 #define AMS_SUPPLY6                     0x03C
  79 #define AMS_SUPPLY7                     0x200
  80 #define AMS_SUPPLY8                     0x204
  81 #define AMS_SUPPLY9                     0x208
  82 #define AMS_SUPPLY10                    0x20C
  83 #define AMS_VCCAMS                      0x210
  84 #define AMS_TEMP_REMOTE                 0x214
  85
  86 #define AMS_REG_VAUX(x)                 (0x40 + 4 * (x))
  87
  88 #define AMS_PS_RESET_VALUE              0xFFFF
  89 #define AMS_PL_RESET_VALUE              0xFFFF
  90
  91 #define AMS_CONF0_CHANNEL_NUM_MASK      GENMASK(6, 0)
  92
  93 #define AMS_CONF1_SEQ_MASK              GENMASK(15, 12)
  94 #define AMS_CONF1_SEQ_DEFAULT           FIELD_PREP(AMS_CONF1_SEQ_MASK, 0)
  95 #define AMS_CONF1_SEQ_CONTINUOUS        FIELD_PREP(AMS_CONF1_SEQ_MASK, 2)
  96 #define AMS_CONF1_SEQ_SINGLE_CHANNEL    FIELD_PREP(AMS_CONF1_SEQ_MASK, 3)
  97
  98 #define AMS_REG_SEQ0_MASK               GENMASK(15, 0)
  99 #define AMS_REG_SEQ2_MASK               GENMASK(21, 16)
 100 #define AMS_REG_SEQ1_MASK               GENMASK_ULL(37, 22)
 101
 102 #define AMS_PS_SEQ_MASK                 GENMASK(21, 0)
 103 #define AMS_PL_SEQ_MASK                 GENMASK_ULL(59, 22)
 104
 105 #define AMS_ALARM_TEMP                  0x140
 106 #define AMS_ALARM_SUPPLY1               0x144
 107 #define AMS_ALARM_SUPPLY2               0x148
 108 #define AMS_ALARM_SUPPLY3               0x160
 109 #define AMS_ALARM_SUPPLY4               0x164
 110 #define AMS_ALARM_SUPPLY5               0x168
 111 #define AMS_ALARM_SUPPLY6               0x16C
 112 #define AMS_ALARM_SUPPLY7               0x180
 113 #define AMS_ALARM_SUPPLY8               0x184
 114 #define AMS_ALARM_SUPPLY9               0x188
 115 #define AMS_ALARM_SUPPLY10              0x18C
 116 #define AMS_ALARM_VCCAMS                0x190
 117 #define AMS_ALARM_TEMP_REMOTE           0x194
 118 #define AMS_ALARM_THRESHOLD_OFF_10      0x10
 119 #define AMS_ALARM_THRESHOLD_OFF_20      0x20
 120
 121 #define AMS_ALARM_THR_DIRECT_MASK       BIT(1)
 122 #define AMS_ALARM_THR_MIN               0x0000
 123 #define AMS_ALARM_THR_MAX               (BIT(16) - 1)
 124
 125 #define AMS_ALARM_MASK                  GENMASK_ULL(63, 0)
 126 #define AMS_NO_OF_ALARMS                32
 127 #define AMS_PL_ALARM_START              16
 128 #define AMS_PL_ALARM_MASK               GENMASK(31, 16)
 129 #define AMS_ISR0_ALARM_MASK             GENMASK(31, 0)
 130 #define AMS_ISR1_ALARM_MASK             (GENMASK(31, 29) | GENMASK(4, 0))
 131 #define AMS_ISR1_EOC_MASK               BIT(3)
 132 #define AMS_ISR1_INTR_MASK              GENMASK_ULL(63, 32)
 133 #define AMS_ISR0_ALARM_2_TO_0_MASK      GENMASK(2, 0)
 134 #define AMS_ISR0_ALARM_6_TO_3_MASK      GENMASK(6, 3)
 135 #define AMS_ISR0_ALARM_12_TO_7_MASK     GENMASK(13, 8)
 136 #define AMS_CONF1_ALARM_2_TO_0_MASK     GENMASK(3, 1)
 137 #define AMS_CONF1_ALARM_6_TO_3_MASK     GENMASK(11, 8)
 138 #define AMS_CONF1_ALARM_12_TO_7_MASK    GENMASK(5, 0)
 139 #define AMS_REGCFG1_ALARM_MASK  \
 140         (AMS_CONF1_ALARM_2_TO_0_MASK | AMS_CONF1_ALARM_6_TO_3_MASK | BIT(0))
 141 #define AMS_REGCFG3_ALARM_MASK          AMS_CONF1_ALARM_12_TO_7_MASK
 142
 143 #define AMS_PS_CSTS_PS_READY            (BIT(27) | BIT(16))
 144 #define AMS_PL_CSTS_ACCESS_MASK         BIT(1)
 145
 146 #define AMS_PL_MAX_FIXED_CHANNEL        10
 147 #define AMS_PL_MAX_EXT_CHANNEL          20
 148
 149 #define AMS_INIT_POLL_TIME_US           200
 150 #define AMS_INIT_TIMEOUT_US             10000
 151 #define AMS_UNMASK_TIMEOUT_MS           500
 152
 153 /*
 154  * Following scale and offset value is derived from
 155  * UG580 (v1.7) December 20, 2016
 156  */
 157 #define AMS_SUPPLY_SCALE_1VOLT_mV               1000
 158 #define AMS_SUPPLY_SCALE_3VOLT_mV               3000
 159 #define AMS_SUPPLY_SCALE_6VOLT_mV               6000
 160 #define AMS_SUPPLY_SCALE_DIV_BIT        16
 161
 162 #define AMS_TEMP_SCALE                  509314
 163 #define AMS_TEMP_SCALE_DIV_BIT          16
 164 #define AMS_TEMP_OFFSET                 -((280230LL << 16) / 509314)
 165
 166 enum ams_alarm_bit {
 167         AMS_ALARM_BIT_TEMP = 0,
 168         AMS_ALARM_BIT_SUPPLY1 = 1,
 169         AMS_ALARM_BIT_SUPPLY2 = 2,
 170         AMS_ALARM_BIT_SUPPLY3 = 3,
 171         AMS_ALARM_BIT_SUPPLY4 = 4,
 172         AMS_ALARM_BIT_SUPPLY5 = 5,
 173         AMS_ALARM_BIT_SUPPLY6 = 6,
 174         AMS_ALARM_BIT_RESERVED = 7,
 175         AMS_ALARM_BIT_SUPPLY7 = 8,
 176         AMS_ALARM_BIT_SUPPLY8 = 9,
 177         AMS_ALARM_BIT_SUPPLY9 = 10,
 178         AMS_ALARM_BIT_SUPPLY10 = 11,
 179         AMS_ALARM_BIT_VCCAMS = 12,
 180         AMS_ALARM_BIT_TEMP_REMOTE = 13,
 181 };
 182
 183 enum ams_seq {
 184         AMS_SEQ_VCC_PSPLL = 0,
 185         AMS_SEQ_VCC_PSBATT = 1,
 186         AMS_SEQ_VCCINT = 2,
 187         AMS_SEQ_VCCBRAM = 3,
 188         AMS_SEQ_VCCAUX = 4,
 189         AMS_SEQ_PSDDRPLL = 5,
 190         AMS_SEQ_INTDDR = 6,
 191 };
 192
 193 enum ams_ps_pl_seq {
 194         AMS_SEQ_CALIB = 0,
 195         AMS_SEQ_RSVD_1 = 1,
 196         AMS_SEQ_RSVD_2 = 2,
 197         AMS_SEQ_TEST = 3,
 198         AMS_SEQ_RSVD_4 = 4,
 199         AMS_SEQ_SUPPLY4 = 5,
 200         AMS_SEQ_SUPPLY5 = 6,
 201         AMS_SEQ_SUPPLY6 = 7,
 202         AMS_SEQ_TEMP = 8,
 203         AMS_SEQ_SUPPLY2 = 9,
 204         AMS_SEQ_SUPPLY1 = 10,
 205         AMS_SEQ_VP_VN = 11,
 206         AMS_SEQ_VREFP = 12,
 207         AMS_SEQ_VREFN = 13,
 208         AMS_SEQ_SUPPLY3 = 14,
 209         AMS_SEQ_CURRENT_MON = 15,
 210         AMS_SEQ_SUPPLY7 = 16,
 211         AMS_SEQ_SUPPLY8 = 17,
 212         AMS_SEQ_SUPPLY9 = 18,
 213         AMS_SEQ_SUPPLY10 = 19,
 214         AMS_SEQ_VCCAMS = 20,
 215         AMS_SEQ_TEMP_REMOTE = 21,
 216         AMS_SEQ_MAX = 22
 217 };
 218
 219 #define AMS_PS_SEQ_MAX          AMS_SEQ_MAX
 220 #define AMS_SEQ(x)              (AMS_SEQ_MAX + (x))
 221 #define PS_SEQ(x)               (x)
 222 #define PL_SEQ(x)               (AMS_PS_SEQ_MAX + (x))
 223 #define AMS_CTRL_SEQ_BASE       (AMS_PS_SEQ_MAX * 3)
 224
 225 #define AMS_CHAN_TEMP(_scan_index, _addr) { \
 226         .type = IIO_TEMP, \
 227         .indexed = 1, \
 228         .address = (_addr), \
 229         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
 230                 BIT(IIO_CHAN_INFO_SCALE) | \
 231                 BIT(IIO_CHAN_INFO_OFFSET), \
 232         .event_spec = ams_temp_events, \
 233         .scan_index = _scan_index, \
 234         .num_event_specs = ARRAY_SIZE(ams_temp_events), \
 235 }
 236
 237 #define AMS_CHAN_VOLTAGE(_scan_index, _addr, _alarm) { \
 238         .type = IIO_VOLTAGE, \
 239         .indexed = 1, \
 240         .address = (_addr), \
 241         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
 242                 BIT(IIO_CHAN_INFO_SCALE), \
 243         .event_spec = (_alarm) ? ams_voltage_events : NULL, \
 244         .scan_index = _scan_index, \
 245         .num_event_specs = (_alarm) ? ARRAY_SIZE(ams_voltage_events) : 0, \
 246 }
 247
 248 #define AMS_PS_CHAN_TEMP(_scan_index, _addr) \
 249         AMS_CHAN_TEMP(PS_SEQ(_scan_index), _addr)
 250 #define AMS_PS_CHAN_VOLTAGE(_scan_index, _addr) \
 251         AMS_CHAN_VOLTAGE(PS_SEQ(_scan_index), _addr, true)
 252
 253 #define AMS_PL_CHAN_TEMP(_scan_index, _addr) \
 254         AMS_CHAN_TEMP(PL_SEQ(_scan_index), _addr)
 255 #define AMS_PL_CHAN_VOLTAGE(_scan_index, _addr, _alarm) \
 256         AMS_CHAN_VOLTAGE(PL_SEQ(_scan_index), _addr, _alarm)
 257 #define AMS_PL_AUX_CHAN_VOLTAGE(_auxno) \
 258         AMS_CHAN_VOLTAGE(PL_SEQ(AMS_SEQ(_auxno)), AMS_REG_VAUX(_auxno), false)
 259 #define AMS_CTRL_CHAN_VOLTAGE(_scan_index, _addr) \
 260         AMS_CHAN_VOLTAGE(PL_SEQ(AMS_SEQ(AMS_SEQ(_scan_index))), _addr, false)
 261
 262 /**
 263  * struct ams - This structure contains necessary state for xilinx-ams to operate
 264  * @base: physical base address of device
 265  * @ps_base: physical base address of PS device
 266  * @pl_base: physical base address of PL device
 267  * @clk: clocks associated with the device
 268  * @dev: pointer to device struct
 269  * @lock: to handle multiple user interaction
 270  * @intr_lock: to protect interrupt mask values
 271  * @alarm_mask: alarm configuration
 272  * @current_masked_alarm: currently masked due to alarm
 273  * @intr_mask: interrupt configuration
 274  * @ams_unmask_work: re-enables event once the event condition disappears
 275  *
 276  */
 277 struct ams {
 278         void __iomem *base;
 279         void __iomem *ps_base;
 280         void __iomem *pl_base;
 281         struct clk *clk;
 282         struct device *dev;
 283         struct mutex lock;
 284         spinlock_t intr_lock;
 285         unsigned int alarm_mask;
 286         unsigned int current_masked_alarm;
 287         u64 intr_mask;
 288         struct delayed_work ams_unmask_work;
 289 };
 290
 291 static inline void ams_ps_update_reg(struct ams *ams, unsigned int offset,
 292                                      u32 mask, u32 data)
 293 {
 294         u32 val, regval;
 295
 296         val = readl(ams->ps_base + offset);
 297         regval = (val & ~mask) | (data & mask);
 298         writel(regval, ams->ps_base + offset);
 299 }
 300
 301 static inline void ams_pl_update_reg(struct ams *ams, unsigned int offset,
 302                                      u32 mask, u32 data)
 303 {
 304         u32 val, regval;
 305
 306         val = readl(ams->pl_base + offset);
 307         regval = (val & ~mask) | (data & mask);
 308         writel(regval, ams->pl_base + offset);
 309 }
 310
 311 static void ams_update_intrmask(struct ams *ams, u64 mask, u64 val)
 312 {
 313         u32 regval;
 314
 315         ams->intr_mask = (ams->intr_mask & ~mask) | (val & mask);
 316
 317         regval = ~(ams->intr_mask | ams->current_masked_alarm);
 318         writel(regval, ams->base + AMS_IER_0);
 319
 320         regval = ~(FIELD_GET(AMS_ISR1_INTR_MASK, ams->intr_mask));
 321         writel(regval, ams->base + AMS_IER_1);
 322
 323         regval = ams->intr_mask | ams->current_masked_alarm;
 324         writel(regval, ams->base + AMS_IDR_0);
 325
 326         regval = FIELD_GET(AMS_ISR1_INTR_MASK, ams->intr_mask);
 327         writel(regval, ams->base + AMS_IDR_1);
 328 }
 329
 330 static void ams_disable_all_alarms(struct ams *ams)
 331 {
 332         /* disable PS module alarm */
 333         if (ams->ps_base) {
 334                 ams_ps_update_reg(ams, AMS_REG_CONFIG1, AMS_REGCFG1_ALARM_MASK,
 335                                   AMS_REGCFG1_ALARM_MASK);
 336                 ams_ps_update_reg(ams, AMS_REG_CONFIG3, AMS_REGCFG3_ALARM_MASK,
 337                                   AMS_REGCFG3_ALARM_MASK);
 338         }
 339
 340         /* disable PL module alarm */
 341         if (ams->pl_base) {
 342                 ams_pl_update_reg(ams, AMS_REG_CONFIG1, AMS_REGCFG1_ALARM_MASK,
 343                                   AMS_REGCFG1_ALARM_MASK);
 344                 ams_pl_update_reg(ams, AMS_REG_CONFIG3, AMS_REGCFG3_ALARM_MASK,
 345                                   AMS_REGCFG3_ALARM_MASK);
 346         }
 347 }
 348
 349 static void ams_update_ps_alarm(struct ams *ams, unsigned long alarm_mask)
 350 {
 351         u32 cfg;
 352         u32 val;
 353
 354         val = FIELD_GET(AMS_ISR0_ALARM_2_TO_0_MASK, alarm_mask);
 355         cfg = ~(FIELD_PREP(AMS_CONF1_ALARM_2_TO_0_MASK, val));
 356
 357         val = FIELD_GET(AMS_ISR0_ALARM_6_TO_3_MASK, alarm_mask);
 358         cfg &= ~(FIELD_PREP(AMS_CONF1_ALARM_6_TO_3_MASK, val));
 359
 360         ams_ps_update_reg(ams, AMS_REG_CONFIG1, AMS_REGCFG1_ALARM_MASK, cfg);
 361
 362         val = FIELD_GET(AMS_ISR0_ALARM_12_TO_7_MASK, alarm_mask);
 363         cfg = ~(FIELD_PREP(AMS_CONF1_ALARM_12_TO_7_MASK, val));
 364         ams_ps_update_reg(ams, AMS_REG_CONFIG3, AMS_REGCFG3_ALARM_MASK, cfg);
 365 }
 366
 367 static void ams_update_pl_alarm(struct ams *ams, unsigned long alarm_mask)
 368 {
 369         unsigned long pl_alarm_mask;
 370         u32 cfg;
 371         u32 val;
 372
 373         pl_alarm_mask = FIELD_GET(AMS_PL_ALARM_MASK, alarm_mask);
 374
 375         val = FIELD_GET(AMS_ISR0_ALARM_2_TO_0_MASK, pl_alarm_mask);
 376         cfg = ~(FIELD_PREP(AMS_CONF1_ALARM_2_TO_0_MASK, val));
 377
 378         val = FIELD_GET(AMS_ISR0_ALARM_6_TO_3_MASK, pl_alarm_mask);
 379         cfg &= ~(FIELD_PREP(AMS_CONF1_ALARM_6_TO_3_MASK, val));
 380
 381         ams_pl_update_reg(ams, AMS_REG_CONFIG1, AMS_REGCFG1_ALARM_MASK, cfg);
 382
 383         val = FIELD_GET(AMS_ISR0_ALARM_12_TO_7_MASK, pl_alarm_mask);
 384         cfg = ~(FIELD_PREP(AMS_CONF1_ALARM_12_TO_7_MASK, val));
 385         ams_pl_update_reg(ams, AMS_REG_CONFIG3, AMS_REGCFG3_ALARM_MASK, cfg);
 386 }
 387
 388 static void ams_update_alarm(struct ams *ams, unsigned long alarm_mask)
 389 {
 390         unsigned long flags;
 391
 392         if (ams->ps_base)
 393                 ams_update_ps_alarm(ams, alarm_mask);
 394
 395         if (ams->pl_base)
 396                 ams_update_pl_alarm(ams, alarm_mask);
 397
 398         spin_lock_irqsave(&ams->intr_lock, flags);
 399         ams_update_intrmask(ams, AMS_ISR0_ALARM_MASK, ~alarm_mask);
 400         spin_unlock_irqrestore(&ams->intr_lock, flags);
 401 }
 402
 403 static void ams_enable_channel_sequence(struct iio_dev *indio_dev)
 404 {
 405         struct ams *ams = iio_priv(indio_dev);
 406         unsigned long long scan_mask;
 407         int i;
 408         u32 regval;
 409
 410         /*
 411          * Enable channel sequence. First 22 bits of scan_mask represent
 412          * PS channels, and next remaining bits represent PL channels.
 413          */
 414
 415         /* Run calibration of PS & PL as part of the sequence */
 416         scan_mask = BIT(0) | BIT(AMS_PS_SEQ_MAX);
 417         for (i = 0; i < indio_dev->num_channels; i++)
 418                 scan_mask |= BIT_ULL(indio_dev->channels[i].scan_index);
 419
 420         if (ams->ps_base) {
 421                 /* put sysmon in a soft reset to change the sequence */
 422                 ams_ps_update_reg(ams, AMS_REG_CONFIG1, AMS_CONF1_SEQ_MASK,
 423                                   AMS_CONF1_SEQ_DEFAULT);
 424
 425                 /* configure basic channels */
 426                 regval = FIELD_GET(AMS_REG_SEQ0_MASK, scan_mask);
 427                 writel(regval, ams->ps_base + AMS_REG_SEQ_CH0);
 428
 429                 regval = FIELD_GET(AMS_REG_SEQ2_MASK, scan_mask);
 430                 writel(regval, ams->ps_base + AMS_REG_SEQ_CH2);
 431
 432                 /* set continuous sequence mode */
 433                 ams_ps_update_reg(ams, AMS_REG_CONFIG1, AMS_CONF1_SEQ_MASK,
 434                                   AMS_CONF1_SEQ_CONTINUOUS);
 435         }
 436
 437         if (ams->pl_base) {
 438                 /* put sysmon in a soft reset to change the sequence */
 439                 ams_pl_update_reg(ams, AMS_REG_CONFIG1, AMS_CONF1_SEQ_MASK,
 440                                   AMS_CONF1_SEQ_DEFAULT);
 441
 442                 /* configure basic channels */
 443                 scan_mask = FIELD_GET(AMS_PL_SEQ_MASK, scan_mask);
 444
 445                 regval = FIELD_GET(AMS_REG_SEQ0_MASK, scan_mask);
 446                 writel(regval, ams->pl_base + AMS_REG_SEQ_CH0);
 447
 448                 regval = FIELD_GET(AMS_REG_SEQ1_MASK, scan_mask);
 449                 writel(regval, ams->pl_base + AMS_REG_SEQ_CH1);
 450
 451                 regval = FIELD_GET(AMS_REG_SEQ2_MASK, scan_mask);
 452                 writel(regval, ams->pl_base + AMS_REG_SEQ_CH2);
 453
 454                 /* set continuous sequence mode */
 455                 ams_pl_update_reg(ams, AMS_REG_CONFIG1, AMS_CONF1_SEQ_MASK,
 456                                   AMS_CONF1_SEQ_CONTINUOUS);
 457         }
 458 }
 459
 460 static int ams_init_device(struct ams *ams)
 461 {
 462         u32 expect = AMS_PS_CSTS_PS_READY;
 463         u32 reg, value;
 464         int ret;
 465
 466         /* reset AMS */
 467         if (ams->ps_base) {
 468                 writel(AMS_PS_RESET_VALUE, ams->ps_base + AMS_VP_VN);
 469
 470                 ret = readl_poll_timeout(ams->base + AMS_PS_CSTS, reg, (reg & expect),
 471                                          AMS_INIT_POLL_TIME_US, AMS_INIT_TIMEOUT_US);
 472                 if (ret)
 473                         return ret;
 474
 475                 /* put sysmon in a default state */
 476                 ams_ps_update_reg(ams, AMS_REG_CONFIG1, AMS_CONF1_SEQ_MASK,
 477                                   AMS_CONF1_SEQ_DEFAULT);
 478         }
 479
 480         if (ams->pl_base) {
 481                 value = readl(ams->base + AMS_PL_CSTS);
 482                 if (value == 0)
 483                         return 0;
 484
 485                 writel(AMS_PL_RESET_VALUE, ams->pl_base + AMS_VP_VN);
 486
 487                 /* put sysmon in a default state */
 488                 ams_pl_update_reg(ams, AMS_REG_CONFIG1, AMS_CONF1_SEQ_MASK,
 489                                   AMS_CONF1_SEQ_DEFAULT);
 490         }
 491
 492         ams_disable_all_alarms(ams);
 493
 494         /* Disable interrupt */
 495         ams_update_intrmask(ams, AMS_ALARM_MASK, AMS_ALARM_MASK);
 496
 497         /* Clear any pending interrupt */
 498         writel(AMS_ISR0_ALARM_MASK, ams->base + AMS_ISR_0);
 499         writel(AMS_ISR1_ALARM_MASK, ams->base + AMS_ISR_1);
 500
 501         return 0;
 502 }
 503
 504 static int ams_enable_single_channel(struct ams *ams, unsigned int offset)
 505 {
 506         u8 channel_num;
 507
 508         switch (offset) {
 509         case AMS_VCC_PSPLL0:
 510                 channel_num = AMS_VCC_PSPLL0_CH;
 511                 break;
 512         case AMS_VCC_PSPLL3:
 513                 channel_num = AMS_VCC_PSPLL3_CH;
 514                 break;
 515         case AMS_VCCINT:
 516                 channel_num = AMS_VCCINT_CH;
 517                 break;
 518         case AMS_VCCBRAM:
 519                 channel_num = AMS_VCCBRAM_CH;
 520                 break;
 521         case AMS_VCCAUX:
 522                 channel_num = AMS_VCCAUX_CH;
 523                 break;
 524         case AMS_PSDDRPLL:
 525                 channel_num = AMS_PSDDRPLL_CH;
 526                 break;
 527         case AMS_PSINTFPDDR:
 528                 channel_num = AMS_PSINTFPDDR_CH;
 529                 break;
 530         default:
 531                 return -EINVAL;
 532         }
 533
 534         /* put sysmon in a soft reset to change the sequence */
 535         ams_ps_update_reg(ams, AMS_REG_CONFIG1, AMS_CONF1_SEQ_MASK,
 536                           AMS_CONF1_SEQ_DEFAULT);
 537
 538         /* write the channel number */
 539         ams_ps_update_reg(ams, AMS_REG_CONFIG0, AMS_CONF0_CHANNEL_NUM_MASK,
 540                           channel_num);
 541
 542         /* set single channel, sequencer off mode */
 543         ams_ps_update_reg(ams, AMS_REG_CONFIG1, AMS_CONF1_SEQ_MASK,
 544                           AMS_CONF1_SEQ_SINGLE_CHANNEL);
 545
 546         return 0;
 547 }
 548
 549 static int ams_read_vcc_reg(struct ams *ams, unsigned int offset, u32 *data)
 550 {
 551         u32 expect = AMS_ISR1_EOC_MASK;
 552         u32 reg;
 553         int ret;
 554
 555         ret = ams_enable_single_channel(ams, offset);
 556         if (ret)
 557                 return ret;
 558
 559         /* clear end-of-conversion flag, wait for next conversion to complete */
 560         writel(expect, ams->base + AMS_ISR_1);
 561         ret = readl_poll_timeout(ams->base + AMS_ISR_1, reg, (reg & expect),
 562                                  AMS_INIT_POLL_TIME_US, AMS_INIT_TIMEOUT_US);
 563         if (ret)
 564                 return ret;
 565
 566         *data = readl(ams->base + offset);
 567
 568         return 0;
 569 }
 570
 571 static int ams_get_ps_scale(int address)
 572 {
 573         int val;
 574
 575         switch (address) {
 576         case AMS_SUPPLY1:
 577         case AMS_SUPPLY2:
 578         case AMS_SUPPLY3:
 579         case AMS_SUPPLY4:
 580         case AMS_SUPPLY9:
 581         case AMS_SUPPLY10:
 582         case AMS_VCCAMS:
 583                 val = AMS_SUPPLY_SCALE_3VOLT_mV;
 584                 break;
 585         case AMS_SUPPLY5:
 586         case AMS_SUPPLY6:
 587         case AMS_SUPPLY7:
 588         case AMS_SUPPLY8:
 589                 val = AMS_SUPPLY_SCALE_6VOLT_mV;
 590                 break;
 591         default:
 592                 val = AMS_SUPPLY_SCALE_1VOLT_mV;
 593                 break;
 594         }
 595
 596         return val;
 597 }
 598
 599 static int ams_get_pl_scale(struct ams *ams, int address)
 600 {
 601         int val, regval;
 602
 603         switch (address) {
 604         case AMS_SUPPLY1:
 605         case AMS_SUPPLY2:
 606         case AMS_SUPPLY3:
 607         case AMS_SUPPLY4:
 608         case AMS_SUPPLY5:
 609         case AMS_SUPPLY6:
 610         case AMS_VCCAMS:
 611         case AMS_VREFP:
 612         case AMS_VREFN:
 613                 val = AMS_SUPPLY_SCALE_3VOLT_mV;
 614                 break;
 615         case AMS_SUPPLY7:
 616                 regval = readl(ams->pl_base + AMS_REG_CONFIG4);
 617                 if (FIELD_GET(AMS_VUSER0_MASK, regval))
 618                         val = AMS_SUPPLY_SCALE_6VOLT_mV;
 619                 else
 620                         val = AMS_SUPPLY_SCALE_3VOLT_mV;
 621                 break;
 622         case AMS_SUPPLY8:
 623                 regval = readl(ams->pl_base + AMS_REG_CONFIG4);
 624                 if (FIELD_GET(AMS_VUSER1_MASK, regval))
 625                         val = AMS_SUPPLY_SCALE_6VOLT_mV;
 626                 else
 627                         val = AMS_SUPPLY_SCALE_3VOLT_mV;
 628                 break;
 629         case AMS_SUPPLY9:
 630                 regval = readl(ams->pl_base + AMS_REG_CONFIG4);
 631                 if (FIELD_GET(AMS_VUSER2_MASK, regval))
 632                         val = AMS_SUPPLY_SCALE_6VOLT_mV;
 633                 else
 634                         val = AMS_SUPPLY_SCALE_3VOLT_mV;
 635                 break;
 636         case AMS_SUPPLY10:
 637                 regval = readl(ams->pl_base + AMS_REG_CONFIG4);
 638                 if (FIELD_GET(AMS_VUSER3_MASK, regval))
 639                         val = AMS_SUPPLY_SCALE_6VOLT_mV;
 640                 else
 641                         val = AMS_SUPPLY_SCALE_3VOLT_mV;
 642                 break;
 643         case AMS_VP_VN:
 644         case AMS_REG_VAUX(0) ... AMS_REG_VAUX(15):
 645                 val = AMS_SUPPLY_SCALE_1VOLT_mV;
 646                 break;
 647         default:
 648                 val = AMS_SUPPLY_SCALE_1VOLT_mV;
 649                 break;
 650         }
 651
 652         return val;
 653 }
 654
 655 static int ams_get_ctrl_scale(int address)
 656 {
 657         int val;
 658
 659         switch (address) {
 660         case AMS_VCC_PSPLL0:
 661         case AMS_VCC_PSPLL3:
 662         case AMS_VCCINT:
 663         case AMS_VCCBRAM:
 664         case AMS_VCCAUX:
 665         case AMS_PSDDRPLL:
 666         case AMS_PSINTFPDDR:
 667                 val = AMS_SUPPLY_SCALE_3VOLT_mV;
 668                 break;
 669         default:
 670                 val = AMS_SUPPLY_SCALE_1VOLT_mV;
 671                 break;
 672         }
 673
 674         return val;
 675 }
 676
 677 static int ams_read_raw(struct iio_dev *indio_dev,
 678                         struct iio_chan_spec const *chan,
 679                         int *val, int *val2, long mask)
 680 {
 681         struct ams *ams = iio_priv(indio_dev);
 682         int ret;
 683
 684         switch (mask) {
 685         case IIO_CHAN_INFO_RAW:
 686                 mutex_lock(&ams->lock);
 687                 if (chan->scan_index >= AMS_CTRL_SEQ_BASE) {
 688                         ret = ams_read_vcc_reg(ams, chan->address, val);
 689                         if (ret)
 690                                 goto unlock_mutex;
 691                         ams_enable_channel_sequence(indio_dev);
 692                 } else if (chan->scan_index >= AMS_PS_SEQ_MAX)
 693                         *val = readl(ams->pl_base + chan->address);
 694                 else
 695                         *val = readl(ams->ps_base + chan->address);
 696
 697                 ret = IIO_VAL_INT;
 698 unlock_mutex:
 699                 mutex_unlock(&ams->lock);
 700                 return ret;
 701         case IIO_CHAN_INFO_SCALE:
 702                 switch (chan->type) {
 703                 case IIO_VOLTAGE:
 704                         if (chan->scan_index < AMS_PS_SEQ_MAX)
 705                                 *val = ams_get_ps_scale(chan->address);
 706                         else if (chan->scan_index >= AMS_PS_SEQ_MAX &&
 707                                  chan->scan_index < AMS_CTRL_SEQ_BASE)
 708                                 *val = ams_get_pl_scale(ams, chan->address);
 709                         else
 710                                 *val = ams_get_ctrl_scale(chan->address);
 711
 712                         *val2 = AMS_SUPPLY_SCALE_DIV_BIT;
 713                         return IIO_VAL_FRACTIONAL_LOG2;
 714                 case IIO_TEMP:
 715                         *val = AMS_TEMP_SCALE;
 716                         *val2 = AMS_TEMP_SCALE_DIV_BIT;
 717                         return IIO_VAL_FRACTIONAL_LOG2;
 718                 default:
 719                         return -EINVAL;
 720                 }
 721         case IIO_CHAN_INFO_OFFSET:
 722                 /* Only the temperature channel has an offset */
 723                 *val = AMS_TEMP_OFFSET;
 724                 return IIO_VAL_INT;
 725         default:
 726                 return -EINVAL;
 727         }
 728 }
 729
 730 static int ams_get_alarm_offset(int scan_index, enum iio_event_direction dir)
 731 {
 732         int offset;
 733
 734         if (scan_index >= AMS_PS_SEQ_MAX)
 735                 scan_index -= AMS_PS_SEQ_MAX;
 736
 737         if (dir == IIO_EV_DIR_FALLING) {
 738                 if (scan_index < AMS_SEQ_SUPPLY7)
 739                         offset = AMS_ALARM_THRESHOLD_OFF_10;
 740                 else
 741                         offset = AMS_ALARM_THRESHOLD_OFF_20;
 742         } else {
 743                 offset = 0;
 744         }
 745
 746         switch (scan_index) {
 747         case AMS_SEQ_TEMP:
 748                 return AMS_ALARM_TEMP + offset;
 749         case AMS_SEQ_SUPPLY1:
 750                 return AMS_ALARM_SUPPLY1 + offset;
 751         case AMS_SEQ_SUPPLY2:
 752                 return AMS_ALARM_SUPPLY2 + offset;
 753         case AMS_SEQ_SUPPLY3:
 754                 return AMS_ALARM_SUPPLY3 + offset;
 755         case AMS_SEQ_SUPPLY4:
 756                 return AMS_ALARM_SUPPLY4 + offset;
 757         case AMS_SEQ_SUPPLY5:
 758                 return AMS_ALARM_SUPPLY5 + offset;
 759         case AMS_SEQ_SUPPLY6:
 760                 return AMS_ALARM_SUPPLY6 + offset;
 761         case AMS_SEQ_SUPPLY7:
 762                 return AMS_ALARM_SUPPLY7 + offset;
 763         case AMS_SEQ_SUPPLY8:
 764                 return AMS_ALARM_SUPPLY8 + offset;
 765         case AMS_SEQ_SUPPLY9:
 766                 return AMS_ALARM_SUPPLY9 + offset;
 767         case AMS_SEQ_SUPPLY10:
 768                 return AMS_ALARM_SUPPLY10 + offset;
 769         case AMS_SEQ_VCCAMS:
 770                 return AMS_ALARM_VCCAMS + offset;
 771         case AMS_SEQ_TEMP_REMOTE:
 772                 return AMS_ALARM_TEMP_REMOTE + offset;
 773         default:
 774                 return 0;
 775         }
 776 }
 777
 778 static const struct iio_chan_spec *ams_event_to_channel(struct iio_dev *dev,
 779                                                         u32 event)
 780 {
 781         int scan_index = 0, i;
 782
 783         if (event >= AMS_PL_ALARM_START) {
 784                 event -= AMS_PL_ALARM_START;
 785                 scan_index = AMS_PS_SEQ_MAX;
 786         }
 787
 788         switch (event) {
 789         case AMS_ALARM_BIT_TEMP:
 790                 scan_index += AMS_SEQ_TEMP;
 791                 break;
 792         case AMS_ALARM_BIT_SUPPLY1:
 793                 scan_index += AMS_SEQ_SUPPLY1;
 794                 break;
 795         case AMS_ALARM_BIT_SUPPLY2:
 796                 scan_index += AMS_SEQ_SUPPLY2;
 797                 break;
 798         case AMS_ALARM_BIT_SUPPLY3:
 799                 scan_index += AMS_SEQ_SUPPLY3;
 800                 break;
 801         case AMS_ALARM_BIT_SUPPLY4:
 802                 scan_index += AMS_SEQ_SUPPLY4;
 803                 break;
 804         case AMS_ALARM_BIT_SUPPLY5:
 805                 scan_index += AMS_SEQ_SUPPLY5;
 806                 break;
 807         case AMS_ALARM_BIT_SUPPLY6:
 808                 scan_index += AMS_SEQ_SUPPLY6;
 809                 break;
 810         case AMS_ALARM_BIT_SUPPLY7:
 811                 scan_index += AMS_SEQ_SUPPLY7;
 812                 break;
 813         case AMS_ALARM_BIT_SUPPLY8:
 814                 scan_index += AMS_SEQ_SUPPLY8;
 815                 break;
 816         case AMS_ALARM_BIT_SUPPLY9:
 817                 scan_index += AMS_SEQ_SUPPLY9;
 818                 break;
 819         case AMS_ALARM_BIT_SUPPLY10:
 820                 scan_index += AMS_SEQ_SUPPLY10;
 821                 break;
 822         case AMS_ALARM_BIT_VCCAMS:
 823                 scan_index += AMS_SEQ_VCCAMS;
 824                 break;
 825         case AMS_ALARM_BIT_TEMP_REMOTE:
 826                 scan_index += AMS_SEQ_TEMP_REMOTE;
 827                 break;
 828         default:
 829                 break;
 830         }
 831
 832         for (i = 0; i < dev->num_channels; i++)
 833                 if (dev->channels[i].scan_index == scan_index)
 834                         break;
 835
 836         return &dev->channels[i];
 837 }
 838
 839 static int ams_get_alarm_mask(int scan_index)
 840 {
 841         int bit = 0;
 842
 843         if (scan_index >= AMS_PS_SEQ_MAX) {
 844                 bit = AMS_PL_ALARM_START;
 845                 scan_index -= AMS_PS_SEQ_MAX;
 846         }
 847
 848         switch (scan_index) {
 849         case AMS_SEQ_TEMP:
 850                 return BIT(AMS_ALARM_BIT_TEMP + bit);
 851         case AMS_SEQ_SUPPLY1:
 852                 return BIT(AMS_ALARM_BIT_SUPPLY1 + bit);
 853         case AMS_SEQ_SUPPLY2:
 854                 return BIT(AMS_ALARM_BIT_SUPPLY2 + bit);
 855         case AMS_SEQ_SUPPLY3:
 856                 return BIT(AMS_ALARM_BIT_SUPPLY3 + bit);
 857         case AMS_SEQ_SUPPLY4:
 858                 return BIT(AMS_ALARM_BIT_SUPPLY4 + bit);
 859         case AMS_SEQ_SUPPLY5:
 860                 return BIT(AMS_ALARM_BIT_SUPPLY5 + bit);
 861         case AMS_SEQ_SUPPLY6:
 862                 return BIT(AMS_ALARM_BIT_SUPPLY6 + bit);
 863         case AMS_SEQ_SUPPLY7:
 864                 return BIT(AMS_ALARM_BIT_SUPPLY7 + bit);
 865         case AMS_SEQ_SUPPLY8:
 866                 return BIT(AMS_ALARM_BIT_SUPPLY8 + bit);
 867         case AMS_SEQ_SUPPLY9:
 868                 return BIT(AMS_ALARM_BIT_SUPPLY9 + bit);
 869         case AMS_SEQ_SUPPLY10:
 870                 return BIT(AMS_ALARM_BIT_SUPPLY10 + bit);
 871         case AMS_SEQ_VCCAMS:
 872                 return BIT(AMS_ALARM_BIT_VCCAMS + bit);
 873         case AMS_SEQ_TEMP_REMOTE:
 874                 return BIT(AMS_ALARM_BIT_TEMP_REMOTE + bit);
 875         default:
 876                 return 0;
 877         }
 878 }
 879
 880 static int ams_read_event_config(struct iio_dev *indio_dev,
 881                                  const struct iio_chan_spec *chan,
 882                                  enum iio_event_type type,
 883                                  enum iio_event_direction dir)
 884 {
 885         struct ams *ams = iio_priv(indio_dev);
 886
 887         return !!(ams->alarm_mask & ams_get_alarm_mask(chan->scan_index));
 888 }
 889
 890 static int ams_write_event_config(struct iio_dev *indio_dev,
 891                                   const struct iio_chan_spec *chan,
 892                                   enum iio_event_type type,
 893                                   enum iio_event_direction dir,
 894                                   int state)
 895 {
 896         struct ams *ams = iio_priv(indio_dev);
 897         unsigned int alarm;
 898
 899         alarm = ams_get_alarm_mask(chan->scan_index);
 900
 901         mutex_lock(&ams->lock);
 902
 903         if (state)
 904                 ams->alarm_mask |= alarm;
 905         else
 906                 ams->alarm_mask &= ~alarm;
 907
 908         ams_update_alarm(ams, ams->alarm_mask);
 909
 910         mutex_unlock(&ams->lock);
 911
 912         return 0;
 913 }
 914
 915 static int ams_read_event_value(struct iio_dev *indio_dev,
 916                                 const struct iio_chan_spec *chan,
 917                                 enum iio_event_type type,
 918                                 enum iio_event_direction dir,
 919                                 enum iio_event_info info, int *val, int *val2)
 920 {
 921         struct ams *ams = iio_priv(indio_dev);
 922         unsigned int offset = ams_get_alarm_offset(chan->scan_index, dir);
 923
 924         mutex_lock(&ams->lock);
 925
 926         if (chan->scan_index >= AMS_PS_SEQ_MAX)
 927                 *val = readl(ams->pl_base + offset);
 928         else
 929                 *val = readl(ams->ps_base + offset);
 930
 931         mutex_unlock(&ams->lock);
 932
 933         return IIO_VAL_INT;
 934 }
 935
 936 static int ams_write_event_value(struct iio_dev *indio_dev,
 937                                  const struct iio_chan_spec *chan,
 938                                  enum iio_event_type type,
 939                                  enum iio_event_direction dir,
 940                                  enum iio_event_info info, int val, int val2)
 941 {
 942         struct ams *ams = iio_priv(indio_dev);
 943         unsigned int offset;
 944
 945         mutex_lock(&ams->lock);
 946
 947         /* Set temperature channel threshold to direct threshold */
 948         if (chan->type == IIO_TEMP) {
 949                 offset = ams_get_alarm_offset(chan->scan_index, IIO_EV_DIR_FALLING);
 950
 951                 if (chan->scan_index >= AMS_PS_SEQ_MAX)
 952                         ams_pl_update_reg(ams, offset,
 953                                           AMS_ALARM_THR_DIRECT_MASK,
 954                                           AMS_ALARM_THR_DIRECT_MASK);
 955                 else
 956                         ams_ps_update_reg(ams, offset,
 957                                           AMS_ALARM_THR_DIRECT_MASK,
 958                                           AMS_ALARM_THR_DIRECT_MASK);
 959         }
 960
 961         offset = ams_get_alarm_offset(chan->scan_index, dir);
 962         if (chan->scan_index >= AMS_PS_SEQ_MAX)
 963                 writel(val, ams->pl_base + offset);
 964         else
 965                 writel(val, ams->ps_base + offset);
 966
 967         mutex_unlock(&ams->lock);
 968
 969         return 0;
 970 }
 971
 972 static void ams_handle_event(struct iio_dev *indio_dev, u32 event)
 973 {
 974         const struct iio_chan_spec *chan;
 975
 976         chan = ams_event_to_channel(indio_dev, event);
 977
 978         if (chan->type == IIO_TEMP) {
 979                 /*
 980                  * The temperature channel only supports over-temperature
 981                  * events.
 982                  */
 983                 iio_push_event(indio_dev,
 984                                IIO_UNMOD_EVENT_CODE(chan->type, chan->channel,
 985                                                     IIO_EV_TYPE_THRESH,
 986                                                     IIO_EV_DIR_RISING),
 987                                iio_get_time_ns(indio_dev));
 988         } else {
 989                 /*
 990                  * For other channels we don't know whether it is a upper or
 991                  * lower threshold event. Userspace will have to check the
 992                  * channel value if it wants to know.
 993                  */
 994                 iio_push_event(indio_dev,
 995                                IIO_UNMOD_EVENT_CODE(chan->type, chan->channel,
 996                                                     IIO_EV_TYPE_THRESH,
 997                                                     IIO_EV_DIR_EITHER),
 998                                iio_get_time_ns(indio_dev));
 999         }
1000 }
1001
1002 static void ams_handle_events(struct iio_dev *indio_dev, unsigned long events)
1003 {
1004         unsigned int bit;
1005
1006         for_each_set_bit(bit, &events, AMS_NO_OF_ALARMS)
1007                 ams_handle_event(indio_dev, bit);
1008 }
1009
1010 /**
1011  * ams_unmask_worker - ams alarm interrupt unmask worker
1012  * @work: work to be done
1013  *
1014  * The ZynqMP threshold interrupts are level sensitive. Since we can't make the
1015  * threshold condition go way from within the interrupt handler, this means as
1016  * soon as a threshold condition is present we would enter the interrupt handler
1017  * again and again. To work around this we mask all active threshold interrupts
1018  * in the interrupt handler and start a timer. In this timer we poll the
1019  * interrupt status and only if the interrupt is inactive we unmask it again.
1020  */
1021 static void ams_unmask_worker(struct work_struct *work)
1022 {
1023         struct ams *ams = container_of(work, struct ams, ams_unmask_work.work);
1024         unsigned int status, unmask;
1025
1026         spin_lock_irq(&ams->intr_lock);
1027
1028         status = readl(ams->base + AMS_ISR_0);
1029
1030         /* Clear those bits which are not active anymore */
1031         unmask = (ams->current_masked_alarm ^ status) & ams->current_masked_alarm;
1032
1033         /* Clear status of disabled alarm */
1034         unmask |= ams->intr_mask;
1035
1036         ams->current_masked_alarm &= status;
1037
1038         /* Also clear those which are masked out anyway */
1039         ams->current_masked_alarm &= ~ams->intr_mask;
1040
1041         /* Clear the interrupts before we unmask them */
1042         writel(unmask, ams->base + AMS_ISR_0);
1043
1044         ams_update_intrmask(ams, ~AMS_ALARM_MASK, ~AMS_ALARM_MASK);
1045
1046         spin_unlock_irq(&ams->intr_lock);
1047
1048         /* If still pending some alarm re-trigger the timer */
1049         if (ams->current_masked_alarm)
1050                 schedule_delayed_work(&ams->ams_unmask_work,
1051                                       msecs_to_jiffies(AMS_UNMASK_TIMEOUT_MS));
1052 }
1053
1054 static irqreturn_t ams_irq(int irq, void *data)
1055 {
1056         struct iio_dev *indio_dev = data;
1057         struct ams *ams = iio_priv(indio_dev);
1058         u32 isr0;
1059
1060         spin_lock(&ams->intr_lock);
1061
1062         isr0 = readl(ams->base + AMS_ISR_0);
1063
1064         /* Only process alarms that are not masked */
1065         isr0 &= ~((ams->intr_mask & AMS_ISR0_ALARM_MASK) | ams->current_masked_alarm);
1066         if (!isr0) {
1067                 spin_unlock(&ams->intr_lock);
1068                 return IRQ_NONE;
1069         }
1070
1071         /* Clear interrupt */
1072         writel(isr0, ams->base + AMS_ISR_0);
1073
1074         /* Mask the alarm interrupts until cleared */
1075         ams->current_masked_alarm |= isr0;
1076         ams_update_intrmask(ams, ~AMS_ALARM_MASK, ~AMS_ALARM_MASK);
1077
1078         ams_handle_events(indio_dev, isr0);
1079
1080         schedule_delayed_work(&ams->ams_unmask_work,
1081                               msecs_to_jiffies(AMS_UNMASK_TIMEOUT_MS));
1082
1083         spin_unlock(&ams->intr_lock);
1084
1085         return IRQ_HANDLED;
1086 }
1087
1088 static const struct iio_event_spec ams_temp_events[] = {
1089         {
1090                 .type = IIO_EV_TYPE_THRESH,
1091                 .dir = IIO_EV_DIR_RISING,
1092                 .mask_separate = BIT(IIO_EV_INFO_ENABLE) | BIT(IIO_EV_INFO_VALUE),
1093         },
1094 };
1095
1096 static const struct iio_event_spec ams_voltage_events[] = {
1097         {
1098                 .type = IIO_EV_TYPE_THRESH,
1099                 .dir = IIO_EV_DIR_RISING,
1100                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
1101         },
1102         {
1103                 .type = IIO_EV_TYPE_THRESH,
1104                 .dir = IIO_EV_DIR_FALLING,
1105                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
1106         },
1107         {
1108                 .type = IIO_EV_TYPE_THRESH,
1109                 .dir = IIO_EV_DIR_EITHER,
1110                 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
1111         },
1112 };
1113
1114 static const struct iio_chan_spec ams_ps_channels[] = {
1115         AMS_PS_CHAN_TEMP(AMS_SEQ_TEMP, AMS_TEMP),
1116         AMS_PS_CHAN_TEMP(AMS_SEQ_TEMP_REMOTE, AMS_TEMP_REMOTE),
1117         AMS_PS_CHAN_VOLTAGE(AMS_SEQ_SUPPLY1, AMS_SUPPLY1),
1118         AMS_PS_CHAN_VOLTAGE(AMS_SEQ_SUPPLY2, AMS_SUPPLY2),
1119         AMS_PS_CHAN_VOLTAGE(AMS_SEQ_SUPPLY3, AMS_SUPPLY3),
1120         AMS_PS_CHAN_VOLTAGE(AMS_SEQ_SUPPLY4, AMS_SUPPLY4),
1121         AMS_PS_CHAN_VOLTAGE(AMS_SEQ_SUPPLY5, AMS_SUPPLY5),
1122         AMS_PS_CHAN_VOLTAGE(AMS_SEQ_SUPPLY6, AMS_SUPPLY6),
1123         AMS_PS_CHAN_VOLTAGE(AMS_SEQ_SUPPLY7, AMS_SUPPLY7),
1124         AMS_PS_CHAN_VOLTAGE(AMS_SEQ_SUPPLY8, AMS_SUPPLY8),
1125         AMS_PS_CHAN_VOLTAGE(AMS_SEQ_SUPPLY9, AMS_SUPPLY9),
1126         AMS_PS_CHAN_VOLTAGE(AMS_SEQ_SUPPLY10, AMS_SUPPLY10),
1127         AMS_PS_CHAN_VOLTAGE(AMS_SEQ_VCCAMS, AMS_VCCAMS),
1128 };
1129
1130 static const struct iio_chan_spec ams_pl_channels[] = {
1131         AMS_PL_CHAN_TEMP(AMS_SEQ_TEMP, AMS_TEMP),
1132         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_SUPPLY1, AMS_SUPPLY1, true),
1133         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_SUPPLY2, AMS_SUPPLY2, true),
1134         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_VREFP, AMS_VREFP, false),
1135         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_VREFN, AMS_VREFN, false),
1136         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_SUPPLY3, AMS_SUPPLY3, true),
1137         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_SUPPLY4, AMS_SUPPLY4, true),
1138         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_SUPPLY5, AMS_SUPPLY5, true),
1139         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_SUPPLY6, AMS_SUPPLY6, true),
1140         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_VCCAMS, AMS_VCCAMS, true),
1141         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_VP_VN, AMS_VP_VN, false),
1142         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_SUPPLY7, AMS_SUPPLY7, true),
1143         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_SUPPLY8, AMS_SUPPLY8, true),
1144         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_SUPPLY9, AMS_SUPPLY9, true),
1145         AMS_PL_CHAN_VOLTAGE(AMS_SEQ_SUPPLY10, AMS_SUPPLY10, true),
1146         AMS_PL_AUX_CHAN_VOLTAGE(0),
1147         AMS_PL_AUX_CHAN_VOLTAGE(1),
1148         AMS_PL_AUX_CHAN_VOLTAGE(2),
1149         AMS_PL_AUX_CHAN_VOLTAGE(3),
1150         AMS_PL_AUX_CHAN_VOLTAGE(4),
1151         AMS_PL_AUX_CHAN_VOLTAGE(5),
1152         AMS_PL_AUX_CHAN_VOLTAGE(6),
1153         AMS_PL_AUX_CHAN_VOLTAGE(7),
1154         AMS_PL_AUX_CHAN_VOLTAGE(8),
1155         AMS_PL_AUX_CHAN_VOLTAGE(9),
1156         AMS_PL_AUX_CHAN_VOLTAGE(10),
1157         AMS_PL_AUX_CHAN_VOLTAGE(11),
1158         AMS_PL_AUX_CHAN_VOLTAGE(12),
1159         AMS_PL_AUX_CHAN_VOLTAGE(13),
1160         AMS_PL_AUX_CHAN_VOLTAGE(14),
1161         AMS_PL_AUX_CHAN_VOLTAGE(15),
1162 };
1163
1164 static const struct iio_chan_spec ams_ctrl_channels[] = {
1165         AMS_CTRL_CHAN_VOLTAGE(AMS_SEQ_VCC_PSPLL, AMS_VCC_PSPLL0),
1166         AMS_CTRL_CHAN_VOLTAGE(AMS_SEQ_VCC_PSBATT, AMS_VCC_PSPLL3),
1167         AMS_CTRL_CHAN_VOLTAGE(AMS_SEQ_VCCINT, AMS_VCCINT),
1168         AMS_CTRL_CHAN_VOLTAGE(AMS_SEQ_VCCBRAM, AMS_VCCBRAM),
1169         AMS_CTRL_CHAN_VOLTAGE(AMS_SEQ_VCCAUX, AMS_VCCAUX),
1170         AMS_CTRL_CHAN_VOLTAGE(AMS_SEQ_PSDDRPLL, AMS_PSDDRPLL),
1171         AMS_CTRL_CHAN_VOLTAGE(AMS_SEQ_INTDDR, AMS_PSINTFPDDR),
1172 };
1173
1174 static int ams_get_ext_chan(struct fwnode_handle *chan_node,
1175                             struct iio_chan_spec *channels, int num_channels)
1176 {
1177         struct iio_chan_spec *chan;
1178         struct fwnode_handle *child;
1179         unsigned int reg, ext_chan;
1180         int ret;
1181
1182         fwnode_for_each_child_node(chan_node, child) {
1183                 ret = fwnode_property_read_u32(child, "reg", &reg);
1184                 if (ret || reg > AMS_PL_MAX_EXT_CHANNEL + 30)
1185                         continue;
1186
1187                 chan = &channels[num_channels];
1188                 ext_chan = reg + AMS_PL_MAX_FIXED_CHANNEL - 30;
1189                 memcpy(chan, &ams_pl_channels[ext_chan], sizeof(*channels));
1190
1191                 if (fwnode_property_read_bool(child, "xlnx,bipolar"))
1192                         chan->scan_type.sign = 's';
1193
1194                 num_channels++;
1195         }
1196
1197         return num_channels;
1198 }
1199
1200 static void ams_iounmap_ps(void *data)
1201 {
1202         struct ams *ams = data;
1203
1204         iounmap(ams->ps_base);
1205 }
1206
1207 static void ams_iounmap_pl(void *data)
1208 {
1209         struct ams *ams = data;
1210
1211         iounmap(ams->pl_base);
1212 }
1213
1214 static int ams_init_module(struct iio_dev *indio_dev,
1215                            struct fwnode_handle *fwnode,
1216                            struct iio_chan_spec *channels)
1217 {
1218         struct device *dev = indio_dev->dev.parent;
1219         struct ams *ams = iio_priv(indio_dev);
1220         int num_channels = 0;
1221         int ret;
1222
1223         if (fwnode_property_match_string(fwnode, "compatible",
1224                                          "xlnx,zynqmp-ams-ps") == 0) {
1225                 ams->ps_base = fwnode_iomap(fwnode, 0);
1226                 if (!ams->ps_base)
1227                         return -ENXIO;
1228                 ret = devm_add_action_or_reset(dev, ams_iounmap_ps, ams);
1229                 if (ret < 0)
1230                         return ret;
1231
1232                 /* add PS channels to iio device channels */
1233                 memcpy(channels, ams_ps_channels, sizeof(ams_ps_channels));
1234                 num_channels = ARRAY_SIZE(ams_ps_channels);
1235         } else if (fwnode_property_match_string(fwnode, "compatible",
1236                                                 "xlnx,zynqmp-ams-pl") == 0) {
1237                 ams->pl_base = fwnode_iomap(fwnode, 0);
1238                 if (!ams->pl_base)
1239                         return -ENXIO;
1240
1241                 ret = devm_add_action_or_reset(dev, ams_iounmap_pl, ams);
1242                 if (ret < 0)
1243                         return ret;
1244
1245                 /* Copy only first 10 fix channels */
1246                 memcpy(channels, ams_pl_channels, AMS_PL_MAX_FIXED_CHANNEL * sizeof(*channels));
1247                 num_channels += AMS_PL_MAX_FIXED_CHANNEL;
1248                 num_channels = ams_get_ext_chan(fwnode, channels,
1249                                                 num_channels);
1250         } else if (fwnode_property_match_string(fwnode, "compatible",
1251                                                 "xlnx,zynqmp-ams") == 0) {
1252                 /* add AMS channels to iio device channels */
1253                 memcpy(channels, ams_ctrl_channels, sizeof(ams_ctrl_channels));
1254                 num_channels += ARRAY_SIZE(ams_ctrl_channels);
1255         } else {
1256                 return -EINVAL;
1257         }
1258
1259         return num_channels;
1260 }
1261
1262 static int ams_parse_firmware(struct iio_dev *indio_dev)
1263 {
1264         struct ams *ams = iio_priv(indio_dev);
1265         struct iio_chan_spec *ams_channels, *dev_channels;
1266         struct device *dev = indio_dev->dev.parent;
1267         struct fwnode_handle *child = NULL;
1268         struct fwnode_handle *fwnode = dev_fwnode(dev);
1269         size_t ams_size, dev_size;
1270         int ret, ch_cnt = 0, i, rising_off, falling_off;
1271         unsigned int num_channels = 0;
1272
1273         ams_size = ARRAY_SIZE(ams_ps_channels) + ARRAY_SIZE(ams_pl_channels) +
1274                 ARRAY_SIZE(ams_ctrl_channels);
1275
1276         /* Initialize buffer for channel specification */
1277         ams_channels = devm_kcalloc(dev, ams_size, sizeof(*ams_channels), GFP_KERNEL);
1278         if (!ams_channels)
1279                 return -ENOMEM;
1280
1281         if (fwnode_device_is_available(fwnode)) {
1282                 ret = ams_init_module(indio_dev, fwnode, ams_channels);
1283                 if (ret < 0)
1284                         return ret;
1285
1286                 num_channels += ret;
1287         }
1288
1289         fwnode_for_each_child_node(fwnode, child) {
1290                 if (fwnode_device_is_available(child)) {
1291                         ret = ams_init_module(indio_dev, child, ams_channels + num_channels);
1292                         if (ret < 0) {
1293                                 fwnode_handle_put(child);
1294                                 return ret;
1295                         }
1296
1297                         num_channels += ret;
1298                 }
1299         }
1300
1301         for (i = 0; i < num_channels; i++) {
1302                 ams_channels[i].channel = ch_cnt++;
1303
1304                 if (ams_channels[i].scan_index < AMS_CTRL_SEQ_BASE) {
1305                         /* set threshold to max and min for each channel */
1306                         falling_off =
1307                                 ams_get_alarm_offset(ams_channels[i].scan_index,
1308                                                      IIO_EV_DIR_FALLING);
1309                         rising_off =
1310                                 ams_get_alarm_offset(ams_channels[i].scan_index,
1311                                                      IIO_EV_DIR_RISING);
1312                         if (ams_channels[i].scan_index >= AMS_PS_SEQ_MAX) {
1313                                 writel(AMS_ALARM_THR_MIN,
1314                                        ams->pl_base + falling_off);
1315                                 writel(AMS_ALARM_THR_MAX,
1316                                        ams->pl_base + rising_off);
1317                         } else {
1318                                 writel(AMS_ALARM_THR_MIN,
1319                                        ams->ps_base + falling_off);
1320                                 writel(AMS_ALARM_THR_MAX,
1321                                        ams->ps_base + rising_off);
1322                         }
1323                 }
1324         }
1325
1326         dev_size = array_size(sizeof(*dev_channels), num_channels);
1327         if (dev_size == SIZE_MAX)
1328                 return -ENOMEM;
1329
1330         dev_channels = devm_krealloc(dev, ams_channels, dev_size, GFP_KERNEL);
1331         if (!dev_channels)
1332                 ret = -ENOMEM;
1333
1334         indio_dev->channels = dev_channels;
1335         indio_dev->num_channels = num_channels;
1336
1337         return 0;
1338 }
1339
1340 static const struct iio_info iio_ams_info = {
1341         .read_raw = &ams_read_raw,
1342         .read_event_config = &ams_read_event_config,
1343         .write_event_config = &ams_write_event_config,
1344         .read_event_value = &ams_read_event_value,
1345         .write_event_value = &ams_write_event_value,
1346 };
1347
1348 static const struct of_device_id ams_of_match_table[] = {
1349         { .compatible = "xlnx,zynqmp-ams" },
1350         { }
1351 };
1352 MODULE_DEVICE_TABLE(of, ams_of_match_table);
1353
1354 static void ams_clk_disable_unprepare(void *data)
1355 {
1356         clk_disable_unprepare(data);
1357 }
1358
1359 static int ams_probe(struct platform_device *pdev)
1360 {
1361         struct iio_dev *indio_dev;
1362         struct ams *ams;
1363         int ret;
1364         int irq;
1365
1366         indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*ams));
1367         if (!indio_dev)
1368                 return -ENOMEM;
1369
1370         ams = iio_priv(indio_dev);
1371         mutex_init(&ams->lock);
1372         spin_lock_init(&ams->intr_lock);
1373
1374         indio_dev->name = "xilinx-ams";
1375
1376         indio_dev->info = &iio_ams_info;
1377         indio_dev->modes = INDIO_DIRECT_MODE;
1378
1379         ams->base = devm_platform_ioremap_resource(pdev, 0);
1380         if (IS_ERR(ams->base))
1381                 return PTR_ERR(ams->base);
1382
1383         ams->clk = devm_clk_get(&pdev->dev, NULL);
1384         if (IS_ERR(ams->clk))
1385                 return PTR_ERR(ams->clk);
1386
1387         ret = clk_prepare_enable(ams->clk);
1388         if (ret < 0)
1389                 return ret;
1390
1391         ret = devm_add_action_or_reset(&pdev->dev, ams_clk_disable_unprepare, ams->clk);
1392         if (ret < 0)
1393                 return ret;
1394
1395         ret = devm_delayed_work_autocancel(&pdev->dev, &ams->ams_unmask_work,
1396                                            ams_unmask_worker);
1397         if (ret < 0)
1398                 return ret;
1399
1400         ret = ams_parse_firmware(indio_dev);
1401         if (ret)
1402                 return dev_err_probe(&pdev->dev, ret, "failure in parsing DT\n");
1403
1404         ret = ams_init_device(ams);
1405         if (ret)
1406                 return dev_err_probe(&pdev->dev, ret, "failed to initialize AMS\n");
1407
1408         ams_enable_channel_sequence(indio_dev);
1409
1410         irq = platform_get_irq(pdev, 0);
1411         if (irq < 0)
1412                 return irq;
1413
1414         ret = devm_request_irq(&pdev->dev, irq, &ams_irq, 0, "ams-irq",
1415                                indio_dev);
1416         if (ret < 0)
1417                 return dev_err_probe(&pdev->dev, ret, "failed to register interrupt\n");
1418
1419         platform_set_drvdata(pdev, indio_dev);
1420
1421         return devm_iio_device_register(&pdev->dev, indio_dev);
1422 }
1423
1424 static int ams_suspend(struct device *dev)
1425 {
1426         struct ams *ams = iio_priv(dev_get_drvdata(dev));
1427
1428         clk_disable_unprepare(ams->clk);
1429
1430         return 0;
1431 }
1432
1433 static int ams_resume(struct device *dev)
1434 {
1435         struct ams *ams = iio_priv(dev_get_drvdata(dev));
1436
1437         return clk_prepare_enable(ams->clk);
1438 }
1439
1440 static DEFINE_SIMPLE_DEV_PM_OPS(ams_pm_ops, ams_suspend, ams_resume);
1441
1442 static struct platform_driver ams_driver = {
1443         .probe = ams_probe,
1444         .driver = {
1445                 .name = "xilinx-ams",
1446                 .pm = pm_sleep_ptr(&ams_pm_ops),
1447                 .of_match_table = ams_of_match_table,
1448         },
1449 };
1450 module_platform_driver(ams_driver);
1451
1452 MODULE_LICENSE("GPL v2");
1453 MODULE_AUTHOR("Xilinx, Inc.");