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 #include <linux/mutex.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, argv, envp, 0); 84 } 85 EXPORT_SYMBOL_GPL(wf_critical_overtemp); 86 87 static int wf_thread_func(void *data) 88 { 89 unsigned long next, delay; 90 91 next = jiffies; 92 93 DBG("wf: thread started\n"); 94 95 while(!kthread_should_stop()) { 96 try_to_freeze(); 97 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 signal, but oh well */ 121 if (signal_pending(current)) { 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.owner = THIS_MODULE; 218 new_ct->attr.attr.mode = 0644; 219 new_ct->attr.show = wf_show_control; 220 new_ct->attr.store = wf_store_control; 221 device_create_file(&wf_platform_device.dev, &new_ct->attr); 222 223 DBG("wf: Registered control %s\n", new_ct->name); 224 225 wf_notify(WF_EVENT_NEW_CONTROL, new_ct); 226 mutex_unlock(&wf_lock); 227 228 return 0; 229 } 230 EXPORT_SYMBOL_GPL(wf_register_control); 231 232 void wf_unregister_control(struct wf_control *ct) 233 { 234 mutex_lock(&wf_lock); 235 list_del(&ct->link); 236 mutex_unlock(&wf_lock); 237 238 DBG("wf: Unregistered control %s\n", ct->name); 239 240 kref_put(&ct->ref, wf_control_release); 241 } 242 EXPORT_SYMBOL_GPL(wf_unregister_control); 243 244 struct wf_control * wf_find_control(const char *name) 245 { 246 struct wf_control *ct; 247 248 mutex_lock(&wf_lock); 249 list_for_each_entry(ct, &wf_controls, link) { 250 if (!strcmp(ct->name, name)) { 251 if (wf_get_control(ct)) 252 ct = NULL; 253 mutex_unlock(&wf_lock); 254 return ct; 255 } 256 } 257 mutex_unlock(&wf_lock); 258 return NULL; 259 } 260 EXPORT_SYMBOL_GPL(wf_find_control); 261 262 int wf_get_control(struct wf_control *ct) 263 { 264 if (!try_module_get(ct->ops->owner)) 265 return -ENODEV; 266 kref_get(&ct->ref); 267 return 0; 268 } 269 EXPORT_SYMBOL_GPL(wf_get_control); 270 271 void wf_put_control(struct wf_control *ct) 272 { 273 struct module *mod = ct->ops->owner; 274 kref_put(&ct->ref, wf_control_release); 275 module_put(mod); 276 } 277 EXPORT_SYMBOL_GPL(wf_put_control); 278 279 280 /* 281 * Sensors 282 */ 283 284 285 static void wf_sensor_release(struct kref *kref) 286 { 287 struct wf_sensor *sr = container_of(kref, struct wf_sensor, ref); 288 289 DBG("wf: Deleting sensor %s\n", sr->name); 290 291 if (sr->ops && sr->ops->release) 292 sr->ops->release(sr); 293 else 294 kfree(sr); 295 } 296 297 static ssize_t wf_show_sensor(struct device *dev, 298 struct device_attribute *attr, char *buf) 299 { 300 struct wf_sensor *sens = container_of(attr, struct wf_sensor, attr); 301 s32 val = 0; 302 int err; 303 304 err = sens->ops->get_value(sens, &val); 305 if (err < 0) 306 return err; 307 return sprintf(buf, "%d.%03d\n", FIX32TOPRINT(val)); 308 } 309 310 int wf_register_sensor(struct wf_sensor *new_sr) 311 { 312 struct wf_sensor *sr; 313 314 mutex_lock(&wf_lock); 315 list_for_each_entry(sr, &wf_sensors, link) { 316 if (!strcmp(sr->name, new_sr->name)) { 317 printk(KERN_WARNING "windfarm: trying to register" 318 " duplicate sensor %s\n", sr->name); 319 mutex_unlock(&wf_lock); 320 return -EEXIST; 321 } 322 } 323 kref_init(&new_sr->ref); 324 list_add(&new_sr->link, &wf_sensors); 325 326 new_sr->attr.attr.name = new_sr->name; 327 new_sr->attr.attr.owner = THIS_MODULE; 328 new_sr->attr.attr.mode = 0444; 329 new_sr->attr.show = wf_show_sensor; 330 new_sr->attr.store = NULL; 331 device_create_file(&wf_platform_device.dev, &new_sr->attr); 332 333 DBG("wf: Registered sensor %s\n", new_sr->name); 334 335 wf_notify(WF_EVENT_NEW_SENSOR, new_sr); 336 mutex_unlock(&wf_lock); 337 338 return 0; 339 } 340 EXPORT_SYMBOL_GPL(wf_register_sensor); 341 342 void wf_unregister_sensor(struct wf_sensor *sr) 343 { 344 mutex_lock(&wf_lock); 345 list_del(&sr->link); 346 mutex_unlock(&wf_lock); 347 348 DBG("wf: Unregistered sensor %s\n", sr->name); 349 350 wf_put_sensor(sr); 351 } 352 EXPORT_SYMBOL_GPL(wf_unregister_sensor); 353 354 struct wf_sensor * wf_find_sensor(const char *name) 355 { 356 struct wf_sensor *sr; 357 358 mutex_lock(&wf_lock); 359 list_for_each_entry(sr, &wf_sensors, link) { 360 if (!strcmp(sr->name, name)) { 361 if (wf_get_sensor(sr)) 362 sr = NULL; 363 mutex_unlock(&wf_lock); 364 return sr; 365 } 366 } 367 mutex_unlock(&wf_lock); 368 return NULL; 369 } 370 EXPORT_SYMBOL_GPL(wf_find_sensor); 371 372 int wf_get_sensor(struct wf_sensor *sr) 373 { 374 if (!try_module_get(sr->ops->owner)) 375 return -ENODEV; 376 kref_get(&sr->ref); 377 return 0; 378 } 379 EXPORT_SYMBOL_GPL(wf_get_sensor); 380 381 void wf_put_sensor(struct wf_sensor *sr) 382 { 383 struct module *mod = sr->ops->owner; 384 kref_put(&sr->ref, wf_sensor_release); 385 module_put(mod); 386 } 387 EXPORT_SYMBOL_GPL(wf_put_sensor); 388 389 390 /* 391 * Client & notification 392 */ 393 394 int wf_register_client(struct notifier_block *nb) 395 { 396 int rc; 397 struct wf_control *ct; 398 struct wf_sensor *sr; 399 400 mutex_lock(&wf_lock); 401 rc = blocking_notifier_chain_register(&wf_client_list, nb); 402 if (rc != 0) 403 goto bail; 404 wf_client_count++; 405 list_for_each_entry(ct, &wf_controls, link) 406 wf_notify(WF_EVENT_NEW_CONTROL, ct); 407 list_for_each_entry(sr, &wf_sensors, link) 408 wf_notify(WF_EVENT_NEW_SENSOR, sr); 409 if (wf_client_count == 1) 410 wf_start_thread(); 411 bail: 412 mutex_unlock(&wf_lock); 413 return rc; 414 } 415 EXPORT_SYMBOL_GPL(wf_register_client); 416 417 int wf_unregister_client(struct notifier_block *nb) 418 { 419 mutex_lock(&wf_lock); 420 blocking_notifier_chain_unregister(&wf_client_list, nb); 421 wf_client_count++; 422 if (wf_client_count == 0) 423 wf_stop_thread(); 424 mutex_unlock(&wf_lock); 425 426 return 0; 427 } 428 EXPORT_SYMBOL_GPL(wf_unregister_client); 429 430 void wf_set_overtemp(void) 431 { 432 mutex_lock(&wf_lock); 433 wf_overtemp++; 434 if (wf_overtemp == 1) { 435 printk(KERN_WARNING "windfarm: Overtemp condition detected !\n"); 436 wf_overtemp_counter = 0; 437 wf_notify(WF_EVENT_OVERTEMP, NULL); 438 } 439 mutex_unlock(&wf_lock); 440 } 441 EXPORT_SYMBOL_GPL(wf_set_overtemp); 442 443 void wf_clear_overtemp(void) 444 { 445 mutex_lock(&wf_lock); 446 WARN_ON(wf_overtemp == 0); 447 if (wf_overtemp == 0) { 448 mutex_unlock(&wf_lock); 449 return; 450 } 451 wf_overtemp--; 452 if (wf_overtemp == 0) { 453 printk(KERN_WARNING "windfarm: Overtemp condition cleared !\n"); 454 wf_notify(WF_EVENT_NORMALTEMP, NULL); 455 } 456 mutex_unlock(&wf_lock); 457 } 458 EXPORT_SYMBOL_GPL(wf_clear_overtemp); 459 460 int wf_is_overtemp(void) 461 { 462 return (wf_overtemp != 0); 463 } 464 EXPORT_SYMBOL_GPL(wf_is_overtemp); 465 466 static int __init windfarm_core_init(void) 467 { 468 DBG("wf: core loaded\n"); 469 470 /* Don't register on old machines that use therm_pm72 for now */ 471 if (machine_is_compatible("PowerMac7,2") || 472 machine_is_compatible("PowerMac7,3") || 473 machine_is_compatible("RackMac3,1")) 474 return -ENODEV; 475 platform_device_register(&wf_platform_device); 476 return 0; 477 } 478 479 static void __exit windfarm_core_exit(void) 480 { 481 BUG_ON(wf_client_count != 0); 482 483 DBG("wf: core unloaded\n"); 484 485 platform_device_unregister(&wf_platform_device); 486 } 487 488 489 module_init(windfarm_core_init); 490 module_exit(windfarm_core_exit); 491 492 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>"); 493 MODULE_DESCRIPTION("Core component of PowerMac thermal control"); 494 MODULE_LICENSE("GPL"); 495 496