cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

envctrl.c (30726B)


      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/of_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 */
    135struct 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 */ 
    145struct 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 */
    153struct 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
    172static void __iomem *i2c;
    173static struct i2c_child_t i2c_childlist[ENVCTRL_MAX_CPU*2];
    174static unsigned char chnls_mask[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
    175static unsigned int warning_temperature = 0;
    176static unsigned int shutdown_temperature = 0;
    177static char read_cpu;
    178
    179/* Forward declarations. */
    180static 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 */
    186static void envtrl_i2c_test_pin(void)
    187{
    188	int limit = 1000000;
    189
    190	while (--limit > 0) {
    191		if (!(readb(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 */
    203static 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(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 */
    221static int envctrl_i2c_read_addr(unsigned char addr)
    222{
    223	envctrl_i2c_test_bb();
    224
    225	/* Load address. */
    226	writeb(addr + 1, i2c + PCF8584_DATA);
    227
    228	envctrl_i2c_test_bb();
    229
    230	writeb(OBD_SEND_START, i2c + PCF8584_CSR);
    231
    232	/* Wait for PIN. */
    233	envtrl_i2c_test_pin();
    234
    235	/* CSR 0 means acknowledged. */
    236	if (!(readb(i2c + PCF8584_CSR) & STATUS_LRB)) {
    237		return readb(i2c + PCF8584_DATA);
    238	} else {
    239		writeb(OBD_SEND_STOP, i2c + PCF8584_CSR);
    240		return 0;
    241	}
    242}
    243
    244/* Function Description: Send the address for write mode.  
    245 * Return : None.
    246 */
    247static void envctrl_i2c_write_addr(unsigned char addr)
    248{
    249	envctrl_i2c_test_bb();
    250	writeb(addr, i2c + PCF8584_DATA);
    251
    252	/* Generate Start condition. */
    253	writeb(OBD_SEND_START, 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 */
    260static unsigned char envctrl_i2c_read_data(void)
    261{
    262	envtrl_i2c_test_pin();
    263	writeb(CONTROL_ES0, i2c + PCF8584_CSR);  /* Send neg ack. */
    264	return readb(i2c + PCF8584_DATA);
    265}
    266
    267/* Function Description: Instruct the device which port to read data from.  
    268 * Return : None.
    269 */
    270static void envctrl_i2c_write_data(unsigned char port)
    271{
    272	envtrl_i2c_test_pin();
    273	writeb(port, i2c + PCF8584_DATA);
    274}
    275
    276/* Function Description: Generate Stop condition after last byte is sent.
    277 * Return : None.
    278 */
    279static void envctrl_i2c_stop(void)
    280{
    281	envtrl_i2c_test_pin();
    282	writeb(OBD_SEND_STOP, i2c + PCF8584_CSR);
    283}
    284
    285/* Function Description: Read adc device.
    286 * Return : Data at address and port.
    287 */
    288static 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(i2c + PCF8584_DATA);
    305}
    306
    307/* Function Description: Read gpio device.
    308 * Return : Data at address.
    309 */
    310static 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 */
    326static 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(bufdata,"%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 */
    362static 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;
    367	char *tbl, j = -1;
    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((unsigned char)pchild->addr,
    383				     (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, pchild->tblprop_array[i].type,
    389					  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 */
    397static 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((unsigned char)pchild->addr,
    414				     (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, pchild->tblprop_array[i].type,
    420					  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 */
    427static 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 */
    466static 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 */
    491static 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 */
    536static ssize_t
    537envctrl_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(buf, data, 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(buf, data, 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, data);
    573		if (copy_to_user(buf, data, 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(read_cpu, pchild, ENVCTRL_CPUTEMP_MON, data);
    581
    582		/* Reset cpu to the default cpu0. */
    583		if (copy_to_user(buf, data, 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(read_cpu, pchild, ENVCTRL_CPUVOLTAGE_MON, data);
    591
    592		/* Reset cpu to the default cpu0. */
    593		if (copy_to_user(buf, data, 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, data);
    601		if (copy_to_user(buf, data, 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, data);
    609		if (copy_to_user(buf, data, 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(pchild->addr);
    617		ret = envctrl_i2c_fan_status(pchild,data[0], data);
    618		if (copy_to_user(buf, data, 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(pchild->addr);
    626		ret = envctrl_i2c_globaladdr(pchild, data[0], data);
    627		if (copy_to_user(buf, data, 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(pchild->addr);
    637		ret = envctrl_i2c_voltage_status(pchild, data[0], data);
    638		if (copy_to_user(buf, data, 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 */
    653static long
    654envctrl_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 */
    696static int
    697envctrl_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 */
    706static int
    707envctrl_release(struct inode *inode, struct file *file)
    708{
    709	return 0;
    710}
    711
    712static 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
    722static 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 */
    731static 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 */
    766static 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(dp, "channels-description", &len);
    774
    775	while (len > 0) {
    776		int l = strlen(pos) + 1;
    777		envctrl_set_mon(pchild, pos, i++);
    778		len -= l;
    779		pos += l;
    780	}
    781
    782	/* Get optional properties. */
    783	pval = of_get_property(dp, "warning-temp", NULL);
    784	if (pval)
    785		warning_temperature = *pval;
    786
    787	pval = of_get_property(dp, "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 */
    795static 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 */
    812static 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. */
    843static 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 */
    860static 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(dp, "reg", &len);
    868	memcpy(&pchild->addr, pval, len);
    869
    870	/* Get tables property.  Read firmware temperature tables. */
    871	pval = of_get_property(dp, "translation", &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(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(dp, "tables", &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("/");
    906		if (of_node_name_eq(root_node, "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(root_node);
    911			return;
    912		}
    913		of_node_put(root_node);
    914	}
    915
    916	/* Get the monitor channels. */
    917	pval = of_get_property(dp, "channels-in-use", &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 */
    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;
    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(true);
    979}
    980
    981static struct task_struct *kenvctrld_task;
    982
    983static 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(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(whichcpu, cputemp,
   1007						      ENVCTRL_CPUTEMP_MON,
   1008						      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
   1024static 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(dp, "gpio")) {
   1040			i2c_childlist[index].i2ctype = I2C_GPIO;
   1041			envctrl_init_i2c_child(dp, &(i2c_childlist[index++]));
   1042		} else if (of_node_name_eq(dp, "adc")) {
   1043			i2c_childlist[index].i2ctype = I2C_ADC;
   1044			envctrl_init_i2c_child(dp, &(i2c_childlist[index++]));
   1045		}
   1046
   1047		dp = dp->sibling;
   1048	}
   1049
   1050	/* Set device address. */
   1051	writeb(CONTROL_PIN, i2c + PCF8584_CSR);
   1052	writeb(PCF8584_ADDRESS, i2c + PCF8584_DATA);
   1053
   1054	/* Set system clock and SCL frequencies. */ 
   1055	writeb(CONTROL_PIN | CONTROL_ES1, i2c + PCF8584_CSR);
   1056	writeb(CLK_4_43 | BUS_CLK_90, i2c + PCF8584_DATA);
   1057
   1058	/* Enable serial interface. */
   1059	writeb(CONTROL_PIN | CONTROL_ES0 | CONTROL_ACK, i2c + PCF8584_CSR);
   1060	udelay(200);
   1061
   1062	/* Register the device as a minor miscellaneous device. */
   1063	err = misc_register(&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(kenvctrld_task)) {
   1084		err = PTR_ERR(kenvctrld_task);
   1085		goto out_deregister;
   1086	}
   1087
   1088	return 0;
   1089
   1090out_deregister:
   1091	misc_deregister(&envctrl_dev);
   1092out_iounmap:
   1093	of_iounmap(&op->resource[0], i2c, 0x2);
   1094	for (index = 0; index < ENVCTRL_MAX_CPU * 2; index++)
   1095		kfree(i2c_childlist[index].tables);
   1096
   1097	return err;
   1098}
   1099
   1100static int envctrl_remove(struct platform_device *op)
   1101{
   1102	int index;
   1103
   1104	kthread_stop(kenvctrld_task);
   1105
   1106	of_iounmap(&op->resource[0], i2c, 0x2);
   1107	misc_deregister(&envctrl_dev);
   1108
   1109	for (index = 0; index < ENVCTRL_MAX_CPU * 2; index++)
   1110		kfree(i2c_childlist[index].tables);
   1111
   1112	return 0;
   1113}
   1114
   1115static const struct of_device_id envctrl_match[] = {
   1116	{
   1117		.name = "i2c",
   1118		.compatible = "i2cpcf,8584",
   1119	},
   1120	{},
   1121};
   1122MODULE_DEVICE_TABLE(of, envctrl_match);
   1123
   1124static struct platform_driver envctrl_driver = {
   1125	.driver = {
   1126		.name = DRIVER_NAME,
   1127		.of_match_table = envctrl_match,
   1128	},
   1129	.probe		= envctrl_probe,
   1130	.remove		= envctrl_remove,
   1131};
   1132
   1133module_platform_driver(envctrl_driver);
   1134
   1135MODULE_LICENSE("GPL");