drivers/iio/adc/xilinx-xadc-events.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Xilinx XADC driver
   4  *
   5  * Copyright 2013 Analog Devices Inc.
   6  *  Author: Lars-Peter Clausen <lars@metafoo.de>
   7  */
   8
   9 #include <linux/iio/events.h>
  10 #include <linux/iio/iio.h>
  11 #include <linux/kernel.h>
  12
  13 #include "xilinx-xadc.h"
  14
  15 static const struct iio_chan_spec *xadc_event_to_channel(
  16         struct iio_dev *indio_dev, unsigned int event)
  17 {
  18         switch (event) {
  19         case XADC_THRESHOLD_OT_MAX:
  20         case XADC_THRESHOLD_TEMP_MAX:
  21                 return &indio_dev->channels[0];
  22         case XADC_THRESHOLD_VCCINT_MAX:
  23         case XADC_THRESHOLD_VCCAUX_MAX:
  24                 return &indio_dev->channels[event];
  25         default:
  26                 return &indio_dev->channels[event-1];
  27         }
  28 }
  29
  30 static void xadc_handle_event(struct iio_dev *indio_dev, unsigned int event)
  31 {
  32         const struct iio_chan_spec *chan;
  33
  34         /* Temperature threshold error, we don't handle this yet */
  35         if (event == 0)
  36                 return;
  37
  38         chan = xadc_event_to_channel(indio_dev, event);
  39
  40         if (chan->type == IIO_TEMP) {
  41                 /*
  42                  * The temperature channel only supports over-temperature
  43                  * events.
  44                  */
  45                 iio_push_event(indio_dev,
  46                         IIO_UNMOD_EVENT_CODE(chan->type, chan->channel,
  47                                 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING),
  48                         iio_get_time_ns(indio_dev));
  49         } else {
  50                 /*
  51                  * For other channels we don't know whether it is a upper or
  52                  * lower threshold event. Userspace will have to check the
  53                  * channel value if it wants to know.
  54                  */
  55                 iio_push_event(indio_dev,
  56                         IIO_UNMOD_EVENT_CODE(chan->type, chan->channel,
  57                                 IIO_EV_TYPE_THRESH, IIO_EV_DIR_EITHER),
  58                         iio_get_time_ns(indio_dev));
  59         }
  60 }
  61
  62 void xadc_handle_events(struct iio_dev *indio_dev, unsigned long events)
  63 {
  64         unsigned int i;
  65
  66         for_each_set_bit(i, &events, 8)
  67                 xadc_handle_event(indio_dev, i);
  68 }
  69
  70 static unsigned int xadc_get_threshold_offset(const struct iio_chan_spec *chan,
  71         enum iio_event_direction dir)
  72 {
  73         unsigned int offset;
  74
  75         if (chan->type == IIO_TEMP) {
  76                 offset = XADC_THRESHOLD_OT_MAX;
  77         } else {
  78                 if (chan->channel < 2)
  79                         offset = chan->channel + 1;
  80                 else
  81                         offset = chan->channel + 6;
  82         }
  83
  84         if (dir == IIO_EV_DIR_FALLING)
  85                 offset += 4;
  86
  87         return offset;
  88 }
  89
  90 static unsigned int xadc_get_alarm_mask(const struct iio_chan_spec *chan)
  91 {
  92         if (chan->type == IIO_TEMP)
  93                 return XADC_ALARM_OT_MASK;
  94         switch (chan->channel) {
  95         case 0:
  96                 return XADC_ALARM_VCCINT_MASK;
  97         case 1:
  98                 return XADC_ALARM_VCCAUX_MASK;
  99         case 2:
 100                 return XADC_ALARM_VCCBRAM_MASK;
 101         case 3:
 102                 return XADC_ALARM_VCCPINT_MASK;
 103         case 4:
 104                 return XADC_ALARM_VCCPAUX_MASK;
 105         case 5:
 106                 return XADC_ALARM_VCCODDR_MASK;
 107         default:
 108                 /* We will never get here */
 109                 return 0;
 110         }
 111 }
 112
 113 int xadc_read_event_config(struct iio_dev *indio_dev,
 114         const struct iio_chan_spec *chan, enum iio_event_type type,
 115         enum iio_event_direction dir)
 116 {
 117         struct xadc *xadc = iio_priv(indio_dev);
 118
 119         return (bool)(xadc->alarm_mask & xadc_get_alarm_mask(chan));
 120 }
 121
 122 int xadc_write_event_config(struct iio_dev *indio_dev,
 123         const struct iio_chan_spec *chan, enum iio_event_type type,
 124         enum iio_event_direction dir, int state)
 125 {
 126         unsigned int alarm = xadc_get_alarm_mask(chan);
 127         struct xadc *xadc = iio_priv(indio_dev);
 128         uint16_t cfg, old_cfg;
 129         int ret;
 130
 131         mutex_lock(&xadc->mutex);
 132
 133         if (state)
 134                 xadc->alarm_mask |= alarm;
 135         else
 136                 xadc->alarm_mask &= ~alarm;
 137
 138         xadc->ops->update_alarm(xadc, xadc->alarm_mask);
 139
 140         ret = _xadc_read_adc_reg(xadc, XADC_REG_CONF1, &cfg);
 141         if (ret)
 142                 goto err_out;
 143
 144         old_cfg = cfg;
 145         cfg |= XADC_CONF1_ALARM_MASK;
 146         cfg &= ~((xadc->alarm_mask & 0xf0) << 4); /* bram, pint, paux, ddr */
 147         cfg &= ~((xadc->alarm_mask & 0x08) >> 3); /* ot */
 148         cfg &= ~((xadc->alarm_mask & 0x07) << 1); /* temp, vccint, vccaux */
 149         if (old_cfg != cfg)
 150                 ret = _xadc_write_adc_reg(xadc, XADC_REG_CONF1, cfg);
 151
 152 err_out:
 153         mutex_unlock(&xadc->mutex);
 154
 155         return ret;
 156 }
 157
 158 /* Register value is msb aligned, the lower 4 bits are ignored */
 159 #define XADC_THRESHOLD_VALUE_SHIFT 4
 160
 161 int xadc_read_event_value(struct iio_dev *indio_dev,
 162         const struct iio_chan_spec *chan, enum iio_event_type type,
 163         enum iio_event_direction dir, enum iio_event_info info,
 164         int *val, int *val2)
 165 {
 166         unsigned int offset = xadc_get_threshold_offset(chan, dir);
 167         struct xadc *xadc = iio_priv(indio_dev);
 168
 169         switch (info) {
 170         case IIO_EV_INFO_VALUE:
 171                 *val = xadc->threshold[offset];
 172                 break;
 173         case IIO_EV_INFO_HYSTERESIS:
 174                 *val = xadc->temp_hysteresis;
 175                 break;
 176         default:
 177                 return -EINVAL;
 178         }
 179
 180         *val >>= XADC_THRESHOLD_VALUE_SHIFT;
 181
 182         return IIO_VAL_INT;
 183 }
 184
 185 int xadc_write_event_value(struct iio_dev *indio_dev,
 186         const struct iio_chan_spec *chan, enum iio_event_type type,
 187         enum iio_event_direction dir, enum iio_event_info info,
 188         int val, int val2)
 189 {
 190         unsigned int offset = xadc_get_threshold_offset(chan, dir);
 191         struct xadc *xadc = iio_priv(indio_dev);
 192         int ret = 0;
 193
 194         val <<= XADC_THRESHOLD_VALUE_SHIFT;
 195
 196         if (val < 0 || val > 0xffff)
 197                 return -EINVAL;
 198
 199         mutex_lock(&xadc->mutex);
 200
 201         switch (info) {
 202         case IIO_EV_INFO_VALUE:
 203                 xadc->threshold[offset] = val;
 204                 break;
 205         case IIO_EV_INFO_HYSTERESIS:
 206                 xadc->temp_hysteresis = val;
 207                 break;
 208         default:
 209                 mutex_unlock(&xadc->mutex);
 210                 return -EINVAL;
 211         }
 212
 213         if (chan->type == IIO_TEMP) {
 214                 /*
 215                  * According to the datasheet we need to set the lower 4 bits to
 216                  * 0x3, otherwise 125 degree celsius will be used as the
 217                  * threshold.
 218                  */
 219                 val |= 0x3;
 220
 221                 /*
 222                  * Since we store the hysteresis as relative (to the threshold)
 223                  * value, but the hardware expects an absolute value we need to
 224                  * recalcualte this value whenever the hysteresis or the
 225                  * threshold changes.
 226                  */
 227                 if (xadc->threshold[offset] < xadc->temp_hysteresis)
 228                         xadc->threshold[offset + 4] = 0;
 229                 else
 230                         xadc->threshold[offset + 4] = xadc->threshold[offset] -
 231                                         xadc->temp_hysteresis;
 232                 ret = _xadc_write_adc_reg(xadc, XADC_REG_THRESHOLD(offset + 4),
 233                         xadc->threshold[offset + 4]);
 234                 if (ret)
 235                         goto out_unlock;
 236         }
 237
 238         if (info == IIO_EV_INFO_VALUE)
 239                 ret = _xadc_write_adc_reg(xadc, XADC_REG_THRESHOLD(offset), val);
 240
 241 out_unlock:
 242         mutex_unlock(&xadc->mutex);
 243
 244         return ret;
 245 }