1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* envctrl.c: Temperature and Fan monitoring on Machines providing it. |
3 | * |
4 | * Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be) |
5 | * Copyright (C) 2000 Vinh Truong (vinh.truong@eng.sun.com) |
6 | * VT - The implementation is to support Sun Microelectronics (SME) platform |
7 | * environment monitoring. SME platforms use pcf8584 as the i2c bus |
8 | * controller to access pcf8591 (8-bit A/D and D/A converter) and |
9 | * pcf8571 (256 x 8-bit static low-voltage RAM with I2C-bus interface). |
10 | * At board level, it follows SME Firmware I2C Specification. Reference: |
11 | * http://www-eu2.semiconductors.com/pip/PCF8584P |
12 | * http://www-eu2.semiconductors.com/pip/PCF8574AP |
13 | * http://www-eu2.semiconductors.com/pip/PCF8591P |
14 | * |
15 | * EB - Added support for CP1500 Global Address and PS/Voltage monitoring. |
16 | * Eric Brower <ebrower@usa.net> |
17 | * |
18 | * DB - Audit every copy_to_user in envctrl_read. |
19 | * Daniele Bellucci <bellucda@tiscali.it> |
20 | */ |
21 | |
22 | #include <linux/module.h> |
23 | #include <linux/kthread.h> |
24 | #include <linux/delay.h> |
25 | #include <linux/ioport.h> |
26 | #include <linux/miscdevice.h> |
27 | #include <linux/kmod.h> |
28 | #include <linux/reboot.h> |
29 | #include <linux/slab.h> |
30 | #include <linux/of.h> |
31 | #include <linux/platform_device.h> |
32 | |
33 | #include <linux/uaccess.h> |
34 | #include <asm/envctrl.h> |
35 | #include <asm/io.h> |
36 | |
37 | #define DRIVER_NAME "envctrl" |
38 | #define PFX DRIVER_NAME ": " |
39 | |
40 | #define PCF8584_ADDRESS 0x55 |
41 | |
42 | #define CONTROL_PIN 0x80 |
43 | #define CONTROL_ES0 0x40 |
44 | #define CONTROL_ES1 0x20 |
45 | #define CONTROL_ES2 0x10 |
46 | #define CONTROL_ENI 0x08 |
47 | #define CONTROL_STA 0x04 |
48 | #define CONTROL_STO 0x02 |
49 | #define CONTROL_ACK 0x01 |
50 | |
51 | #define STATUS_PIN 0x80 |
52 | #define STATUS_STS 0x20 |
53 | #define STATUS_BER 0x10 |
54 | #define STATUS_LRB 0x08 |
55 | #define STATUS_AD0 0x08 |
56 | #define STATUS_AAB 0x04 |
57 | #define STATUS_LAB 0x02 |
58 | #define STATUS_BB 0x01 |
59 | |
60 | /* |
61 | * CLK Mode Register. |
62 | */ |
63 | #define BUS_CLK_90 0x00 |
64 | #define BUS_CLK_45 0x01 |
65 | #define BUS_CLK_11 0x02 |
66 | #define BUS_CLK_1_5 0x03 |
67 | |
68 | #define CLK_3 0x00 |
69 | #define CLK_4_43 0x10 |
70 | #define CLK_6 0x14 |
71 | #define CLK_8 0x18 |
72 | #define CLK_12 0x1c |
73 | |
74 | #define OBD_SEND_START 0xc5 /* value to generate I2c_bus START condition */ |
75 | #define OBD_SEND_STOP 0xc3 /* value to generate I2c_bus STOP condition */ |
76 | |
77 | /* Monitor type of i2c child device. |
78 | * Firmware definitions. |
79 | */ |
80 | #define PCF8584_MAX_CHANNELS 8 |
81 | #define PCF8584_GLOBALADDR_TYPE 6 /* global address monitor */ |
82 | #define PCF8584_FANSTAT_TYPE 3 /* fan status monitor */ |
83 | #define PCF8584_VOLTAGE_TYPE 2 /* voltage monitor */ |
84 | #define PCF8584_TEMP_TYPE 1 /* temperature monitor*/ |
85 | |
86 | /* Monitor type of i2c child device. |
87 | * Driver definitions. |
88 | */ |
89 | #define ENVCTRL_NOMON 0 |
90 | #define ENVCTRL_CPUTEMP_MON 1 /* cpu temperature monitor */ |
91 | #define ENVCTRL_CPUVOLTAGE_MON 2 /* voltage monitor */ |
92 | #define ENVCTRL_FANSTAT_MON 3 /* fan status monitor */ |
93 | #define ENVCTRL_ETHERTEMP_MON 4 /* ethernet temperature */ |
94 | /* monitor */ |
95 | #define ENVCTRL_VOLTAGESTAT_MON 5 /* voltage status monitor */ |
96 | #define ENVCTRL_MTHRBDTEMP_MON 6 /* motherboard temperature */ |
97 | #define ENVCTRL_SCSITEMP_MON 7 /* scsi temperature */ |
98 | #define ENVCTRL_GLOBALADDR_MON 8 /* global address */ |
99 | |
100 | /* Child device type. |
101 | * Driver definitions. |
102 | */ |
103 | #define I2C_ADC 0 /* pcf8591 */ |
104 | #define I2C_GPIO 1 /* pcf8571 */ |
105 | |
106 | /* Data read from child device may need to decode |
107 | * through a data table and a scale. |
108 | * Translation type as defined by firmware. |
109 | */ |
110 | #define ENVCTRL_TRANSLATE_NO 0 |
111 | #define ENVCTRL_TRANSLATE_PARTIAL 1 |
112 | #define ENVCTRL_TRANSLATE_COMBINED 2 |
113 | #define ENVCTRL_TRANSLATE_FULL 3 /* table[data] */ |
114 | #define ENVCTRL_TRANSLATE_SCALE 4 /* table[data]/scale */ |
115 | |
116 | /* Driver miscellaneous definitions. */ |
117 | #define ENVCTRL_MAX_CPU 4 |
118 | #define CHANNEL_DESC_SZ 256 |
119 | |
120 | /* Mask values for combined GlobalAddress/PowerStatus node */ |
121 | #define ENVCTRL_GLOBALADDR_ADDR_MASK 0x1F |
122 | #define ENVCTRL_GLOBALADDR_PSTAT_MASK 0x60 |
123 | |
124 | /* Node 0x70 ignored on CompactPCI CP1400/1500 platforms |
125 | * (see envctrl_init_i2c_child) |
126 | */ |
127 | #define ENVCTRL_CPCI_IGNORED_NODE 0x70 |
128 | |
129 | #define PCF8584_DATA 0x00 |
130 | #define PCF8584_CSR 0x01 |
131 | |
132 | /* Each child device can be monitored by up to PCF8584_MAX_CHANNELS. |
133 | * Property of a port or channel as defined by the firmware. |
134 | */ |
135 | struct pcf8584_channel { |
136 | unsigned char chnl_no; |
137 | unsigned char io_direction; |
138 | unsigned char type; |
139 | unsigned char last; |
140 | }; |
141 | |
142 | /* Each child device may have one or more tables of bytes to help decode |
143 | * data. Table property as defined by the firmware. |
144 | */ |
145 | struct pcf8584_tblprop { |
146 | unsigned int type; |
147 | unsigned int scale; |
148 | unsigned int offset; /* offset from the beginning of the table */ |
149 | unsigned int size; |
150 | }; |
151 | |
152 | /* i2c child */ |
153 | struct i2c_child_t { |
154 | /* Either ADC or GPIO. */ |
155 | unsigned char i2ctype; |
156 | unsigned long addr; |
157 | struct pcf8584_channel chnl_array[PCF8584_MAX_CHANNELS]; |
158 | |
159 | /* Channel info. */ |
160 | unsigned int total_chnls; /* Number of monitor channels. */ |
161 | unsigned char fan_mask; /* Byte mask for fan status channels. */ |
162 | unsigned char voltage_mask; /* Byte mask for voltage status channels. */ |
163 | struct pcf8584_tblprop tblprop_array[PCF8584_MAX_CHANNELS]; |
164 | |
165 | /* Properties of all monitor channels. */ |
166 | unsigned int total_tbls; /* Number of monitor tables. */ |
167 | char *tables; /* Pointer to table(s). */ |
168 | char chnls_desc[CHANNEL_DESC_SZ]; /* Channel description. */ |
169 | char mon_type[PCF8584_MAX_CHANNELS]; |
170 | }; |
171 | |
172 | static void __iomem *i2c; |
173 | static struct i2c_child_t i2c_childlist[ENVCTRL_MAX_CPU*2]; |
174 | static unsigned char chnls_mask[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 }; |
175 | static unsigned int warning_temperature = 0; |
176 | static unsigned int shutdown_temperature = 0; |
177 | static char read_cpu; |
178 | |
179 | /* Forward declarations. */ |
180 | static struct i2c_child_t *envctrl_get_i2c_child(unsigned char); |
181 | |
182 | /* Function Description: Test the PIN bit (Pending Interrupt Not) |
183 | * to test when serial transmission is completed . |
184 | * Return : None. |
185 | */ |
186 | static void envtrl_i2c_test_pin(void) |
187 | { |
188 | int limit = 1000000; |
189 | |
190 | while (--limit > 0) { |
191 | if (!(readb(addr: i2c + PCF8584_CSR) & STATUS_PIN)) |
192 | break; |
193 | udelay(1); |
194 | } |
195 | |
196 | if (limit <= 0) |
197 | printk(KERN_INFO PFX "Pin status will not clear.\n" ); |
198 | } |
199 | |
200 | /* Function Description: Test busy bit. |
201 | * Return : None. |
202 | */ |
203 | static void envctrl_i2c_test_bb(void) |
204 | { |
205 | int limit = 1000000; |
206 | |
207 | while (--limit > 0) { |
208 | /* Busy bit 0 means busy. */ |
209 | if (readb(addr: i2c + PCF8584_CSR) & STATUS_BB) |
210 | break; |
211 | udelay(1); |
212 | } |
213 | |
214 | if (limit <= 0) |
215 | printk(KERN_INFO PFX "Busy bit will not clear.\n" ); |
216 | } |
217 | |
218 | /* Function Description: Send the address for a read access. |
219 | * Return : 0 if not acknowledged, otherwise acknowledged. |
220 | */ |
221 | static int envctrl_i2c_read_addr(unsigned char addr) |
222 | { |
223 | envctrl_i2c_test_bb(); |
224 | |
225 | /* Load address. */ |
226 | writeb(val: addr + 1, addr: i2c + PCF8584_DATA); |
227 | |
228 | envctrl_i2c_test_bb(); |
229 | |
230 | writeb(OBD_SEND_START, addr: i2c + PCF8584_CSR); |
231 | |
232 | /* Wait for PIN. */ |
233 | envtrl_i2c_test_pin(); |
234 | |
235 | /* CSR 0 means acknowledged. */ |
236 | if (!(readb(addr: i2c + PCF8584_CSR) & STATUS_LRB)) { |
237 | return readb(addr: i2c + PCF8584_DATA); |
238 | } else { |
239 | writeb(OBD_SEND_STOP, addr: i2c + PCF8584_CSR); |
240 | return 0; |
241 | } |
242 | } |
243 | |
244 | /* Function Description: Send the address for write mode. |
245 | * Return : None. |
246 | */ |
247 | static void envctrl_i2c_write_addr(unsigned char addr) |
248 | { |
249 | envctrl_i2c_test_bb(); |
250 | writeb(val: addr, addr: i2c + PCF8584_DATA); |
251 | |
252 | /* Generate Start condition. */ |
253 | writeb(OBD_SEND_START, addr: i2c + PCF8584_CSR); |
254 | } |
255 | |
256 | /* Function Description: Read 1 byte of data from addr |
257 | * set by envctrl_i2c_read_addr() |
258 | * Return : Data from address set by envctrl_i2c_read_addr(). |
259 | */ |
260 | static unsigned char envctrl_i2c_read_data(void) |
261 | { |
262 | envtrl_i2c_test_pin(); |
263 | writeb(CONTROL_ES0, addr: i2c + PCF8584_CSR); /* Send neg ack. */ |
264 | return readb(addr: i2c + PCF8584_DATA); |
265 | } |
266 | |
267 | /* Function Description: Instruct the device which port to read data from. |
268 | * Return : None. |
269 | */ |
270 | static void envctrl_i2c_write_data(unsigned char port) |
271 | { |
272 | envtrl_i2c_test_pin(); |
273 | writeb(val: port, addr: i2c + PCF8584_DATA); |
274 | } |
275 | |
276 | /* Function Description: Generate Stop condition after last byte is sent. |
277 | * Return : None. |
278 | */ |
279 | static void envctrl_i2c_stop(void) |
280 | { |
281 | envtrl_i2c_test_pin(); |
282 | writeb(OBD_SEND_STOP, addr: i2c + PCF8584_CSR); |
283 | } |
284 | |
285 | /* Function Description: Read adc device. |
286 | * Return : Data at address and port. |
287 | */ |
288 | static unsigned char envctrl_i2c_read_8591(unsigned char addr, unsigned char port) |
289 | { |
290 | /* Send address. */ |
291 | envctrl_i2c_write_addr(addr); |
292 | |
293 | /* Setup port to read. */ |
294 | envctrl_i2c_write_data(port); |
295 | envctrl_i2c_stop(); |
296 | |
297 | /* Read port. */ |
298 | envctrl_i2c_read_addr(addr); |
299 | |
300 | /* Do a single byte read and send stop. */ |
301 | envctrl_i2c_read_data(); |
302 | envctrl_i2c_stop(); |
303 | |
304 | return readb(addr: i2c + PCF8584_DATA); |
305 | } |
306 | |
307 | /* Function Description: Read gpio device. |
308 | * Return : Data at address. |
309 | */ |
310 | static unsigned char envctrl_i2c_read_8574(unsigned char addr) |
311 | { |
312 | unsigned char rd; |
313 | |
314 | envctrl_i2c_read_addr(addr); |
315 | |
316 | /* Do a single byte read and send stop. */ |
317 | rd = envctrl_i2c_read_data(); |
318 | envctrl_i2c_stop(); |
319 | return rd; |
320 | } |
321 | |
322 | /* Function Description: Decode data read from an adc device using firmware |
323 | * table. |
324 | * Return: Number of read bytes. Data is stored in bufdata in ascii format. |
325 | */ |
326 | static int envctrl_i2c_data_translate(unsigned char data, int translate_type, |
327 | int scale, char *tbl, char *bufdata) |
328 | { |
329 | int len = 0; |
330 | |
331 | switch (translate_type) { |
332 | case ENVCTRL_TRANSLATE_NO: |
333 | /* No decode necessary. */ |
334 | len = 1; |
335 | bufdata[0] = data; |
336 | break; |
337 | |
338 | case ENVCTRL_TRANSLATE_FULL: |
339 | /* Decode this way: data = table[data]. */ |
340 | len = 1; |
341 | bufdata[0] = tbl[data]; |
342 | break; |
343 | |
344 | case ENVCTRL_TRANSLATE_SCALE: |
345 | /* Decode this way: data = table[data]/scale */ |
346 | sprintf(buf: bufdata,fmt: "%d " , (tbl[data] * 10) / (scale)); |
347 | len = strlen(bufdata); |
348 | bufdata[len - 1] = bufdata[len - 2]; |
349 | bufdata[len - 2] = '.'; |
350 | break; |
351 | |
352 | default: |
353 | break; |
354 | } |
355 | |
356 | return len; |
357 | } |
358 | |
359 | /* Function Description: Read cpu-related data such as cpu temperature, voltage. |
360 | * Return: Number of read bytes. Data is stored in bufdata in ascii format. |
361 | */ |
362 | static int envctrl_read_cpu_info(int cpu, struct i2c_child_t *pchild, |
363 | char mon_type, unsigned char *bufdata) |
364 | { |
365 | unsigned char data; |
366 | int i, j = -1; |
367 | char *tbl; |
368 | |
369 | /* Find the right monitor type and channel. */ |
370 | for (i = 0; i < PCF8584_MAX_CHANNELS; i++) { |
371 | if (pchild->mon_type[i] == mon_type) { |
372 | if (++j == cpu) { |
373 | break; |
374 | } |
375 | } |
376 | } |
377 | |
378 | if (j != cpu) |
379 | return 0; |
380 | |
381 | /* Read data from address and port. */ |
382 | data = envctrl_i2c_read_8591(addr: (unsigned char)pchild->addr, |
383 | port: (unsigned char)pchild->chnl_array[i].chnl_no); |
384 | |
385 | /* Find decoding table. */ |
386 | tbl = pchild->tables + pchild->tblprop_array[i].offset; |
387 | |
388 | return envctrl_i2c_data_translate(data, translate_type: pchild->tblprop_array[i].type, |
389 | scale: pchild->tblprop_array[i].scale, |
390 | tbl, bufdata); |
391 | } |
392 | |
393 | /* Function Description: Read noncpu-related data such as motherboard |
394 | * temperature. |
395 | * Return: Number of read bytes. Data is stored in bufdata in ascii format. |
396 | */ |
397 | static int envctrl_read_noncpu_info(struct i2c_child_t *pchild, |
398 | char mon_type, unsigned char *bufdata) |
399 | { |
400 | unsigned char data; |
401 | int i; |
402 | char *tbl = NULL; |
403 | |
404 | for (i = 0; i < PCF8584_MAX_CHANNELS; i++) { |
405 | if (pchild->mon_type[i] == mon_type) |
406 | break; |
407 | } |
408 | |
409 | if (i >= PCF8584_MAX_CHANNELS) |
410 | return 0; |
411 | |
412 | /* Read data from address and port. */ |
413 | data = envctrl_i2c_read_8591(addr: (unsigned char)pchild->addr, |
414 | port: (unsigned char)pchild->chnl_array[i].chnl_no); |
415 | |
416 | /* Find decoding table. */ |
417 | tbl = pchild->tables + pchild->tblprop_array[i].offset; |
418 | |
419 | return envctrl_i2c_data_translate(data, translate_type: pchild->tblprop_array[i].type, |
420 | scale: pchild->tblprop_array[i].scale, |
421 | tbl, bufdata); |
422 | } |
423 | |
424 | /* Function Description: Read fan status. |
425 | * Return : Always 1 byte. Status stored in bufdata. |
426 | */ |
427 | static int envctrl_i2c_fan_status(struct i2c_child_t *pchild, |
428 | unsigned char data, |
429 | char *bufdata) |
430 | { |
431 | unsigned char tmp, ret = 0; |
432 | int i, j = 0; |
433 | |
434 | tmp = data & pchild->fan_mask; |
435 | |
436 | if (tmp == pchild->fan_mask) { |
437 | /* All bits are on. All fans are functioning. */ |
438 | ret = ENVCTRL_ALL_FANS_GOOD; |
439 | } else if (tmp == 0) { |
440 | /* No bits are on. No fans are functioning. */ |
441 | ret = ENVCTRL_ALL_FANS_BAD; |
442 | } else { |
443 | /* Go through all channels, mark 'on' the matched bits. |
444 | * Notice that fan_mask may have discontiguous bits but |
445 | * return mask are always contiguous. For example if we |
446 | * monitor 4 fans at channels 0,1,2,4, the return mask |
447 | * should be 00010000 if only fan at channel 4 is working. |
448 | */ |
449 | for (i = 0; i < PCF8584_MAX_CHANNELS;i++) { |
450 | if (pchild->fan_mask & chnls_mask[i]) { |
451 | if (!(chnls_mask[i] & tmp)) |
452 | ret |= chnls_mask[j]; |
453 | |
454 | j++; |
455 | } |
456 | } |
457 | } |
458 | |
459 | bufdata[0] = ret; |
460 | return 1; |
461 | } |
462 | |
463 | /* Function Description: Read global addressing line. |
464 | * Return : Always 1 byte. Status stored in bufdata. |
465 | */ |
466 | static int envctrl_i2c_globaladdr(struct i2c_child_t *pchild, |
467 | unsigned char data, |
468 | char *bufdata) |
469 | { |
470 | /* Translatation table is not necessary, as global |
471 | * addr is the integer value of the GA# bits. |
472 | * |
473 | * NOTE: MSB is documented as zero, but I see it as '1' always.... |
474 | * |
475 | * ----------------------------------------------- |
476 | * | 0 | FAL | DEG | GA4 | GA3 | GA2 | GA1 | GA0 | |
477 | * ----------------------------------------------- |
478 | * GA0 - GA4 integer value of Global Address (backplane slot#) |
479 | * DEG 0 = cPCI Power supply output is starting to degrade |
480 | * 1 = cPCI Power supply output is OK |
481 | * FAL 0 = cPCI Power supply has failed |
482 | * 1 = cPCI Power supply output is OK |
483 | */ |
484 | bufdata[0] = (data & ENVCTRL_GLOBALADDR_ADDR_MASK); |
485 | return 1; |
486 | } |
487 | |
488 | /* Function Description: Read standard voltage and power supply status. |
489 | * Return : Always 1 byte. Status stored in bufdata. |
490 | */ |
491 | static unsigned char envctrl_i2c_voltage_status(struct i2c_child_t *pchild, |
492 | unsigned char data, |
493 | char *bufdata) |
494 | { |
495 | unsigned char tmp, ret = 0; |
496 | int i, j = 0; |
497 | |
498 | tmp = data & pchild->voltage_mask; |
499 | |
500 | /* Two channels are used to monitor voltage and power supply. */ |
501 | if (tmp == pchild->voltage_mask) { |
502 | /* All bits are on. Voltage and power supply are okay. */ |
503 | ret = ENVCTRL_VOLTAGE_POWERSUPPLY_GOOD; |
504 | } else if (tmp == 0) { |
505 | /* All bits are off. Voltage and power supply are bad */ |
506 | ret = ENVCTRL_VOLTAGE_POWERSUPPLY_BAD; |
507 | } else { |
508 | /* Either voltage or power supply has problem. */ |
509 | for (i = 0; i < PCF8584_MAX_CHANNELS; i++) { |
510 | if (pchild->voltage_mask & chnls_mask[i]) { |
511 | j++; |
512 | |
513 | /* Break out when there is a mismatch. */ |
514 | if (!(chnls_mask[i] & tmp)) |
515 | break; |
516 | } |
517 | } |
518 | |
519 | /* Make a wish that hardware will always use the |
520 | * first channel for voltage and the second for |
521 | * power supply. |
522 | */ |
523 | if (j == 1) |
524 | ret = ENVCTRL_VOLTAGE_BAD; |
525 | else |
526 | ret = ENVCTRL_POWERSUPPLY_BAD; |
527 | } |
528 | |
529 | bufdata[0] = ret; |
530 | return 1; |
531 | } |
532 | |
533 | /* Function Description: Read a byte from /dev/envctrl. Mapped to user read(). |
534 | * Return: Number of read bytes. 0 for error. |
535 | */ |
536 | static ssize_t |
537 | envctrl_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) |
538 | { |
539 | struct i2c_child_t *pchild; |
540 | unsigned char data[10]; |
541 | int ret = 0; |
542 | |
543 | /* Get the type of read as decided in ioctl() call. |
544 | * Find the appropriate i2c child. |
545 | * Get the data and put back to the user buffer. |
546 | */ |
547 | |
548 | switch ((int)(long)file->private_data) { |
549 | case ENVCTRL_RD_WARNING_TEMPERATURE: |
550 | if (warning_temperature == 0) |
551 | return 0; |
552 | |
553 | data[0] = (unsigned char)(warning_temperature); |
554 | ret = 1; |
555 | if (copy_to_user(to: buf, from: data, n: ret)) |
556 | ret = -EFAULT; |
557 | break; |
558 | |
559 | case ENVCTRL_RD_SHUTDOWN_TEMPERATURE: |
560 | if (shutdown_temperature == 0) |
561 | return 0; |
562 | |
563 | data[0] = (unsigned char)(shutdown_temperature); |
564 | ret = 1; |
565 | if (copy_to_user(to: buf, from: data, n: ret)) |
566 | ret = -EFAULT; |
567 | break; |
568 | |
569 | case ENVCTRL_RD_MTHRBD_TEMPERATURE: |
570 | if (!(pchild = envctrl_get_i2c_child(ENVCTRL_MTHRBDTEMP_MON))) |
571 | return 0; |
572 | ret = envctrl_read_noncpu_info(pchild, ENVCTRL_MTHRBDTEMP_MON, bufdata: data); |
573 | if (copy_to_user(to: buf, from: data, n: ret)) |
574 | ret = -EFAULT; |
575 | break; |
576 | |
577 | case ENVCTRL_RD_CPU_TEMPERATURE: |
578 | if (!(pchild = envctrl_get_i2c_child(ENVCTRL_CPUTEMP_MON))) |
579 | return 0; |
580 | ret = envctrl_read_cpu_info(cpu: read_cpu, pchild, ENVCTRL_CPUTEMP_MON, bufdata: data); |
581 | |
582 | /* Reset cpu to the default cpu0. */ |
583 | if (copy_to_user(to: buf, from: data, n: ret)) |
584 | ret = -EFAULT; |
585 | break; |
586 | |
587 | case ENVCTRL_RD_CPU_VOLTAGE: |
588 | if (!(pchild = envctrl_get_i2c_child(ENVCTRL_CPUVOLTAGE_MON))) |
589 | return 0; |
590 | ret = envctrl_read_cpu_info(cpu: read_cpu, pchild, ENVCTRL_CPUVOLTAGE_MON, bufdata: data); |
591 | |
592 | /* Reset cpu to the default cpu0. */ |
593 | if (copy_to_user(to: buf, from: data, n: ret)) |
594 | ret = -EFAULT; |
595 | break; |
596 | |
597 | case ENVCTRL_RD_SCSI_TEMPERATURE: |
598 | if (!(pchild = envctrl_get_i2c_child(ENVCTRL_SCSITEMP_MON))) |
599 | return 0; |
600 | ret = envctrl_read_noncpu_info(pchild, ENVCTRL_SCSITEMP_MON, bufdata: data); |
601 | if (copy_to_user(to: buf, from: data, n: ret)) |
602 | ret = -EFAULT; |
603 | break; |
604 | |
605 | case ENVCTRL_RD_ETHERNET_TEMPERATURE: |
606 | if (!(pchild = envctrl_get_i2c_child(ENVCTRL_ETHERTEMP_MON))) |
607 | return 0; |
608 | ret = envctrl_read_noncpu_info(pchild, ENVCTRL_ETHERTEMP_MON, bufdata: data); |
609 | if (copy_to_user(to: buf, from: data, n: ret)) |
610 | ret = -EFAULT; |
611 | break; |
612 | |
613 | case ENVCTRL_RD_FAN_STATUS: |
614 | if (!(pchild = envctrl_get_i2c_child(ENVCTRL_FANSTAT_MON))) |
615 | return 0; |
616 | data[0] = envctrl_i2c_read_8574(addr: pchild->addr); |
617 | ret = envctrl_i2c_fan_status(pchild,data: data[0], bufdata: data); |
618 | if (copy_to_user(to: buf, from: data, n: ret)) |
619 | ret = -EFAULT; |
620 | break; |
621 | |
622 | case ENVCTRL_RD_GLOBALADDRESS: |
623 | if (!(pchild = envctrl_get_i2c_child(ENVCTRL_GLOBALADDR_MON))) |
624 | return 0; |
625 | data[0] = envctrl_i2c_read_8574(addr: pchild->addr); |
626 | ret = envctrl_i2c_globaladdr(pchild, data: data[0], bufdata: data); |
627 | if (copy_to_user(to: buf, from: data, n: ret)) |
628 | ret = -EFAULT; |
629 | break; |
630 | |
631 | case ENVCTRL_RD_VOLTAGE_STATUS: |
632 | if (!(pchild = envctrl_get_i2c_child(ENVCTRL_VOLTAGESTAT_MON))) |
633 | /* If voltage monitor not present, check for CPCI equivalent */ |
634 | if (!(pchild = envctrl_get_i2c_child(ENVCTRL_GLOBALADDR_MON))) |
635 | return 0; |
636 | data[0] = envctrl_i2c_read_8574(addr: pchild->addr); |
637 | ret = envctrl_i2c_voltage_status(pchild, data: data[0], bufdata: data); |
638 | if (copy_to_user(to: buf, from: data, n: ret)) |
639 | ret = -EFAULT; |
640 | break; |
641 | |
642 | default: |
643 | break; |
644 | |
645 | } |
646 | |
647 | return ret; |
648 | } |
649 | |
650 | /* Function Description: Command what to read. Mapped to user ioctl(). |
651 | * Return: Gives 0 for implemented commands, -EINVAL otherwise. |
652 | */ |
653 | static long |
654 | envctrl_ioctl(struct file *file, unsigned int cmd, unsigned long arg) |
655 | { |
656 | char __user *infobuf; |
657 | |
658 | switch (cmd) { |
659 | case ENVCTRL_RD_WARNING_TEMPERATURE: |
660 | case ENVCTRL_RD_SHUTDOWN_TEMPERATURE: |
661 | case ENVCTRL_RD_MTHRBD_TEMPERATURE: |
662 | case ENVCTRL_RD_FAN_STATUS: |
663 | case ENVCTRL_RD_VOLTAGE_STATUS: |
664 | case ENVCTRL_RD_ETHERNET_TEMPERATURE: |
665 | case ENVCTRL_RD_SCSI_TEMPERATURE: |
666 | case ENVCTRL_RD_GLOBALADDRESS: |
667 | file->private_data = (void *)(long)cmd; |
668 | break; |
669 | |
670 | case ENVCTRL_RD_CPU_TEMPERATURE: |
671 | case ENVCTRL_RD_CPU_VOLTAGE: |
672 | /* Check to see if application passes in any cpu number, |
673 | * the default is cpu0. |
674 | */ |
675 | infobuf = (char __user *) arg; |
676 | if (infobuf == NULL) { |
677 | read_cpu = 0; |
678 | }else { |
679 | get_user(read_cpu, infobuf); |
680 | } |
681 | |
682 | /* Save the command for use when reading. */ |
683 | file->private_data = (void *)(long)cmd; |
684 | break; |
685 | |
686 | default: |
687 | return -EINVAL; |
688 | } |
689 | |
690 | return 0; |
691 | } |
692 | |
693 | /* Function Description: open device. Mapped to user open(). |
694 | * Return: Always 0. |
695 | */ |
696 | static int |
697 | envctrl_open(struct inode *inode, struct file *file) |
698 | { |
699 | file->private_data = NULL; |
700 | return 0; |
701 | } |
702 | |
703 | /* Function Description: Open device. Mapped to user close(). |
704 | * Return: Always 0. |
705 | */ |
706 | static int |
707 | envctrl_release(struct inode *inode, struct file *file) |
708 | { |
709 | return 0; |
710 | } |
711 | |
712 | static const struct file_operations envctrl_fops = { |
713 | .owner = THIS_MODULE, |
714 | .read = envctrl_read, |
715 | .unlocked_ioctl = envctrl_ioctl, |
716 | .compat_ioctl = compat_ptr_ioctl, |
717 | .open = envctrl_open, |
718 | .release = envctrl_release, |
719 | .llseek = noop_llseek, |
720 | }; |
721 | |
722 | static struct miscdevice envctrl_dev = { |
723 | ENVCTRL_MINOR, |
724 | "envctrl" , |
725 | &envctrl_fops |
726 | }; |
727 | |
728 | /* Function Description: Set monitor type based on firmware description. |
729 | * Return: None. |
730 | */ |
731 | static void envctrl_set_mon(struct i2c_child_t *pchild, |
732 | const char *chnl_desc, |
733 | int chnl_no) |
734 | { |
735 | /* Firmware only has temperature type. It does not distinguish |
736 | * different kinds of temperatures. We use channel description |
737 | * to disinguish them. |
738 | */ |
739 | if (!(strcmp(chnl_desc,"temp,cpu" )) || |
740 | !(strcmp(chnl_desc,"temp,cpu0" )) || |
741 | !(strcmp(chnl_desc,"temp,cpu1" )) || |
742 | !(strcmp(chnl_desc,"temp,cpu2" )) || |
743 | !(strcmp(chnl_desc,"temp,cpu3" ))) |
744 | pchild->mon_type[chnl_no] = ENVCTRL_CPUTEMP_MON; |
745 | |
746 | if (!(strcmp(chnl_desc,"vddcore,cpu0" )) || |
747 | !(strcmp(chnl_desc,"vddcore,cpu1" )) || |
748 | !(strcmp(chnl_desc,"vddcore,cpu2" )) || |
749 | !(strcmp(chnl_desc,"vddcore,cpu3" ))) |
750 | pchild->mon_type[chnl_no] = ENVCTRL_CPUVOLTAGE_MON; |
751 | |
752 | if (!(strcmp(chnl_desc,"temp,motherboard" ))) |
753 | pchild->mon_type[chnl_no] = ENVCTRL_MTHRBDTEMP_MON; |
754 | |
755 | if (!(strcmp(chnl_desc,"temp,scsi" ))) |
756 | pchild->mon_type[chnl_no] = ENVCTRL_SCSITEMP_MON; |
757 | |
758 | if (!(strcmp(chnl_desc,"temp,ethernet" ))) |
759 | pchild->mon_type[chnl_no] = ENVCTRL_ETHERTEMP_MON; |
760 | } |
761 | |
762 | /* Function Description: Initialize monitor channel with channel desc, |
763 | * decoding tables, monitor type, optional properties. |
764 | * Return: None. |
765 | */ |
766 | static void envctrl_init_adc(struct i2c_child_t *pchild, struct device_node *dp) |
767 | { |
768 | int i = 0, len; |
769 | const char *pos; |
770 | const unsigned int *pval; |
771 | |
772 | /* Firmware describe channels into a stream separated by a '\0'. */ |
773 | pos = of_get_property(node: dp, name: "channels-description" , lenp: &len); |
774 | |
775 | while (len > 0) { |
776 | int l = strlen(pos) + 1; |
777 | envctrl_set_mon(pchild, chnl_desc: pos, chnl_no: i++); |
778 | len -= l; |
779 | pos += l; |
780 | } |
781 | |
782 | /* Get optional properties. */ |
783 | pval = of_get_property(node: dp, name: "warning-temp" , NULL); |
784 | if (pval) |
785 | warning_temperature = *pval; |
786 | |
787 | pval = of_get_property(node: dp, name: "shutdown-temp" , NULL); |
788 | if (pval) |
789 | shutdown_temperature = *pval; |
790 | } |
791 | |
792 | /* Function Description: Initialize child device monitoring fan status. |
793 | * Return: None. |
794 | */ |
795 | static void envctrl_init_fanstat(struct i2c_child_t *pchild) |
796 | { |
797 | int i; |
798 | |
799 | /* Go through all channels and set up the mask. */ |
800 | for (i = 0; i < pchild->total_chnls; i++) |
801 | pchild->fan_mask |= chnls_mask[(pchild->chnl_array[i]).chnl_no]; |
802 | |
803 | /* We only need to know if this child has fan status monitored. |
804 | * We don't care which channels since we have the mask already. |
805 | */ |
806 | pchild->mon_type[0] = ENVCTRL_FANSTAT_MON; |
807 | } |
808 | |
809 | /* Function Description: Initialize child device for global addressing line. |
810 | * Return: None. |
811 | */ |
812 | static void envctrl_init_globaladdr(struct i2c_child_t *pchild) |
813 | { |
814 | int i; |
815 | |
816 | /* Voltage/PowerSupply monitoring is piggybacked |
817 | * with Global Address on CompactPCI. See comments |
818 | * within envctrl_i2c_globaladdr for bit assignments. |
819 | * |
820 | * The mask is created here by assigning mask bits to each |
821 | * bit position that represents PCF8584_VOLTAGE_TYPE data. |
822 | * Channel numbers are not consecutive within the globaladdr |
823 | * node (why?), so we use the actual counter value as chnls_mask |
824 | * index instead of the chnl_array[x].chnl_no value. |
825 | * |
826 | * NOTE: This loop could be replaced with a constant representing |
827 | * a mask of bits 5&6 (ENVCTRL_GLOBALADDR_PSTAT_MASK). |
828 | */ |
829 | for (i = 0; i < pchild->total_chnls; i++) { |
830 | if (PCF8584_VOLTAGE_TYPE == pchild->chnl_array[i].type) { |
831 | pchild->voltage_mask |= chnls_mask[i]; |
832 | } |
833 | } |
834 | |
835 | /* We only need to know if this child has global addressing |
836 | * line monitored. We don't care which channels since we know |
837 | * the mask already (ENVCTRL_GLOBALADDR_ADDR_MASK). |
838 | */ |
839 | pchild->mon_type[0] = ENVCTRL_GLOBALADDR_MON; |
840 | } |
841 | |
842 | /* Initialize child device monitoring voltage status. */ |
843 | static void envctrl_init_voltage_status(struct i2c_child_t *pchild) |
844 | { |
845 | int i; |
846 | |
847 | /* Go through all channels and set up the mask. */ |
848 | for (i = 0; i < pchild->total_chnls; i++) |
849 | pchild->voltage_mask |= chnls_mask[(pchild->chnl_array[i]).chnl_no]; |
850 | |
851 | /* We only need to know if this child has voltage status monitored. |
852 | * We don't care which channels since we have the mask already. |
853 | */ |
854 | pchild->mon_type[0] = ENVCTRL_VOLTAGESTAT_MON; |
855 | } |
856 | |
857 | /* Function Description: Initialize i2c child device. |
858 | * Return: None. |
859 | */ |
860 | static void envctrl_init_i2c_child(struct device_node *dp, |
861 | struct i2c_child_t *pchild) |
862 | { |
863 | int len, i, tbls_size = 0; |
864 | const void *pval; |
865 | |
866 | /* Get device address. */ |
867 | pval = of_get_property(node: dp, name: "reg" , lenp: &len); |
868 | memcpy(&pchild->addr, pval, len); |
869 | |
870 | /* Get tables property. Read firmware temperature tables. */ |
871 | pval = of_get_property(node: dp, name: "translation" , lenp: &len); |
872 | if (pval && len > 0) { |
873 | memcpy(pchild->tblprop_array, pval, len); |
874 | pchild->total_tbls = len / sizeof(struct pcf8584_tblprop); |
875 | for (i = 0; i < pchild->total_tbls; i++) { |
876 | if ((pchild->tblprop_array[i].size + pchild->tblprop_array[i].offset) > tbls_size) { |
877 | tbls_size = pchild->tblprop_array[i].size + pchild->tblprop_array[i].offset; |
878 | } |
879 | } |
880 | |
881 | pchild->tables = kmalloc(size: tbls_size, GFP_KERNEL); |
882 | if (pchild->tables == NULL){ |
883 | printk(KERN_ERR PFX "Failed to allocate table.\n" ); |
884 | return; |
885 | } |
886 | pval = of_get_property(node: dp, name: "tables" , lenp: &len); |
887 | if (!pval || len <= 0) { |
888 | printk(KERN_ERR PFX "Failed to get table.\n" ); |
889 | return; |
890 | } |
891 | memcpy(pchild->tables, pval, len); |
892 | } |
893 | |
894 | /* SPARCengine ASM Reference Manual (ref. SMI doc 805-7581-04) |
895 | * sections 2.5, 3.5, 4.5 state node 0x70 for CP1400/1500 is |
896 | * "For Factory Use Only." |
897 | * |
898 | * We ignore the node on these platforms by assigning the |
899 | * 'NULL' monitor type. |
900 | */ |
901 | if (ENVCTRL_CPCI_IGNORED_NODE == pchild->addr) { |
902 | struct device_node *root_node; |
903 | int len; |
904 | |
905 | root_node = of_find_node_by_path(path: "/" ); |
906 | if (of_node_name_eq(np: root_node, name: "SUNW,UltraSPARC-IIi-cEngine" )) { |
907 | for (len = 0; len < PCF8584_MAX_CHANNELS; ++len) { |
908 | pchild->mon_type[len] = ENVCTRL_NOMON; |
909 | } |
910 | of_node_put(node: root_node); |
911 | return; |
912 | } |
913 | of_node_put(node: root_node); |
914 | } |
915 | |
916 | /* Get the monitor channels. */ |
917 | pval = of_get_property(node: dp, name: "channels-in-use" , lenp: &len); |
918 | memcpy(pchild->chnl_array, pval, len); |
919 | pchild->total_chnls = len / sizeof(struct pcf8584_channel); |
920 | |
921 | for (i = 0; i < pchild->total_chnls; i++) { |
922 | switch (pchild->chnl_array[i].type) { |
923 | case PCF8584_TEMP_TYPE: |
924 | envctrl_init_adc(pchild, dp); |
925 | break; |
926 | |
927 | case PCF8584_GLOBALADDR_TYPE: |
928 | envctrl_init_globaladdr(pchild); |
929 | i = pchild->total_chnls; |
930 | break; |
931 | |
932 | case PCF8584_FANSTAT_TYPE: |
933 | envctrl_init_fanstat(pchild); |
934 | i = pchild->total_chnls; |
935 | break; |
936 | |
937 | case PCF8584_VOLTAGE_TYPE: |
938 | if (pchild->i2ctype == I2C_ADC) { |
939 | envctrl_init_adc(pchild,dp); |
940 | } else { |
941 | envctrl_init_voltage_status(pchild); |
942 | } |
943 | i = pchild->total_chnls; |
944 | break; |
945 | |
946 | default: |
947 | break; |
948 | } |
949 | } |
950 | } |
951 | |
952 | /* Function Description: Search the child device list for a device. |
953 | * Return : The i2c child if found. NULL otherwise. |
954 | */ |
955 | static struct i2c_child_t *envctrl_get_i2c_child(unsigned char mon_type) |
956 | { |
957 | int i, j; |
958 | |
959 | for (i = 0; i < ENVCTRL_MAX_CPU*2; i++) { |
960 | for (j = 0; j < PCF8584_MAX_CHANNELS; j++) { |
961 | if (i2c_childlist[i].mon_type[j] == mon_type) { |
962 | return (struct i2c_child_t *)(&(i2c_childlist[i])); |
963 | } |
964 | } |
965 | } |
966 | return NULL; |
967 | } |
968 | |
969 | static void envctrl_do_shutdown(void) |
970 | { |
971 | static int inprog = 0; |
972 | |
973 | if (inprog != 0) |
974 | return; |
975 | |
976 | inprog = 1; |
977 | printk(KERN_CRIT "kenvctrld: WARNING: Shutting down the system now.\n" ); |
978 | orderly_poweroff(force: true); |
979 | } |
980 | |
981 | static struct task_struct *kenvctrld_task; |
982 | |
983 | static int kenvctrld(void *__unused) |
984 | { |
985 | int poll_interval; |
986 | int whichcpu; |
987 | char tempbuf[10]; |
988 | struct i2c_child_t *cputemp; |
989 | |
990 | if (NULL == (cputemp = envctrl_get_i2c_child(ENVCTRL_CPUTEMP_MON))) { |
991 | printk(KERN_ERR PFX |
992 | "kenvctrld unable to monitor CPU temp-- exiting\n" ); |
993 | return -ENODEV; |
994 | } |
995 | |
996 | poll_interval = 5000; /* TODO env_mon_interval */ |
997 | |
998 | printk(KERN_INFO PFX "%s starting...\n" , current->comm); |
999 | for (;;) { |
1000 | msleep_interruptible(msecs: poll_interval); |
1001 | |
1002 | if (kthread_should_stop()) |
1003 | break; |
1004 | |
1005 | for (whichcpu = 0; whichcpu < ENVCTRL_MAX_CPU; ++whichcpu) { |
1006 | if (0 < envctrl_read_cpu_info(cpu: whichcpu, pchild: cputemp, |
1007 | ENVCTRL_CPUTEMP_MON, |
1008 | bufdata: tempbuf)) { |
1009 | if (tempbuf[0] >= shutdown_temperature) { |
1010 | printk(KERN_CRIT |
1011 | "%s: WARNING: CPU%i temperature %i C meets or exceeds " \ |
1012 | "shutdown threshold %i C\n" , |
1013 | current->comm, whichcpu, |
1014 | tempbuf[0], shutdown_temperature); |
1015 | envctrl_do_shutdown(); |
1016 | } |
1017 | } |
1018 | } |
1019 | } |
1020 | printk(KERN_INFO PFX "%s exiting...\n" , current->comm); |
1021 | return 0; |
1022 | } |
1023 | |
1024 | static int envctrl_probe(struct platform_device *op) |
1025 | { |
1026 | struct device_node *dp; |
1027 | int index, err; |
1028 | |
1029 | if (i2c) |
1030 | return -EINVAL; |
1031 | |
1032 | i2c = of_ioremap(&op->resource[0], 0, 0x2, DRIVER_NAME); |
1033 | if (!i2c) |
1034 | return -ENOMEM; |
1035 | |
1036 | index = 0; |
1037 | dp = op->dev.of_node->child; |
1038 | while (dp) { |
1039 | if (of_node_name_eq(np: dp, name: "gpio" )) { |
1040 | i2c_childlist[index].i2ctype = I2C_GPIO; |
1041 | envctrl_init_i2c_child(dp, pchild: &(i2c_childlist[index++])); |
1042 | } else if (of_node_name_eq(np: dp, name: "adc" )) { |
1043 | i2c_childlist[index].i2ctype = I2C_ADC; |
1044 | envctrl_init_i2c_child(dp, pchild: &(i2c_childlist[index++])); |
1045 | } |
1046 | |
1047 | dp = dp->sibling; |
1048 | } |
1049 | |
1050 | /* Set device address. */ |
1051 | writeb(CONTROL_PIN, addr: i2c + PCF8584_CSR); |
1052 | writeb(PCF8584_ADDRESS, addr: i2c + PCF8584_DATA); |
1053 | |
1054 | /* Set system clock and SCL frequencies. */ |
1055 | writeb(CONTROL_PIN | CONTROL_ES1, addr: i2c + PCF8584_CSR); |
1056 | writeb(CLK_4_43 | BUS_CLK_90, addr: i2c + PCF8584_DATA); |
1057 | |
1058 | /* Enable serial interface. */ |
1059 | writeb(CONTROL_PIN | CONTROL_ES0 | CONTROL_ACK, addr: i2c + PCF8584_CSR); |
1060 | udelay(200); |
1061 | |
1062 | /* Register the device as a minor miscellaneous device. */ |
1063 | err = misc_register(misc: &envctrl_dev); |
1064 | if (err) { |
1065 | printk(KERN_ERR PFX "Unable to get misc minor %d\n" , |
1066 | envctrl_dev.minor); |
1067 | goto out_iounmap; |
1068 | } |
1069 | |
1070 | /* Note above traversal routine post-incremented 'i' to accommodate |
1071 | * a next child device, so we decrement before reverse-traversal of |
1072 | * child devices. |
1073 | */ |
1074 | printk(KERN_INFO PFX "Initialized " ); |
1075 | for (--index; index >= 0; --index) { |
1076 | printk("[%s 0x%lx]%s" , |
1077 | (I2C_ADC == i2c_childlist[index].i2ctype) ? "adc" : |
1078 | ((I2C_GPIO == i2c_childlist[index].i2ctype) ? "gpio" : "unknown" ), |
1079 | i2c_childlist[index].addr, (0 == index) ? "\n" : " " ); |
1080 | } |
1081 | |
1082 | kenvctrld_task = kthread_run(kenvctrld, NULL, "kenvctrld" ); |
1083 | if (IS_ERR(ptr: kenvctrld_task)) { |
1084 | err = PTR_ERR(ptr: kenvctrld_task); |
1085 | goto out_deregister; |
1086 | } |
1087 | |
1088 | return 0; |
1089 | |
1090 | out_deregister: |
1091 | misc_deregister(misc: &envctrl_dev); |
1092 | out_iounmap: |
1093 | of_iounmap(&op->resource[0], i2c, 0x2); |
1094 | for (index = 0; index < ENVCTRL_MAX_CPU * 2; index++) |
1095 | kfree(objp: i2c_childlist[index].tables); |
1096 | |
1097 | return err; |
1098 | } |
1099 | |
1100 | static void envctrl_remove(struct platform_device *op) |
1101 | { |
1102 | int index; |
1103 | |
1104 | kthread_stop(k: kenvctrld_task); |
1105 | |
1106 | of_iounmap(&op->resource[0], i2c, 0x2); |
1107 | misc_deregister(misc: &envctrl_dev); |
1108 | |
1109 | for (index = 0; index < ENVCTRL_MAX_CPU * 2; index++) |
1110 | kfree(objp: i2c_childlist[index].tables); |
1111 | } |
1112 | |
1113 | static const struct of_device_id envctrl_match[] = { |
1114 | { |
1115 | .name = "i2c" , |
1116 | .compatible = "i2cpcf,8584" , |
1117 | }, |
1118 | {}, |
1119 | }; |
1120 | MODULE_DEVICE_TABLE(of, envctrl_match); |
1121 | |
1122 | static struct platform_driver envctrl_driver = { |
1123 | .driver = { |
1124 | .name = DRIVER_NAME, |
1125 | .of_match_table = envctrl_match, |
1126 | }, |
1127 | .probe = envctrl_probe, |
1128 | .remove_new = envctrl_remove, |
1129 | }; |
1130 | |
1131 | module_platform_driver(envctrl_driver); |
1132 | |
1133 | MODULE_LICENSE("GPL" ); |
1134 | |