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