Commit 75722d39 authored by Benjamin Herrenschmidt's avatar Benjamin Herrenschmidt Committed by Paul Mackerras
Browse files

[PATCH] ppc64: Thermal control for SMU based machines 



This adds a new thermal control framework for PowerMac, along with the
implementation for PowerMac8,1, PowerMac8,2 (iMac G5 rev 1 and 2), and
PowerMac9,1 (latest single CPU desktop). In the future, I expect to move
the older G5 thermal control to the new framework as well.

Signed-off-by: default avatarBenjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: default avatarPaul Mackerras <paulus@samba.org>
parent 7d49697e

drivers/macintosh/Kconfig

+19 −0
Original line number Diff line number Diff line
@@ -169,6 +169,25 @@ config THERM_PM72 
	  This driver provides thermostat and fan control for the desktop

	  G5 machines. 



config WINDFARM

	tristate "New PowerMac thermal control infrastructure"



config WINDFARM_PM81

	tristate "Support for thermal management on iMac G5"

	depends on WINDFARM && I2C && CPU_FREQ_PMAC64 && PMAC_SMU

	select I2C_PMAC_SMU

	help

	  This driver provides thermal control for the iMacG5



config WINDFARM_PM91

	tristate "Support for thermal management on PowerMac9,1"

	depends on WINDFARM && I2C && CPU_FREQ_PMAC64 && PMAC_SMU

	select I2C_PMAC_SMU

	help

	  This driver provides thermal control for the PowerMac9,1

          which is the recent (SMU based) single CPU desktop G5





config ANSLCD

	tristate "Support for ANS LCD display"

	depends on ADB_CUDA && PPC_PMAC

drivers/macintosh/Makefile

+9 −0
Original line number Diff line number Diff line
@@ -26,3 +26,12 @@ obj-$(CONFIG_ADB_MACIO) += macio-adb.o 
obj-$(CONFIG_THERM_PM72)	+= therm_pm72.o

obj-$(CONFIG_THERM_WINDTUNNEL)	+= therm_windtunnel.o

obj-$(CONFIG_THERM_ADT746X)	+= therm_adt746x.o

obj-$(CONFIG_WINDFARM)	        += windfarm_core.o

obj-$(CONFIG_WINDFARM_PM81)     += windfarm_smu_controls.o \

				   windfarm_smu_sensors.o \

				   windfarm_lm75_sensor.o windfarm_pid.o \

				   windfarm_cpufreq_clamp.o windfarm_pm81.o

obj-$(CONFIG_WINDFARM_PM91)     += windfarm_smu_controls.o \

				   windfarm_smu_sensors.o \

				   windfarm_lm75_sensor.o windfarm_pid.o \

				   windfarm_cpufreq_clamp.o windfarm_pm91.o

drivers/macintosh/smu.c

+2 −0
Original line number Diff line number Diff line
@@ -590,6 +590,8 @@ static void smu_expose_childs(void *unused) 
			sprintf(name, "smu-i2c-%02x", *reg);

			of_platform_device_create(np, name, &smu->of_dev->dev);

		}

		if (device_is_compatible(np, "smu-sensors"))

			of_platform_device_create(np, "smu-sensors", &smu->of_dev->dev);

	}



}

drivers/macintosh/windfarm.h

0 → 100644
+131 −0
Original line number Diff line number Diff line 
/*

 * Windfarm PowerMac thermal control.

 *

 * (c) Copyright 2005 Benjamin Herrenschmidt, IBM Corp.

 *                    <benh@kernel.crashing.org>

 *

 * Released under the term of the GNU GPL v2.

 */



#ifndef __WINDFARM_H__

#define __WINDFARM_H__



#include <linux/kref.h>

#include <linux/list.h>

#include <linux/module.h>

#include <linux/notifier.h>



/* Display a 16.16 fixed point value */

#define FIX32TOPRINT(f)	((f) >> 16),((((f) & 0xffff) * 1000) >> 16)



/*

 * Control objects

 */



struct wf_control;



struct wf_control_ops {

	int			(*set_value)(struct wf_control *ct, s32 val);

	int			(*get_value)(struct wf_control *ct, s32 *val);

	s32			(*get_min)(struct wf_control *ct);

	s32			(*get_max)(struct wf_control *ct);

	void			(*release)(struct wf_control *ct);

	struct module		*owner;

};



struct wf_control {

	struct list_head	link;

	struct wf_control_ops	*ops;

	char			*name;

	int			type;

	struct kref		ref;

};



#define WF_CONTROL_TYPE_GENERIC		0

#define WF_CONTROL_RPM_FAN		1

#define WF_CONTROL_PWM_FAN		2





/* Note about lifetime rules: wf_register_control() will initialize

 * the kref and wf_unregister_control will decrement it, thus the

 * object creating/disposing a given control shouldn't assume it

 * still exists after wf_unregister_control has been called.

 * wf_find_control will inc the refcount for you

 */

extern int wf_register_control(struct wf_control *ct);

extern void wf_unregister_control(struct wf_control *ct);

extern struct wf_control * wf_find_control(const char *name);

extern int wf_get_control(struct wf_control *ct);

extern void wf_put_control(struct wf_control *ct);



static inline int wf_control_set_max(struct wf_control *ct)

{

	s32 vmax = ct->ops->get_max(ct);

	return ct->ops->set_value(ct, vmax);

}



static inline int wf_control_set_min(struct wf_control *ct)

{

	s32 vmin = ct->ops->get_min(ct);

	return ct->ops->set_value(ct, vmin);

}



/*

 * Sensor objects

 */



struct wf_sensor;



struct wf_sensor_ops {

	int			(*get_value)(struct wf_sensor *sr, s32 *val);

	void			(*release)(struct wf_sensor *sr);

	struct module		*owner;

};



struct wf_sensor {

	struct list_head	link;

	struct wf_sensor_ops	*ops;

	char			*name;

	struct kref		ref;

};



/* Same lifetime rules as controls */

extern int wf_register_sensor(struct wf_sensor *sr);

extern void wf_unregister_sensor(struct wf_sensor *sr);

extern struct wf_sensor * wf_find_sensor(const char *name);

extern int wf_get_sensor(struct wf_sensor *sr);

extern void wf_put_sensor(struct wf_sensor *sr);



/* For use by clients. Note that we are a bit racy here since

 * notifier_block doesn't have a module owner field. I may fix

 * it one day ...

 *

 * LOCKING NOTE !

 *

 * All "events" except WF_EVENT_TICK are called with an internal mutex

 * held which will deadlock if you call basically any core routine.

 * So don't ! Just take note of the event and do your actual operations

 * from the ticker.

 *

 */

extern int wf_register_client(struct notifier_block *nb);

extern int wf_unregister_client(struct notifier_block *nb);



/* Overtemp conditions. Those are refcounted */

extern void wf_set_overtemp(void);

extern void wf_clear_overtemp(void);

extern int wf_is_overtemp(void);



#define WF_EVENT_NEW_CONTROL	0 /* param is wf_control * */

#define WF_EVENT_NEW_SENSOR	1 /* param is wf_sensor * */

#define WF_EVENT_OVERTEMP	2 /* no param */

#define WF_EVENT_NORMALTEMP	3 /* overtemp condition cleared */

#define WF_EVENT_TICK		4 /* 1 second tick */



/* Note: If that driver gets more broad use, we could replace the

 * simplistic overtemp bits with "environmental conditions". That

 * could then be used to also notify of things like fan failure,

 * case open, battery conditions, ...

 */



#endif /* __WINDFARM_H__ */

drivers/macintosh/windfarm_core.c

0 → 100644
+426 −0
Original line number Diff line number Diff line 
/*

 * Windfarm PowerMac thermal control. Core

 *

 * (c) Copyright 2005 Benjamin Herrenschmidt, IBM Corp.

 *                    <benh@kernel.crashing.org>

 *

 * Released under the term of the GNU GPL v2.

 *

 * This core code tracks the list of sensors & controls, register

 * clients, and holds the kernel thread used for control.

 *

 * TODO:

 *

 * Add some information about sensor/control type and data format to

 * sensors/controls, and have the sysfs attribute stuff be moved

 * generically here instead of hard coded in the platform specific

 * driver as it us currently

 *

 * This however requires solving some annoying lifetime issues with

 * sysfs which doesn't seem to have lifetime rules for struct attribute,

 * I may have to create full features kobjects for every sensor/control

 * instead which is a bit of an overkill imho

 */



#include <linux/types.h>

#include <linux/errno.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/spinlock.h>

#include <linux/smp_lock.h>

#include <linux/kthread.h>

#include <linux/jiffies.h>

#include <linux/reboot.h>

#include <linux/device.h>

#include <linux/platform_device.h>



#include "windfarm.h"



#define VERSION "0.2"



#undef DEBUG



#ifdef DEBUG

#define DBG(args...)	printk(args)

#else

#define DBG(args...)	do { } while(0)

#endif



static LIST_HEAD(wf_controls);

static LIST_HEAD(wf_sensors);

static DECLARE_MUTEX(wf_lock);

static struct notifier_block *wf_client_list;

static int wf_client_count;

static unsigned int wf_overtemp;

static unsigned int wf_overtemp_counter;

struct task_struct *wf_thread;



/*

 * Utilities & tick thread

 */



static inline void wf_notify(int event, void *param)

{

	notifier_call_chain(&wf_client_list, event, param);

}



int wf_critical_overtemp(void)

{

	static char * critical_overtemp_path = "/sbin/critical_overtemp";

	char *argv[] = { critical_overtemp_path, NULL };

	static char *envp[] = { "HOME=/",

				"TERM=linux",

				"PATH=/sbin:/usr/sbin:/bin:/usr/bin",

				NULL };



	return call_usermodehelper(critical_overtemp_path, argv, envp, 0);

}

EXPORT_SYMBOL_GPL(wf_critical_overtemp);



static int wf_thread_func(void *data)

{

	unsigned long next, delay;



	next = jiffies;



	DBG("wf: thread started\n");



	while(!kthread_should_stop()) {

		try_to_freeze();



		if (time_after_eq(jiffies, next)) {

			wf_notify(WF_EVENT_TICK, NULL);

			if (wf_overtemp) {

				wf_overtemp_counter++;

				/* 10 seconds overtemp, notify userland */

				if (wf_overtemp_counter > 10)

					wf_critical_overtemp();

				/* 30 seconds, shutdown */

				if (wf_overtemp_counter > 30) {

					printk(KERN_ERR "windfarm: Overtemp "

					       "for more than 30"

					       " seconds, shutting down\n");

					machine_power_off();

				}

			}

			next += HZ;

		}



		delay = next - jiffies;

		if (delay <= HZ)

			schedule_timeout_interruptible(delay);



		/* there should be no signal, but oh well */

		if (signal_pending(current)) {

			printk(KERN_WARNING "windfarm: thread got sigl !\n");

			break;

		}

	}



	DBG("wf: thread stopped\n");



	return 0;

}



static void wf_start_thread(void)

{

	wf_thread = kthread_run(wf_thread_func, NULL, "kwindfarm");

	if (IS_ERR(wf_thread)) {

		printk(KERN_ERR "windfarm: failed to create thread,err %ld\n",

		       PTR_ERR(wf_thread));

		wf_thread = NULL;

	}

}





static void wf_stop_thread(void)

{

	if (wf_thread)

		kthread_stop(wf_thread);

	wf_thread = NULL;

}



/*

 * Controls

 */



static void wf_control_release(struct kref *kref)

{

	struct wf_control *ct = container_of(kref, struct wf_control, ref);



	DBG("wf: Deleting control %s\n", ct->name);



	if (ct->ops && ct->ops->release)

		ct->ops->release(ct);

	else

		kfree(ct);

}



int wf_register_control(struct wf_control *new_ct)

{

	struct wf_control *ct;



	down(&wf_lock);

	list_for_each_entry(ct, &wf_controls, link) {

		if (!strcmp(ct->name, new_ct->name)) {

			printk(KERN_WARNING "windfarm: trying to register"

			       " duplicate control %s\n", ct->name);

			up(&wf_lock);

			return -EEXIST;

		}

	}

	kref_init(&new_ct->ref);

	list_add(&new_ct->link, &wf_controls);



	DBG("wf: Registered control %s\n", new_ct->name);



	wf_notify(WF_EVENT_NEW_CONTROL, new_ct);

	up(&wf_lock);



	return 0;

}

EXPORT_SYMBOL_GPL(wf_register_control);



void wf_unregister_control(struct wf_control *ct)

{

	down(&wf_lock);

	list_del(&ct->link);

	up(&wf_lock);



	DBG("wf: Unregistered control %s\n", ct->name);



	kref_put(&ct->ref, wf_control_release);

}

EXPORT_SYMBOL_GPL(wf_unregister_control);



struct wf_control * wf_find_control(const char *name)

{

	struct wf_control *ct;



	down(&wf_lock);

	list_for_each_entry(ct, &wf_controls, link) {

		if (!strcmp(ct->name, name)) {

			if (wf_get_control(ct))

				ct = NULL;

			up(&wf_lock);

			return ct;

		}

	}

	up(&wf_lock);

	return NULL;

}

EXPORT_SYMBOL_GPL(wf_find_control);



int wf_get_control(struct wf_control *ct)

{

	if (!try_module_get(ct->ops->owner))

		return -ENODEV;

	kref_get(&ct->ref);

	return 0;

}

EXPORT_SYMBOL_GPL(wf_get_control);



void wf_put_control(struct wf_control *ct)

{

	struct module *mod = ct->ops->owner;

	kref_put(&ct->ref, wf_control_release);

	module_put(mod);

}

EXPORT_SYMBOL_GPL(wf_put_control);





/*

 * Sensors

 */





static void wf_sensor_release(struct kref *kref)

{

	struct wf_sensor *sr = container_of(kref, struct wf_sensor, ref);



	DBG("wf: Deleting sensor %s\n", sr->name);



	if (sr->ops && sr->ops->release)

		sr->ops->release(sr);

	else

		kfree(sr);

}



int wf_register_sensor(struct wf_sensor *new_sr)

{

	struct wf_sensor *sr;



	down(&wf_lock);

	list_for_each_entry(sr, &wf_sensors, link) {

		if (!strcmp(sr->name, new_sr->name)) {

			printk(KERN_WARNING "windfarm: trying to register"

			       " duplicate sensor %s\n", sr->name);

			up(&wf_lock);

			return -EEXIST;

		}

	}

	kref_init(&new_sr->ref);

	list_add(&new_sr->link, &wf_sensors);



	DBG("wf: Registered sensor %s\n", new_sr->name);



	wf_notify(WF_EVENT_NEW_SENSOR, new_sr);

	up(&wf_lock);



	return 0;

}

EXPORT_SYMBOL_GPL(wf_register_sensor);



void wf_unregister_sensor(struct wf_sensor *sr)

{

	down(&wf_lock);

	list_del(&sr->link);

	up(&wf_lock);



	DBG("wf: Unregistered sensor %s\n", sr->name);



	wf_put_sensor(sr);

}

EXPORT_SYMBOL_GPL(wf_unregister_sensor);



struct wf_sensor * wf_find_sensor(const char *name)

{

	struct wf_sensor *sr;



	down(&wf_lock);

	list_for_each_entry(sr, &wf_sensors, link) {

		if (!strcmp(sr->name, name)) {

			if (wf_get_sensor(sr))

				sr = NULL;

			up(&wf_lock);

			return sr;

		}

	}

	up(&wf_lock);

	return NULL;

}

EXPORT_SYMBOL_GPL(wf_find_sensor);



int wf_get_sensor(struct wf_sensor *sr)

{

	if (!try_module_get(sr->ops->owner))

		return -ENODEV;

	kref_get(&sr->ref);

	return 0;

}

EXPORT_SYMBOL_GPL(wf_get_sensor);



void wf_put_sensor(struct wf_sensor *sr)

{

	struct module *mod = sr->ops->owner;

	kref_put(&sr->ref, wf_sensor_release);

	module_put(mod);

}

EXPORT_SYMBOL_GPL(wf_put_sensor);





/*

 * Client & notification

 */



int wf_register_client(struct notifier_block *nb)

{

	int rc;

	struct wf_control *ct;

	struct wf_sensor *sr;



	down(&wf_lock);

	rc = notifier_chain_register(&wf_client_list, nb);

	if (rc != 0)

		goto bail;

	wf_client_count++;

	list_for_each_entry(ct, &wf_controls, link)

		wf_notify(WF_EVENT_NEW_CONTROL, ct);

	list_for_each_entry(sr, &wf_sensors, link)

		wf_notify(WF_EVENT_NEW_SENSOR, sr);

	if (wf_client_count == 1)

		wf_start_thread();

 bail:

	up(&wf_lock);

	return rc;

}

EXPORT_SYMBOL_GPL(wf_register_client);



int wf_unregister_client(struct notifier_block *nb)

{

	down(&wf_lock);

	notifier_chain_unregister(&wf_client_list, nb);

	wf_client_count++;

	if (wf_client_count == 0)

		wf_stop_thread();

	up(&wf_lock);



	return 0;

}

EXPORT_SYMBOL_GPL(wf_unregister_client);



void wf_set_overtemp(void)

{

	down(&wf_lock);

	wf_overtemp++;

	if (wf_overtemp == 1) {

		printk(KERN_WARNING "windfarm: Overtemp condition detected !\n");

		wf_overtemp_counter = 0;

		wf_notify(WF_EVENT_OVERTEMP, NULL);

	}

	up(&wf_lock);

}

EXPORT_SYMBOL_GPL(wf_set_overtemp);



void wf_clear_overtemp(void)

{

	down(&wf_lock);

	WARN_ON(wf_overtemp == 0);

	if (wf_overtemp == 0) {

		up(&wf_lock);

		return;

	}

	wf_overtemp--;

	if (wf_overtemp == 0) {

		printk(KERN_WARNING "windfarm: Overtemp condition cleared !\n");

		wf_notify(WF_EVENT_NORMALTEMP, NULL);

	}

	up(&wf_lock);

}

EXPORT_SYMBOL_GPL(wf_clear_overtemp);



int wf_is_overtemp(void)

{

	return (wf_overtemp != 0);

}

EXPORT_SYMBOL_GPL(wf_is_overtemp);



static struct platform_device wf_platform_device = {

	.name	= "windfarm",

};



static int __init windfarm_core_init(void)

{

	DBG("wf: core loaded\n");



	platform_device_register(&wf_platform_device);

	return 0;

}



static void __exit windfarm_core_exit(void)

{

	BUG_ON(wf_client_count != 0);



	DBG("wf: core unloaded\n");



	platform_device_unregister(&wf_platform_device);

}





module_init(windfarm_core_init);

module_exit(windfarm_core_exit);



MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");

MODULE_DESCRIPTION("Core component of PowerMac thermal control");

MODULE_LICENSE("GPL");

CRA Git | Maintained and supported by SUSTech CRA and CCSE