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 int xadc_read_event_value(struct iio_dev *indio_dev, 159 const struct iio_chan_spec *chan, enum iio_event_type type, 160 enum iio_event_direction dir, enum iio_event_info info, 161 int *val, int *val2) 162 { 163 unsigned int offset = xadc_get_threshold_offset(chan, dir); 164 struct xadc *xadc = iio_priv(indio_dev); 165 166 switch (info) { 167 case IIO_EV_INFO_VALUE: 168 *val = xadc->threshold[offset]; 169 break; 170 case IIO_EV_INFO_HYSTERESIS: 171 *val = xadc->temp_hysteresis; 172 break; 173 default: 174 return -EINVAL; 175 } 176 177 /* MSB aligned */ 178 *val >>= 16 - chan->scan_type.realbits; 179 180 return IIO_VAL_INT; 181 } 182 183 int xadc_write_event_value(struct iio_dev *indio_dev, 184 const struct iio_chan_spec *chan, enum iio_event_type type, 185 enum iio_event_direction dir, enum iio_event_info info, 186 int val, int val2) 187 { 188 unsigned int offset = xadc_get_threshold_offset(chan, dir); 189 struct xadc *xadc = iio_priv(indio_dev); 190 int ret = 0; 191 192 /* MSB aligned */ 193 val <<= 16 - chan->scan_type.realbits; 194 195 if (val < 0 || val > 0xffff) 196 return -EINVAL; 197 198 mutex_lock(&xadc->mutex); 199 200 switch (info) { 201 case IIO_EV_INFO_VALUE: 202 xadc->threshold[offset] = val; 203 break; 204 case IIO_EV_INFO_HYSTERESIS: 205 xadc->temp_hysteresis = val; 206 break; 207 default: 208 mutex_unlock(&xadc->mutex); 209 return -EINVAL; 210 } 211 212 if (chan->type == IIO_TEMP) { 213 /* 214 * According to the datasheet we need to set the lower 4 bits to 215 * 0x3, otherwise 125 degree celsius will be used as the 216 * threshold. 217 */ 218 val |= 0x3; 219 220 /* 221 * Since we store the hysteresis as relative (to the threshold) 222 * value, but the hardware expects an absolute value we need to 223 * recalcualte this value whenever the hysteresis or the 224 * threshold changes. 225 */ 226 if (xadc->threshold[offset] < xadc->temp_hysteresis) 227 xadc->threshold[offset + 4] = 0; 228 else 229 xadc->threshold[offset + 4] = xadc->threshold[offset] - 230 xadc->temp_hysteresis; 231 ret = _xadc_write_adc_reg(xadc, XADC_REG_THRESHOLD(offset + 4), 232 xadc->threshold[offset + 4]); 233 if (ret) 234 goto out_unlock; 235 } 236 237 if (info == IIO_EV_INFO_VALUE) 238 ret = _xadc_write_adc_reg(xadc, XADC_REG_THRESHOLD(offset), val); 239 240 out_unlock: 241 mutex_unlock(&xadc->mutex); 242 243 return ret; 244 } 245