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 } 249