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