URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [macintosh/] [windfarm_smu_sensors.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * Windfarm PowerMac thermal control. SMU based sensors
 *
 * (c) Copyright 2005 Benjamin Herrenschmidt, IBM Corp.
 *                    <benh@kernel.crashing.org>
 *
 * Released under the term of the GNU GPL v2.
 */
 
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/wait.h>
#include <linux/completion.h>
#include <asm/prom.h>
#include <asm/machdep.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/sections.h>
#include <asm/smu.h>
 
#include "windfarm.h"
 
#define VERSION "0.2"
 
#undef DEBUG
 
#ifdef DEBUG
#define DBG(args...)    printk(args)
#else
#define DBG(args...)    do { } while(0)
#endif
 
/*
 * Various SMU "partitions" calibration objects for which we
 * keep pointers here for use by bits & pieces of the driver
 */
static struct smu_sdbp_cpuvcp *cpuvcp;
static int  cpuvcp_version;
static struct smu_sdbp_cpudiode *cpudiode;
static struct smu_sdbp_slotspow *slotspow;
static u8 *debugswitches;
 
/*
 * SMU basic sensors objects
 */
 
static LIST_HEAD(smu_ads);
 
struct smu_ad_sensor {
        struct list_head        link;
        u32                     reg;            /* index in SMU */
        struct wf_sensor        sens;
};
#define to_smu_ads(c) container_of(c, struct smu_ad_sensor, sens)
 
static void smu_ads_release(struct wf_sensor *sr)
{
        struct smu_ad_sensor *ads = to_smu_ads(sr);
 
        kfree(ads);
}
 
static int smu_read_adc(u8 id, s32 *value)
{
        struct smu_simple_cmd   cmd;
        DECLARE_COMPLETION_ONSTACK(comp);
        int rc;
 
        rc = smu_queue_simple(&cmd, SMU_CMD_READ_ADC, 1,
                              smu_done_complete, &comp, id);
        if (rc)
                return rc;
        wait_for_completion(&comp);
        if (cmd.cmd.status != 0)
                return cmd.cmd.status;
        if (cmd.cmd.reply_len != 2) {
                printk(KERN_ERR "winfarm: read ADC 0x%x returned %d bytes !\n",
                       id, cmd.cmd.reply_len);
                return -EIO;
        }
        *value = *((u16 *)cmd.buffer);
        return 0;
}
 
static int smu_cputemp_get(struct wf_sensor *sr, s32 *value)
{
        struct smu_ad_sensor *ads = to_smu_ads(sr);
        int rc;
        s32 val;
        s64 scaled;
 
        rc = smu_read_adc(ads->reg, &val);
        if (rc) {
                printk(KERN_ERR "windfarm: read CPU temp failed, err %d\n",
                       rc);
                return rc;
        }
 
        /* Ok, we have to scale & adjust, taking units into account */
        scaled = (s64)(((u64)val) * (u64)cpudiode->m_value);
        scaled >>= 3;
        scaled += ((s64)cpudiode->b_value) << 9;
        *value = (s32)(scaled << 1);
 
        return 0;
}
 
static int smu_cpuamp_get(struct wf_sensor *sr, s32 *value)
{
        struct smu_ad_sensor *ads = to_smu_ads(sr);
        s32 val, scaled;
        int rc;
 
        rc = smu_read_adc(ads->reg, &val);
        if (rc) {
                printk(KERN_ERR "windfarm: read CPU current failed, err %d\n",
                       rc);
                return rc;
        }
 
        /* Ok, we have to scale & adjust, taking units into account */
        scaled = (s32)(val * (u32)cpuvcp->curr_scale);
        scaled += (s32)cpuvcp->curr_offset;
        *value = scaled << 4;
 
        return 0;
}
 
static int smu_cpuvolt_get(struct wf_sensor *sr, s32 *value)
{
        struct smu_ad_sensor *ads = to_smu_ads(sr);
        s32 val, scaled;
        int rc;
 
        rc = smu_read_adc(ads->reg, &val);
        if (rc) {
                printk(KERN_ERR "windfarm: read CPU voltage failed, err %d\n",
                       rc);
                return rc;
        }
 
        /* Ok, we have to scale & adjust, taking units into account */
        scaled = (s32)(val * (u32)cpuvcp->volt_scale);
        scaled += (s32)cpuvcp->volt_offset;
        *value = scaled << 4;
 
        return 0;
}
 
static int smu_slotspow_get(struct wf_sensor *sr, s32 *value)
{
        struct smu_ad_sensor *ads = to_smu_ads(sr);
        s32 val, scaled;
        int rc;
 
        rc = smu_read_adc(ads->reg, &val);
        if (rc) {
                printk(KERN_ERR "windfarm: read slots power failed, err %d\n",
                       rc);
                return rc;
        }
 
        /* Ok, we have to scale & adjust, taking units into account */
        scaled = (s32)(val * (u32)slotspow->pow_scale);
        scaled += (s32)slotspow->pow_offset;
        *value = scaled << 4;
 
        return 0;
}
 
 
static struct wf_sensor_ops smu_cputemp_ops = {
        .get_value      = smu_cputemp_get,
        .release        = smu_ads_release,
        .owner          = THIS_MODULE,
};
static struct wf_sensor_ops smu_cpuamp_ops = {
        .get_value      = smu_cpuamp_get,
        .release        = smu_ads_release,
        .owner          = THIS_MODULE,
};
static struct wf_sensor_ops smu_cpuvolt_ops = {
        .get_value      = smu_cpuvolt_get,
        .release        = smu_ads_release,
        .owner          = THIS_MODULE,
};
static struct wf_sensor_ops smu_slotspow_ops = {
        .get_value      = smu_slotspow_get,
        .release        = smu_ads_release,
        .owner          = THIS_MODULE,
};
 
 
static struct smu_ad_sensor *smu_ads_create(struct device_node *node)
{
        struct smu_ad_sensor *ads;
        const char *c, *l;
        const u32 *v;
 
        ads = kmalloc(sizeof(struct smu_ad_sensor), GFP_KERNEL);
        if (ads == NULL)
                return NULL;
        c = of_get_property(node, "device_type", NULL);
        l = of_get_property(node, "location", NULL);
        if (c == NULL || l == NULL)
                goto fail;
 
        /* We currently pick the sensors based on the OF name and location
         * properties, while Darwin uses the sensor-id's.
         * The problem with the IDs is that they are model specific while it
         * looks like apple has been doing a reasonably good job at keeping
         * the names and locations consistents so I'll stick with the names
         * and locations for now.
         */
        if (!strcmp(c, "temp-sensor") &&
            !strcmp(l, "CPU T-Diode")) {
                ads->sens.ops = &smu_cputemp_ops;
                ads->sens.name = "cpu-temp";
                if (cpudiode == NULL) {
                        DBG("wf: cpudiode partition (%02x) not found\n",
                            SMU_SDB_CPUDIODE_ID);
                        goto fail;
                }
        } else if (!strcmp(c, "current-sensor") &&
                   !strcmp(l, "CPU Current")) {
                ads->sens.ops = &smu_cpuamp_ops;
                ads->sens.name = "cpu-current";
                if (cpuvcp == NULL) {
                        DBG("wf: cpuvcp partition (%02x) not found\n",
                            SMU_SDB_CPUVCP_ID);
                        goto fail;
                }
        } else if (!strcmp(c, "voltage-sensor") &&
                   !strcmp(l, "CPU Voltage")) {
                ads->sens.ops = &smu_cpuvolt_ops;
                ads->sens.name = "cpu-voltage";
                if (cpuvcp == NULL) {
                        DBG("wf: cpuvcp partition (%02x) not found\n",
                            SMU_SDB_CPUVCP_ID);
                        goto fail;
                }
        } else if (!strcmp(c, "power-sensor") &&
                   !strcmp(l, "Slots Power")) {
                ads->sens.ops = &smu_slotspow_ops;
                ads->sens.name = "slots-power";
                if (slotspow == NULL) {
                        DBG("wf: slotspow partition (%02x) not found\n",
                            SMU_SDB_SLOTSPOW_ID);
                        goto fail;
                }
        } else
                goto fail;
 
        v = of_get_property(node, "reg", NULL);
        if (v == NULL)
                goto fail;
        ads->reg = *v;
 
        if (wf_register_sensor(&ads->sens))
                goto fail;
        return ads;
 fail:
        kfree(ads);
        return NULL;
}
 
/*
 * SMU Power combo sensor object
 */
 
struct smu_cpu_power_sensor {
        struct list_head        link;
        struct wf_sensor        *volts;
        struct wf_sensor        *amps;
        int                     fake_volts : 1;
        int                     quadratic : 1;
        struct wf_sensor        sens;
};
#define to_smu_cpu_power(c) container_of(c, struct smu_cpu_power_sensor, sens)
 
static struct smu_cpu_power_sensor *smu_cpu_power;
 
static void smu_cpu_power_release(struct wf_sensor *sr)
{
        struct smu_cpu_power_sensor *pow = to_smu_cpu_power(sr);
 
        if (pow->volts)
                wf_put_sensor(pow->volts);
        if (pow->amps)
                wf_put_sensor(pow->amps);
        kfree(pow);
}
 
static int smu_cpu_power_get(struct wf_sensor *sr, s32 *value)
{
        struct smu_cpu_power_sensor *pow = to_smu_cpu_power(sr);
        s32 volts, amps, power;
        u64 tmps, tmpa, tmpb;
        int rc;
 
        rc = pow->amps->ops->get_value(pow->amps, &amps);
        if (rc)
                return rc;
 
        if (pow->fake_volts) {
                *value = amps * 12 - 0x30000;
                return 0;
        }
 
        rc = pow->volts->ops->get_value(pow->volts, &volts);
        if (rc)
                return rc;
 
        power = (s32)((((u64)volts) * ((u64)amps)) >> 16);
        if (!pow->quadratic) {
                *value = power;
                return 0;
        }
        tmps = (((u64)power) * ((u64)power)) >> 16;
        tmpa = ((u64)cpuvcp->power_quads[0]) * tmps;
        tmpb = ((u64)cpuvcp->power_quads[1]) * ((u64)power);
        *value = (tmpa >> 28) + (tmpb >> 28) + (cpuvcp->power_quads[2] >> 12);
 
        return 0;
}
 
static struct wf_sensor_ops smu_cpu_power_ops = {
        .get_value      = smu_cpu_power_get,
        .release        = smu_cpu_power_release,
        .owner          = THIS_MODULE,
};
 
 
static struct smu_cpu_power_sensor *
smu_cpu_power_create(struct wf_sensor *volts, struct wf_sensor *amps)
{
        struct smu_cpu_power_sensor *pow;
 
        pow = kmalloc(sizeof(struct smu_cpu_power_sensor), GFP_KERNEL);
        if (pow == NULL)
                return NULL;
        pow->sens.ops = &smu_cpu_power_ops;
        pow->sens.name = "cpu-power";
 
        wf_get_sensor(volts);
        pow->volts = volts;
        wf_get_sensor(amps);
        pow->amps = amps;
 
        /* Some early machines need a faked voltage */
        if (debugswitches && ((*debugswitches) & 0x80)) {
                printk(KERN_INFO "windfarm: CPU Power sensor using faked"
                       " voltage !\n");
                pow->fake_volts = 1;
        } else
                pow->fake_volts = 0;
 
        /* Try to use quadratic transforms on PowerMac8,1 and 9,1 for now,
         * I yet have to figure out what's up with 8,2 and will have to
         * adjust for later, unless we can 100% trust the SDB partition...
         */
        if ((machine_is_compatible("PowerMac8,1") ||
             machine_is_compatible("PowerMac8,2") ||
             machine_is_compatible("PowerMac9,1")) &&
            cpuvcp_version >= 2) {
                pow->quadratic = 1;
                DBG("windfarm: CPU Power using quadratic transform\n");
        } else
                pow->quadratic = 0;
 
        if (wf_register_sensor(&pow->sens))
                goto fail;
        return pow;
 fail:
        kfree(pow);
        return NULL;
}
 
static void smu_fetch_param_partitions(void)
{
        const struct smu_sdbp_header *hdr;
 
        /* Get CPU voltage/current/power calibration data */
        hdr = smu_get_sdb_partition(SMU_SDB_CPUVCP_ID, NULL);
        if (hdr != NULL) {
                cpuvcp = (struct smu_sdbp_cpuvcp *)&hdr[1];
                /* Keep version around */
                cpuvcp_version = hdr->version;
        }
 
        /* Get CPU diode calibration data */
        hdr = smu_get_sdb_partition(SMU_SDB_CPUDIODE_ID, NULL);
        if (hdr != NULL)
                cpudiode = (struct smu_sdbp_cpudiode *)&hdr[1];
 
        /* Get slots power calibration data if any */
        hdr = smu_get_sdb_partition(SMU_SDB_SLOTSPOW_ID, NULL);
        if (hdr != NULL)
                slotspow = (struct smu_sdbp_slotspow *)&hdr[1];
 
        /* Get debug switches if any */
        hdr = smu_get_sdb_partition(SMU_SDB_DEBUG_SWITCHES_ID, NULL);
        if (hdr != NULL)
                debugswitches = (u8 *)&hdr[1];
}
 
static int __init smu_sensors_init(void)
{
        struct device_node *smu, *sensors, *s;
        struct smu_ad_sensor *volt_sensor = NULL, *curr_sensor = NULL;
 
        if (!smu_present())
                return -ENODEV;
 
        /* Get parameters partitions */
        smu_fetch_param_partitions();
 
        smu = of_find_node_by_type(NULL, "smu");
        if (smu == NULL)
                return -ENODEV;
 
        /* Look for sensors subdir */
        for (sensors = NULL;
             (sensors = of_get_next_child(smu, sensors)) != NULL;)
                if (!strcmp(sensors->name, "sensors"))
                        break;
 
        of_node_put(smu);
 
        /* Create basic sensors */
        for (s = NULL;
             sensors && (s = of_get_next_child(sensors, s)) != NULL;) {
                struct smu_ad_sensor *ads;
 
                ads = smu_ads_create(s);
                if (ads == NULL)
                        continue;
                list_add(&ads->link, &smu_ads);
                /* keep track of cpu voltage & current */
                if (!strcmp(ads->sens.name, "cpu-voltage"))
                        volt_sensor = ads;
                else if (!strcmp(ads->sens.name, "cpu-current"))
                        curr_sensor = ads;
        }
 
        of_node_put(sensors);
 
        /* Create CPU power sensor if possible */
        if (volt_sensor && curr_sensor)
                smu_cpu_power = smu_cpu_power_create(&volt_sensor->sens,
                                                     &curr_sensor->sens);
 
        return 0;
}
 
static void __exit smu_sensors_exit(void)
{
        struct smu_ad_sensor *ads;
 
        /* dispose of power sensor */
        if (smu_cpu_power)
                wf_unregister_sensor(&smu_cpu_power->sens);
 
        /* dispose of basic sensors */
        while (!list_empty(&smu_ads)) {
                ads = list_entry(smu_ads.next, struct smu_ad_sensor, link);
                list_del(&ads->link);
                wf_unregister_sensor(&ads->sens);
        }
}
 
 
module_init(smu_sensors_init);
module_exit(smu_sensors_exit);
 
MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
MODULE_DESCRIPTION("SMU sensor objects for PowerMacs thermal control");
MODULE_LICENSE("GPL");
 

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [macintosh/] [windfarm_smu_sensors.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* Windfarm PowerMac thermal control. SMU based sensors`
3			`*`
4			`* (c) Copyright 2005 Benjamin Herrenschmidt, IBM Corp.`
5			`* <benh@kernel.crashing.org>`
6			`*`
7			`* Released under the term of the GNU GPL v2.`
8			`*/`
9
10			`#include <linux/types.h>`
11			`#include <linux/errno.h>`
12			`#include <linux/kernel.h>`
13			`#include <linux/delay.h>`
14			`#include <linux/slab.h>`
15			`#include <linux/init.h>`
16			`#include <linux/wait.h>`
17			`#include <linux/completion.h>`
18			`#include <asm/prom.h>`
19			`#include <asm/machdep.h>`
20			`#include <asm/io.h>`
21			`#include <asm/system.h>`
22			`#include <asm/sections.h>`
23			`#include <asm/smu.h>`
24
25			`#include "windfarm.h"`
26
27			`#define VERSION "0.2"`
28
29			`#undef DEBUG`
30
31			`#ifdef DEBUG`
32			`#define DBG(args...) printk(args)`
33			`#else`
34			`#define DBG(args...) do { } while(0)`
35			`#endif`
36
37			`/*`
38			`* Various SMU "partitions" calibration objects for which we`
39			`* keep pointers here for use by bits & pieces of the driver`
40			`*/`
41			`static struct smu_sdbp_cpuvcp *cpuvcp;`
42			`static int cpuvcp_version;`
43			`static struct smu_sdbp_cpudiode *cpudiode;`
44			`static struct smu_sdbp_slotspow *slotspow;`
45			`static u8 *debugswitches;`
46
47			`/*`
48			`* SMU basic sensors objects`
49			`*/`
50
51			`static LIST_HEAD(smu_ads);`
52
53			`struct smu_ad_sensor {`
54			`struct list_head link;`
55			`u32 reg; /* index in SMU */`
56			`struct wf_sensor sens;`
57			`};`
58			`#define to_smu_ads(c) container_of(c, struct smu_ad_sensor, sens)`
59
60			`static void smu_ads_release(struct wf_sensor *sr)`
61			`{`
62			`struct smu_ad_sensor *ads = to_smu_ads(sr);`
63
64			`kfree(ads);`
65			`}`
66
67			`static int smu_read_adc(u8 id, s32 *value)`
68			`{`
69			`struct smu_simple_cmd cmd;`
70			`DECLARE_COMPLETION_ONSTACK(comp);`
71			`int rc;`
72
73			`rc = smu_queue_simple(&cmd, SMU_CMD_READ_ADC, 1,`
74			`smu_done_complete, &comp, id);`
75			`if (rc)`
76			`return rc;`
77			`wait_for_completion(&comp);`
78			`if (cmd.cmd.status != 0)`
79			`return cmd.cmd.status;`
80			`if (cmd.cmd.reply_len != 2) {`
81			`printk(KERN_ERR "winfarm: read ADC 0x%x returned %d bytes !\n",`
82			`id, cmd.cmd.reply_len);`
83			`return -EIO;`
84			`}`
85			`value = ((u16 *)cmd.buffer);`
86			`return 0;`
87			`}`
88
89			`static int smu_cputemp_get(struct wf_sensor sr, s32 value)`
90			`{`
91			`struct smu_ad_sensor *ads = to_smu_ads(sr);`
92			`int rc;`
93			`s32 val;`
94			`s64 scaled;`
95
96			`rc = smu_read_adc(ads->reg, &val);`
97			`if (rc) {`
98			`printk(KERN_ERR "windfarm: read CPU temp failed, err %d\n",`
99			`rc);`
100			`return rc;`
101			`}`
102
103			`/* Ok, we have to scale & adjust, taking units into account */`
104			`scaled = (s64)(((u64)val) * (u64)cpudiode->m_value);`
105			`scaled >>= 3;`
106			`scaled += ((s64)cpudiode->b_value) << 9;`
107			`*value = (s32)(scaled << 1);`
108
109			`return 0;`
110			`}`
111
112			`static int smu_cpuamp_get(struct wf_sensor sr, s32 value)`
113			`{`
114			`struct smu_ad_sensor *ads = to_smu_ads(sr);`
115			`s32 val, scaled;`
116			`int rc;`
117
118			`rc = smu_read_adc(ads->reg, &val);`
119			`if (rc) {`
120			`printk(KERN_ERR "windfarm: read CPU current failed, err %d\n",`
121			`rc);`
122			`return rc;`
123			`}`
124
125			`/* Ok, we have to scale & adjust, taking units into account */`
126			`scaled = (s32)(val * (u32)cpuvcp->curr_scale);`
127			`scaled += (s32)cpuvcp->curr_offset;`
128			`*value = scaled << 4;`
129
130			`return 0;`
131			`}`
132
133			`static int smu_cpuvolt_get(struct wf_sensor sr, s32 value)`
134			`{`
135			`struct smu_ad_sensor *ads = to_smu_ads(sr);`
136			`s32 val, scaled;`
137			`int rc;`
138
139			`rc = smu_read_adc(ads->reg, &val);`
140			`if (rc) {`
141			`printk(KERN_ERR "windfarm: read CPU voltage failed, err %d\n",`
142			`rc);`
143			`return rc;`
144			`}`
145
146			`/* Ok, we have to scale & adjust, taking units into account */`
147			`scaled = (s32)(val * (u32)cpuvcp->volt_scale);`
148			`scaled += (s32)cpuvcp->volt_offset;`
149			`*value = scaled << 4;`
150
151			`return 0;`
152			`}`
153
154			`static int smu_slotspow_get(struct wf_sensor sr, s32 value)`
155			`{`
156			`struct smu_ad_sensor *ads = to_smu_ads(sr);`
157			`s32 val, scaled;`
158			`int rc;`
159
160			`rc = smu_read_adc(ads->reg, &val);`
161			`if (rc) {`
162			`printk(KERN_ERR "windfarm: read slots power failed, err %d\n",`
163			`rc);`
164			`return rc;`
165			`}`
166
167			`/* Ok, we have to scale & adjust, taking units into account */`
168			`scaled = (s32)(val * (u32)slotspow->pow_scale);`
169			`scaled += (s32)slotspow->pow_offset;`
170			`*value = scaled << 4;`
171
172			`return 0;`
173			`}`
174
175
176			`static struct wf_sensor_ops smu_cputemp_ops = {`
177			`.get_value = smu_cputemp_get,`
178			`.release = smu_ads_release,`
179			`.owner = THIS_MODULE,`
180			`};`
181			`static struct wf_sensor_ops smu_cpuamp_ops = {`
182			`.get_value = smu_cpuamp_get,`
183			`.release = smu_ads_release,`
184			`.owner = THIS_MODULE,`
185			`};`
186			`static struct wf_sensor_ops smu_cpuvolt_ops = {`
187			`.get_value = smu_cpuvolt_get,`
188			`.release = smu_ads_release,`
189			`.owner = THIS_MODULE,`
190			`};`
191			`static struct wf_sensor_ops smu_slotspow_ops = {`
192			`.get_value = smu_slotspow_get,`
193			`.release = smu_ads_release,`
194			`.owner = THIS_MODULE,`
195			`};`
196
197
198			`static struct smu_ad_sensor smu_ads_create(struct device_node node)`
199			`{`
200			`struct smu_ad_sensor *ads;`
201			`const char c, l;`
202			`const u32 *v;`
203
204			`ads = kmalloc(sizeof(struct smu_ad_sensor), GFP_KERNEL);`
205			`if (ads == NULL)`
206			`return NULL;`
207			`c = of_get_property(node, "device_type", NULL);`
208			`l = of_get_property(node, "location", NULL);`
209			`if (c == NULL \|\| l == NULL)`
210			`goto fail;`
211
212			`/* We currently pick the sensors based on the OF name and location`
213			`* properties, while Darwin uses the sensor-id's.`
214			`* The problem with the IDs is that they are model specific while it`
215			`* looks like apple has been doing a reasonably good job at keeping`
216			`* the names and locations consistents so I'll stick with the names`
217			`* and locations for now.`
218			`*/`
219			`if (!strcmp(c, "temp-sensor") &&`
220			`!strcmp(l, "CPU T-Diode")) {`
221			`ads->sens.ops = &smu_cputemp_ops;`
222			`ads->sens.name = "cpu-temp";`
223			`if (cpudiode == NULL) {`
224			`DBG("wf: cpudiode partition (%02x) not found\n",`
225			`SMU_SDB_CPUDIODE_ID);`
226			`goto fail;`
227			`}`
228			`} else if (!strcmp(c, "current-sensor") &&`
229			`!strcmp(l, "CPU Current")) {`
230			`ads->sens.ops = &smu_cpuamp_ops;`
231			`ads->sens.name = "cpu-current";`
232			`if (cpuvcp == NULL) {`
233			`DBG("wf: cpuvcp partition (%02x) not found\n",`
234			`SMU_SDB_CPUVCP_ID);`
235			`goto fail;`
236			`}`
237			`} else if (!strcmp(c, "voltage-sensor") &&`
238			`!strcmp(l, "CPU Voltage")) {`
239			`ads->sens.ops = &smu_cpuvolt_ops;`
240			`ads->sens.name = "cpu-voltage";`
241			`if (cpuvcp == NULL) {`
242			`DBG("wf: cpuvcp partition (%02x) not found\n",`
243			`SMU_SDB_CPUVCP_ID);`
244			`goto fail;`
245			`}`
246			`} else if (!strcmp(c, "power-sensor") &&`
247			`!strcmp(l, "Slots Power")) {`
248			`ads->sens.ops = &smu_slotspow_ops;`
249			`ads->sens.name = "slots-power";`
250			`if (slotspow == NULL) {`
251			`DBG("wf: slotspow partition (%02x) not found\n",`
252			`SMU_SDB_SLOTSPOW_ID);`
253			`goto fail;`
254			`}`
255			`} else`
256			`goto fail;`
257
258			`v = of_get_property(node, "reg", NULL);`
259			`if (v == NULL)`
260			`goto fail;`
261			`ads->reg = *v;`
262
263			`if (wf_register_sensor(&ads->sens))`
264			`goto fail;`
265			`return ads;`
266			`fail:`
267			`kfree(ads);`
268			`return NULL;`
269			`}`
270
271			`/*`
272			`* SMU Power combo sensor object`
273			`*/`
274
275			`struct smu_cpu_power_sensor {`
276			`struct list_head link;`
277			`struct wf_sensor *volts;`
278			`struct wf_sensor *amps;`
279			`int fake_volts : 1;`
280			`int quadratic : 1;`
281			`struct wf_sensor sens;`
282			`};`
283			`#define to_smu_cpu_power(c) container_of(c, struct smu_cpu_power_sensor, sens)`
284
285			`static struct smu_cpu_power_sensor *smu_cpu_power;`
286
287			`static void smu_cpu_power_release(struct wf_sensor *sr)`
288			`{`
289			`struct smu_cpu_power_sensor *pow = to_smu_cpu_power(sr);`
290
291			`if (pow->volts)`
292			`wf_put_sensor(pow->volts);`
293			`if (pow->amps)`
294			`wf_put_sensor(pow->amps);`
295			`kfree(pow);`
296			`}`
297
298			`static int smu_cpu_power_get(struct wf_sensor sr, s32 value)`
299			`{`
300			`struct smu_cpu_power_sensor *pow = to_smu_cpu_power(sr);`
301			`s32 volts, amps, power;`
302			`u64 tmps, tmpa, tmpb;`
303			`int rc;`
304
305			`rc = pow->amps->ops->get_value(pow->amps, &amps);`
306			`if (rc)`
307			`return rc;`
308
309			`if (pow->fake_volts) {`
310			`value = amps 12 - 0x30000;`
311			`return 0;`
312			`}`
313
314			`rc = pow->volts->ops->get_value(pow->volts, &volts);`
315			`if (rc)`
316			`return rc;`
317
318			`power = (s32)((((u64)volts) * ((u64)amps)) >> 16);`
319			`if (!pow->quadratic) {`
320			`*value = power;`
321			`return 0;`
322			`}`
323			`tmps = (((u64)power) * ((u64)power)) >> 16;`
324			`tmpa = ((u64)cpuvcp->power_quads[0]) * tmps;`
325			`tmpb = ((u64)cpuvcp->power_quads[1]) * ((u64)power);`
326			`*value = (tmpa >> 28) + (tmpb >> 28) + (cpuvcp->power_quads[2] >> 12);`
327
328			`return 0;`
329			`}`
330
331			`static struct wf_sensor_ops smu_cpu_power_ops = {`
332			`.get_value = smu_cpu_power_get,`
333			`.release = smu_cpu_power_release,`
334			`.owner = THIS_MODULE,`
335			`};`
336
337
338			`static struct smu_cpu_power_sensor *`
339			`smu_cpu_power_create(struct wf_sensor volts, struct wf_sensor amps)`
340			`{`
341			`struct smu_cpu_power_sensor *pow;`
342
343			`pow = kmalloc(sizeof(struct smu_cpu_power_sensor), GFP_KERNEL);`
344			`if (pow == NULL)`
345			`return NULL;`
346			`pow->sens.ops = &smu_cpu_power_ops;`
347			`pow->sens.name = "cpu-power";`
348
349			`wf_get_sensor(volts);`
350			`pow->volts = volts;`
351			`wf_get_sensor(amps);`
352			`pow->amps = amps;`
353
354			`/* Some early machines need a faked voltage */`
355			`if (debugswitches && ((*debugswitches) & 0x80)) {`
356			`printk(KERN_INFO "windfarm: CPU Power sensor using faked"`
357			`" voltage !\n");`
358			`pow->fake_volts = 1;`
359			`} else`
360			`pow->fake_volts = 0;`
361
362			`/* Try to use quadratic transforms on PowerMac8,1 and 9,1 for now,`
363			`* I yet have to figure out what's up with 8,2 and will have to`
364			`* adjust for later, unless we can 100% trust the SDB partition...`
365			`*/`
366			`if ((machine_is_compatible("PowerMac8,1") \|\|`
367			`machine_is_compatible("PowerMac8,2") \|\|`
368			`machine_is_compatible("PowerMac9,1")) &&`
369			`cpuvcp_version >= 2) {`
370			`pow->quadratic = 1;`
371			`DBG("windfarm: CPU Power using quadratic transform\n");`
372			`} else`
373			`pow->quadratic = 0;`
374
375			`if (wf_register_sensor(&pow->sens))`
376			`goto fail;`
377			`return pow;`
378			`fail:`
379			`kfree(pow);`
380			`return NULL;`
381			`}`
382
383			`static void smu_fetch_param_partitions(void)`
384			`{`
385			`const struct smu_sdbp_header *hdr;`
386
387			`/* Get CPU voltage/current/power calibration data */`
388			`hdr = smu_get_sdb_partition(SMU_SDB_CPUVCP_ID, NULL);`
389			`if (hdr != NULL) {`
390			`cpuvcp = (struct smu_sdbp_cpuvcp *)&hdr[1];`
391			`/* Keep version around */`
392			`cpuvcp_version = hdr->version;`
393			`}`
394
395			`/* Get CPU diode calibration data */`
396			`hdr = smu_get_sdb_partition(SMU_SDB_CPUDIODE_ID, NULL);`
397			`if (hdr != NULL)`
398			`cpudiode = (struct smu_sdbp_cpudiode *)&hdr[1];`
399
400			`/* Get slots power calibration data if any */`
401			`hdr = smu_get_sdb_partition(SMU_SDB_SLOTSPOW_ID, NULL);`
402			`if (hdr != NULL)`
403			`slotspow = (struct smu_sdbp_slotspow *)&hdr[1];`
404
405			`/* Get debug switches if any */`
406			`hdr = smu_get_sdb_partition(SMU_SDB_DEBUG_SWITCHES_ID, NULL);`
407			`if (hdr != NULL)`
408			`debugswitches = (u8 *)&hdr[1];`
409			`}`
410
411			`static int __init smu_sensors_init(void)`
412			`{`
413			`struct device_node smu, sensors, *s;`
414			`struct smu_ad_sensor volt_sensor = NULL, curr_sensor = NULL;`
415
416			`if (!smu_present())`
417			`return -ENODEV;`
418
419			`/* Get parameters partitions */`
420			`smu_fetch_param_partitions();`
421
422			`smu = of_find_node_by_type(NULL, "smu");`
423			`if (smu == NULL)`
424			`return -ENODEV;`
425
426			`/* Look for sensors subdir */`
427			`for (sensors = NULL;`
428			`(sensors = of_get_next_child(smu, sensors)) != NULL;)`
429			`if (!strcmp(sensors->name, "sensors"))`
430			`break;`
431
432			`of_node_put(smu);`
433
434			`/* Create basic sensors */`
435			`for (s = NULL;`
436			`sensors && (s = of_get_next_child(sensors, s)) != NULL;) {`
437			`struct smu_ad_sensor *ads;`
438
439			`ads = smu_ads_create(s);`
440			`if (ads == NULL)`
441			`continue;`
442			`list_add(&ads->link, &smu_ads);`
443			`/* keep track of cpu voltage & current */`
444			`if (!strcmp(ads->sens.name, "cpu-voltage"))`
445			`volt_sensor = ads;`
446			`else if (!strcmp(ads->sens.name, "cpu-current"))`
447			`curr_sensor = ads;`
448			`}`
449
450			`of_node_put(sensors);`
451
452			`/* Create CPU power sensor if possible */`
453			`if (volt_sensor && curr_sensor)`
454			`smu_cpu_power = smu_cpu_power_create(&volt_sensor->sens,`
455			`&curr_sensor->sens);`
456
457			`return 0;`
458			`}`
459
460			`static void __exit smu_sensors_exit(void)`
461			`{`
462			`struct smu_ad_sensor *ads;`
463
464			`/* dispose of power sensor */`
465			`if (smu_cpu_power)`
466			`wf_unregister_sensor(&smu_cpu_power->sens);`
467
468			`/* dispose of basic sensors */`
469			`while (!list_empty(&smu_ads)) {`
470			`ads = list_entry(smu_ads.next, struct smu_ad_sensor, link);`
471			`list_del(&ads->link);`
472			`wf_unregister_sensor(&ads->sens);`
473			`}`
474			`}`
475
476
477			`module_init(smu_sensors_init);`
478			`module_exit(smu_sensors_exit);`
479
480			`MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");`
481			`MODULE_DESCRIPTION("SMU sensor objects for PowerMacs thermal control");`
482			`MODULE_LICENSE("GPL");`
483