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/kthread.h> 31 #include <linux/jiffies.h> 32 #include <linux/reboot.h> 33 #include <linux/device.h> 34 #include <linux/platform_device.h> 35 #include <linux/mutex.h> 36 #include <linux/freezer.h> 37 38 #include <asm/prom.h> 39 40 #include "windfarm.h" 41 42 #define VERSION "0.2" 43 44 #undef DEBUG 45 46 #ifdef DEBUG 47 #define DBG(args...) printk(args) 48 #else 49 #define DBG(args...) do { } while(0) 50 #endif 51 52 static LIST_HEAD(wf_controls); 53 static LIST_HEAD(wf_sensors); 54 static DEFINE_MUTEX(wf_lock); 55 static BLOCKING_NOTIFIER_HEAD(wf_client_list); 56 static int wf_client_count; 57 static unsigned int wf_overtemp; 58 static unsigned int wf_overtemp_counter; 59 struct task_struct *wf_thread; 60 61 static struct platform_device wf_platform_device = { 62 .name = "windfarm", 63 }; 64 65 /* 66 * Utilities & tick thread 67 */ 68 69 static inline void wf_notify(int event, void *param) 70 { 71 blocking_notifier_call_chain(&wf_client_list, event, param); 72 } 73 74 int wf_critical_overtemp(void) 75 { 76 static char * critical_overtemp_path = "/sbin/critical_overtemp"; 77 char *argv[] = { critical_overtemp_path, NULL }; 78 static char *envp[] = { "HOME=/", 79 "TERM=linux", 80 "PATH=/sbin:/usr/sbin:/bin:/usr/bin", 81 NULL }; 82 83 return call_usermodehelper(critical_overtemp_path, 84 argv, envp, UMH_WAIT_EXEC); 85 } 86 EXPORT_SYMBOL_GPL(wf_critical_overtemp); 87 88 static int wf_thread_func(void *data) 89 { 90 unsigned long next, delay; 91 92 next = jiffies; 93 94 DBG("wf: thread started\n"); 95 96 set_freezable(); 97 while(!kthread_should_stop()) { 98 if (time_after_eq(jiffies, next)) { 99 wf_notify(WF_EVENT_TICK, NULL); 100 if (wf_overtemp) { 101 wf_overtemp_counter++; 102 /* 10 seconds overtemp, notify userland */ 103 if (wf_overtemp_counter > 10) 104 wf_critical_overtemp(); 105 /* 30 seconds, shutdown */ 106 if (wf_overtemp_counter > 30) { 107 printk(KERN_ERR "windfarm: Overtemp " 108 "for more than 30" 109 " seconds, shutting down\n"); 110 machine_power_off(); 111 } 112 } 113 next += HZ; 114 } 115 116 delay = next - jiffies; 117 if (delay <= HZ) 118 schedule_timeout_interruptible(delay); 119 120 /* there should be no non-suspend signal, but oh well */ 121 if (signal_pending(current) && !try_to_freeze()) { 122 printk(KERN_WARNING "windfarm: thread got sigl !\n"); 123 break; 124 } 125 } 126 127 DBG("wf: thread stopped\n"); 128 129 return 0; 130 } 131 132 static void wf_start_thread(void) 133 { 134 wf_thread = kthread_run(wf_thread_func, NULL, "kwindfarm"); 135 if (IS_ERR(wf_thread)) { 136 printk(KERN_ERR "windfarm: failed to create thread,err %ld\n", 137 PTR_ERR(wf_thread)); 138 wf_thread = NULL; 139 } 140 } 141 142 143 static void wf_stop_thread(void) 144 { 145 if (wf_thread) 146 kthread_stop(wf_thread); 147 wf_thread = NULL; 148 } 149 150 /* 151 * Controls 152 */ 153 154 static void wf_control_release(struct kref *kref) 155 { 156 struct wf_control *ct = container_of(kref, struct wf_control, ref); 157 158 DBG("wf: Deleting control %s\n", ct->name); 159 160 if (ct->ops && ct->ops->release) 161 ct->ops->release(ct); 162 else 163 kfree(ct); 164 } 165 166 static ssize_t wf_show_control(struct device *dev, 167 struct device_attribute *attr, char *buf) 168 { 169 struct wf_control *ctrl = container_of(attr, struct wf_control, attr); 170 s32 val = 0; 171 int err; 172 173 err = ctrl->ops->get_value(ctrl, &val); 174 if (err < 0) 175 return err; 176 return sprintf(buf, "%d\n", val); 177 } 178 179 /* This is really only for debugging... */ 180 static ssize_t wf_store_control(struct device *dev, 181 struct device_attribute *attr, 182 const char *buf, size_t count) 183 { 184 struct wf_control *ctrl = container_of(attr, struct wf_control, attr); 185 int val; 186 int err; 187 char *endp; 188 189 val = simple_strtoul(buf, &endp, 0); 190 while (endp < buf + count && (*endp == ' ' || *endp == '\n')) 191 ++endp; 192 if (endp - buf < count) 193 return -EINVAL; 194 err = ctrl->ops->set_value(ctrl, val); 195 if (err < 0) 196 return err; 197 return count; 198 } 199 200 int wf_register_control(struct wf_control *new_ct) 201 { 202 struct wf_control *ct; 203 204 mutex_lock(&wf_lock); 205 list_for_each_entry(ct, &wf_controls, link) { 206 if (!strcmp(ct->name, new_ct->name)) { 207 printk(KERN_WARNING "windfarm: trying to register" 208 " duplicate control %s\n", ct->name); 209 mutex_unlock(&wf_lock); 210 return -EEXIST; 211 } 212 } 213 kref_init(&new_ct->ref); 214 list_add(&new_ct->link, &wf_controls); 215 216 new_ct->attr.attr.name = new_ct->name; 217 new_ct->attr.attr.mode = 0644; 218 new_ct->attr.show = wf_show_control; 219 new_ct->attr.store = wf_store_control; 220 if (device_create_file(&wf_platform_device.dev, &new_ct->attr)) 221 printk(KERN_WARNING "windfarm: device_create_file failed" 222 " for %s\n", new_ct->name); 223 /* the subsystem still does useful work without the file */ 224 225 DBG("wf: Registered control %s\n", new_ct->name); 226 227 wf_notify(WF_EVENT_NEW_CONTROL, new_ct); 228 mutex_unlock(&wf_lock); 229 230 return 0; 231 } 232 EXPORT_SYMBOL_GPL(wf_register_control); 233 234 void wf_unregister_control(struct wf_control *ct) 235 { 236 mutex_lock(&wf_lock); 237 list_del(&ct->link); 238 mutex_unlock(&wf_lock); 239 240 DBG("wf: Unregistered control %s\n", ct->name); 241 242 kref_put(&ct->ref, wf_control_release); 243 } 244 EXPORT_SYMBOL_GPL(wf_unregister_control); 245 246 struct wf_control * wf_find_control(const char *name) 247 { 248 struct wf_control *ct; 249 250 mutex_lock(&wf_lock); 251 list_for_each_entry(ct, &wf_controls, link) { 252 if (!strcmp(ct->name, name)) { 253 if (wf_get_control(ct)) 254 ct = NULL; 255 mutex_unlock(&wf_lock); 256 return ct; 257 } 258 } 259 mutex_unlock(&wf_lock); 260 return NULL; 261 } 262 EXPORT_SYMBOL_GPL(wf_find_control); 263 264 int wf_get_control(struct wf_control *ct) 265 { 266 if (!try_module_get(ct->ops->owner)) 267 return -ENODEV; 268 kref_get(&ct->ref); 269 return 0; 270 } 271 EXPORT_SYMBOL_GPL(wf_get_control); 272 273 void wf_put_control(struct wf_control *ct) 274 { 275 struct module *mod = ct->ops->owner; 276 kref_put(&ct->ref, wf_control_release); 277 module_put(mod); 278 } 279 EXPORT_SYMBOL_GPL(wf_put_control); 280 281 282 /* 283 * Sensors 284 */ 285 286 287 static void wf_sensor_release(struct kref *kref) 288 { 289 struct wf_sensor *sr = container_of(kref, struct wf_sensor, ref); 290 291 DBG("wf: Deleting sensor %s\n", sr->name); 292 293 if (sr->ops && sr->ops->release) 294 sr->ops->release(sr); 295 else 296 kfree(sr); 297 } 298 299 static ssize_t wf_show_sensor(struct device *dev, 300 struct device_attribute *attr, char *buf) 301 { 302 struct wf_sensor *sens = container_of(attr, struct wf_sensor, attr); 303 s32 val = 0; 304 int err; 305 306 err = sens->ops->get_value(sens, &val); 307 if (err < 0) 308 return err; 309 return sprintf(buf, "%d.%03d\n", FIX32TOPRINT(val)); 310 } 311 312 int wf_register_sensor(struct wf_sensor *new_sr) 313 { 314 struct wf_sensor *sr; 315 316 mutex_lock(&wf_lock); 317 list_for_each_entry(sr, &wf_sensors, link) { 318 if (!strcmp(sr->name, new_sr->name)) { 319 printk(KERN_WARNING "windfarm: trying to register" 320 " duplicate sensor %s\n", sr->name); 321 mutex_unlock(&wf_lock); 322 return -EEXIST; 323 } 324 } 325 kref_init(&new_sr->ref); 326 list_add(&new_sr->link, &wf_sensors); 327 328 new_sr->attr.attr.name = new_sr->name; 329 new_sr->attr.attr.mode = 0444; 330 new_sr->attr.show = wf_show_sensor; 331 new_sr->attr.store = NULL; 332 if (device_create_file(&wf_platform_device.dev, &new_sr->attr)) 333 printk(KERN_WARNING "windfarm: device_create_file failed" 334 " for %s\n", new_sr->name); 335 /* the subsystem still does useful work without the file */ 336 337 DBG("wf: Registered sensor %s\n", new_sr->name); 338 339 wf_notify(WF_EVENT_NEW_SENSOR, new_sr); 340 mutex_unlock(&wf_lock); 341 342 return 0; 343 } 344 EXPORT_SYMBOL_GPL(wf_register_sensor); 345 346 void wf_unregister_sensor(struct wf_sensor *sr) 347 { 348 mutex_lock(&wf_lock); 349 list_del(&sr->link); 350 mutex_unlock(&wf_lock); 351 352 DBG("wf: Unregistered sensor %s\n", sr->name); 353 354 wf_put_sensor(sr); 355 } 356 EXPORT_SYMBOL_GPL(wf_unregister_sensor); 357 358 struct wf_sensor * wf_find_sensor(const char *name) 359 { 360 struct wf_sensor *sr; 361 362 mutex_lock(&wf_lock); 363 list_for_each_entry(sr, &wf_sensors, link) { 364 if (!strcmp(sr->name, name)) { 365 if (wf_get_sensor(sr)) 366 sr = NULL; 367 mutex_unlock(&wf_lock); 368 return sr; 369 } 370 } 371 mutex_unlock(&wf_lock); 372 return NULL; 373 } 374 EXPORT_SYMBOL_GPL(wf_find_sensor); 375 376 int wf_get_sensor(struct wf_sensor *sr) 377 { 378 if (!try_module_get(sr->ops->owner)) 379 return -ENODEV; 380 kref_get(&sr->ref); 381 return 0; 382 } 383 EXPORT_SYMBOL_GPL(wf_get_sensor); 384 385 void wf_put_sensor(struct wf_sensor *sr) 386 { 387 struct module *mod = sr->ops->owner; 388 kref_put(&sr->ref, wf_sensor_release); 389 module_put(mod); 390 } 391 EXPORT_SYMBOL_GPL(wf_put_sensor); 392 393 394 /* 395 * Client & notification 396 */ 397 398 int wf_register_client(struct notifier_block *nb) 399 { 400 int rc; 401 struct wf_control *ct; 402 struct wf_sensor *sr; 403 404 mutex_lock(&wf_lock); 405 rc = blocking_notifier_chain_register(&wf_client_list, nb); 406 if (rc != 0) 407 goto bail; 408 wf_client_count++; 409 list_for_each_entry(ct, &wf_controls, link) 410 wf_notify(WF_EVENT_NEW_CONTROL, ct); 411 list_for_each_entry(sr, &wf_sensors, link) 412 wf_notify(WF_EVENT_NEW_SENSOR, sr); 413 if (wf_client_count == 1) 414 wf_start_thread(); 415 bail: 416 mutex_unlock(&wf_lock); 417 return rc; 418 } 419 EXPORT_SYMBOL_GPL(wf_register_client); 420 421 int wf_unregister_client(struct notifier_block *nb) 422 { 423 mutex_lock(&wf_lock); 424 blocking_notifier_chain_unregister(&wf_client_list, nb); 425 wf_client_count++; 426 if (wf_client_count == 0) 427 wf_stop_thread(); 428 mutex_unlock(&wf_lock); 429 430 return 0; 431 } 432 EXPORT_SYMBOL_GPL(wf_unregister_client); 433 434 void wf_set_overtemp(void) 435 { 436 mutex_lock(&wf_lock); 437 wf_overtemp++; 438 if (wf_overtemp == 1) { 439 printk(KERN_WARNING "windfarm: Overtemp condition detected !\n"); 440 wf_overtemp_counter = 0; 441 wf_notify(WF_EVENT_OVERTEMP, NULL); 442 } 443 mutex_unlock(&wf_lock); 444 } 445 EXPORT_SYMBOL_GPL(wf_set_overtemp); 446 447 void wf_clear_overtemp(void) 448 { 449 mutex_lock(&wf_lock); 450 WARN_ON(wf_overtemp == 0); 451 if (wf_overtemp == 0) { 452 mutex_unlock(&wf_lock); 453 return; 454 } 455 wf_overtemp--; 456 if (wf_overtemp == 0) { 457 printk(KERN_WARNING "windfarm: Overtemp condition cleared !\n"); 458 wf_notify(WF_EVENT_NORMALTEMP, NULL); 459 } 460 mutex_unlock(&wf_lock); 461 } 462 EXPORT_SYMBOL_GPL(wf_clear_overtemp); 463 464 int wf_is_overtemp(void) 465 { 466 return (wf_overtemp != 0); 467 } 468 EXPORT_SYMBOL_GPL(wf_is_overtemp); 469 470 static int __init windfarm_core_init(void) 471 { 472 DBG("wf: core loaded\n"); 473 474 /* Don't register on old machines that use therm_pm72 for now */ 475 if (machine_is_compatible("PowerMac7,2") || 476 machine_is_compatible("PowerMac7,3") || 477 machine_is_compatible("RackMac3,1")) 478 return -ENODEV; 479 platform_device_register(&wf_platform_device); 480 return 0; 481 } 482 483 static void __exit windfarm_core_exit(void) 484 { 485 BUG_ON(wf_client_count != 0); 486 487 DBG("wf: core unloaded\n"); 488 489 platform_device_unregister(&wf_platform_device); 490 } 491 492 493 module_init(windfarm_core_init); 494 module_exit(windfarm_core_exit); 495 496 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>"); 497 MODULE_DESCRIPTION("Core component of PowerMac thermal control"); 498 MODULE_LICENSE("GPL"); 499 500