[linux.git] / drivers / macintosh / therm_windtunnel.c

/* 
 *   Creation Date: <2003/03/14 20:54:13 samuel>
 *   Time-stamp: <2004/03/20 14:20:59 samuel>
 *   
 *	<therm_windtunnel.c>
 *	
 *	The G4 "windtunnel" has a single fan controlled by an
 *	ADM1030 fan controller and a DS1775 thermostat.
 *
 *	The fan controller is equipped with a temperature sensor
 *	which measures the case temperature. The DS1775 sensor
 *	measures the CPU temperature. This driver tunes the
 *	behavior of the fan. It is based upon empirical observations
 *	of the 'AppleFan' driver under Mac OS X.
 *
 *	WARNING: This driver has only been testen on Apple's
 *	1.25 MHz Dual G4 (March 03). It is tuned for a CPU
 *	temperature around 57 C.
 *
 *   Copyright (C) 2003, 2004 Samuel Rydh ([email protected])
 *
 *   Loosely based upon 'thermostat.c' written by Benjamin Herrenschmidt
 *   
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License
 *   as published by the Free Software Foundation
 *   
 */

#include <linux/types.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/kthread.h>
#include <linux/of_platform.h>

#include <asm/prom.h>
#include <asm/machdep.h>
#include <asm/io.h>
#include <asm/sections.h>
#include <asm/macio.h>

#define LOG_TEMP		0			/* continuously log temperature */

static struct {
	volatile int		running;
	struct task_struct	*poll_task;
	
	struct mutex	 	lock;
	struct platform_device	*of_dev;
	
	struct i2c_client	*thermostat;
	struct i2c_client	*fan;

	int			overheat_temp;		/* 100% fan at this temp */
	int			overheat_hyst;
	int			temp;
	int			casetemp;
	int			fan_level;		/* active fan_table setting */

	int			downind;
	int			upind;

	int			r0, r1, r20, r23, r25;	/* saved register */
} x;

#define T(x,y)			(((x)<<8) | (y)*0x100/10 )

static struct {
	int			fan_down_setting;
	int			temp;
	int			fan_up_setting;
} fan_table[] = {
	{ 11, T(0,0),  11 },	/* min fan */
	{ 11, T(55,0), 11 },
	{  6, T(55,3), 11 },
	{  7, T(56,0), 11 },
	{  8, T(57,0), 8 },
	{  7, T(58,3), 7 },
	{  6, T(58,8), 6 },
	{  5, T(59,2), 5 },
	{  4, T(59,6), 4 },
	{  3, T(59,9), 3 },
	{  2, T(60,1), 2 },
	{  1, 0xfffff, 1 }	/* on fire */
};

static void
print_temp( const char *s, int temp )
{
	printk("%s%d.%d C", s ? s : "", temp>>8, (temp & 255)*10/256 );
}

static ssize_t
show_cpu_temperature( struct device *dev, struct device_attribute *attr, char *buf )
{
	return sprintf(buf, "%d.%d\n", x.temp>>8, (x.temp & 255)*10/256 );
}

static ssize_t
show_case_temperature( struct device *dev, struct device_attribute *attr, char *buf )
{
	return sprintf(buf, "%d.%d\n", x.casetemp>>8, (x.casetemp & 255)*10/256 );
}

static DEVICE_ATTR(cpu_temperature, S_IRUGO, show_cpu_temperature, NULL );
static DEVICE_ATTR(case_temperature, S_IRUGO, show_case_temperature, NULL );


/************************************************************************/
/*	controller thread						*/
/************************************************************************/

static int
write_reg( struct i2c_client *cl, int reg, int data, int len )
{
	u8 tmp[3];

	if( len < 1 || len > 2 || data < 0 )
		return -EINVAL;

	tmp[0] = reg;
	tmp[1] = (len == 1) ? data : (data >> 8);
	tmp[2] = data;
	len++;
	
	if( i2c_master_send(cl, tmp, len) != len )
		return -ENODEV;
	return 0;
}

static int
read_reg( struct i2c_client *cl, int reg, int len )
{
	u8 buf[2];

	if( len != 1 && len != 2 )
		return -EINVAL;
	buf[0] = reg;
	if( i2c_master_send(cl, buf, 1) != 1 )
		return -ENODEV;
	if( i2c_master_recv(cl, buf, len) != len )
		return -ENODEV;
	return (len == 2)? ((unsigned int)buf[0] << 8) | buf[1] : buf[0];
}

static void
tune_fan( int fan_setting )
{
	int val = (fan_setting << 3) | 7;

	/* write_reg( x.fan, 0x24, val, 1 ); */
	write_reg( x.fan, 0x25, val, 1 );
	write_reg( x.fan, 0x20, 0, 1 );
	print_temp("CPU-temp: ", x.temp );
	if( x.casetemp )
		print_temp(", Case: ", x.casetemp );
	printk(",  Fan: %d (tuned %+d)\n", 11-fan_setting, x.fan_level-fan_setting );

	x.fan_level = fan_setting;
}

static void
poll_temp( void )
{
	int temp, i, level, casetemp;

	temp = read_reg( x.thermostat, 0, 2 );

	/* this actually occurs when the computer is loaded */
	if( temp < 0 )
		return;

	casetemp = read_reg(x.fan, 0x0b, 1) << 8;
	casetemp |= (read_reg(x.fan, 0x06, 1) & 0x7) << 5;

	if( LOG_TEMP && x.temp != temp ) {
		print_temp("CPU-temp: ", temp );
		print_temp(", Case: ", casetemp );
		printk(",  Fan: %d\n", 11-x.fan_level );
	}
	x.temp = temp;
	x.casetemp = casetemp;

	level = -1;
	for( i=0; (temp & 0xffff) > fan_table[i].temp ; i++ )
		;
	if( i < x.downind )
		level = fan_table[i].fan_down_setting;
	x.downind = i;

	for( i=0; (temp & 0xffff) >= fan_table[i+1].temp ; i++ )
		;
	if( x.upind < i )
		level = fan_table[i].fan_up_setting;
	x.upind = i;

	if( level >= 0 )
		tune_fan( level );
}


static void
setup_hardware( void )
{
	int val;
	int err;

	/* save registers (if we unload the module) */
	x.r0 = read_reg( x.fan, 0x00, 1 );
	x.r1 = read_reg( x.fan, 0x01, 1 );
	x.r20 = read_reg( x.fan, 0x20, 1 );
	x.r23 = read_reg( x.fan, 0x23, 1 );
	x.r25 = read_reg( x.fan, 0x25, 1 );

	/* improve measurement resolution (convergence time 1.5s) */
	if( (val=read_reg(x.thermostat, 1, 1)) >= 0 ) {
		val |= 0x60;
		if( write_reg( x.thermostat, 1, val, 1 ) )
			printk("Failed writing config register\n");
	}
	/* disable interrupts and TAC input */
	write_reg( x.fan, 0x01, 0x01, 1 );
	/* enable filter */
	write_reg( x.fan, 0x23, 0x91, 1 );
	/* remote temp. controls fan */
	write_reg( x.fan, 0x00, 0x95, 1 );

	/* The thermostat (which besides measureing temperature controls
	 * has a THERM output which puts the fan on 100%) is usually
	 * set to kick in at 80 C (chip default). We reduce this a bit
	 * to be on the safe side (OSX doesn't)...
	 */
	if( x.overheat_temp == (80 << 8) ) {
		x.overheat_temp = 75 << 8;
		x.overheat_hyst = 70 << 8;
		write_reg( x.thermostat, 2, x.overheat_hyst, 2 );
		write_reg( x.thermostat, 3, x.overheat_temp, 2 );

		print_temp("Reducing overheating limit to ", x.overheat_temp );
		print_temp(" (Hyst: ", x.overheat_hyst );
		printk(")\n");
	}

	/* set an initial fan setting */
	x.downind = 0xffff;
	x.upind = -1;
	/* tune_fan( fan_up_table[x.upind].fan_setting ); */

	err = device_create_file( &x.of_dev->dev, &dev_attr_cpu_temperature );
	err |= device_create_file( &x.of_dev->dev, &dev_attr_case_temperature );
	if (err)
		printk(KERN_WARNING
			"Failed to create temperature attribute file(s).\n");
}

static void
restore_regs( void )
{
	device_remove_file( &x.of_dev->dev, &dev_attr_cpu_temperature );
	device_remove_file( &x.of_dev->dev, &dev_attr_case_temperature );

	write_reg( x.fan, 0x01, x.r1, 1 );
	write_reg( x.fan, 0x20, x.r20, 1 );
	write_reg( x.fan, 0x23, x.r23, 1 );
	write_reg( x.fan, 0x25, x.r25, 1 );
	write_reg( x.fan, 0x00, x.r0, 1 );
}

static int control_loop(void *dummy)
{
	mutex_lock(&x.lock);
	setup_hardware();
	mutex_unlock(&x.lock);

	for (;;) {
		msleep_interruptible(8000);
		if (kthread_should_stop())
			break;

		mutex_lock(&x.lock);
		poll_temp();
		mutex_unlock(&x.lock);
	}

	mutex_lock(&x.lock);
	restore_regs();
	mutex_unlock(&x.lock);

	return 0;
}


/************************************************************************/
/*	i2c probing and setup						*/
/************************************************************************/

static int
do_attach( struct i2c_adapter *adapter )
{
	/* scan 0x48-0x4f (DS1775) and 0x2c-2x2f (ADM1030) */
	static const unsigned short scan_ds1775[] = {
		0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
		I2C_CLIENT_END
	};
	static const unsigned short scan_adm1030[] = {
		0x2c, 0x2d, 0x2e, 0x2f,
		I2C_CLIENT_END
	};

	if( strncmp(adapter->name, "uni-n", 5) )
		return 0;

	if( !x.running ) {
		struct i2c_board_info info;

		memset(&info, 0, sizeof(struct i2c_board_info));
		strlcpy(info.type, "therm_ds1775", I2C_NAME_SIZE);
		i2c_new_probed_device(adapter, &info, scan_ds1775, NULL);

		strlcpy(info.type, "therm_adm1030", I2C_NAME_SIZE);
		i2c_new_probed_device(adapter, &info, scan_adm1030, NULL);

		if( x.thermostat && x.fan ) {
			x.running = 1;
			x.poll_task = kthread_run(control_loop, NULL, "g4fand");
		}
	}
	return 0;
}

static int
do_remove(struct i2c_client *client)
{
	if (x.running) {
		x.running = 0;
		kthread_stop(x.poll_task);
		x.poll_task = NULL;
	}
	if (client == x.thermostat)
		x.thermostat = NULL;
	else if (client == x.fan)
		x.fan = NULL;
	else
		printk(KERN_ERR "g4fan: bad client\n");

	return 0;
}

static int
attach_fan( struct i2c_client *cl )
{
	if( x.fan )
		goto out;

	/* check that this is an ADM1030 */
	if( read_reg(cl, 0x3d, 1) != 0x30 || read_reg(cl, 0x3e, 1) != 0x41 )
		goto out;
	printk("ADM1030 fan controller [@%02x]\n", cl->addr );

	x.fan = cl;
 out:
	return 0;
}

static int
attach_thermostat( struct i2c_client *cl ) 
{
	int hyst_temp, os_temp, temp;

	if( x.thermostat )
		goto out;

	if( (temp=read_reg(cl, 0, 2)) < 0 )
		goto out;
	
	/* temperature sanity check */
	if( temp < 0x1600 || temp > 0x3c00 )
		goto out;
	hyst_temp = read_reg(cl, 2, 2);
	os_temp = read_reg(cl, 3, 2);
	if( hyst_temp < 0 || os_temp < 0 )
		goto out;

	printk("DS1775 digital thermometer [@%02x]\n", cl->addr );
	print_temp("Temp: ", temp );
	print_temp("  Hyst: ", hyst_temp );
	print_temp("  OS: ", os_temp );
	printk("\n");

	x.temp = temp;
	x.overheat_temp = os_temp;
	x.overheat_hyst = hyst_temp;
	x.thermostat = cl;
out:
	return 0;
}

enum chip { ds1775, adm1030 };

static const struct i2c_device_id therm_windtunnel_id[] = {
	{ "therm_ds1775", ds1775 },
	{ "therm_adm1030", adm1030 },
	{ }
};

static int
do_probe(struct i2c_client *cl, const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter = cl->adapter;

	if( !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA
				     | I2C_FUNC_SMBUS_WRITE_BYTE) )
		return 0;

	switch (id->driver_data) {
	case adm1030:
		return attach_fan( cl );
	case ds1775:
		return attach_thermostat(cl);
	}
	return 0;
}

static struct i2c_driver g4fan_driver = {
	.driver = {
		.name	= "therm_windtunnel",
	},
	.attach_adapter = do_attach,
	.probe		= do_probe,
	.remove		= do_remove,
	.id_table	= therm_windtunnel_id,
};


/************************************************************************/
/*	initialization / cleanup					*/
/************************************************************************/

static int therm_of_probe(struct platform_device *dev)
{
	return i2c_add_driver( &g4fan_driver );
}

static int
therm_of_remove( struct platform_device *dev )
{
	i2c_del_driver( &g4fan_driver );
	return 0;
}

static const struct of_device_id therm_of_match[] = {{
	.name		= "fan",
	.compatible	= "adm1030"
    }, {}
};

static struct platform_driver therm_of_driver = {
	.driver = {
		.name = "temperature",
		.owner = THIS_MODULE,
		.of_match_table = therm_of_match,
	},
	.probe		= therm_of_probe,
	.remove		= therm_of_remove,
};

struct apple_thermal_info {
	u8		id;			/* implementation ID */
	u8		fan_count;		/* number of fans */
	u8		thermostat_count;	/* number of thermostats */
	u8		unused;
};

static int __init
g4fan_init( void )
{
	const struct apple_thermal_info *info;
	struct device_node *np;

	mutex_init(&x.lock);

	if( !(np=of_find_node_by_name(NULL, "power-mgt")) )
		return -ENODEV;
	info = of_get_property(np, "thermal-info", NULL);
	of_node_put(np);

	if( !info || !of_machine_is_compatible("PowerMac3,6") )
		return -ENODEV;

	if( info->id != 3 ) {
		printk(KERN_ERR "therm_windtunnel: unsupported thermal design %d\n", info->id );
		return -ENODEV;
	}
	if( !(np=of_find_node_by_name(NULL, "fan")) )
		return -ENODEV;
	x.of_dev = of_platform_device_create(np, "temperature", NULL);
	of_node_put( np );

	if( !x.of_dev ) {
		printk(KERN_ERR "Can't register fan controller!\n");
		return -ENODEV;
	}

	platform_driver_register( &therm_of_driver );
	return 0;
}

static void __exit
g4fan_exit( void )
{
	platform_driver_unregister( &therm_of_driver );

	if( x.of_dev )
		of_device_unregister( x.of_dev );
}

module_init(g4fan_init);
module_exit(g4fan_exit);

MODULE_AUTHOR("Samuel Rydh <[email protected]>");
MODULE_DESCRIPTION("Apple G4 (windtunnel) fan controller");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Creation Date: <2003/03/14 20:54:13 samuel>
	3	* Time-stamp: <2004/03/20 14:20:59 samuel>
	4	*
	5	* <therm_windtunnel.c>
	6	*
	7	* The G4 "windtunnel" has a single fan controlled by an
	8	* ADM1030 fan controller and a DS1775 thermostat.
	9	*
	10	* The fan controller is equipped with a temperature sensor
	11	* which measures the case temperature. The DS1775 sensor
	12	* measures the CPU temperature. This driver tunes the
	13	* behavior of the fan. It is based upon empirical observations
	14	* of the 'AppleFan' driver under Mac OS X.
	15	*
	16	* WARNING: This driver has only been testen on Apple's
	17	* 1.25 MHz Dual G4 (March 03). It is tuned for a CPU
af901ca1	18	* temperature around 57 C.
1da177e4 LT	19	*
	20	* Copyright (C) 2003, 2004 Samuel Rydh ([email protected])
	21	*
	22	* Loosely based upon 'thermostat.c' written by Benjamin Herrenschmidt
	23	*
	24	* This program is free software; you can redistribute it and/or
	25	* modify it under the terms of the GNU General Public License
	26	* as published by the Free Software Foundation
	27	*
	28	*/
	29
1da177e4 LT	30	#include <linux/types.h>
	31	#include <linux/module.h>
	32	#include <linux/errno.h>
	33	#include <linux/kernel.h>
	34	#include <linux/delay.h>
	35	#include <linux/sched.h>
	36	#include <linux/i2c.h>
1da177e4	37	#include <linux/init.h>
98f6740e	38	#include <linux/kthread.h>
ad9e05ae	39	#include <linux/of_platform.h>
7eebde70	40
1da177e4 LT	41	#include <asm/prom.h>
	42	#include <asm/machdep.h>
	43	#include <asm/io.h>
1da177e4	44	#include <asm/sections.h>
5e655772	45	#include <asm/macio.h>
1da177e4	46
25985edc	47	#define LOG_TEMP 0 /* continuously log temperature */
1da177e4	48
1da177e4 LT	49	static struct {
1da177e4 LT	50	volatile int running;
98f6740e	51	struct task_struct *poll_task;
1da177e4	52
1baaeea0	53	struct mutex lock;
2dc11581	54	struct platform_device *of_dev;
1da177e4 LT	55
	56	struct i2c_client *thermostat;
	57	struct i2c_client *fan;
	58
	59	int overheat_temp; /* 100% fan at this temp */
	60	int overheat_hyst;
	61	int temp;
	62	int casetemp;
	63	int fan_level; /* active fan_table setting */
	64
	65	int downind;
	66	int upind;
	67
	68	int r0, r1, r20, r23, r25; /* saved register */
	69	} x;
	70
	71	#define T(x,y) (((x)<<8) \| (y)*0x100/10 )
	72
	73	static struct {
	74	int fan_down_setting;
	75	int temp;
	76	int fan_up_setting;
	77	} fan_table[] = {
	78	{ 11, T(0,0), 11 }, /* min fan */
	79	{ 11, T(55,0), 11 },
	80	{ 6, T(55,3), 11 },
	81	{ 7, T(56,0), 11 },
	82	{ 8, T(57,0), 8 },
	83	{ 7, T(58,3), 7 },
	84	{ 6, T(58,8), 6 },
	85	{ 5, T(59,2), 5 },
	86	{ 4, T(59,6), 4 },
	87	{ 3, T(59,9), 3 },
	88	{ 2, T(60,1), 2 },
	89	{ 1, 0xfffff, 1 } /* on fire */
	90	};
	91
	92	static void
	93	print_temp( const char *s, int temp )
	94	{
	95	printk("%s%d.%d C", s ? s : "", temp>>8, (temp & 255)*10/256 );
	96	}
	97
	98	static ssize_t
e404e274	99	show_cpu_temperature( struct device dev, struct device_attribute attr, char *buf )
1da177e4 LT	100	{
	101	return sprintf(buf, "%d.%d\n", x.temp>>8, (x.temp & 255)*10/256 );
	102	}
	103
	104	static ssize_t
e404e274	105	show_case_temperature( struct device dev, struct device_attribute attr, char *buf )
1da177e4 LT	106	{
	107	return sprintf(buf, "%d.%d\n", x.casetemp>>8, (x.casetemp & 255)*10/256 );
	108	}
	109
	110	static DEVICE_ATTR(cpu_temperature, S_IRUGO, show_cpu_temperature, NULL );
	111	static DEVICE_ATTR(case_temperature, S_IRUGO, show_case_temperature, NULL );
	112
	113
	114
	115	/************************************************************************/
	116	/* controller thread */
	117	/************************************************************************/
	118
	119	static int
	120	write_reg( struct i2c_client *cl, int reg, int data, int len )
	121	{
	122	u8 tmp[3];
	123
	124	if( len < 1 \|\| len > 2 \|\| data < 0 )
	125	return -EINVAL;
	126
	127	tmp[0] = reg;
	128	tmp[1] = (len == 1) ? data : (data >> 8);
	129	tmp[2] = data;
	130	len++;
	131
	132	if( i2c_master_send(cl, tmp, len) != len )
	133	return -ENODEV;
	134	return 0;
	135	}
	136
	137	static int
	138	read_reg( struct i2c_client *cl, int reg, int len )
	139	{
	140	u8 buf[2];
	141
	142	if( len != 1 && len != 2 )
	143	return -EINVAL;
	144	buf[0] = reg;
	145	if( i2c_master_send(cl, buf, 1) != 1 )
	146	return -ENODEV;
	147	if( i2c_master_recv(cl, buf, len) != len )
	148	return -ENODEV;
	149	return (len == 2)? ((unsigned int)buf[0] << 8) \| buf[1] : buf[0];
	150	}
	151
	152	static void
	153	tune_fan( int fan_setting )
	154	{
	155	int val = (fan_setting << 3) \| 7;
	156
	157	/* write_reg( x.fan, 0x24, val, 1 ); */
	158	write_reg( x.fan, 0x25, val, 1 );
	159	write_reg( x.fan, 0x20, 0, 1 );
	160	print_temp("CPU-temp: ", x.temp );
	161	if( x.casetemp )
	162	print_temp(", Case: ", x.casetemp );
	163	printk(", Fan: %d (tuned %+d)\n", 11-fan_setting, x.fan_level-fan_setting );
	164
	165	x.fan_level = fan_setting;
	166	}
	167
	168	static void
	169	poll_temp( void )
170	{
171	int temp, i, level, casetemp;
172
173	temp = read_reg( x.thermostat, 0, 2 );
174
175	/* this actually occurs when the computer is loaded */
176	if( temp < 0 )
177	return;
178
179	casetemp = read_reg(x.fan, 0x0b, 1) << 8;
180	casetemp \|= (read_reg(x.fan, 0x06, 1) & 0x7) << 5;
181
182	if( LOG_TEMP && x.temp != temp ) {
183	print_temp("CPU-temp: ", temp );
184	print_temp(", Case: ", casetemp );
185	printk(", Fan: %d\n", 11-x.fan_level );
186	}
187	x.temp = temp;
188	x.casetemp = casetemp;
189
190	level = -1;
191	for( i=0; (temp & 0xffff) > fan_table[i].temp ; i++ )
192	;
193	if( i < x.downind )
194	level = fan_table[i].fan_down_setting;
195	x.downind = i;
196
197	for( i=0; (temp & 0xffff) >= fan_table[i+1].temp ; i++ )
198	;
199	if( x.upind < i )
200	level = fan_table[i].fan_up_setting;
201	x.upind = i;
202
203	if( level >= 0 )
204	tune_fan( level );
205	}
206
207
208	static void
209	setup_hardware( void )
210	{
211	int val;
98894dff	212	int err;
1da177e4 LT	213
	214	/* save registers (if we unload the module) */
	215	x.r0 = read_reg( x.fan, 0x00, 1 );
	216	x.r1 = read_reg( x.fan, 0x01, 1 );
	217	x.r20 = read_reg( x.fan, 0x20, 1 );
	218	x.r23 = read_reg( x.fan, 0x23, 1 );
	219	x.r25 = read_reg( x.fan, 0x25, 1 );
	220
	221	/* improve measurement resolution (convergence time 1.5s) */
	222	if( (val=read_reg(x.thermostat, 1, 1)) >= 0 ) {
	223	val \|= 0x60;
	224	if( write_reg( x.thermostat, 1, val, 1 ) )
	225	printk("Failed writing config register\n");
	226	}
	227	/* disable interrupts and TAC input */
	228	write_reg( x.fan, 0x01, 0x01, 1 );
	229	/* enable filter */
	230	write_reg( x.fan, 0x23, 0x91, 1 );
	231	/* remote temp. controls fan */
	232	write_reg( x.fan, 0x00, 0x95, 1 );
	233
	234	/* The thermostat (which besides measureing temperature controls
	235	* has a THERM output which puts the fan on 100%) is usually
	236	* set to kick in at 80 C (chip default). We reduce this a bit
	237	* to be on the safe side (OSX doesn't)...
	238	*/
	239	if( x.overheat_temp == (80 << 8) ) {
b8e4a7da LV	240	x.overheat_temp = 75 << 8;
b8e4a7da LV	241	x.overheat_hyst = 70 << 8;
1da177e4 LT	242	write_reg( x.thermostat, 2, x.overheat_hyst, 2 );
	243	write_reg( x.thermostat, 3, x.overheat_temp, 2 );
	244
	245	print_temp("Reducing overheating limit to ", x.overheat_temp );
	246	print_temp(" (Hyst: ", x.overheat_hyst );
	247	printk(")\n");
	248	}
	249
	250	/* set an initial fan setting */
	251	x.downind = 0xffff;
	252	x.upind = -1;
	253	/* tune_fan( fan_up_table[x.upind].fan_setting ); */
	254
98894dff SR	255	err = device_create_file( &x.of_dev->dev, &dev_attr_cpu_temperature );
	256	err \|= device_create_file( &x.of_dev->dev, &dev_attr_case_temperature );
	257	if (err)
	258	printk(KERN_WARNING
	259	"Failed to create temperature attribute file(s).\n");
1da177e4 LT	260	}
	261
	262	static void
	263	restore_regs( void )
	264	{
	265	device_remove_file( &x.of_dev->dev, &dev_attr_cpu_temperature );
	266	device_remove_file( &x.of_dev->dev, &dev_attr_case_temperature );
	267
	268	write_reg( x.fan, 0x01, x.r1, 1 );
	269	write_reg( x.fan, 0x20, x.r20, 1 );
	270	write_reg( x.fan, 0x23, x.r23, 1 );
	271	write_reg( x.fan, 0x25, x.r25, 1 );
	272	write_reg( x.fan, 0x00, x.r0, 1 );
	273	}
	274
98f6740e	275	static int control_loop(void *dummy)
1da177e4	276	{
1baaeea0	277	mutex_lock(&x.lock);
1da177e4	278	setup_hardware();
1baaeea0	279	mutex_unlock(&x.lock);
1da177e4	280
98f6740e	281	for (;;) {
1da177e4	282	msleep_interruptible(8000);
98f6740e PM	283	if (kthread_should_stop())
	284	break;
	285
1baaeea0	286	mutex_lock(&x.lock);
1da177e4	287	poll_temp();
1baaeea0	288	mutex_unlock(&x.lock);
1da177e4 LT	289	}
1da177e4 LT	290
1baaeea0	291	mutex_lock(&x.lock);
1da177e4	292	restore_regs();
1baaeea0	293	mutex_unlock(&x.lock);
1da177e4	294
98f6740e	295	return 0;
1da177e4 LT	296	}
	297
	298
	299	/************************************************************************/
	300	/* i2c probing and setup */
	301	/************************************************************************/
	302
	303	static int
	304	do_attach( struct i2c_adapter *adapter )
	305	{
036533e2 JD	306	/* scan 0x48-0x4f (DS1775) and 0x2c-2x2f (ADM1030) */
	307	static const unsigned short scan_ds1775[] = {
	308	0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
	309	I2C_CLIENT_END
	310	};
	311	static const unsigned short scan_adm1030[] = {
	312	0x2c, 0x2d, 0x2e, 0x2f,
	313	I2C_CLIENT_END
	314	};
1da177e4 LT	315
	316	if( strncmp(adapter->name, "uni-n", 5) )
	317	return 0;
	318
	319	if( !x.running ) {
036533e2 JD	320	struct i2c_board_info info;
	321
	322	memset(&info, 0, sizeof(struct i2c_board_info));
	323	strlcpy(info.type, "therm_ds1775", I2C_NAME_SIZE);
9a94241a	324	i2c_new_probed_device(adapter, &info, scan_ds1775, NULL);
036533e2 JD	325
036533e2 JD	326	strlcpy(info.type, "therm_adm1030", I2C_NAME_SIZE);
9a94241a	327	i2c_new_probed_device(adapter, &info, scan_adm1030, NULL);
036533e2	328
1da177e4 LT	329	if( x.thermostat && x.fan ) {
1da177e4 LT	330	x.running = 1;
98f6740e	331	x.poll_task = kthread_run(control_loop, NULL, "g4fand");
1da177e4 LT	332	}
1da177e4 LT	333	}
036533e2	334	return 0;
1da177e4 LT	335	}
	336
	337	static int
036533e2	338	do_remove(struct i2c_client *client)
1da177e4	339	{
036533e2 JD	340	if (x.running) {
	341	x.running = 0;
	342	kthread_stop(x.poll_task);
	343	x.poll_task = NULL;
1da177e4	344	}
036533e2 JD	345	if (client == x.thermostat)
	346	x.thermostat = NULL;
	347	else if (client == x.fan)
	348	x.fan = NULL;
	349	else
	350	printk(KERN_ERR "g4fan: bad client\n");
1da177e4	351
036533e2 JD	352	return 0;
036533e2 JD	353	}
1da177e4 LT	354
	355	static int
	356	attach_fan( struct i2c_client *cl )
	357	{
	358	if( x.fan )
	359	goto out;
	360
	361	/* check that this is an ADM1030 */
	362	if( read_reg(cl, 0x3d, 1) != 0x30 \|\| read_reg(cl, 0x3e, 1) != 0x41 )
	363	goto out;
	364	printk("ADM1030 fan controller [@%02x]\n", cl->addr );
	365
036533e2	366	x.fan = cl;
1da177e4	367	out:
1da177e4 LT	368	return 0;
	369	}
	370
	371	static int
	372	attach_thermostat( struct i2c_client *cl )
	373	{
	374	int hyst_temp, os_temp, temp;
	375
	376	if( x.thermostat )
	377	goto out;
	378
	379	if( (temp=read_reg(cl, 0, 2)) < 0 )
	380	goto out;
	381
	382	/* temperature sanity check */
	383	if( temp < 0x1600 \|\| temp > 0x3c00 )
	384	goto out;
	385	hyst_temp = read_reg(cl, 2, 2);
	386	os_temp = read_reg(cl, 3, 2);
	387	if( hyst_temp < 0 \|\| os_temp < 0 )
	388	goto out;
	389
	390	printk("DS1775 digital thermometer [@%02x]\n", cl->addr );
	391	print_temp("Temp: ", temp );
	392	print_temp(" Hyst: ", hyst_temp );
	393	print_temp(" OS: ", os_temp );
	394	printk("\n");
	395
	396	x.temp = temp;
	397	x.overheat_temp = os_temp;
	398	x.overheat_hyst = hyst_temp;
036533e2	399	x.thermostat = cl;
1da177e4	400	out:
1da177e4 LT	401	return 0;
	402	}
	403
036533e2 JD	404	enum chip { ds1775, adm1030 };
	405
	406	static const struct i2c_device_id therm_windtunnel_id[] = {
	407	{ "therm_ds1775", ds1775 },
	408	{ "therm_adm1030", adm1030 },
	409	{ }
	410	};
	411
1da177e4	412	static int
036533e2	413	do_probe(struct i2c_client cl, const struct i2c_device_id id)
1da177e4	414	{
036533e2	415	struct i2c_adapter *adapter = cl->adapter;
1da177e4 LT	416
	417	if( !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA
	418	\| I2C_FUNC_SMBUS_WRITE_BYTE) )
	419	return 0;
	420
036533e2 JD	421	switch (id->driver_data) {
036533e2 JD	422	case adm1030:
1da177e4	423	return attach_fan( cl );
036533e2 JD	424	case ds1775:
	425	return attach_thermostat(cl);
	426	}
	427	return 0;
1da177e4 LT	428	}
1da177e4 LT	429
036533e2 JD	430	static struct i2c_driver g4fan_driver = {
	431	.driver = {
	432	.name = "therm_windtunnel",
	433	},
	434	.attach_adapter = do_attach,
	435	.probe = do_probe,
	436	.remove = do_remove,
	437	.id_table = therm_windtunnel_id,
	438	};
	439
1da177e4 LT	440
	441	/************************************************************************/
	442	/* initialization / cleanup */
	443	/************************************************************************/
	444
00006124	445	static int therm_of_probe(struct platform_device *dev)
1da177e4 LT	446	{
	447	return i2c_add_driver( &g4fan_driver );
	448	}
	449
	450	static int
2dc11581	451	therm_of_remove( struct platform_device *dev )
1da177e4	452	{
b3e82096 JD	453	i2c_del_driver( &g4fan_driver );
b3e82096 JD	454	return 0;
1da177e4 LT	455	}
1da177e4 LT	456
46759a7c	457	static const struct of_device_id therm_of_match[] = {{
1da177e4	458	.name = "fan",
1da177e4 LT	459	.compatible = "adm1030"
	460	}, {}
	461	};
	462
00006124	463	static struct platform_driver therm_of_driver = {
4018294b GL	464	.driver = {
	465	.name = "temperature",
	466	.owner = THIS_MODULE,
	467	.of_match_table = therm_of_match,
	468	},
1da177e4 LT	469	.probe = therm_of_probe,
	470	.remove = therm_of_remove,
	471	};
	472
	473	struct apple_thermal_info {
	474	u8 id; /* implementation ID */
	475	u8 fan_count; /* number of fans */
	476	u8 thermostat_count; /* number of thermostats */
	477	u8 unused;
	478	};
	479
	480	static int __init
	481	g4fan_init( void )
	482	{
018a3d1d	483	const struct apple_thermal_info *info;
1da177e4 LT	484	struct device_node *np;
1da177e4 LT	485
1baaeea0	486	mutex_init(&x.lock);
1da177e4 LT	487
	488	if( !(np=of_find_node_by_name(NULL, "power-mgt")) )
	489	return -ENODEV;
01b2726d	490	info = of_get_property(np, "thermal-info", NULL);
1da177e4 LT	491	of_node_put(np);
1da177e4 LT	492
71a157e8	493	if( !info \|\| !of_machine_is_compatible("PowerMac3,6") )
1da177e4 LT	494	return -ENODEV;
	495
	496	if( info->id != 3 ) {
	497	printk(KERN_ERR "therm_windtunnel: unsupported thermal design %d\n", info->id );
	498	return -ENODEV;
	499	}
	500	if( !(np=of_find_node_by_name(NULL, "fan")) )
	501	return -ENODEV;
0365ba7f	502	x.of_dev = of_platform_device_create(np, "temperature", NULL);
1da177e4 LT	503	of_node_put( np );
	504
	505	if( !x.of_dev ) {
	506	printk(KERN_ERR "Can't register fan controller!\n");
	507	return -ENODEV;
	508	}
	509
00006124	510	platform_driver_register( &therm_of_driver );
1da177e4 LT	511	return 0;
	512	}
	513
	514	static void __exit
	515	g4fan_exit( void )
	516	{
00006124	517	platform_driver_unregister( &therm_of_driver );
1da177e4 LT	518
	519	if( x.of_dev )
	520	of_device_unregister( x.of_dev );
	521	}
	522
	523	module_init(g4fan_init);
	524	module_exit(g4fan_exit);
	525
	526	MODULE_AUTHOR("Samuel Rydh <[email protected]>");
	527	MODULE_DESCRIPTION("Apple G4 (windtunnel) fan controller");
	528	MODULE_LICENSE("GPL");