Root/drivers/macintosh/windfarm_ad7417_sensor.c

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

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive