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

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