GNU Linux-libre 4.4.289-gnu1
[releases.git] / drivers / macintosh / windfarm_smu_sat.c
1 /*
2  * Windfarm PowerMac thermal control.  SMU "satellite" controller sensors.
3  *
4  * Copyright (C) 2005 Paul Mackerras, IBM Corp. <paulus@samba.org>
5  *
6  * Released under the terms 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/slab.h>
13 #include <linux/init.h>
14 #include <linux/wait.h>
15 #include <linux/i2c.h>
16 #include <linux/mutex.h>
17 #include <asm/prom.h>
18 #include <asm/smu.h>
19 #include <asm/pmac_low_i2c.h>
20
21 #include "windfarm.h"
22
23 #define VERSION "1.0"
24
25 /* If the cache is older than 800ms we'll refetch it */
26 #define MAX_AGE         msecs_to_jiffies(800)
27
28 struct wf_sat {
29         struct kref             ref;
30         int                     nr;
31         struct mutex            mutex;
32         unsigned long           last_read; /* jiffies when cache last updated */
33         u8                      cache[16];
34         struct list_head        sensors;
35         struct i2c_client       *i2c;
36         struct device_node      *node;
37 };
38
39 static struct wf_sat *sats[2];
40
41 struct wf_sat_sensor {
42         struct list_head        link;
43         int                     index;
44         int                     index2;         /* used for power sensors */
45         int                     shift;
46         struct wf_sat           *sat;
47         struct wf_sensor        sens;
48 };
49
50 #define wf_to_sat(c)    container_of(c, struct wf_sat_sensor, sens)
51
52 struct smu_sdbp_header *smu_sat_get_sdb_partition(unsigned int sat_id, int id,
53                                                   unsigned int *size)
54 {
55         struct wf_sat *sat;
56         int err;
57         unsigned int i, len;
58         u8 *buf;
59         u8 data[4];
60
61         /* TODO: Add the resulting partition to the device-tree */
62
63         if (sat_id > 1 || (sat = sats[sat_id]) == NULL)
64                 return NULL;
65
66         err = i2c_smbus_write_word_data(sat->i2c, 8, id << 8);
67         if (err) {
68                 printk(KERN_ERR "smu_sat_get_sdb_part wr error %d\n", err);
69                 return NULL;
70         }
71
72         err = i2c_smbus_read_word_data(sat->i2c, 9);
73         if (err < 0) {
74                 printk(KERN_ERR "smu_sat_get_sdb_part rd len error\n");
75                 return NULL;
76         }
77         len = err;
78         if (len == 0) {
79                 printk(KERN_ERR "smu_sat_get_sdb_part no partition %x\n", id);
80                 return NULL;
81         }
82
83         len = le16_to_cpu(len);
84         len = (len + 3) & ~3;
85         buf = kmalloc(len, GFP_KERNEL);
86         if (buf == NULL)
87                 return NULL;
88
89         for (i = 0; i < len; i += 4) {
90                 err = i2c_smbus_read_i2c_block_data(sat->i2c, 0xa, 4, data);
91                 if (err < 0) {
92                         printk(KERN_ERR "smu_sat_get_sdb_part rd err %d\n",
93                                err);
94                         goto fail;
95                 }
96                 buf[i] = data[1];
97                 buf[i+1] = data[0];
98                 buf[i+2] = data[3];
99                 buf[i+3] = data[2];
100         }
101
102         printk(KERN_DEBUG "sat %d partition %x:", sat_id, id);
103         print_hex_dump(KERN_DEBUG, "  ", DUMP_PREFIX_OFFSET,
104                        16, 1, buf, len, false);
105         if (size)
106                 *size = len;
107         return (struct smu_sdbp_header *) buf;
108
109  fail:
110         kfree(buf);
111         return NULL;
112 }
113 EXPORT_SYMBOL_GPL(smu_sat_get_sdb_partition);
114
115 /* refresh the cache */
116 static int wf_sat_read_cache(struct wf_sat *sat)
117 {
118         int err;
119
120         err = i2c_smbus_read_i2c_block_data(sat->i2c, 0x3f, 16, sat->cache);
121         if (err < 0)
122                 return err;
123         sat->last_read = jiffies;
124
125 #ifdef LOTSA_DEBUG
126         {
127                 int i;
128                 printk(KERN_DEBUG "wf_sat_get: data is");
129                 print_hex_dump(KERN_DEBUG, "  ", DUMP_PREFIX_OFFSET,
130                                16, 1, sat->cache, 16, false);
131         }
132 #endif
133         return 0;
134 }
135
136 static int wf_sat_sensor_get(struct wf_sensor *sr, s32 *value)
137 {
138         struct wf_sat_sensor *sens = wf_to_sat(sr);
139         struct wf_sat *sat = sens->sat;
140         int i, err;
141         s32 val;
142
143         if (sat->i2c == NULL)
144                 return -ENODEV;
145
146         mutex_lock(&sat->mutex);
147         if (time_after(jiffies, (sat->last_read + MAX_AGE))) {
148                 err = wf_sat_read_cache(sat);
149                 if (err)
150                         goto fail;
151         }
152
153         i = sens->index * 2;
154         val = ((sat->cache[i] << 8) + sat->cache[i+1]) << sens->shift;
155         if (sens->index2 >= 0) {
156                 i = sens->index2 * 2;
157                 /* 4.12 * 8.8 -> 12.20; shift right 4 to get 16.16 */
158                 val = (val * ((sat->cache[i] << 8) + sat->cache[i+1])) >> 4;
159         }
160
161         *value = val;
162         err = 0;
163
164  fail:
165         mutex_unlock(&sat->mutex);
166         return err;
167 }
168
169 static void wf_sat_release(struct kref *ref)
170 {
171         struct wf_sat *sat = container_of(ref, struct wf_sat, ref);
172
173         if (sat->nr >= 0)
174                 sats[sat->nr] = NULL;
175         kfree(sat);
176 }
177
178 static void wf_sat_sensor_release(struct wf_sensor *sr)
179 {
180         struct wf_sat_sensor *sens = wf_to_sat(sr);
181         struct wf_sat *sat = sens->sat;
182
183         kfree(sens);
184         kref_put(&sat->ref, wf_sat_release);
185 }
186
187 static struct wf_sensor_ops wf_sat_ops = {
188         .get_value      = wf_sat_sensor_get,
189         .release        = wf_sat_sensor_release,
190         .owner          = THIS_MODULE,
191 };
192
193 static int wf_sat_probe(struct i2c_client *client,
194                         const struct i2c_device_id *id)
195 {
196         struct device_node *dev = client->dev.of_node;
197         struct wf_sat *sat;
198         struct wf_sat_sensor *sens;
199         const u32 *reg;
200         const char *loc, *type;
201         u8 chip, core;
202         struct device_node *child;
203         int shift, cpu, index;
204         char *name;
205         int vsens[2], isens[2];
206
207         sat = kzalloc(sizeof(struct wf_sat), GFP_KERNEL);
208         if (sat == NULL)
209                 return -ENOMEM;
210         sat->nr = -1;
211         sat->node = of_node_get(dev);
212         kref_init(&sat->ref);
213         mutex_init(&sat->mutex);
214         sat->i2c = client;
215         INIT_LIST_HEAD(&sat->sensors);
216         i2c_set_clientdata(client, sat);
217
218         vsens[0] = vsens[1] = -1;
219         isens[0] = isens[1] = -1;
220         child = NULL;
221         while ((child = of_get_next_child(dev, child)) != NULL) {
222                 reg = of_get_property(child, "reg", NULL);
223                 type = of_get_property(child, "device_type", NULL);
224                 loc = of_get_property(child, "location", NULL);
225                 if (reg == NULL || loc == NULL)
226                         continue;
227
228                 /* the cooked sensors are between 0x30 and 0x37 */
229                 if (*reg < 0x30 || *reg > 0x37)
230                         continue;
231                 index = *reg - 0x30;
232
233                 /* expect location to be CPU [AB][01] ... */
234                 if (strncmp(loc, "CPU ", 4) != 0)
235                         continue;
236                 chip = loc[4] - 'A';
237                 core = loc[5] - '0';
238                 if (chip > 1 || core > 1) {
239                         printk(KERN_ERR "wf_sat_create: don't understand "
240                                "location %s for %s\n", loc, child->full_name);
241                         continue;
242                 }
243                 cpu = 2 * chip + core;
244                 if (sat->nr < 0)
245                         sat->nr = chip;
246                 else if (sat->nr != chip) {
247                         printk(KERN_ERR "wf_sat_create: can't cope with "
248                                "multiple CPU chips on one SAT (%s)\n", loc);
249                         continue;
250                 }
251
252                 if (strcmp(type, "voltage-sensor") == 0) {
253                         name = "cpu-voltage";
254                         shift = 4;
255                         vsens[core] = index;
256                 } else if (strcmp(type, "current-sensor") == 0) {
257                         name = "cpu-current";
258                         shift = 8;
259                         isens[core] = index;
260                 } else if (strcmp(type, "temp-sensor") == 0) {
261                         name = "cpu-temp";
262                         shift = 10;
263                 } else
264                         continue;       /* hmmm shouldn't happen */
265
266                 /* the +16 is enough for "cpu-voltage-n" */
267                 sens = kzalloc(sizeof(struct wf_sat_sensor) + 16, GFP_KERNEL);
268                 if (sens == NULL) {
269                         printk(KERN_ERR "wf_sat_create: couldn't create "
270                                "%s sensor %d (no memory)\n", name, cpu);
271                         continue;
272                 }
273                 sens->index = index;
274                 sens->index2 = -1;
275                 sens->shift = shift;
276                 sens->sat = sat;
277                 sens->sens.ops = &wf_sat_ops;
278                 sens->sens.name = (char *) (sens + 1);
279                 snprintf((char *)sens->sens.name, 16, "%s-%d", name, cpu);
280
281                 if (wf_register_sensor(&sens->sens))
282                         kfree(sens);
283                 else {
284                         list_add(&sens->link, &sat->sensors);
285                         kref_get(&sat->ref);
286                 }
287         }
288
289         /* make the power sensors */
290         for (core = 0; core < 2; ++core) {
291                 if (vsens[core] < 0 || isens[core] < 0)
292                         continue;
293                 cpu = 2 * sat->nr + core;
294                 sens = kzalloc(sizeof(struct wf_sat_sensor) + 16, GFP_KERNEL);
295                 if (sens == NULL) {
296                         printk(KERN_ERR "wf_sat_create: couldn't create power "
297                                "sensor %d (no memory)\n", cpu);
298                         continue;
299                 }
300                 sens->index = vsens[core];
301                 sens->index2 = isens[core];
302                 sens->shift = 0;
303                 sens->sat = sat;
304                 sens->sens.ops = &wf_sat_ops;
305                 sens->sens.name = (char *) (sens + 1);
306                 snprintf((char *)sens->sens.name, 16, "cpu-power-%d", cpu);
307
308                 if (wf_register_sensor(&sens->sens))
309                         kfree(sens);
310                 else {
311                         list_add(&sens->link, &sat->sensors);
312                         kref_get(&sat->ref);
313                 }
314         }
315
316         if (sat->nr >= 0)
317                 sats[sat->nr] = sat;
318
319         return 0;
320 }
321
322 static int wf_sat_remove(struct i2c_client *client)
323 {
324         struct wf_sat *sat = i2c_get_clientdata(client);
325         struct wf_sat_sensor *sens;
326
327         /* release sensors */
328         while(!list_empty(&sat->sensors)) {
329                 sens = list_first_entry(&sat->sensors,
330                                         struct wf_sat_sensor, link);
331                 list_del(&sens->link);
332                 wf_unregister_sensor(&sens->sens);
333         }
334         sat->i2c = NULL;
335         kref_put(&sat->ref, wf_sat_release);
336
337         return 0;
338 }
339
340 static const struct i2c_device_id wf_sat_id[] = {
341         { "MAC,smu-sat", 0 },
342         { }
343 };
344 MODULE_DEVICE_TABLE(i2c, wf_sat_id);
345
346 static struct i2c_driver wf_sat_driver = {
347         .driver = {
348                 .name           = "wf_smu_sat",
349         },
350         .probe          = wf_sat_probe,
351         .remove         = wf_sat_remove,
352         .id_table       = wf_sat_id,
353 };
354
355 module_i2c_driver(wf_sat_driver);
356
357 MODULE_AUTHOR("Paul Mackerras <paulus@samba.org>");
358 MODULE_DESCRIPTION("SMU satellite sensors for PowerMac thermal control");
359 MODULE_LICENSE("GPL");