1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Windfarm PowerMac thermal control. AD7417 sensors
4  *
5  * Copyright 2012 Benjamin Herrenschmidt, IBM Corp.
6  */
7 
8 #include <linux/types.h>
9 #include <linux/errno.h>
10 #include <linux/kernel.h>
11 #include <linux/delay.h>
12 #include <linux/slab.h>
13 #include <linux/init.h>
14 #include <linux/wait.h>
15 #include <linux/i2c.h>
16 #include <asm/prom.h>
17 #include <asm/machdep.h>
18 #include <asm/io.h>
19 #include <asm/sections.h>
20 
21 #include "windfarm.h"
22 #include "windfarm_mpu.h"
23 
24 #define VERSION "1.0"
25 
26 struct wf_ad7417_priv {
27 	struct kref		ref;
28 	struct i2c_client	*i2c;
29 	u8			config;
30 	u8			cpu;
31 	const struct mpu_data	*mpu;
32 	struct wf_sensor	sensors[5];
33 	struct mutex		lock;
34 };
35 
36 static int wf_ad7417_temp_get(struct wf_sensor *sr, s32 *value)
37 {
38 	struct wf_ad7417_priv *pv = sr->priv;
39 	u8 buf[2];
40 	s16 raw;
41 	int rc;
42 
43 	*value = 0;
44 	mutex_lock(&pv->lock);
45 
46 	/* Read temp register */
47 	buf[0] = 0;
48 	rc = i2c_master_send(pv->i2c, buf, 1);
49 	if (rc < 0)
50 		goto error;
51 	rc = i2c_master_recv(pv->i2c, buf, 2);
52 	if (rc < 0)
53 		goto error;
54 
55 	/* Read a a 16-bit signed value */
56 	raw = be16_to_cpup((__le16 *)buf);
57 
58 	/* Convert 8.8-bit to 16.16 fixed point */
59 	*value = ((s32)raw) << 8;
60 
61 	mutex_unlock(&pv->lock);
62 	return 0;
63 
64 error:
65 	mutex_unlock(&pv->lock);
66 	return -1;
67 }
68 
69 /*
70  * Scaling factors for the AD7417 ADC converters (except
71  * for the CPU diode which is obtained from the EEPROM).
72  * Those values are obtained from the property list of
73  * the darwin driver
74  */
75 #define ADC_12V_CURRENT_SCALE	0x0320	/* _AD2 */
76 #define ADC_CPU_VOLTAGE_SCALE	0x00a0	/* _AD3 */
77 #define ADC_CPU_CURRENT_SCALE	0x1f40	/* _AD4 */
78 
79 static void wf_ad7417_adc_convert(struct wf_ad7417_priv *pv,
80 				  int chan, s32 raw, s32 *value)
81 {
82 	switch(chan) {
83 	case 1: /* Diode */
84 		*value = (raw * (s32)pv->mpu->mdiode +
85 			((s32)pv->mpu->bdiode << 12)) >> 2;
86 		break;
87 	case 2: /* 12v current */
88 		*value = raw * ADC_12V_CURRENT_SCALE;
89 		break;
90 	case 3: /* core voltage */
91 		*value = raw * ADC_CPU_VOLTAGE_SCALE;
92 		break;
93 	case 4: /* core current */
94 		*value = raw * ADC_CPU_CURRENT_SCALE;
95 		break;
96 	}
97 }
98 
99 static int wf_ad7417_adc_get(struct wf_sensor *sr, s32 *value)
100 {
101 	struct wf_ad7417_priv *pv = sr->priv;
102 	int chan = sr - pv->sensors;
103 	int i, rc;
104 	u8 buf[2];
105 	u16 raw;
106 
107 	*value = 0;
108 	mutex_lock(&pv->lock);
109 	for (i = 0; i < 10; i++) {
110 		/* Set channel */
111 		buf[0] = 1;
112 		buf[1] = (pv->config & 0x1f) | (chan << 5);
113 		rc = i2c_master_send(pv->i2c, buf, 2);
114 		if (rc < 0)
115 			goto error;
116 
117 		/* Wait for conversion */
118 		msleep(1);
119 
120 		/* Switch to data register */
121 		buf[0] = 4;
122 		rc = i2c_master_send(pv->i2c, buf, 1);
123 		if (rc < 0)
124 			goto error;
125 
126 		/* Read result */
127 		rc = i2c_master_recv(pv->i2c, buf, 2);
128 		if (rc < 0)
129 			goto error;
130 
131 		/* Read a a 16-bit signed value */
132 		raw = be16_to_cpup((__le16 *)buf) >> 6;
133 		wf_ad7417_adc_convert(pv, chan, raw, value);
134 
135 		dev_vdbg(&pv->i2c->dev, "ADC chan %d [%s]"
136 			 " raw value: 0x%x, conv to: 0x%08x\n",
137 			 chan, sr->name, raw, *value);
138 
139 		mutex_unlock(&pv->lock);
140 		return 0;
141 
142 	error:
143 		dev_dbg(&pv->i2c->dev,
144 			  "Error reading ADC, try %d...\n", i);
145 		if (i < 9)
146 			msleep(10);
147 	}
148 	mutex_unlock(&pv->lock);
149 	return -1;
150 }
151 
152 static void wf_ad7417_release(struct kref *ref)
153 {
154 	struct wf_ad7417_priv *pv = container_of(ref,
155 						 struct wf_ad7417_priv, ref);
156 	kfree(pv);
157 }
158 
159 static void wf_ad7417_sensor_release(struct wf_sensor *sr)
160 {
161 	struct wf_ad7417_priv *pv = sr->priv;
162 
163 	kfree(sr->name);
164 	kref_put(&pv->ref, wf_ad7417_release);
165 }
166 
167 static const struct wf_sensor_ops wf_ad7417_temp_ops = {
168 	.get_value	= wf_ad7417_temp_get,
169 	.release	= wf_ad7417_sensor_release,
170 	.owner		= THIS_MODULE,
171 };
172 
173 static const struct wf_sensor_ops wf_ad7417_adc_ops = {
174 	.get_value	= wf_ad7417_adc_get,
175 	.release	= wf_ad7417_sensor_release,
176 	.owner		= THIS_MODULE,
177 };
178 
179 static void wf_ad7417_add_sensor(struct wf_ad7417_priv *pv,
180 				 int index, const char *name,
181 				 const struct wf_sensor_ops *ops)
182 {
183 	pv->sensors[index].name = kasprintf(GFP_KERNEL, "%s-%d", name, pv->cpu);
184 	pv->sensors[index].priv = pv;
185 	pv->sensors[index].ops = ops;
186 	if (!wf_register_sensor(&pv->sensors[index]))
187 		kref_get(&pv->ref);
188 }
189 
190 static void wf_ad7417_init_chip(struct wf_ad7417_priv *pv)
191 {
192 	int rc;
193 	u8 buf[2];
194 	u8 config = 0;
195 
196 	/*
197 	 * Read ADC the configuration register and cache it. We
198 	 * also make sure Config2 contains proper values, I've seen
199 	 * cases where we got stale grabage in there, thus preventing
200 	 * proper reading of conv. values
201 	 */
202 
203 	/* Clear Config2 */
204 	buf[0] = 5;
205 	buf[1] = 0;
206 	i2c_master_send(pv->i2c, buf, 2);
207 
208 	/* Read & cache Config1 */
209 	buf[0] = 1;
210 	rc = i2c_master_send(pv->i2c, buf, 1);
211 	if (rc > 0) {
212 		rc = i2c_master_recv(pv->i2c, buf, 1);
213 		if (rc > 0) {
214 			config = buf[0];
215 
216 			dev_dbg(&pv->i2c->dev, "ADC config reg: %02x\n",
217 				config);
218 
219 			/* Disable shutdown mode */
220 			config &= 0xfe;
221 			buf[0] = 1;
222 			buf[1] = config;
223 			rc = i2c_master_send(pv->i2c, buf, 2);
224 		}
225 	}
226 	if (rc <= 0)
227 		dev_err(&pv->i2c->dev, "Error reading ADC config\n");
228 
229 	pv->config = config;
230 }
231 
232 static int wf_ad7417_probe(struct i2c_client *client,
233 			   const struct i2c_device_id *id)
234 {
235 	struct wf_ad7417_priv *pv;
236 	const struct mpu_data *mpu;
237 	const char *loc;
238 	int cpu_nr;
239 
240 	loc = of_get_property(client->dev.of_node, "hwsensor-location", NULL);
241 	if (!loc) {
242 		dev_warn(&client->dev, "Missing hwsensor-location property!\n");
243 		return -ENXIO;
244 	}
245 
246 	/*
247 	 * Identify which CPU we belong to by looking at the first entry
248 	 * in the hwsensor-location list
249 	 */
250 	if (!strncmp(loc, "CPU A", 5))
251 		cpu_nr = 0;
252 	else if (!strncmp(loc, "CPU B", 5))
253 		cpu_nr = 1;
254 	else {
255 		pr_err("wf_ad7417: Can't identify location %s\n", loc);
256 		return -ENXIO;
257 	}
258 	mpu = wf_get_mpu(cpu_nr);
259 	if (!mpu) {
260 		dev_err(&client->dev, "Failed to retrieve MPU data\n");
261 		return -ENXIO;
262 	}
263 
264 	pv = kzalloc(sizeof(struct wf_ad7417_priv), GFP_KERNEL);
265 	if (pv == NULL)
266 		return -ENODEV;
267 
268 	kref_init(&pv->ref);
269 	mutex_init(&pv->lock);
270 	pv->i2c = client;
271 	pv->cpu = cpu_nr;
272 	pv->mpu = mpu;
273 	dev_set_drvdata(&client->dev, pv);
274 
275 	/* Initialize the chip */
276 	wf_ad7417_init_chip(pv);
277 
278 	/*
279 	 * We cannot rely on Apple device-tree giving us child
280 	 * node with the names of the individual sensors so we
281 	 * just hard code what we know about them
282 	 */
283 	wf_ad7417_add_sensor(pv, 0, "cpu-amb-temp", &wf_ad7417_temp_ops);
284 	wf_ad7417_add_sensor(pv, 1, "cpu-diode-temp", &wf_ad7417_adc_ops);
285 	wf_ad7417_add_sensor(pv, 2, "cpu-12v-current", &wf_ad7417_adc_ops);
286 	wf_ad7417_add_sensor(pv, 3, "cpu-voltage", &wf_ad7417_adc_ops);
287 	wf_ad7417_add_sensor(pv, 4, "cpu-current", &wf_ad7417_adc_ops);
288 
289 	return 0;
290 }
291 
292 static int wf_ad7417_remove(struct i2c_client *client)
293 {
294 	struct wf_ad7417_priv *pv = dev_get_drvdata(&client->dev);
295 	int i;
296 
297 	/* Mark client detached */
298 	pv->i2c = NULL;
299 
300 	/* Release sensor */
301 	for (i = 0; i < 5; i++)
302 		wf_unregister_sensor(&pv->sensors[i]);
303 
304 	kref_put(&pv->ref, wf_ad7417_release);
305 
306 	return 0;
307 }
308 
309 static const struct i2c_device_id wf_ad7417_id[] = {
310 	{ "MAC,ad7417", 0 },
311 	{ }
312 };
313 MODULE_DEVICE_TABLE(i2c, wf_ad7417_id);
314 
315 static const struct of_device_id wf_ad7417_of_id[] = {
316 	{ .compatible = "ad7417", },
317 	{ }
318 };
319 MODULE_DEVICE_TABLE(of, wf_ad7417_of_id);
320 
321 static struct i2c_driver wf_ad7417_driver = {
322 	.driver = {
323 		.name	= "wf_ad7417",
324 		.of_match_table = wf_ad7417_of_id,
325 	},
326 	.probe		= wf_ad7417_probe,
327 	.remove		= wf_ad7417_remove,
328 	.id_table	= wf_ad7417_id,
329 };
330 
331 static int wf_ad7417_init(void)
332 {
333 	/* This is only supported on these machines */
334 	if (!of_machine_is_compatible("PowerMac7,2") &&
335 	    !of_machine_is_compatible("PowerMac7,3") &&
336 	    !of_machine_is_compatible("RackMac3,1"))
337 		return -ENODEV;
338 
339 	return i2c_add_driver(&wf_ad7417_driver);
340 }
341 
342 static void wf_ad7417_exit(void)
343 {
344 	i2c_del_driver(&wf_ad7417_driver);
345 }
346 
347 module_init(wf_ad7417_init);
348 module_exit(wf_ad7417_exit);
349 
350 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
351 MODULE_DESCRIPTION("ad7417 sensor driver for PowerMacs");
352 MODULE_LICENSE("GPL");
353 
354