2008-08-29 22:05:15 -06:00
|
|
|
/* envctrl.c: Temperature and Fan monitoring on Machines providing it.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be)
|
|
|
|
* Copyright (C) 2000 Vinh Truong (vinh.truong@eng.sun.com)
|
|
|
|
* VT - The implementation is to support Sun Microelectronics (SME) platform
|
|
|
|
* environment monitoring. SME platforms use pcf8584 as the i2c bus
|
|
|
|
* controller to access pcf8591 (8-bit A/D and D/A converter) and
|
|
|
|
* pcf8571 (256 x 8-bit static low-voltage RAM with I2C-bus interface).
|
|
|
|
* At board level, it follows SME Firmware I2C Specification. Reference:
|
|
|
|
* http://www-eu2.semiconductors.com/pip/PCF8584P
|
|
|
|
* http://www-eu2.semiconductors.com/pip/PCF8574AP
|
|
|
|
* http://www-eu2.semiconductors.com/pip/PCF8591P
|
|
|
|
*
|
|
|
|
* EB - Added support for CP1500 Global Address and PS/Voltage monitoring.
|
|
|
|
* Eric Brower <ebrower@usa.net>
|
|
|
|
*
|
|
|
|
* DB - Audit every copy_to_user in envctrl_read.
|
|
|
|
* Daniele Bellucci <bellucda@tiscali.it>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
2005-08-09 13:30:07 -06:00
|
|
|
#include <linux/kthread.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/miscdevice.h>
|
2006-10-17 20:19:08 -06:00
|
|
|
#include <linux/kmod.h>
|
2007-07-17 19:37:02 -06:00
|
|
|
#include <linux/reboot.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2008-08-29 22:05:15 -06:00
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/of_device.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/envctrl.h>
|
2007-05-11 17:34:35 -06:00
|
|
|
#include <asm/io.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-29 22:05:15 -06:00
|
|
|
#define DRIVER_NAME "envctrl"
|
|
|
|
#define PFX DRIVER_NAME ": "
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ENVCTRL_MINOR 162
|
|
|
|
|
|
|
|
#define PCF8584_ADDRESS 0x55
|
|
|
|
|
|
|
|
#define CONTROL_PIN 0x80
|
|
|
|
#define CONTROL_ES0 0x40
|
|
|
|
#define CONTROL_ES1 0x20
|
|
|
|
#define CONTROL_ES2 0x10
|
|
|
|
#define CONTROL_ENI 0x08
|
|
|
|
#define CONTROL_STA 0x04
|
|
|
|
#define CONTROL_STO 0x02
|
|
|
|
#define CONTROL_ACK 0x01
|
|
|
|
|
|
|
|
#define STATUS_PIN 0x80
|
|
|
|
#define STATUS_STS 0x20
|
|
|
|
#define STATUS_BER 0x10
|
|
|
|
#define STATUS_LRB 0x08
|
|
|
|
#define STATUS_AD0 0x08
|
|
|
|
#define STATUS_AAB 0x04
|
|
|
|
#define STATUS_LAB 0x02
|
|
|
|
#define STATUS_BB 0x01
|
|
|
|
|
|
|
|
/*
|
|
|
|
* CLK Mode Register.
|
|
|
|
*/
|
|
|
|
#define BUS_CLK_90 0x00
|
|
|
|
#define BUS_CLK_45 0x01
|
|
|
|
#define BUS_CLK_11 0x02
|
|
|
|
#define BUS_CLK_1_5 0x03
|
|
|
|
|
|
|
|
#define CLK_3 0x00
|
|
|
|
#define CLK_4_43 0x10
|
|
|
|
#define CLK_6 0x14
|
|
|
|
#define CLK_8 0x18
|
|
|
|
#define CLK_12 0x1c
|
|
|
|
|
|
|
|
#define OBD_SEND_START 0xc5 /* value to generate I2c_bus START condition */
|
|
|
|
#define OBD_SEND_STOP 0xc3 /* value to generate I2c_bus STOP condition */
|
|
|
|
|
|
|
|
/* Monitor type of i2c child device.
|
|
|
|
* Firmware definitions.
|
|
|
|
*/
|
|
|
|
#define PCF8584_MAX_CHANNELS 8
|
|
|
|
#define PCF8584_GLOBALADDR_TYPE 6 /* global address monitor */
|
|
|
|
#define PCF8584_FANSTAT_TYPE 3 /* fan status monitor */
|
|
|
|
#define PCF8584_VOLTAGE_TYPE 2 /* voltage monitor */
|
|
|
|
#define PCF8584_TEMP_TYPE 1 /* temperature monitor*/
|
|
|
|
|
|
|
|
/* Monitor type of i2c child device.
|
|
|
|
* Driver definitions.
|
|
|
|
*/
|
|
|
|
#define ENVCTRL_NOMON 0
|
|
|
|
#define ENVCTRL_CPUTEMP_MON 1 /* cpu temperature monitor */
|
|
|
|
#define ENVCTRL_CPUVOLTAGE_MON 2 /* voltage monitor */
|
|
|
|
#define ENVCTRL_FANSTAT_MON 3 /* fan status monitor */
|
tree-wide: fix assorted typos all over the place
That is "success", "unknown", "through", "performance", "[re|un]mapping"
, "access", "default", "reasonable", "[con]currently", "temperature"
, "channel", "[un]used", "application", "example","hierarchy", "therefore"
, "[over|under]flow", "contiguous", "threshold", "enough" and others.
Signed-off-by: André Goddard Rosa <andre.goddard@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2009-11-14 08:09:05 -07:00
|
|
|
#define ENVCTRL_ETHERTEMP_MON 4 /* ethernet temperature */
|
2005-04-16 16:20:36 -06:00
|
|
|
/* monitor */
|
|
|
|
#define ENVCTRL_VOLTAGESTAT_MON 5 /* voltage status monitor */
|
|
|
|
#define ENVCTRL_MTHRBDTEMP_MON 6 /* motherboard temperature */
|
tree-wide: fix assorted typos all over the place
That is "success", "unknown", "through", "performance", "[re|un]mapping"
, "access", "default", "reasonable", "[con]currently", "temperature"
, "channel", "[un]used", "application", "example","hierarchy", "therefore"
, "[over|under]flow", "contiguous", "threshold", "enough" and others.
Signed-off-by: André Goddard Rosa <andre.goddard@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2009-11-14 08:09:05 -07:00
|
|
|
#define ENVCTRL_SCSITEMP_MON 7 /* scsi temperature */
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ENVCTRL_GLOBALADDR_MON 8 /* global address */
|
|
|
|
|
|
|
|
/* Child device type.
|
|
|
|
* Driver definitions.
|
|
|
|
*/
|
|
|
|
#define I2C_ADC 0 /* pcf8591 */
|
|
|
|
#define I2C_GPIO 1 /* pcf8571 */
|
|
|
|
|
|
|
|
/* Data read from child device may need to decode
|
|
|
|
* through a data table and a scale.
|
|
|
|
* Translation type as defined by firmware.
|
|
|
|
*/
|
|
|
|
#define ENVCTRL_TRANSLATE_NO 0
|
|
|
|
#define ENVCTRL_TRANSLATE_PARTIAL 1
|
|
|
|
#define ENVCTRL_TRANSLATE_COMBINED 2
|
|
|
|
#define ENVCTRL_TRANSLATE_FULL 3 /* table[data] */
|
|
|
|
#define ENVCTRL_TRANSLATE_SCALE 4 /* table[data]/scale */
|
|
|
|
|
|
|
|
/* Driver miscellaneous definitions. */
|
|
|
|
#define ENVCTRL_MAX_CPU 4
|
|
|
|
#define CHANNEL_DESC_SZ 256
|
|
|
|
|
|
|
|
/* Mask values for combined GlobalAddress/PowerStatus node */
|
|
|
|
#define ENVCTRL_GLOBALADDR_ADDR_MASK 0x1F
|
|
|
|
#define ENVCTRL_GLOBALADDR_PSTAT_MASK 0x60
|
|
|
|
|
|
|
|
/* Node 0x70 ignored on CompactPCI CP1400/1500 platforms
|
|
|
|
* (see envctrl_init_i2c_child)
|
|
|
|
*/
|
|
|
|
#define ENVCTRL_CPCI_IGNORED_NODE 0x70
|
|
|
|
|
|
|
|
#define PCF8584_DATA 0x00
|
|
|
|
#define PCF8584_CSR 0x01
|
|
|
|
|
|
|
|
/* Each child device can be monitored by up to PCF8584_MAX_CHANNELS.
|
|
|
|
* Property of a port or channel as defined by the firmware.
|
|
|
|
*/
|
|
|
|
struct pcf8584_channel {
|
|
|
|
unsigned char chnl_no;
|
|
|
|
unsigned char io_direction;
|
|
|
|
unsigned char type;
|
|
|
|
unsigned char last;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Each child device may have one or more tables of bytes to help decode
|
|
|
|
* data. Table property as defined by the firmware.
|
|
|
|
*/
|
|
|
|
struct pcf8584_tblprop {
|
|
|
|
unsigned int type;
|
|
|
|
unsigned int scale;
|
|
|
|
unsigned int offset; /* offset from the beginning of the table */
|
|
|
|
unsigned int size;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* i2c child */
|
|
|
|
struct i2c_child_t {
|
|
|
|
/* Either ADC or GPIO. */
|
|
|
|
unsigned char i2ctype;
|
|
|
|
unsigned long addr;
|
|
|
|
struct pcf8584_channel chnl_array[PCF8584_MAX_CHANNELS];
|
|
|
|
|
|
|
|
/* Channel info. */
|
|
|
|
unsigned int total_chnls; /* Number of monitor channels. */
|
|
|
|
unsigned char fan_mask; /* Byte mask for fan status channels. */
|
|
|
|
unsigned char voltage_mask; /* Byte mask for voltage status channels. */
|
|
|
|
struct pcf8584_tblprop tblprop_array[PCF8584_MAX_CHANNELS];
|
|
|
|
|
|
|
|
/* Properties of all monitor channels. */
|
|
|
|
unsigned int total_tbls; /* Number of monitor tables. */
|
|
|
|
char *tables; /* Pointer to table(s). */
|
|
|
|
char chnls_desc[CHANNEL_DESC_SZ]; /* Channel description. */
|
|
|
|
char mon_type[PCF8584_MAX_CHANNELS];
|
|
|
|
};
|
|
|
|
|
|
|
|
static void __iomem *i2c;
|
|
|
|
static struct i2c_child_t i2c_childlist[ENVCTRL_MAX_CPU*2];
|
|
|
|
static unsigned char chnls_mask[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
|
|
|
|
static unsigned int warning_temperature = 0;
|
|
|
|
static unsigned int shutdown_temperature = 0;
|
|
|
|
static char read_cpu;
|
|
|
|
|
|
|
|
/* Forward declarations. */
|
|
|
|
static struct i2c_child_t *envctrl_get_i2c_child(unsigned char);
|
|
|
|
|
|
|
|
/* Function Description: Test the PIN bit (Pending Interrupt Not)
|
|
|
|
* to test when serial transmission is completed .
|
|
|
|
* Return : None.
|
|
|
|
*/
|
|
|
|
static void envtrl_i2c_test_pin(void)
|
|
|
|
{
|
|
|
|
int limit = 1000000;
|
|
|
|
|
|
|
|
while (--limit > 0) {
|
|
|
|
if (!(readb(i2c + PCF8584_CSR) & STATUS_PIN))
|
|
|
|
break;
|
|
|
|
udelay(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (limit <= 0)
|
2008-08-29 22:05:15 -06:00
|
|
|
printk(KERN_INFO PFX "Pin status will not clear.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Test busy bit.
|
|
|
|
* Return : None.
|
|
|
|
*/
|
|
|
|
static void envctrl_i2c_test_bb(void)
|
|
|
|
{
|
|
|
|
int limit = 1000000;
|
|
|
|
|
|
|
|
while (--limit > 0) {
|
|
|
|
/* Busy bit 0 means busy. */
|
|
|
|
if (readb(i2c + PCF8584_CSR) & STATUS_BB)
|
|
|
|
break;
|
|
|
|
udelay(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (limit <= 0)
|
2008-08-29 22:05:15 -06:00
|
|
|
printk(KERN_INFO PFX "Busy bit will not clear.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Send the address for a read access.
|
|
|
|
* Return : 0 if not acknowledged, otherwise acknowledged.
|
|
|
|
*/
|
|
|
|
static int envctrl_i2c_read_addr(unsigned char addr)
|
|
|
|
{
|
|
|
|
envctrl_i2c_test_bb();
|
|
|
|
|
|
|
|
/* Load address. */
|
|
|
|
writeb(addr + 1, i2c + PCF8584_DATA);
|
|
|
|
|
|
|
|
envctrl_i2c_test_bb();
|
|
|
|
|
|
|
|
writeb(OBD_SEND_START, i2c + PCF8584_CSR);
|
|
|
|
|
|
|
|
/* Wait for PIN. */
|
|
|
|
envtrl_i2c_test_pin();
|
|
|
|
|
|
|
|
/* CSR 0 means acknowledged. */
|
|
|
|
if (!(readb(i2c + PCF8584_CSR) & STATUS_LRB)) {
|
|
|
|
return readb(i2c + PCF8584_DATA);
|
|
|
|
} else {
|
|
|
|
writeb(OBD_SEND_STOP, i2c + PCF8584_CSR);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Send the address for write mode.
|
|
|
|
* Return : None.
|
|
|
|
*/
|
|
|
|
static void envctrl_i2c_write_addr(unsigned char addr)
|
|
|
|
{
|
|
|
|
envctrl_i2c_test_bb();
|
|
|
|
writeb(addr, i2c + PCF8584_DATA);
|
|
|
|
|
|
|
|
/* Generate Start condition. */
|
|
|
|
writeb(OBD_SEND_START, i2c + PCF8584_CSR);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Read 1 byte of data from addr
|
|
|
|
* set by envctrl_i2c_read_addr()
|
|
|
|
* Return : Data from address set by envctrl_i2c_read_addr().
|
|
|
|
*/
|
|
|
|
static unsigned char envctrl_i2c_read_data(void)
|
|
|
|
{
|
|
|
|
envtrl_i2c_test_pin();
|
|
|
|
writeb(CONTROL_ES0, i2c + PCF8584_CSR); /* Send neg ack. */
|
|
|
|
return readb(i2c + PCF8584_DATA);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Instruct the device which port to read data from.
|
|
|
|
* Return : None.
|
|
|
|
*/
|
|
|
|
static void envctrl_i2c_write_data(unsigned char port)
|
|
|
|
{
|
|
|
|
envtrl_i2c_test_pin();
|
|
|
|
writeb(port, i2c + PCF8584_DATA);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Generate Stop condition after last byte is sent.
|
|
|
|
* Return : None.
|
|
|
|
*/
|
|
|
|
static void envctrl_i2c_stop(void)
|
|
|
|
{
|
|
|
|
envtrl_i2c_test_pin();
|
|
|
|
writeb(OBD_SEND_STOP, i2c + PCF8584_CSR);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Read adc device.
|
|
|
|
* Return : Data at address and port.
|
|
|
|
*/
|
|
|
|
static unsigned char envctrl_i2c_read_8591(unsigned char addr, unsigned char port)
|
|
|
|
{
|
|
|
|
/* Send address. */
|
|
|
|
envctrl_i2c_write_addr(addr);
|
|
|
|
|
|
|
|
/* Setup port to read. */
|
|
|
|
envctrl_i2c_write_data(port);
|
|
|
|
envctrl_i2c_stop();
|
|
|
|
|
|
|
|
/* Read port. */
|
|
|
|
envctrl_i2c_read_addr(addr);
|
|
|
|
|
|
|
|
/* Do a single byte read and send stop. */
|
|
|
|
envctrl_i2c_read_data();
|
|
|
|
envctrl_i2c_stop();
|
|
|
|
|
|
|
|
return readb(i2c + PCF8584_DATA);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Read gpio device.
|
|
|
|
* Return : Data at address.
|
|
|
|
*/
|
|
|
|
static unsigned char envctrl_i2c_read_8574(unsigned char addr)
|
|
|
|
{
|
|
|
|
unsigned char rd;
|
|
|
|
|
|
|
|
envctrl_i2c_read_addr(addr);
|
|
|
|
|
|
|
|
/* Do a single byte read and send stop. */
|
|
|
|
rd = envctrl_i2c_read_data();
|
|
|
|
envctrl_i2c_stop();
|
|
|
|
return rd;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Decode data read from an adc device using firmware
|
|
|
|
* table.
|
|
|
|
* Return: Number of read bytes. Data is stored in bufdata in ascii format.
|
|
|
|
*/
|
|
|
|
static int envctrl_i2c_data_translate(unsigned char data, int translate_type,
|
|
|
|
int scale, char *tbl, char *bufdata)
|
|
|
|
{
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
switch (translate_type) {
|
|
|
|
case ENVCTRL_TRANSLATE_NO:
|
|
|
|
/* No decode necessary. */
|
|
|
|
len = 1;
|
|
|
|
bufdata[0] = data;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENVCTRL_TRANSLATE_FULL:
|
|
|
|
/* Decode this way: data = table[data]. */
|
|
|
|
len = 1;
|
|
|
|
bufdata[0] = tbl[data];
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENVCTRL_TRANSLATE_SCALE:
|
|
|
|
/* Decode this way: data = table[data]/scale */
|
|
|
|
sprintf(bufdata,"%d ", (tbl[data] * 10) / (scale));
|
|
|
|
len = strlen(bufdata);
|
|
|
|
bufdata[len - 1] = bufdata[len - 2];
|
|
|
|
bufdata[len - 2] = '.';
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
2012-09-12 01:03:12 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Read cpu-related data such as cpu temperature, voltage.
|
|
|
|
* Return: Number of read bytes. Data is stored in bufdata in ascii format.
|
|
|
|
*/
|
|
|
|
static int envctrl_read_cpu_info(int cpu, struct i2c_child_t *pchild,
|
|
|
|
char mon_type, unsigned char *bufdata)
|
|
|
|
{
|
|
|
|
unsigned char data;
|
|
|
|
int i;
|
|
|
|
char *tbl, j = -1;
|
|
|
|
|
|
|
|
/* Find the right monitor type and channel. */
|
|
|
|
for (i = 0; i < PCF8584_MAX_CHANNELS; i++) {
|
|
|
|
if (pchild->mon_type[i] == mon_type) {
|
|
|
|
if (++j == cpu) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (j != cpu)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Read data from address and port. */
|
|
|
|
data = envctrl_i2c_read_8591((unsigned char)pchild->addr,
|
|
|
|
(unsigned char)pchild->chnl_array[i].chnl_no);
|
|
|
|
|
|
|
|
/* Find decoding table. */
|
|
|
|
tbl = pchild->tables + pchild->tblprop_array[i].offset;
|
|
|
|
|
|
|
|
return envctrl_i2c_data_translate(data, pchild->tblprop_array[i].type,
|
|
|
|
pchild->tblprop_array[i].scale,
|
|
|
|
tbl, bufdata);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Read noncpu-related data such as motherboard
|
|
|
|
* temperature.
|
|
|
|
* Return: Number of read bytes. Data is stored in bufdata in ascii format.
|
|
|
|
*/
|
|
|
|
static int envctrl_read_noncpu_info(struct i2c_child_t *pchild,
|
|
|
|
char mon_type, unsigned char *bufdata)
|
|
|
|
{
|
|
|
|
unsigned char data;
|
|
|
|
int i;
|
|
|
|
char *tbl = NULL;
|
|
|
|
|
|
|
|
for (i = 0; i < PCF8584_MAX_CHANNELS; i++) {
|
|
|
|
if (pchild->mon_type[i] == mon_type)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i >= PCF8584_MAX_CHANNELS)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Read data from address and port. */
|
|
|
|
data = envctrl_i2c_read_8591((unsigned char)pchild->addr,
|
|
|
|
(unsigned char)pchild->chnl_array[i].chnl_no);
|
|
|
|
|
|
|
|
/* Find decoding table. */
|
|
|
|
tbl = pchild->tables + pchild->tblprop_array[i].offset;
|
|
|
|
|
|
|
|
return envctrl_i2c_data_translate(data, pchild->tblprop_array[i].type,
|
|
|
|
pchild->tblprop_array[i].scale,
|
|
|
|
tbl, bufdata);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Read fan status.
|
|
|
|
* Return : Always 1 byte. Status stored in bufdata.
|
|
|
|
*/
|
|
|
|
static int envctrl_i2c_fan_status(struct i2c_child_t *pchild,
|
|
|
|
unsigned char data,
|
|
|
|
char *bufdata)
|
|
|
|
{
|
|
|
|
unsigned char tmp, ret = 0;
|
|
|
|
int i, j = 0;
|
|
|
|
|
|
|
|
tmp = data & pchild->fan_mask;
|
|
|
|
|
|
|
|
if (tmp == pchild->fan_mask) {
|
|
|
|
/* All bits are on. All fans are functioning. */
|
|
|
|
ret = ENVCTRL_ALL_FANS_GOOD;
|
|
|
|
} else if (tmp == 0) {
|
|
|
|
/* No bits are on. No fans are functioning. */
|
|
|
|
ret = ENVCTRL_ALL_FANS_BAD;
|
|
|
|
} else {
|
|
|
|
/* Go through all channels, mark 'on' the matched bits.
|
|
|
|
* Notice that fan_mask may have discontiguous bits but
|
|
|
|
* return mask are always contiguous. For example if we
|
|
|
|
* monitor 4 fans at channels 0,1,2,4, the return mask
|
|
|
|
* should be 00010000 if only fan at channel 4 is working.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < PCF8584_MAX_CHANNELS;i++) {
|
|
|
|
if (pchild->fan_mask & chnls_mask[i]) {
|
|
|
|
if (!(chnls_mask[i] & tmp))
|
|
|
|
ret |= chnls_mask[j];
|
|
|
|
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bufdata[0] = ret;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Read global addressing line.
|
|
|
|
* Return : Always 1 byte. Status stored in bufdata.
|
|
|
|
*/
|
|
|
|
static int envctrl_i2c_globaladdr(struct i2c_child_t *pchild,
|
|
|
|
unsigned char data,
|
|
|
|
char *bufdata)
|
|
|
|
{
|
|
|
|
/* Translatation table is not necessary, as global
|
|
|
|
* addr is the integer value of the GA# bits.
|
|
|
|
*
|
|
|
|
* NOTE: MSB is documented as zero, but I see it as '1' always....
|
|
|
|
*
|
|
|
|
* -----------------------------------------------
|
|
|
|
* | 0 | FAL | DEG | GA4 | GA3 | GA2 | GA1 | GA0 |
|
|
|
|
* -----------------------------------------------
|
|
|
|
* GA0 - GA4 integer value of Global Address (backplane slot#)
|
|
|
|
* DEG 0 = cPCI Power supply output is starting to degrade
|
|
|
|
* 1 = cPCI Power supply output is OK
|
|
|
|
* FAL 0 = cPCI Power supply has failed
|
|
|
|
* 1 = cPCI Power supply output is OK
|
|
|
|
*/
|
|
|
|
bufdata[0] = (data & ENVCTRL_GLOBALADDR_ADDR_MASK);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Read standard voltage and power supply status.
|
|
|
|
* Return : Always 1 byte. Status stored in bufdata.
|
|
|
|
*/
|
|
|
|
static unsigned char envctrl_i2c_voltage_status(struct i2c_child_t *pchild,
|
|
|
|
unsigned char data,
|
|
|
|
char *bufdata)
|
|
|
|
{
|
|
|
|
unsigned char tmp, ret = 0;
|
|
|
|
int i, j = 0;
|
|
|
|
|
|
|
|
tmp = data & pchild->voltage_mask;
|
|
|
|
|
|
|
|
/* Two channels are used to monitor voltage and power supply. */
|
|
|
|
if (tmp == pchild->voltage_mask) {
|
|
|
|
/* All bits are on. Voltage and power supply are okay. */
|
|
|
|
ret = ENVCTRL_VOLTAGE_POWERSUPPLY_GOOD;
|
|
|
|
} else if (tmp == 0) {
|
|
|
|
/* All bits are off. Voltage and power supply are bad */
|
|
|
|
ret = ENVCTRL_VOLTAGE_POWERSUPPLY_BAD;
|
|
|
|
} else {
|
|
|
|
/* Either voltage or power supply has problem. */
|
|
|
|
for (i = 0; i < PCF8584_MAX_CHANNELS; i++) {
|
|
|
|
if (pchild->voltage_mask & chnls_mask[i]) {
|
|
|
|
j++;
|
|
|
|
|
|
|
|
/* Break out when there is a mismatch. */
|
|
|
|
if (!(chnls_mask[i] & tmp))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make a wish that hardware will always use the
|
|
|
|
* first channel for voltage and the second for
|
|
|
|
* power supply.
|
|
|
|
*/
|
|
|
|
if (j == 1)
|
|
|
|
ret = ENVCTRL_VOLTAGE_BAD;
|
|
|
|
else
|
|
|
|
ret = ENVCTRL_POWERSUPPLY_BAD;
|
|
|
|
}
|
|
|
|
|
|
|
|
bufdata[0] = ret;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Read a byte from /dev/envctrl. Mapped to user read().
|
|
|
|
* Return: Number of read bytes. 0 for error.
|
|
|
|
*/
|
|
|
|
static ssize_t
|
|
|
|
envctrl_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
struct i2c_child_t *pchild;
|
|
|
|
unsigned char data[10];
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* Get the type of read as decided in ioctl() call.
|
|
|
|
* Find the appropriate i2c child.
|
|
|
|
* Get the data and put back to the user buffer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
switch ((int)(long)file->private_data) {
|
|
|
|
case ENVCTRL_RD_WARNING_TEMPERATURE:
|
|
|
|
if (warning_temperature == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
data[0] = (unsigned char)(warning_temperature);
|
|
|
|
ret = 1;
|
|
|
|
if (copy_to_user(buf, data, ret))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENVCTRL_RD_SHUTDOWN_TEMPERATURE:
|
|
|
|
if (shutdown_temperature == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
data[0] = (unsigned char)(shutdown_temperature);
|
|
|
|
ret = 1;
|
|
|
|
if (copy_to_user(buf, data, ret))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENVCTRL_RD_MTHRBD_TEMPERATURE:
|
|
|
|
if (!(pchild = envctrl_get_i2c_child(ENVCTRL_MTHRBDTEMP_MON)))
|
|
|
|
return 0;
|
|
|
|
ret = envctrl_read_noncpu_info(pchild, ENVCTRL_MTHRBDTEMP_MON, data);
|
|
|
|
if (copy_to_user(buf, data, ret))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENVCTRL_RD_CPU_TEMPERATURE:
|
|
|
|
if (!(pchild = envctrl_get_i2c_child(ENVCTRL_CPUTEMP_MON)))
|
|
|
|
return 0;
|
|
|
|
ret = envctrl_read_cpu_info(read_cpu, pchild, ENVCTRL_CPUTEMP_MON, data);
|
|
|
|
|
|
|
|
/* Reset cpu to the default cpu0. */
|
|
|
|
if (copy_to_user(buf, data, ret))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENVCTRL_RD_CPU_VOLTAGE:
|
|
|
|
if (!(pchild = envctrl_get_i2c_child(ENVCTRL_CPUVOLTAGE_MON)))
|
|
|
|
return 0;
|
|
|
|
ret = envctrl_read_cpu_info(read_cpu, pchild, ENVCTRL_CPUVOLTAGE_MON, data);
|
|
|
|
|
|
|
|
/* Reset cpu to the default cpu0. */
|
|
|
|
if (copy_to_user(buf, data, ret))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENVCTRL_RD_SCSI_TEMPERATURE:
|
|
|
|
if (!(pchild = envctrl_get_i2c_child(ENVCTRL_SCSITEMP_MON)))
|
|
|
|
return 0;
|
|
|
|
ret = envctrl_read_noncpu_info(pchild, ENVCTRL_SCSITEMP_MON, data);
|
|
|
|
if (copy_to_user(buf, data, ret))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENVCTRL_RD_ETHERNET_TEMPERATURE:
|
|
|
|
if (!(pchild = envctrl_get_i2c_child(ENVCTRL_ETHERTEMP_MON)))
|
|
|
|
return 0;
|
|
|
|
ret = envctrl_read_noncpu_info(pchild, ENVCTRL_ETHERTEMP_MON, data);
|
|
|
|
if (copy_to_user(buf, data, ret))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENVCTRL_RD_FAN_STATUS:
|
|
|
|
if (!(pchild = envctrl_get_i2c_child(ENVCTRL_FANSTAT_MON)))
|
|
|
|
return 0;
|
|
|
|
data[0] = envctrl_i2c_read_8574(pchild->addr);
|
|
|
|
ret = envctrl_i2c_fan_status(pchild,data[0], data);
|
|
|
|
if (copy_to_user(buf, data, ret))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENVCTRL_RD_GLOBALADDRESS:
|
|
|
|
if (!(pchild = envctrl_get_i2c_child(ENVCTRL_GLOBALADDR_MON)))
|
|
|
|
return 0;
|
|
|
|
data[0] = envctrl_i2c_read_8574(pchild->addr);
|
|
|
|
ret = envctrl_i2c_globaladdr(pchild, data[0], data);
|
|
|
|
if (copy_to_user(buf, data, ret))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENVCTRL_RD_VOLTAGE_STATUS:
|
|
|
|
if (!(pchild = envctrl_get_i2c_child(ENVCTRL_VOLTAGESTAT_MON)))
|
|
|
|
/* If voltage monitor not present, check for CPCI equivalent */
|
|
|
|
if (!(pchild = envctrl_get_i2c_child(ENVCTRL_GLOBALADDR_MON)))
|
|
|
|
return 0;
|
|
|
|
data[0] = envctrl_i2c_read_8574(pchild->addr);
|
|
|
|
ret = envctrl_i2c_voltage_status(pchild, data[0], data);
|
|
|
|
if (copy_to_user(buf, data, ret))
|
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
|
2012-09-12 01:03:12 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Command what to read. Mapped to user ioctl().
|
|
|
|
* Return: Gives 0 for implemented commands, -EINVAL otherwise.
|
|
|
|
*/
|
2005-11-07 15:12:34 -07:00
|
|
|
static long
|
|
|
|
envctrl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
char __user *infobuf;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case ENVCTRL_RD_WARNING_TEMPERATURE:
|
|
|
|
case ENVCTRL_RD_SHUTDOWN_TEMPERATURE:
|
|
|
|
case ENVCTRL_RD_MTHRBD_TEMPERATURE:
|
|
|
|
case ENVCTRL_RD_FAN_STATUS:
|
|
|
|
case ENVCTRL_RD_VOLTAGE_STATUS:
|
|
|
|
case ENVCTRL_RD_ETHERNET_TEMPERATURE:
|
|
|
|
case ENVCTRL_RD_SCSI_TEMPERATURE:
|
|
|
|
case ENVCTRL_RD_GLOBALADDRESS:
|
|
|
|
file->private_data = (void *)(long)cmd;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ENVCTRL_RD_CPU_TEMPERATURE:
|
|
|
|
case ENVCTRL_RD_CPU_VOLTAGE:
|
|
|
|
/* Check to see if application passes in any cpu number,
|
|
|
|
* the default is cpu0.
|
|
|
|
*/
|
|
|
|
infobuf = (char __user *) arg;
|
|
|
|
if (infobuf == NULL) {
|
|
|
|
read_cpu = 0;
|
|
|
|
}else {
|
|
|
|
get_user(read_cpu, infobuf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Save the command for use when reading. */
|
|
|
|
file->private_data = (void *)(long)cmd;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
2012-09-12 01:03:12 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: open device. Mapped to user open().
|
|
|
|
* Return: Always 0.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
envctrl_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
file->private_data = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Open device. Mapped to user close().
|
|
|
|
* Return: Always 0.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
envctrl_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-02-12 01:55:34 -07:00
|
|
|
static const struct file_operations envctrl_fops = {
|
2005-11-07 15:12:34 -07:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.read = envctrl_read,
|
|
|
|
.unlocked_ioctl = envctrl_ioctl,
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
.compat_ioctl = envctrl_ioctl,
|
|
|
|
#endif
|
|
|
|
.open = envctrl_open,
|
|
|
|
.release = envctrl_release,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 10:52:59 -06:00
|
|
|
.llseek = noop_llseek,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct miscdevice envctrl_dev = {
|
|
|
|
ENVCTRL_MINOR,
|
|
|
|
"envctrl",
|
|
|
|
&envctrl_fops
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Function Description: Set monitor type based on firmware description.
|
|
|
|
* Return: None.
|
|
|
|
*/
|
|
|
|
static void envctrl_set_mon(struct i2c_child_t *pchild,
|
2007-03-29 01:49:54 -06:00
|
|
|
const char *chnl_desc,
|
2005-04-16 16:20:36 -06:00
|
|
|
int chnl_no)
|
|
|
|
{
|
|
|
|
/* Firmware only has temperature type. It does not distinguish
|
|
|
|
* different kinds of temperatures. We use channel description
|
|
|
|
* to disinguish them.
|
|
|
|
*/
|
|
|
|
if (!(strcmp(chnl_desc,"temp,cpu")) ||
|
|
|
|
!(strcmp(chnl_desc,"temp,cpu0")) ||
|
|
|
|
!(strcmp(chnl_desc,"temp,cpu1")) ||
|
|
|
|
!(strcmp(chnl_desc,"temp,cpu2")) ||
|
|
|
|
!(strcmp(chnl_desc,"temp,cpu3")))
|
|
|
|
pchild->mon_type[chnl_no] = ENVCTRL_CPUTEMP_MON;
|
|
|
|
|
|
|
|
if (!(strcmp(chnl_desc,"vddcore,cpu0")) ||
|
|
|
|
!(strcmp(chnl_desc,"vddcore,cpu1")) ||
|
|
|
|
!(strcmp(chnl_desc,"vddcore,cpu2")) ||
|
|
|
|
!(strcmp(chnl_desc,"vddcore,cpu3")))
|
|
|
|
pchild->mon_type[chnl_no] = ENVCTRL_CPUVOLTAGE_MON;
|
|
|
|
|
|
|
|
if (!(strcmp(chnl_desc,"temp,motherboard")))
|
|
|
|
pchild->mon_type[chnl_no] = ENVCTRL_MTHRBDTEMP_MON;
|
|
|
|
|
|
|
|
if (!(strcmp(chnl_desc,"temp,scsi")))
|
|
|
|
pchild->mon_type[chnl_no] = ENVCTRL_SCSITEMP_MON;
|
|
|
|
|
|
|
|
if (!(strcmp(chnl_desc,"temp,ethernet")))
|
|
|
|
pchild->mon_type[chnl_no] = ENVCTRL_ETHERTEMP_MON;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Initialize monitor channel with channel desc,
|
|
|
|
* decoding tables, monitor type, optional properties.
|
|
|
|
* Return: None.
|
|
|
|
*/
|
2006-06-22 20:12:03 -06:00
|
|
|
static void envctrl_init_adc(struct i2c_child_t *pchild, struct device_node *dp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i = 0, len;
|
2007-03-29 01:49:54 -06:00
|
|
|
const char *pos;
|
|
|
|
const unsigned int *pval;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Firmware describe channels into a stream separated by a '\0'. */
|
2006-06-22 20:12:03 -06:00
|
|
|
pos = of_get_property(dp, "channels-description", &len);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
while (len > 0) {
|
|
|
|
int l = strlen(pos) + 1;
|
|
|
|
envctrl_set_mon(pchild, pos, i++);
|
|
|
|
len -= l;
|
|
|
|
pos += l;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get optional properties. */
|
2006-06-22 20:12:03 -06:00
|
|
|
pval = of_get_property(dp, "warning-temp", NULL);
|
|
|
|
if (pval)
|
|
|
|
warning_temperature = *pval;
|
|
|
|
|
|
|
|
pval = of_get_property(dp, "shutdown-temp", NULL);
|
|
|
|
if (pval)
|
|
|
|
shutdown_temperature = *pval;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Initialize child device monitoring fan status.
|
|
|
|
* Return: None.
|
|
|
|
*/
|
|
|
|
static void envctrl_init_fanstat(struct i2c_child_t *pchild)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Go through all channels and set up the mask. */
|
|
|
|
for (i = 0; i < pchild->total_chnls; i++)
|
|
|
|
pchild->fan_mask |= chnls_mask[(pchild->chnl_array[i]).chnl_no];
|
|
|
|
|
|
|
|
/* We only need to know if this child has fan status monitored.
|
|
|
|
* We don't care which channels since we have the mask already.
|
|
|
|
*/
|
|
|
|
pchild->mon_type[0] = ENVCTRL_FANSTAT_MON;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Initialize child device for global addressing line.
|
|
|
|
* Return: None.
|
|
|
|
*/
|
|
|
|
static void envctrl_init_globaladdr(struct i2c_child_t *pchild)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Voltage/PowerSupply monitoring is piggybacked
|
|
|
|
* with Global Address on CompactPCI. See comments
|
|
|
|
* within envctrl_i2c_globaladdr for bit assignments.
|
|
|
|
*
|
|
|
|
* The mask is created here by assigning mask bits to each
|
|
|
|
* bit position that represents PCF8584_VOLTAGE_TYPE data.
|
|
|
|
* Channel numbers are not consecutive within the globaladdr
|
|
|
|
* node (why?), so we use the actual counter value as chnls_mask
|
|
|
|
* index instead of the chnl_array[x].chnl_no value.
|
|
|
|
*
|
|
|
|
* NOTE: This loop could be replaced with a constant representing
|
|
|
|
* a mask of bits 5&6 (ENVCTRL_GLOBALADDR_PSTAT_MASK).
|
|
|
|
*/
|
|
|
|
for (i = 0; i < pchild->total_chnls; i++) {
|
|
|
|
if (PCF8584_VOLTAGE_TYPE == pchild->chnl_array[i].type) {
|
|
|
|
pchild->voltage_mask |= chnls_mask[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We only need to know if this child has global addressing
|
|
|
|
* line monitored. We don't care which channels since we know
|
|
|
|
* the mask already (ENVCTRL_GLOBALADDR_ADDR_MASK).
|
|
|
|
*/
|
|
|
|
pchild->mon_type[0] = ENVCTRL_GLOBALADDR_MON;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize child device monitoring voltage status. */
|
|
|
|
static void envctrl_init_voltage_status(struct i2c_child_t *pchild)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Go through all channels and set up the mask. */
|
|
|
|
for (i = 0; i < pchild->total_chnls; i++)
|
|
|
|
pchild->voltage_mask |= chnls_mask[(pchild->chnl_array[i]).chnl_no];
|
|
|
|
|
|
|
|
/* We only need to know if this child has voltage status monitored.
|
|
|
|
* We don't care which channels since we have the mask already.
|
|
|
|
*/
|
|
|
|
pchild->mon_type[0] = ENVCTRL_VOLTAGESTAT_MON;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Initialize i2c child device.
|
|
|
|
* Return: None.
|
|
|
|
*/
|
2008-08-29 22:05:15 -06:00
|
|
|
static void envctrl_init_i2c_child(struct device_node *dp,
|
2005-04-16 16:20:36 -06:00
|
|
|
struct i2c_child_t *pchild)
|
|
|
|
{
|
2006-06-22 20:12:03 -06:00
|
|
|
int len, i, tbls_size = 0;
|
2007-03-29 01:49:54 -06:00
|
|
|
const void *pval;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Get device address. */
|
2006-06-22 20:12:03 -06:00
|
|
|
pval = of_get_property(dp, "reg", &len);
|
|
|
|
memcpy(&pchild->addr, pval, len);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Get tables property. Read firmware temperature tables. */
|
2006-06-22 20:12:03 -06:00
|
|
|
pval = of_get_property(dp, "translation", &len);
|
|
|
|
if (pval && len > 0) {
|
|
|
|
memcpy(pchild->tblprop_array, pval, len);
|
2005-04-16 16:20:36 -06:00
|
|
|
pchild->total_tbls = len / sizeof(struct pcf8584_tblprop);
|
|
|
|
for (i = 0; i < pchild->total_tbls; i++) {
|
|
|
|
if ((pchild->tblprop_array[i].size + pchild->tblprop_array[i].offset) > tbls_size) {
|
|
|
|
tbls_size = pchild->tblprop_array[i].size + pchild->tblprop_array[i].offset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pchild->tables = kmalloc(tbls_size, GFP_KERNEL);
|
|
|
|
if (pchild->tables == NULL){
|
2008-08-29 22:05:15 -06:00
|
|
|
printk(KERN_ERR PFX "Failed to allocate table.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
2006-06-22 20:12:03 -06:00
|
|
|
pval = of_get_property(dp, "tables", &len);
|
|
|
|
if (!pval || len <= 0) {
|
2008-08-29 22:05:15 -06:00
|
|
|
printk(KERN_ERR PFX "Failed to get table.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
2006-06-22 20:12:03 -06:00
|
|
|
memcpy(pchild->tables, pval, len);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* SPARCengine ASM Reference Manual (ref. SMI doc 805-7581-04)
|
|
|
|
* sections 2.5, 3.5, 4.5 state node 0x70 for CP1400/1500 is
|
|
|
|
* "For Factory Use Only."
|
|
|
|
*
|
|
|
|
* We ignore the node on these platforms by assigning the
|
|
|
|
* 'NULL' monitor type.
|
|
|
|
*/
|
|
|
|
if (ENVCTRL_CPCI_IGNORED_NODE == pchild->addr) {
|
2006-06-22 20:12:03 -06:00
|
|
|
struct device_node *root_node;
|
2005-04-16 16:20:36 -06:00
|
|
|
int len;
|
|
|
|
|
2006-06-22 20:12:03 -06:00
|
|
|
root_node = of_find_node_by_path("/");
|
|
|
|
if (!strcmp(root_node->name, "SUNW,UltraSPARC-IIi-cEngine")) {
|
2005-04-16 16:20:36 -06:00
|
|
|
for (len = 0; len < PCF8584_MAX_CHANNELS; ++len) {
|
|
|
|
pchild->mon_type[len] = ENVCTRL_NOMON;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get the monitor channels. */
|
2006-06-22 20:12:03 -06:00
|
|
|
pval = of_get_property(dp, "channels-in-use", &len);
|
|
|
|
memcpy(pchild->chnl_array, pval, len);
|
2005-04-16 16:20:36 -06:00
|
|
|
pchild->total_chnls = len / sizeof(struct pcf8584_channel);
|
|
|
|
|
|
|
|
for (i = 0; i < pchild->total_chnls; i++) {
|
|
|
|
switch (pchild->chnl_array[i].type) {
|
|
|
|
case PCF8584_TEMP_TYPE:
|
2006-06-22 20:12:03 -06:00
|
|
|
envctrl_init_adc(pchild, dp);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PCF8584_GLOBALADDR_TYPE:
|
|
|
|
envctrl_init_globaladdr(pchild);
|
|
|
|
i = pchild->total_chnls;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PCF8584_FANSTAT_TYPE:
|
|
|
|
envctrl_init_fanstat(pchild);
|
|
|
|
i = pchild->total_chnls;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PCF8584_VOLTAGE_TYPE:
|
|
|
|
if (pchild->i2ctype == I2C_ADC) {
|
2006-06-22 20:12:03 -06:00
|
|
|
envctrl_init_adc(pchild,dp);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
envctrl_init_voltage_status(pchild);
|
|
|
|
}
|
|
|
|
i = pchild->total_chnls;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
2012-09-12 01:03:12 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Function Description: Search the child device list for a device.
|
|
|
|
* Return : The i2c child if found. NULL otherwise.
|
|
|
|
*/
|
|
|
|
static struct i2c_child_t *envctrl_get_i2c_child(unsigned char mon_type)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
for (i = 0; i < ENVCTRL_MAX_CPU*2; i++) {
|
|
|
|
for (j = 0; j < PCF8584_MAX_CHANNELS; j++) {
|
|
|
|
if (i2c_childlist[i].mon_type[j] == mon_type) {
|
|
|
|
return (struct i2c_child_t *)(&(i2c_childlist[i]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void envctrl_do_shutdown(void)
|
|
|
|
{
|
|
|
|
static int inprog = 0;
|
2006-10-02 03:18:31 -06:00
|
|
|
int ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (inprog != 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
inprog = 1;
|
|
|
|
printk(KERN_CRIT "kenvctrld: WARNING: Shutting down the system now.\n");
|
2007-07-17 19:37:02 -06:00
|
|
|
ret = orderly_poweroff(true);
|
2006-10-02 03:18:31 -06:00
|
|
|
if (ret < 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_CRIT "kenvctrld: WARNING: system shutdown failed!\n");
|
|
|
|
inprog = 0; /* unlikely to succeed, but we could try again */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct task_struct *kenvctrld_task;
|
|
|
|
|
|
|
|
static int kenvctrld(void *__unused)
|
|
|
|
{
|
|
|
|
int poll_interval;
|
|
|
|
int whichcpu;
|
|
|
|
char tempbuf[10];
|
|
|
|
struct i2c_child_t *cputemp;
|
|
|
|
|
|
|
|
if (NULL == (cputemp = envctrl_get_i2c_child(ENVCTRL_CPUTEMP_MON))) {
|
2008-08-29 22:05:15 -06:00
|
|
|
printk(KERN_ERR PFX
|
|
|
|
"kenvctrld unable to monitor CPU temp-- exiting\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2005-07-24 20:34:33 -06:00
|
|
|
poll_interval = 5000; /* TODO env_mon_interval */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-29 22:05:15 -06:00
|
|
|
printk(KERN_INFO PFX "%s starting...\n", current->comm);
|
2005-04-16 16:20:36 -06:00
|
|
|
for (;;) {
|
2005-08-09 13:30:07 -06:00
|
|
|
msleep_interruptible(poll_interval);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-09 13:30:07 -06:00
|
|
|
if (kthread_should_stop())
|
|
|
|
break;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
for (whichcpu = 0; whichcpu < ENVCTRL_MAX_CPU; ++whichcpu) {
|
|
|
|
if (0 < envctrl_read_cpu_info(whichcpu, cputemp,
|
|
|
|
ENVCTRL_CPUTEMP_MON,
|
|
|
|
tempbuf)) {
|
|
|
|
if (tempbuf[0] >= shutdown_temperature) {
|
|
|
|
printk(KERN_CRIT
|
|
|
|
"%s: WARNING: CPU%i temperature %i C meets or exceeds "\
|
|
|
|
"shutdown threshold %i C\n",
|
|
|
|
current->comm, whichcpu,
|
|
|
|
tempbuf[0], shutdown_temperature);
|
|
|
|
envctrl_do_shutdown();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-08-29 22:05:15 -06:00
|
|
|
printk(KERN_INFO PFX "%s exiting...\n", current->comm);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-12-21 14:24:23 -07:00
|
|
|
static int envctrl_probe(struct platform_device *op)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-08-29 22:05:15 -06:00
|
|
|
struct device_node *dp;
|
|
|
|
int index, err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-29 22:05:15 -06:00
|
|
|
if (i2c)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
i2c = of_ioremap(&op->resource[0], 0, 0x2, DRIVER_NAME);
|
|
|
|
if (!i2c)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
index = 0;
|
2010-04-13 17:12:29 -06:00
|
|
|
dp = op->dev.of_node->child;
|
2008-08-29 22:05:15 -06:00
|
|
|
while (dp) {
|
|
|
|
if (!strcmp(dp->name, "gpio")) {
|
|
|
|
i2c_childlist[index].i2ctype = I2C_GPIO;
|
|
|
|
envctrl_init_i2c_child(dp, &(i2c_childlist[index++]));
|
|
|
|
} else if (!strcmp(dp->name, "adc")) {
|
|
|
|
i2c_childlist[index].i2ctype = I2C_ADC;
|
|
|
|
envctrl_init_i2c_child(dp, &(i2c_childlist[index++]));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-08-29 22:05:15 -06:00
|
|
|
dp = dp->sibling;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set device address. */
|
|
|
|
writeb(CONTROL_PIN, i2c + PCF8584_CSR);
|
|
|
|
writeb(PCF8584_ADDRESS, i2c + PCF8584_DATA);
|
|
|
|
|
|
|
|
/* Set system clock and SCL frequencies. */
|
|
|
|
writeb(CONTROL_PIN | CONTROL_ES1, i2c + PCF8584_CSR);
|
|
|
|
writeb(CLK_4_43 | BUS_CLK_90, i2c + PCF8584_DATA);
|
|
|
|
|
|
|
|
/* Enable serial interface. */
|
|
|
|
writeb(CONTROL_PIN | CONTROL_ES0 | CONTROL_ACK, i2c + PCF8584_CSR);
|
|
|
|
udelay(200);
|
|
|
|
|
|
|
|
/* Register the device as a minor miscellaneous device. */
|
|
|
|
err = misc_register(&envctrl_dev);
|
|
|
|
if (err) {
|
2008-08-29 22:05:15 -06:00
|
|
|
printk(KERN_ERR PFX "Unable to get misc minor %d\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
envctrl_dev.minor);
|
|
|
|
goto out_iounmap;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Note above traversal routine post-incremented 'i' to accommodate
|
|
|
|
* a next child device, so we decrement before reverse-traversal of
|
|
|
|
* child devices.
|
|
|
|
*/
|
2008-08-29 22:05:15 -06:00
|
|
|
printk(KERN_INFO PFX "Initialized ");
|
|
|
|
for (--index; index >= 0; --index) {
|
2005-04-16 16:20:36 -06:00
|
|
|
printk("[%s 0x%lx]%s",
|
2008-08-29 22:05:15 -06:00
|
|
|
(I2C_ADC == i2c_childlist[index].i2ctype) ? "adc" :
|
|
|
|
((I2C_GPIO == i2c_childlist[index].i2ctype) ? "gpio" : "unknown"),
|
|
|
|
i2c_childlist[index].addr, (0 == index) ? "\n" : " ");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-09 13:30:07 -06:00
|
|
|
kenvctrld_task = kthread_run(kenvctrld, NULL, "kenvctrld");
|
|
|
|
if (IS_ERR(kenvctrld_task)) {
|
2005-08-09 15:43:14 -06:00
|
|
|
err = PTR_ERR(kenvctrld_task);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out_deregister;
|
2005-08-09 13:30:07 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_deregister:
|
|
|
|
misc_deregister(&envctrl_dev);
|
|
|
|
out_iounmap:
|
2008-08-29 22:05:15 -06:00
|
|
|
of_iounmap(&op->resource[0], i2c, 0x2);
|
|
|
|
for (index = 0; index < ENVCTRL_MAX_CPU * 2; index++)
|
|
|
|
kfree(i2c_childlist[index].tables);
|
2005-11-07 02:01:32 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-12-21 14:24:23 -07:00
|
|
|
static int envctrl_remove(struct platform_device *op)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-08-29 22:05:15 -06:00
|
|
|
int index;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-08-09 13:30:07 -06:00
|
|
|
kthread_stop(kenvctrld_task);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-29 22:05:15 -06:00
|
|
|
of_iounmap(&op->resource[0], i2c, 0x2);
|
2005-04-16 16:20:36 -06:00
|
|
|
misc_deregister(&envctrl_dev);
|
|
|
|
|
2008-08-29 22:05:15 -06:00
|
|
|
for (index = 0; index < ENVCTRL_MAX_CPU * 2; index++)
|
|
|
|
kfree(i2c_childlist[index].tables);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-31 02:23:17 -06:00
|
|
|
static const struct of_device_id envctrl_match[] = {
|
2008-08-29 22:05:15 -06:00
|
|
|
{
|
|
|
|
.name = "i2c",
|
|
|
|
.compatible = "i2cpcf,8584",
|
|
|
|
},
|
|
|
|
{},
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, envctrl_match);
|
|
|
|
|
2011-02-22 20:01:33 -07:00
|
|
|
static struct platform_driver envctrl_driver = {
|
2010-04-13 17:13:02 -06:00
|
|
|
.driver = {
|
|
|
|
.name = DRIVER_NAME,
|
|
|
|
.of_match_table = envctrl_match,
|
|
|
|
},
|
2008-08-29 22:05:15 -06:00
|
|
|
.probe = envctrl_probe,
|
2012-12-21 14:24:23 -07:00
|
|
|
.remove = envctrl_remove,
|
2008-08-29 22:05:15 -06:00
|
|
|
};
|
|
|
|
|
2011-11-26 12:04:25 -07:00
|
|
|
module_platform_driver(envctrl_driver);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|