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
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
wf_ad7417_temp_get(struct wf_sensor * sr,s32 * value)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
wf_ad7417_adc_convert(struct wf_ad7417_priv * pv,int chan,s32 raw,s32 * value)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
wf_ad7417_adc_get(struct wf_sensor * sr,s32 * value)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
wf_ad7417_release(struct kref * ref)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
wf_ad7417_sensor_release(struct wf_sensor * sr)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
wf_ad7417_add_sensor(struct wf_ad7417_priv * pv,int index,const char * name,const struct wf_sensor_ops * ops)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
wf_ad7417_init_chip(struct wf_ad7417_priv * pv)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
wf_ad7417_probe(struct i2c_client * client)232 static int wf_ad7417_probe(struct i2c_client *client)
233 {
234 struct wf_ad7417_priv *pv;
235 const struct mpu_data *mpu;
236 const char *loc;
237 int cpu_nr;
238
239 loc = of_get_property(client->dev.of_node, "hwsensor-location", NULL);
240 if (!loc) {
241 dev_warn(&client->dev, "Missing hwsensor-location property!\n");
242 return -ENXIO;
243 }
244
245 /*
246 * Identify which CPU we belong to by looking at the first entry
247 * in the hwsensor-location list
248 */
249 if (!strncmp(loc, "CPU A", 5))
250 cpu_nr = 0;
251 else if (!strncmp(loc, "CPU B", 5))
252 cpu_nr = 1;
253 else {
254 pr_err("wf_ad7417: Can't identify location %s\n", loc);
255 return -ENXIO;
256 }
257 mpu = wf_get_mpu(cpu_nr);
258 if (!mpu) {
259 dev_err(&client->dev, "Failed to retrieve MPU data\n");
260 return -ENXIO;
261 }
262
263 pv = kzalloc(sizeof(struct wf_ad7417_priv), GFP_KERNEL);
264 if (pv == NULL)
265 return -ENODEV;
266
267 kref_init(&pv->ref);
268 mutex_init(&pv->lock);
269 pv->i2c = client;
270 pv->cpu = cpu_nr;
271 pv->mpu = mpu;
272 dev_set_drvdata(&client->dev, pv);
273
274 /* Initialize the chip */
275 wf_ad7417_init_chip(pv);
276
277 /*
278 * We cannot rely on Apple device-tree giving us child
279 * node with the names of the individual sensors so we
280 * just hard code what we know about them
281 */
282 wf_ad7417_add_sensor(pv, 0, "cpu-amb-temp", &wf_ad7417_temp_ops);
283 wf_ad7417_add_sensor(pv, 1, "cpu-diode-temp", &wf_ad7417_adc_ops);
284 wf_ad7417_add_sensor(pv, 2, "cpu-12v-current", &wf_ad7417_adc_ops);
285 wf_ad7417_add_sensor(pv, 3, "cpu-voltage", &wf_ad7417_adc_ops);
286 wf_ad7417_add_sensor(pv, 4, "cpu-current", &wf_ad7417_adc_ops);
287
288 return 0;
289 }
290
wf_ad7417_remove(struct i2c_client * client)291 static void wf_ad7417_remove(struct i2c_client *client)
292 {
293 struct wf_ad7417_priv *pv = dev_get_drvdata(&client->dev);
294 int i;
295
296 /* Mark client detached */
297 pv->i2c = NULL;
298
299 /* Release sensor */
300 for (i = 0; i < 5; i++)
301 wf_unregister_sensor(&pv->sensors[i]);
302
303 kref_put(&pv->ref, wf_ad7417_release);
304 }
305
306 static const struct i2c_device_id wf_ad7417_id[] = {
307 { "MAC,ad7417", 0 },
308 { }
309 };
310 MODULE_DEVICE_TABLE(i2c, wf_ad7417_id);
311
312 static const struct of_device_id wf_ad7417_of_id[] = {
313 { .compatible = "ad7417", },
314 { }
315 };
316 MODULE_DEVICE_TABLE(of, wf_ad7417_of_id);
317
318 static struct i2c_driver wf_ad7417_driver = {
319 .driver = {
320 .name = "wf_ad7417",
321 .of_match_table = wf_ad7417_of_id,
322 },
323 .probe = wf_ad7417_probe,
324 .remove = wf_ad7417_remove,
325 .id_table = wf_ad7417_id,
326 };
327
wf_ad7417_init(void)328 static int wf_ad7417_init(void)
329 {
330 /* This is only supported on these machines */
331 if (!of_machine_is_compatible("PowerMac7,2") &&
332 !of_machine_is_compatible("PowerMac7,3") &&
333 !of_machine_is_compatible("RackMac3,1"))
334 return -ENODEV;
335
336 return i2c_add_driver(&wf_ad7417_driver);
337 }
338
wf_ad7417_exit(void)339 static void wf_ad7417_exit(void)
340 {
341 i2c_del_driver(&wf_ad7417_driver);
342 }
343
344 module_init(wf_ad7417_init);
345 module_exit(wf_ad7417_exit);
346
347 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
348 MODULE_DESCRIPTION("ad7417 sensor driver for PowerMacs");
349 MODULE_LICENSE("GPL");
350
351