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