drivers/macintosh/windfarm_core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Windfarm PowerMac thermal control. Core
   4  *
   5  * (c) Copyright 2005 Benjamin Herrenschmidt, IBM Corp.
   6  *                    <benh@kernel.crashing.org>
   7  *
   8  * This core code tracks the list of sensors & controls, register
   9  * clients, and holds the kernel thread used for control.
  10  *
  11  * TODO:
  12  *
  13  * Add some information about sensor/control type and data format to
  14  * sensors/controls, and have the sysfs attribute stuff be moved
  15  * generically here instead of hard coded in the platform specific
  16  * driver as it us currently
  17  *
  18  * This however requires solving some annoying lifetime issues with
  19  * sysfs which doesn't seem to have lifetime rules for struct attribute,
  20  * I may have to create full features kobjects for every sensor/control
  21  * instead which is a bit of an overkill imho
  22  */
  23
  24 #include <linux/types.h>
  25 #include <linux/errno.h>
  26 #include <linux/kernel.h>
  27 #include <linux/slab.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 "windfarm.h"
  39
  40 #define VERSION "0.2"
  41
  42 #undef DEBUG
  43
  44 #ifdef DEBUG
  45 #define DBG(args...)    printk(args)
  46 #else
  47 #define DBG(args...)    do { } while(0)
  48 #endif
  49
  50 static LIST_HEAD(wf_controls);
  51 static LIST_HEAD(wf_sensors);
  52 static DEFINE_MUTEX(wf_lock);
  53 static BLOCKING_NOTIFIER_HEAD(wf_client_list);
  54 static int wf_client_count;
  55 static unsigned int wf_overtemp;
  56 static unsigned int wf_overtemp_counter;
  57 static struct task_struct *wf_thread;
  58
  59 static struct platform_device wf_platform_device = {
  60         .name   = "windfarm",
  61 };
  62
  63 /*
  64  * Utilities & tick thread
  65  */
  66
  67 static inline void wf_notify(int event, void *param)
  68 {
  69         blocking_notifier_call_chain(&wf_client_list, event, param);
  70 }
  71
  72 static int wf_critical_overtemp(void)
  73 {
  74         static char const critical_overtemp_path[] = "/sbin/critical_overtemp";
  75         char *argv[] = { (char *)critical_overtemp_path, NULL };
  76         static char *envp[] = { "HOME=/",
  77                                 "TERM=linux",
  78                                 "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
  79                                 NULL };
  80
  81         return call_usermodehelper(critical_overtemp_path,
  82                                    argv, envp, UMH_WAIT_EXEC);
  83 }
  84
  85 static int wf_thread_func(void *data)
  86 {
  87         unsigned long next, delay;
  88
  89         next = jiffies;
  90
  91         DBG("wf: thread started\n");
  92
  93         set_freezable();
  94         while (!kthread_should_stop()) {
  95                 try_to_freeze();
  96
  97                 if (time_after_eq(jiffies, next)) {
  98                         wf_notify(WF_EVENT_TICK, NULL);
  99                         if (wf_overtemp) {
 100                                 wf_overtemp_counter++;
 101                                 /* 10 seconds overtemp, notify userland */
 102                                 if (wf_overtemp_counter > 10)
 103                                         wf_critical_overtemp();
 104                                 /* 30 seconds, shutdown */
 105                                 if (wf_overtemp_counter > 30) {
 106                                         printk(KERN_ERR "windfarm: Overtemp "
 107                                                "for more than 30"
 108                                                " seconds, shutting down\n");
 109                                         machine_power_off();
 110                                 }
 111                         }
 112                         next += HZ;
 113                 }
 114
 115                 delay = next - jiffies;
 116                 if (delay <= HZ)
 117                         schedule_timeout_interruptible(delay);
 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 static ssize_t wf_show_control(struct device *dev,
 160                                struct device_attribute *attr, char *buf)
 161 {
 162         struct wf_control *ctrl = container_of(attr, struct wf_control, attr);
 163         const char *typestr;
 164         s32 val = 0;
 165         int err;
 166
 167         err = ctrl->ops->get_value(ctrl, &val);
 168         if (err < 0) {
 169                 if (err == -EFAULT)
 170                         return sprintf(buf, "<HW FAULT>\n");
 171                 return err;
 172         }
 173         switch(ctrl->type) {
 174         case WF_CONTROL_RPM_FAN:
 175                 typestr = " RPM";
 176                 break;
 177         case WF_CONTROL_PWM_FAN:
 178                 typestr = " %";
 179                 break;
 180         default:
 181                 typestr = "";
 182         }
 183         return sprintf(buf, "%d%s\n", val, typestr);
 184 }
 185
 186 /* This is really only for debugging... */
 187 static ssize_t wf_store_control(struct device *dev,
 188                                 struct device_attribute *attr,
 189                                 const char *buf, size_t count)
 190 {
 191         struct wf_control *ctrl = container_of(attr, struct wf_control, attr);
 192         int val;
 193         int err;
 194         char *endp;
 195
 196         val = simple_strtoul(buf, &endp, 0);
 197         while (endp < buf + count && (*endp == ' ' || *endp == '\n'))
 198                 ++endp;
 199         if (endp - buf < count)
 200                 return -EINVAL;
 201         err = ctrl->ops->set_value(ctrl, val);
 202         if (err < 0)
 203                 return err;
 204         return count;
 205 }
 206
 207 int wf_register_control(struct wf_control *new_ct)
 208 {
 209         struct wf_control *ct;
 210
 211         mutex_lock(&wf_lock);
 212         list_for_each_entry(ct, &wf_controls, link) {
 213                 if (!strcmp(ct->name, new_ct->name)) {
 214                         printk(KERN_WARNING "windfarm: trying to register"
 215                                " duplicate control %s\n", ct->name);
 216                         mutex_unlock(&wf_lock);
 217                         return -EEXIST;
 218                 }
 219         }
 220         kref_init(&new_ct->ref);
 221         list_add(&new_ct->link, &wf_controls);
 222
 223         sysfs_attr_init(&new_ct->attr.attr);
 224         new_ct->attr.attr.name = new_ct->name;
 225         new_ct->attr.attr.mode = 0644;
 226         new_ct->attr.show = wf_show_control;
 227         new_ct->attr.store = wf_store_control;
 228         if (device_create_file(&wf_platform_device.dev, &new_ct->attr))
 229                 printk(KERN_WARNING "windfarm: device_create_file failed"
 230                         " for %s\n", new_ct->name);
 231                 /* the subsystem still does useful work without the file */
 232
 233         DBG("wf: Registered control %s\n", new_ct->name);
 234
 235         wf_notify(WF_EVENT_NEW_CONTROL, new_ct);
 236         mutex_unlock(&wf_lock);
 237
 238         return 0;
 239 }
 240 EXPORT_SYMBOL_GPL(wf_register_control);
 241
 242 void wf_unregister_control(struct wf_control *ct)
 243 {
 244         mutex_lock(&wf_lock);
 245         list_del(&ct->link);
 246         mutex_unlock(&wf_lock);
 247
 248         DBG("wf: Unregistered control %s\n", ct->name);
 249
 250         kref_put(&ct->ref, wf_control_release);
 251 }
 252 EXPORT_SYMBOL_GPL(wf_unregister_control);
 253
 254 int wf_get_control(struct wf_control *ct)
 255 {
 256         if (!try_module_get(ct->ops->owner))
 257                 return -ENODEV;
 258         kref_get(&ct->ref);
 259         return 0;
 260 }
 261 EXPORT_SYMBOL_GPL(wf_get_control);
 262
 263 void wf_put_control(struct wf_control *ct)
 264 {
 265         struct module *mod = ct->ops->owner;
 266         kref_put(&ct->ref, wf_control_release);
 267         module_put(mod);
 268 }
 269 EXPORT_SYMBOL_GPL(wf_put_control);
 270
 271
 272 /*
 273  * Sensors
 274  */
 275
 276
 277 static void wf_sensor_release(struct kref *kref)
 278 {
 279         struct wf_sensor *sr = container_of(kref, struct wf_sensor, ref);
 280
 281         DBG("wf: Deleting sensor %s\n", sr->name);
 282
 283         if (sr->ops && sr->ops->release)
 284                 sr->ops->release(sr);
 285         else
 286                 kfree(sr);
 287 }
 288
 289 static ssize_t wf_show_sensor(struct device *dev,
 290                               struct device_attribute *attr, char *buf)
 291 {
 292         struct wf_sensor *sens = container_of(attr, struct wf_sensor, attr);
 293         s32 val = 0;
 294         int err;
 295
 296         err = sens->ops->get_value(sens, &val);
 297         if (err < 0)
 298                 return err;
 299         return sprintf(buf, "%d.%03d\n", FIX32TOPRINT(val));
 300 }
 301
 302 int wf_register_sensor(struct wf_sensor *new_sr)
 303 {
 304         struct wf_sensor *sr;
 305
 306         mutex_lock(&wf_lock);
 307         list_for_each_entry(sr, &wf_sensors, link) {
 308                 if (!strcmp(sr->name, new_sr->name)) {
 309                         printk(KERN_WARNING "windfarm: trying to register"
 310                                " duplicate sensor %s\n", sr->name);
 311                         mutex_unlock(&wf_lock);
 312                         return -EEXIST;
 313                 }
 314         }
 315         kref_init(&new_sr->ref);
 316         list_add(&new_sr->link, &wf_sensors);
 317
 318         sysfs_attr_init(&new_sr->attr.attr);
 319         new_sr->attr.attr.name = new_sr->name;
 320         new_sr->attr.attr.mode = 0444;
 321         new_sr->attr.show = wf_show_sensor;
 322         new_sr->attr.store = NULL;
 323         if (device_create_file(&wf_platform_device.dev, &new_sr->attr))
 324                 printk(KERN_WARNING "windfarm: device_create_file failed"
 325                         " for %s\n", new_sr->name);
 326                 /* the subsystem still does useful work without the file */
 327
 328         DBG("wf: Registered sensor %s\n", new_sr->name);
 329
 330         wf_notify(WF_EVENT_NEW_SENSOR, new_sr);
 331         mutex_unlock(&wf_lock);
 332
 333         return 0;
 334 }
 335 EXPORT_SYMBOL_GPL(wf_register_sensor);
 336
 337 void wf_unregister_sensor(struct wf_sensor *sr)
 338 {
 339         mutex_lock(&wf_lock);
 340         list_del(&sr->link);
 341         mutex_unlock(&wf_lock);
 342
 343         DBG("wf: Unregistered sensor %s\n", sr->name);
 344
 345         wf_put_sensor(sr);
 346 }
 347 EXPORT_SYMBOL_GPL(wf_unregister_sensor);
 348
 349 int wf_get_sensor(struct wf_sensor *sr)
 350 {
 351         if (!try_module_get(sr->ops->owner))
 352                 return -ENODEV;
 353         kref_get(&sr->ref);
 354         return 0;
 355 }
 356 EXPORT_SYMBOL_GPL(wf_get_sensor);
 357
 358 void wf_put_sensor(struct wf_sensor *sr)
 359 {
 360         struct module *mod = sr->ops->owner;
 361         kref_put(&sr->ref, wf_sensor_release);
 362         module_put(mod);
 363 }
 364 EXPORT_SYMBOL_GPL(wf_put_sensor);
 365
 366
 367 /*
 368  * Client & notification
 369  */
 370
 371 int wf_register_client(struct notifier_block *nb)
 372 {
 373         int rc;
 374         struct wf_control *ct;
 375         struct wf_sensor *sr;
 376
 377         mutex_lock(&wf_lock);
 378         rc = blocking_notifier_chain_register(&wf_client_list, nb);
 379         if (rc != 0)
 380                 goto bail;
 381         wf_client_count++;
 382         list_for_each_entry(ct, &wf_controls, link)
 383                 wf_notify(WF_EVENT_NEW_CONTROL, ct);
 384         list_for_each_entry(sr, &wf_sensors, link)
 385                 wf_notify(WF_EVENT_NEW_SENSOR, sr);
 386         if (wf_client_count == 1)
 387                 wf_start_thread();
 388  bail:
 389         mutex_unlock(&wf_lock);
 390         return rc;
 391 }
 392 EXPORT_SYMBOL_GPL(wf_register_client);
 393
 394 int wf_unregister_client(struct notifier_block *nb)
 395 {
 396         mutex_lock(&wf_lock);
 397         blocking_notifier_chain_unregister(&wf_client_list, nb);
 398         wf_client_count--;
 399         if (wf_client_count == 0)
 400                 wf_stop_thread();
 401         mutex_unlock(&wf_lock);
 402
 403         return 0;
 404 }
 405 EXPORT_SYMBOL_GPL(wf_unregister_client);
 406
 407 void wf_set_overtemp(void)
 408 {
 409         mutex_lock(&wf_lock);
 410         wf_overtemp++;
 411         if (wf_overtemp == 1) {
 412                 printk(KERN_WARNING "windfarm: Overtemp condition detected !\n");
 413                 wf_overtemp_counter = 0;
 414                 wf_notify(WF_EVENT_OVERTEMP, NULL);
 415         }
 416         mutex_unlock(&wf_lock);
 417 }
 418 EXPORT_SYMBOL_GPL(wf_set_overtemp);
 419
 420 void wf_clear_overtemp(void)
 421 {
 422         mutex_lock(&wf_lock);
 423         WARN_ON(wf_overtemp == 0);
 424         if (wf_overtemp == 0) {
 425                 mutex_unlock(&wf_lock);
 426                 return;
 427         }
 428         wf_overtemp--;
 429         if (wf_overtemp == 0) {
 430                 printk(KERN_WARNING "windfarm: Overtemp condition cleared !\n");
 431                 wf_notify(WF_EVENT_NORMALTEMP, NULL);
 432         }
 433         mutex_unlock(&wf_lock);
 434 }
 435 EXPORT_SYMBOL_GPL(wf_clear_overtemp);
 436
 437 static int __init windfarm_core_init(void)
 438 {
 439         DBG("wf: core loaded\n");
 440
 441         platform_device_register(&wf_platform_device);
 442         return 0;
 443 }
 444
 445 static void __exit windfarm_core_exit(void)
 446 {
 447         BUG_ON(wf_client_count != 0);
 448
 449         DBG("wf: core unloaded\n");
 450
 451         platform_device_unregister(&wf_platform_device);
 452 }
 453
 454
 455 module_init(windfarm_core_init);
 456 module_exit(windfarm_core_exit);
 457
 458 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
 459 MODULE_DESCRIPTION("Core component of PowerMac thermal control");
 460 MODULE_LICENSE("GPL");
 461