git.oblomov.eu Git - linux-2.6/blob - drivers/macintosh/windfarm_core.c

   1 /*
   2  * Windfarm PowerMac thermal control. Core
   3  *
   4  * (c) Copyright 2005 Benjamin Herrenschmidt, IBM Corp.
   5  *                    <benh@kernel.crashing.org>
   6  *
   7  * Released under the term of the GNU GPL v2.
   8  *
   9  * This core code tracks the list of sensors & controls, register
  10  * clients, and holds the kernel thread used for control.
  11  *
  12  * TODO:
  13  *
  14  * Add some information about sensor/control type and data format to
  15  * sensors/controls, and have the sysfs attribute stuff be moved
  16  * generically here instead of hard coded in the platform specific
  17  * driver as it us currently
  18  *
  19  * This however requires solving some annoying lifetime issues with
  20  * sysfs which doesn't seem to have lifetime rules for struct attribute,
  21  * I may have to create full features kobjects for every sensor/control
  22  * instead which is a bit of an overkill imho
  23  */
  24
  25 #include <linux/types.h>
  26 #include <linux/errno.h>
  27 #include <linux/kernel.h>
  28 #include <linux/init.h>
  29 #include <linux/spinlock.h>
  30 #include <linux/smp_lock.h>
  31 #include <linux/kthread.h>
  32 #include <linux/jiffies.h>
  33 #include <linux/reboot.h>
  34 #include <linux/device.h>
  35 #include <linux/platform_device.h>
  36
  37 #include "windfarm.h"
  38
  39 #define VERSION "0.2"
  40
  41 #undef DEBUG
  42
  43 #ifdef DEBUG
  44 #define DBG(args...)    printk(args)
  45 #else
  46 #define DBG(args...)    do { } while(0)
  47 #endif
  48
  49 static LIST_HEAD(wf_controls);
  50 static LIST_HEAD(wf_sensors);
  51 static DECLARE_MUTEX(wf_lock);
  52 static struct notifier_block *wf_client_list;
  53 static int wf_client_count;
  54 static unsigned int wf_overtemp;
  55 static unsigned int wf_overtemp_counter;
  56 struct task_struct *wf_thread;
  57
  58 /*
  59  * Utilities & tick thread
  60  */
  61
  62 static inline void wf_notify(int event, void *param)
  63 {
  64         notifier_call_chain(&wf_client_list, event, param);
  65 }
  66
  67 int wf_critical_overtemp(void)
  68 {
  69         static char * critical_overtemp_path = "/sbin/critical_overtemp";
  70         char *argv[] = { critical_overtemp_path, NULL };
  71         static char *envp[] = { "HOME=/",
  72                                 "TERM=linux",
  73                                 "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
  74                                 NULL };
  75
  76         return call_usermodehelper(critical_overtemp_path, argv, envp, 0);
  77 }
  78 EXPORT_SYMBOL_GPL(wf_critical_overtemp);
  79
  80 static int wf_thread_func(void *data)
  81 {
  82         unsigned long next, delay;
  83
  84         next = jiffies;
  85
  86         DBG("wf: thread started\n");
  87
  88         while(!kthread_should_stop()) {
  89                 try_to_freeze();
  90
  91                 if (time_after_eq(jiffies, next)) {
  92                         wf_notify(WF_EVENT_TICK, NULL);
  93                         if (wf_overtemp) {
  94                                 wf_overtemp_counter++;
  95                                 /* 10 seconds overtemp, notify userland */
  96                                 if (wf_overtemp_counter > 10)
  97                                         wf_critical_overtemp();
  98                                 /* 30 seconds, shutdown */
  99                                 if (wf_overtemp_counter > 30) {
 100                                         printk(KERN_ERR "windfarm: Overtemp "
 101                                                "for more than 30"
 102                                                " seconds, shutting down\n");
 103                                         machine_power_off();
 104                                 }
 105                         }
 106                         next += HZ;
 107                 }
 108
 109                 delay = next - jiffies;
 110                 if (delay <= HZ)
 111                         schedule_timeout_interruptible(delay);
 112
 113                 /* there should be no signal, but oh well */
 114                 if (signal_pending(current)) {
 115                         printk(KERN_WARNING "windfarm: thread got sigl !\n");
 116                         break;
 117                 }
 118         }
 119
 120         DBG("wf: thread stopped\n");
 121
 122         return 0;
 123 }
 124
 125 static void wf_start_thread(void)
 126 {
 127         wf_thread = kthread_run(wf_thread_func, NULL, "kwindfarm");
 128         if (IS_ERR(wf_thread)) {
 129                 printk(KERN_ERR "windfarm: failed to create thread,err %ld\n",
 130                        PTR_ERR(wf_thread));
 131                 wf_thread = NULL;
 132         }
 133 }
 134
 135
 136 static void wf_stop_thread(void)
 137 {
 138         if (wf_thread)
 139                 kthread_stop(wf_thread);
 140         wf_thread = NULL;
 141 }
 142
 143 /*
 144  * Controls
 145  */
 146
 147 static void wf_control_release(struct kref *kref)
 148 {
 149         struct wf_control *ct = container_of(kref, struct wf_control, ref);
 150
 151         DBG("wf: Deleting control %s\n", ct->name);
 152
 153         if (ct->ops && ct->ops->release)
 154                 ct->ops->release(ct);
 155         else
 156                 kfree(ct);
 157 }
 158
 159 int wf_register_control(struct wf_control *new_ct)
 160 {
 161         struct wf_control *ct;
 162
 163         down(&wf_lock);
 164         list_for_each_entry(ct, &wf_controls, link) {
 165                 if (!strcmp(ct->name, new_ct->name)) {
 166                         printk(KERN_WARNING "windfarm: trying to register"
 167                                " duplicate control %s\n", ct->name);
 168                         up(&wf_lock);
 169                         return -EEXIST;
 170                 }
 171         }
 172         kref_init(&new_ct->ref);
 173         list_add(&new_ct->link, &wf_controls);
 174
 175         DBG("wf: Registered control %s\n", new_ct->name);
 176
 177         wf_notify(WF_EVENT_NEW_CONTROL, new_ct);
 178         up(&wf_lock);
 179
 180         return 0;
 181 }
 182 EXPORT_SYMBOL_GPL(wf_register_control);
 183
 184 void wf_unregister_control(struct wf_control *ct)
 185 {
 186         down(&wf_lock);
 187         list_del(&ct->link);
 188         up(&wf_lock);
 189
 190         DBG("wf: Unregistered control %s\n", ct->name);
 191
 192         kref_put(&ct->ref, wf_control_release);
 193 }
 194 EXPORT_SYMBOL_GPL(wf_unregister_control);
 195
 196 struct wf_control * wf_find_control(const char *name)
 197 {
 198         struct wf_control *ct;
 199
 200         down(&wf_lock);
 201         list_for_each_entry(ct, &wf_controls, link) {
 202                 if (!strcmp(ct->name, name)) {
 203                         if (wf_get_control(ct))
 204                                 ct = NULL;
 205                         up(&wf_lock);
 206                         return ct;
 207                 }
 208         }
 209         up(&wf_lock);
 210         return NULL;
 211 }
 212 EXPORT_SYMBOL_GPL(wf_find_control);
 213
 214 int wf_get_control(struct wf_control *ct)
 215 {
 216         if (!try_module_get(ct->ops->owner))
 217                 return -ENODEV;
 218         kref_get(&ct->ref);
 219         return 0;
 220 }
 221 EXPORT_SYMBOL_GPL(wf_get_control);
 222
 223 void wf_put_control(struct wf_control *ct)
 224 {
 225         struct module *mod = ct->ops->owner;
 226         kref_put(&ct->ref, wf_control_release);
 227         module_put(mod);
 228 }
 229 EXPORT_SYMBOL_GPL(wf_put_control);
 230
 231
 232 /*
 233  * Sensors
 234  */
 235
 236
 237 static void wf_sensor_release(struct kref *kref)
 238 {
 239         struct wf_sensor *sr = container_of(kref, struct wf_sensor, ref);
 240
 241         DBG("wf: Deleting sensor %s\n", sr->name);
 242
 243         if (sr->ops && sr->ops->release)
 244                 sr->ops->release(sr);
 245         else
 246                 kfree(sr);
 247 }
 248
 249 int wf_register_sensor(struct wf_sensor *new_sr)
 250 {
 251         struct wf_sensor *sr;
 252
 253         down(&wf_lock);
 254         list_for_each_entry(sr, &wf_sensors, link) {
 255                 if (!strcmp(sr->name, new_sr->name)) {
 256                         printk(KERN_WARNING "windfarm: trying to register"
 257                                " duplicate sensor %s\n", sr->name);
 258                         up(&wf_lock);
 259                         return -EEXIST;
 260                 }
 261         }
 262         kref_init(&new_sr->ref);
 263         list_add(&new_sr->link, &wf_sensors);
 264
 265         DBG("wf: Registered sensor %s\n", new_sr->name);
 266
 267         wf_notify(WF_EVENT_NEW_SENSOR, new_sr);
 268         up(&wf_lock);
 269
 270         return 0;
 271 }
 272 EXPORT_SYMBOL_GPL(wf_register_sensor);
 273
 274 void wf_unregister_sensor(struct wf_sensor *sr)
 275 {
 276         down(&wf_lock);
 277         list_del(&sr->link);
 278         up(&wf_lock);
 279
 280         DBG("wf: Unregistered sensor %s\n", sr->name);
 281
 282         wf_put_sensor(sr);
 283 }
 284 EXPORT_SYMBOL_GPL(wf_unregister_sensor);
 285
 286 struct wf_sensor * wf_find_sensor(const char *name)
 287 {
 288         struct wf_sensor *sr;
 289
 290         down(&wf_lock);
 291         list_for_each_entry(sr, &wf_sensors, link) {
 292                 if (!strcmp(sr->name, name)) {
 293                         if (wf_get_sensor(sr))
 294                                 sr = NULL;
 295                         up(&wf_lock);
 296                         return sr;
 297                 }
 298         }
 299         up(&wf_lock);
 300         return NULL;
 301 }
 302 EXPORT_SYMBOL_GPL(wf_find_sensor);
 303
 304 int wf_get_sensor(struct wf_sensor *sr)
 305 {
 306         if (!try_module_get(sr->ops->owner))
 307                 return -ENODEV;
 308         kref_get(&sr->ref);
 309         return 0;
 310 }
 311 EXPORT_SYMBOL_GPL(wf_get_sensor);
 312
 313 void wf_put_sensor(struct wf_sensor *sr)
 314 {
 315         struct module *mod = sr->ops->owner;
 316         kref_put(&sr->ref, wf_sensor_release);
 317         module_put(mod);
 318 }
 319 EXPORT_SYMBOL_GPL(wf_put_sensor);
 320
 321
 322 /*
 323  * Client & notification
 324  */
 325
 326 int wf_register_client(struct notifier_block *nb)
 327 {
 328         int rc;
 329         struct wf_control *ct;
 330         struct wf_sensor *sr;
 331
 332         down(&wf_lock);
 333         rc = notifier_chain_register(&wf_client_list, nb);
 334         if (rc != 0)
 335                 goto bail;
 336         wf_client_count++;
 337         list_for_each_entry(ct, &wf_controls, link)
 338                 wf_notify(WF_EVENT_NEW_CONTROL, ct);
 339         list_for_each_entry(sr, &wf_sensors, link)
 340                 wf_notify(WF_EVENT_NEW_SENSOR, sr);
 341         if (wf_client_count == 1)
 342                 wf_start_thread();
 343  bail:
 344         up(&wf_lock);
 345         return rc;
 346 }
 347 EXPORT_SYMBOL_GPL(wf_register_client);
 348
 349 int wf_unregister_client(struct notifier_block *nb)
 350 {
 351         down(&wf_lock);
 352         notifier_chain_unregister(&wf_client_list, nb);
 353         wf_client_count++;
 354         if (wf_client_count == 0)
 355                 wf_stop_thread();
 356         up(&wf_lock);
 357
 358         return 0;
 359 }
 360 EXPORT_SYMBOL_GPL(wf_unregister_client);
 361
 362 void wf_set_overtemp(void)
 363 {
 364         down(&wf_lock);
 365         wf_overtemp++;
 366         if (wf_overtemp == 1) {
 367                 printk(KERN_WARNING "windfarm: Overtemp condition detected !\n");
 368                 wf_overtemp_counter = 0;
 369                 wf_notify(WF_EVENT_OVERTEMP, NULL);
 370         }
 371         up(&wf_lock);
 372 }
 373 EXPORT_SYMBOL_GPL(wf_set_overtemp);
 374
 375 void wf_clear_overtemp(void)
 376 {
 377         down(&wf_lock);
 378         WARN_ON(wf_overtemp == 0);
 379         if (wf_overtemp == 0) {
 380                 up(&wf_lock);
 381                 return;
 382         }
 383         wf_overtemp--;
 384         if (wf_overtemp == 0) {
 385                 printk(KERN_WARNING "windfarm: Overtemp condition cleared !\n");
 386                 wf_notify(WF_EVENT_NORMALTEMP, NULL);
 387         }
 388         up(&wf_lock);
 389 }
 390 EXPORT_SYMBOL_GPL(wf_clear_overtemp);
 391
 392 int wf_is_overtemp(void)
 393 {
 394         return (wf_overtemp != 0);
 395 }
 396 EXPORT_SYMBOL_GPL(wf_is_overtemp);
 397
 398 static struct platform_device wf_platform_device = {
 399         .name   = "windfarm",
 400 };
 401
 402 static int __init windfarm_core_init(void)
 403 {
 404         DBG("wf: core loaded\n");
 405
 406         platform_device_register(&wf_platform_device);
 407         return 0;
 408 }
 409
 410 static void __exit windfarm_core_exit(void)
 411 {
 412         BUG_ON(wf_client_count != 0);
 413
 414         DBG("wf: core unloaded\n");
 415
 416         platform_device_unregister(&wf_platform_device);
 417 }
 418
 419
 420 module_init(windfarm_core_init);
 421 module_exit(windfarm_core_exit);
 422
 423 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
 424 MODULE_DESCRIPTION("Core component of PowerMac thermal control");
 425 MODULE_LICENSE("GPL");
 426