?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: remove smbfs
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / thermal / thermal_sys.c
blob7d0e63c79280c37c6a88e9be1e8834eea11eba31
1 /*
2 * thermal.c - Generic Thermal Management Sysfs support.
3 *
4 * Copyright (C) 2008 Intel Corp
5 * Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
6 * Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
7 *
8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2 of the License.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
22 *
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24 */
25
26 #include <linux/module.h>
27 #include <linux/device.h>
28 #include <linux/err.h>
29 #include <linux/slab.h>
30 #include <linux/kdev_t.h>
31 #include <linux/idr.h>
32 #include <linux/thermal.h>
33 #include <linux/spinlock.h>
34 #include <linux/reboot.h>
35 #include <net/netlink.h>
36 #include <net/genetlink.h>
37
38 MODULE_AUTHOR("Zhang Rui");
39 MODULE_DESCRIPTION("Generic thermal management sysfs support");
40 MODULE_LICENSE("GPL");
41
42 #define PREFIX "Thermal: "
43
44 struct thermal_cooling_device_instance {
45 int id;
46 char name[THERMAL_NAME_LENGTH];
47 struct thermal_zone_device *tz;
48 struct thermal_cooling_device *cdev;
49 int trip;
50 char attr_name[THERMAL_NAME_LENGTH];
51 struct device_attribute attr;
52 struct list_head node;
53 };
54
55 static DEFINE_IDR(thermal_tz_idr);
56 static DEFINE_IDR(thermal_cdev_idr);
57 static DEFINE_MUTEX(thermal_idr_lock);
58
59 static LIST_HEAD(thermal_tz_list);
60 static LIST_HEAD(thermal_cdev_list);
61 static DEFINE_MUTEX(thermal_list_lock);
62
63 static unsigned int thermal_event_seqnum;
64
65 static struct genl_family thermal_event_genl_family = {
66 .id = GENL_ID_GENERATE,
67 .name = THERMAL_GENL_FAMILY_NAME,
68 .version = THERMAL_GENL_VERSION,
69 .maxattr = THERMAL_GENL_ATTR_MAX,
70 };
71
72 static struct genl_multicast_group thermal_event_mcgrp = {
73 .name = THERMAL_GENL_MCAST_GROUP_NAME,
74 };
75
76 static int genetlink_init(void);
77 static void genetlink_exit(void);
78
79 static int get_idr(struct idr *idr, struct mutex *lock, int *id)
80 {
81 int err;
82
83 again:
84 if (unlikely(idr_pre_get(idr, GFP_KERNEL) == 0))
85 return -ENOMEM;
86
87 if (lock)
88 mutex_lock(lock);
89 err = idr_get_new(idr, NULL, id);
90 if (lock)
91 mutex_unlock(lock);
92 if (unlikely(err == -EAGAIN))
93 goto again;
94 else if (unlikely(err))
95 return err;
96
97 *id = *id & MAX_ID_MASK;
98 return 0;
99 }
100
101 static void release_idr(struct idr *idr, struct mutex *lock, int id)
102 {
103 if (lock)
104 mutex_lock(lock);
105 idr_remove(idr, id);
106 if (lock)
107 mutex_unlock(lock);
108 }
109
110 /* sys I/F for thermal zone */
111
112 #define to_thermal_zone(_dev) \
113 container_of(_dev, struct thermal_zone_device, device)
114
115 static ssize_t
116 type_show(struct device *dev, struct device_attribute *attr, char *buf)
117 {
118 struct thermal_zone_device *tz = to_thermal_zone(dev);
119
120 return sprintf(buf, "%s\n", tz->type);
121 }
122
123 static ssize_t
124 temp_show(struct device *dev, struct device_attribute *attr, char *buf)
125 {
126 struct thermal_zone_device *tz = to_thermal_zone(dev);
127 long temperature;
128 int ret;
129
130 if (!tz->ops->get_temp)
131 return -EPERM;
132
133 ret = tz->ops->get_temp(tz, &temperature);
134
135 if (ret)
136 return ret;
137
138 return sprintf(buf, "%ld\n", temperature);
139 }
140
141 static ssize_t
142 mode_show(struct device *dev, struct device_attribute *attr, char *buf)
143 {
144 struct thermal_zone_device *tz = to_thermal_zone(dev);
145 enum thermal_device_mode mode;
146 int result;
147
148 if (!tz->ops->get_mode)
149 return -EPERM;
150
151 result = tz->ops->get_mode(tz, &mode);
152 if (result)
153 return result;
154
155 return sprintf(buf, "%s\n", mode == THERMAL_DEVICE_ENABLED ? "enabled"
156 : "disabled");
157 }
158
159 static ssize_t
160 mode_store(struct device *dev, struct device_attribute *attr,
161 const char *buf, size_t count)
162 {
163 struct thermal_zone_device *tz = to_thermal_zone(dev);
164 int result;
165
166 if (!tz->ops->set_mode)
167 return -EPERM;
168
169 if (!strncmp(buf, "enabled", sizeof("enabled")))
170 result = tz->ops->set_mode(tz, THERMAL_DEVICE_ENABLED);
171 else if (!strncmp(buf, "disabled", sizeof("disabled")))
172 result = tz->ops->set_mode(tz, THERMAL_DEVICE_DISABLED);
173 else
174 result = -EINVAL;
175
176 if (result)
177 return result;
178
179 return count;
180 }
181
182 static ssize_t
183 trip_point_type_show(struct device *dev, struct device_attribute *attr,
184 char *buf)
185 {
186 struct thermal_zone_device *tz = to_thermal_zone(dev);
187 enum thermal_trip_type type;
188 int trip, result;
189
190 if (!tz->ops->get_trip_type)
191 return -EPERM;
192
193 if (!sscanf(attr->attr.name, "trip_point_%d_type", &trip))
194 return -EINVAL;
195
196 result = tz->ops->get_trip_type(tz, trip, &type);
197 if (result)
198 return result;
199
200 switch (type) {
201 case THERMAL_TRIP_CRITICAL:
202 return sprintf(buf, "critical\n");
203 case THERMAL_TRIP_HOT:
204 return sprintf(buf, "hot\n");
205 case THERMAL_TRIP_PASSIVE:
206 return sprintf(buf, "passive\n");
207 case THERMAL_TRIP_ACTIVE:
208 return sprintf(buf, "active\n");
209 default:
210 return sprintf(buf, "unknown\n");
211 }
212 }
213
214 static ssize_t
215 trip_point_temp_show(struct device *dev, struct device_attribute *attr,
216 char *buf)
217 {
218 struct thermal_zone_device *tz = to_thermal_zone(dev);
219 int trip, ret;
220 long temperature;
221
222 if (!tz->ops->get_trip_temp)
223 return -EPERM;
224
225 if (!sscanf(attr->attr.name, "trip_point_%d_temp", &trip))
226 return -EINVAL;
227
228 ret = tz->ops->get_trip_temp(tz, trip, &temperature);
229
230 if (ret)
231 return ret;
232
233 return sprintf(buf, "%ld\n", temperature);
234 }
235
236 static ssize_t
237 passive_store(struct device *dev, struct device_attribute *attr,
238 const char *buf, size_t count)
239 {
240 struct thermal_zone_device *tz = to_thermal_zone(dev);
241 struct thermal_cooling_device *cdev = NULL;
242 int state;
243
244 if (!sscanf(buf, "%d\n", &state))
245 return -EINVAL;
246
247 /* sanity check: values below 1000 millicelcius don't make sense
248 * and can cause the system to go into a thermal heart attack
249 */
250 if (state && state < 1000)
251 return -EINVAL;
252
253 if (state && !tz->forced_passive) {
254 mutex_lock(&thermal_list_lock);
255 list_for_each_entry(cdev, &thermal_cdev_list, node) {
256 if (!strncmp("Processor", cdev->type,
257 sizeof("Processor")))
258 thermal_zone_bind_cooling_device(tz,
259 THERMAL_TRIPS_NONE,
260 cdev);
261 }
262 mutex_unlock(&thermal_list_lock);
263 if (!tz->passive_delay)
264 tz->passive_delay = 1000;
265 } else if (!state && tz->forced_passive) {
266 mutex_lock(&thermal_list_lock);
267 list_for_each_entry(cdev, &thermal_cdev_list, node) {
268 if (!strncmp("Processor", cdev->type,
269 sizeof("Processor")))
270 thermal_zone_unbind_cooling_device(tz,
271 THERMAL_TRIPS_NONE,
272 cdev);
273 }
274 mutex_unlock(&thermal_list_lock);
275 tz->passive_delay = 0;
276 }
277
278 tz->tc1 = 1;
279 tz->tc2 = 1;
280
281 tz->forced_passive = state;
282
283 thermal_zone_device_update(tz);
284
285 return count;
286 }
287
288 static ssize_t
289 passive_show(struct device *dev, struct device_attribute *attr,
290 char *buf)
291 {
292 struct thermal_zone_device *tz = to_thermal_zone(dev);
293
294 return sprintf(buf, "%d\n", tz->forced_passive);
295 }
296
297 static DEVICE_ATTR(type, 0444, type_show, NULL);
298 static DEVICE_ATTR(temp, 0444, temp_show, NULL);
299 static DEVICE_ATTR(mode, 0644, mode_show, mode_store);
300 static DEVICE_ATTR(passive, S_IRUGO | S_IWUSR, passive_show, \
301 passive_store);
302
303 static struct device_attribute trip_point_attrs[] = {
304 __ATTR(trip_point_0_type, 0444, trip_point_type_show, NULL),
305 __ATTR(trip_point_0_temp, 0444, trip_point_temp_show, NULL),
306 __ATTR(trip_point_1_type, 0444, trip_point_type_show, NULL),
307 __ATTR(trip_point_1_temp, 0444, trip_point_temp_show, NULL),
308 __ATTR(trip_point_2_type, 0444, trip_point_type_show, NULL),
309 __ATTR(trip_point_2_temp, 0444, trip_point_temp_show, NULL),
310 __ATTR(trip_point_3_type, 0444, trip_point_type_show, NULL),
311 __ATTR(trip_point_3_temp, 0444, trip_point_temp_show, NULL),
312 __ATTR(trip_point_4_type, 0444, trip_point_type_show, NULL),
313 __ATTR(trip_point_4_temp, 0444, trip_point_temp_show, NULL),
314 __ATTR(trip_point_5_type, 0444, trip_point_type_show, NULL),
315 __ATTR(trip_point_5_temp, 0444, trip_point_temp_show, NULL),
316 __ATTR(trip_point_6_type, 0444, trip_point_type_show, NULL),
317 __ATTR(trip_point_6_temp, 0444, trip_point_temp_show, NULL),
318 __ATTR(trip_point_7_type, 0444, trip_point_type_show, NULL),
319 __ATTR(trip_point_7_temp, 0444, trip_point_temp_show, NULL),
320 __ATTR(trip_point_8_type, 0444, trip_point_type_show, NULL),
321 __ATTR(trip_point_8_temp, 0444, trip_point_temp_show, NULL),
322 __ATTR(trip_point_9_type, 0444, trip_point_type_show, NULL),
323 __ATTR(trip_point_9_temp, 0444, trip_point_temp_show, NULL),
324 __ATTR(trip_point_10_type, 0444, trip_point_type_show, NULL),
325 __ATTR(trip_point_10_temp, 0444, trip_point_temp_show, NULL),
326 __ATTR(trip_point_11_type, 0444, trip_point_type_show, NULL),
327 __ATTR(trip_point_11_temp, 0444, trip_point_temp_show, NULL),
328 };
329
330 #define TRIP_POINT_ATTR_ADD(_dev, _index, result) \
331 do { \
332 result = device_create_file(_dev, \
333 &trip_point_attrs[_index * 2]); \
334 if (result) \
335 break; \
336 result = device_create_file(_dev, \
337 &trip_point_attrs[_index * 2 + 1]); \
338 } while (0)
339
340 #define TRIP_POINT_ATTR_REMOVE(_dev, _index) \
341 do { \
342 device_remove_file(_dev, &trip_point_attrs[_index * 2]); \
343 device_remove_file(_dev, &trip_point_attrs[_index * 2 + 1]); \
344 } while (0)
345
346 /* sys I/F for cooling device */
347 #define to_cooling_device(_dev) \
348 container_of(_dev, struct thermal_cooling_device, device)
349
350 static ssize_t
351 thermal_cooling_device_type_show(struct device *dev,
352 struct device_attribute *attr, char *buf)
353 {
354 struct thermal_cooling_device *cdev = to_cooling_device(dev);
355
356 return sprintf(buf, "%s\n", cdev->type);
357 }
358
359 static ssize_t
360 thermal_cooling_device_max_state_show(struct device *dev,
361 struct device_attribute *attr, char *buf)
362 {
363 struct thermal_cooling_device *cdev = to_cooling_device(dev);
364 unsigned long state;
365 int ret;
366
367 ret = cdev->ops->get_max_state(cdev, &state);
368 if (ret)
369 return ret;
370 return sprintf(buf, "%ld\n", state);
371 }
372
373 static ssize_t
374 thermal_cooling_device_cur_state_show(struct device *dev,
375 struct device_attribute *attr, char *buf)
376 {
377 struct thermal_cooling_device *cdev = to_cooling_device(dev);
378 unsigned long state;
379 int ret;
380
381 ret = cdev->ops->get_cur_state(cdev, &state);
382 if (ret)
383 return ret;
384 return sprintf(buf, "%ld\n", state);
385 }
386
387 static ssize_t
388 thermal_cooling_device_cur_state_store(struct device *dev,
389 struct device_attribute *attr,
390 const char *buf, size_t count)
391 {
392 struct thermal_cooling_device *cdev = to_cooling_device(dev);
393 unsigned long state;
394 int result;
395
396 if (!sscanf(buf, "%ld\n", &state))
397 return -EINVAL;
398
399 if ((long)state < 0)
400 return -EINVAL;
401
402 result = cdev->ops->set_cur_state(cdev, state);
403 if (result)
404 return result;
405 return count;
406 }
407
408 static struct device_attribute dev_attr_cdev_type =
409 __ATTR(type, 0444, thermal_cooling_device_type_show, NULL);
410 static DEVICE_ATTR(max_state, 0444,
411 thermal_cooling_device_max_state_show, NULL);
412 static DEVICE_ATTR(cur_state, 0644,
413 thermal_cooling_device_cur_state_show,
414 thermal_cooling_device_cur_state_store);
415
416 static ssize_t
417 thermal_cooling_device_trip_point_show(struct device *dev,
418 struct device_attribute *attr, char *buf)
419 {
420 struct thermal_cooling_device_instance *instance;
421
422 instance =
423 container_of(attr, struct thermal_cooling_device_instance, attr);
424
425 if (instance->trip == THERMAL_TRIPS_NONE)
426 return sprintf(buf, "-1\n");
427 else
428 return sprintf(buf, "%d\n", instance->trip);
429 }
430
431 /* Device management */
432
433 #if defined(CONFIG_THERMAL_HWMON)
434
435 /* hwmon sys I/F */
436 #include <linux/hwmon.h>
437 static LIST_HEAD(thermal_hwmon_list);
438
439 static ssize_t
440 name_show(struct device *dev, struct device_attribute *attr, char *buf)
441 {
442 struct thermal_hwmon_device *hwmon = dev_get_drvdata(dev);
443 return sprintf(buf, "%s\n", hwmon->type);
444 }
445 static DEVICE_ATTR(name, 0444, name_show, NULL);
446
447 static ssize_t
448 temp_input_show(struct device *dev, struct device_attribute *attr, char *buf)
449 {
450 long temperature;
451 int ret;
452 struct thermal_hwmon_attr *hwmon_attr
453 = container_of(attr, struct thermal_hwmon_attr, attr);
454 struct thermal_zone_device *tz
455 = container_of(hwmon_attr, struct thermal_zone_device,
456 temp_input);
457
458 ret = tz->ops->get_temp(tz, &temperature);
459
460 if (ret)
461 return ret;
462
463 return sprintf(buf, "%ld\n", temperature);
464 }
465
466 static ssize_t
467 temp_crit_show(struct device *dev, struct device_attribute *attr,
468 char *buf)
469 {
470 struct thermal_hwmon_attr *hwmon_attr
471 = container_of(attr, struct thermal_hwmon_attr, attr);
472 struct thermal_zone_device *tz
473 = container_of(hwmon_attr, struct thermal_zone_device,
474 temp_crit);
475 long temperature;
476 int ret;
477
478 ret = tz->ops->get_trip_temp(tz, 0, &temperature);
479 if (ret)
480 return ret;
481
482 return sprintf(buf, "%ld\n", temperature);
483 }
484
485
486 static int
487 thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
488 {
489 struct thermal_hwmon_device *hwmon;
490 int new_hwmon_device = 1;
491 int result;
492
493 mutex_lock(&thermal_list_lock);
494 list_for_each_entry(hwmon, &thermal_hwmon_list, node)
495 if (!strcmp(hwmon->type, tz->type)) {
496 new_hwmon_device = 0;
497 mutex_unlock(&thermal_list_lock);
498 goto register_sys_interface;
499 }
500 mutex_unlock(&thermal_list_lock);
501
502 hwmon = kzalloc(sizeof(struct thermal_hwmon_device), GFP_KERNEL);
503 if (!hwmon)
504 return -ENOMEM;
505
506 INIT_LIST_HEAD(&hwmon->tz_list);
507 strlcpy(hwmon->type, tz->type, THERMAL_NAME_LENGTH);
508 hwmon->device = hwmon_device_register(NULL);
509 if (IS_ERR(hwmon->device)) {
510 result = PTR_ERR(hwmon->device);
511 goto free_mem;
512 }
513 dev_set_drvdata(hwmon->device, hwmon);
514 result = device_create_file(hwmon->device, &dev_attr_name);
515 if (result)
516 goto unregister_hwmon_device;
517
518 register_sys_interface:
519 tz->hwmon = hwmon;
520 hwmon->count++;
521
522 snprintf(tz->temp_input.name, THERMAL_NAME_LENGTH,
523 "temp%d_input", hwmon->count);
524 tz->temp_input.attr.attr.name = tz->temp_input.name;
525 tz->temp_input.attr.attr.mode = 0444;
526 tz->temp_input.attr.show = temp_input_show;
527 sysfs_attr_init(&tz->temp_input.attr.attr);
528 result = device_create_file(hwmon->device, &tz->temp_input.attr);
529 if (result)
530 goto unregister_hwmon_device;
531
532 if (tz->ops->get_crit_temp) {
533 unsigned long temperature;
534 if (!tz->ops->get_crit_temp(tz, &temperature)) {
535 snprintf(tz->temp_crit.name, THERMAL_NAME_LENGTH,
536 "temp%d_crit", hwmon->count);
537 tz->temp_crit.attr.attr.name = tz->temp_crit.name;
538 tz->temp_crit.attr.attr.mode = 0444;
539 tz->temp_crit.attr.show = temp_crit_show;
540 sysfs_attr_init(&tz->temp_crit.attr.attr);
541 result = device_create_file(hwmon->device,
542 &tz->temp_crit.attr);
543 if (result)
544 goto unregister_hwmon_device;
545 }
546 }
547
548 mutex_lock(&thermal_list_lock);
549 if (new_hwmon_device)
550 list_add_tail(&hwmon->node, &thermal_hwmon_list);
551 list_add_tail(&tz->hwmon_node, &hwmon->tz_list);
552 mutex_unlock(&thermal_list_lock);
553
554 return 0;
555
556 unregister_hwmon_device:
557 device_remove_file(hwmon->device, &tz->temp_crit.attr);
558 device_remove_file(hwmon->device, &tz->temp_input.attr);
559 if (new_hwmon_device) {
560 device_remove_file(hwmon->device, &dev_attr_name);
561 hwmon_device_unregister(hwmon->device);
562 }
563 free_mem:
564 if (new_hwmon_device)
565 kfree(hwmon);
566
567 return result;
568 }
569
570 static void
571 thermal_remove_hwmon_sysfs(struct thermal_zone_device *tz)
572 {
573 struct thermal_hwmon_device *hwmon = tz->hwmon;
574
575 tz->hwmon = NULL;
576 device_remove_file(hwmon->device, &tz->temp_input.attr);
577 device_remove_file(hwmon->device, &tz->temp_crit.attr);
578
579 mutex_lock(&thermal_list_lock);
580 list_del(&tz->hwmon_node);
581 if (!list_empty(&hwmon->tz_list)) {
582 mutex_unlock(&thermal_list_lock);
583 return;
584 }
585 list_del(&hwmon->node);
586 mutex_unlock(&thermal_list_lock);
587
588 device_remove_file(hwmon->device, &dev_attr_name);
589 hwmon_device_unregister(hwmon->device);
590 kfree(hwmon);
591 }
592 #else
593 static int
594 thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
595 {
596 return 0;
597 }
598
599 static void
600 thermal_remove_hwmon_sysfs(struct thermal_zone_device *tz)
601 {
602 }
603 #endif
604
605 static void thermal_zone_device_set_polling(struct thermal_zone_device *tz,
606 int delay)
607 {
608 cancel_delayed_work(&(tz->poll_queue));
609
610 if (!delay)
611 return;
612
613 if (delay > 1000)
614 schedule_delayed_work(&(tz->poll_queue),
615 round_jiffies(msecs_to_jiffies(delay)));
616 else
617 schedule_delayed_work(&(tz->poll_queue),
618 msecs_to_jiffies(delay));
619 }
620
621 static void thermal_zone_device_passive(struct thermal_zone_device *tz,
622 int temp, int trip_temp, int trip)
623 {
624 int trend = 0;
625 struct thermal_cooling_device_instance *instance;
626 struct thermal_cooling_device *cdev;
627 long state, max_state;
628
629 /*
630 * Above Trip?
631 * -----------
632 * Calculate the thermal trend (using the passive cooling equation)
633 * and modify the performance limit for all passive cooling devices
634 * accordingly. Note that we assume symmetry.
635 */
636 if (temp >= trip_temp) {
637 tz->passive = true;
638
639 trend = (tz->tc1 * (temp - tz->last_temperature)) +
640 (tz->tc2 * (temp - trip_temp));
641
642 /* Heating up? */
643 if (trend > 0) {
644 list_for_each_entry(instance, &tz->cooling_devices,
645 node) {
646 if (instance->trip != trip)
647 continue;
648 cdev = instance->cdev;
649 cdev->ops->get_cur_state(cdev, &state);
650 cdev->ops->get_max_state(cdev, &max_state);
651 if (state++ < max_state)
652 cdev->ops->set_cur_state(cdev, state);
653 }
654 } else if (trend < 0) { /* Cooling off? */
655 list_for_each_entry(instance, &tz->cooling_devices,
656 node) {
657 if (instance->trip != trip)
658 continue;
659 cdev = instance->cdev;
660 cdev->ops->get_cur_state(cdev, &state);
661 cdev->ops->get_max_state(cdev, &max_state);
662 if (state > 0)
663 cdev->ops->set_cur_state(cdev, --state);
664 }
665 }
666 return;
667 }
668
669 /*
670 * Below Trip?
671 * -----------
672 * Implement passive cooling hysteresis to slowly increase performance
673 * and avoid thrashing around the passive trip point. Note that we
674 * assume symmetry.
675 */
676 list_for_each_entry(instance, &tz->cooling_devices, node) {
677 if (instance->trip != trip)
678 continue;
679 cdev = instance->cdev;
680 cdev->ops->get_cur_state(cdev, &state);
681 cdev->ops->get_max_state(cdev, &max_state);
682 if (state > 0)
683 cdev->ops->set_cur_state(cdev, --state);
684 if (state == 0)
685 tz->passive = false;
686 }
687 }
688
689 static void thermal_zone_device_check(struct work_struct *work)
690 {
691 struct thermal_zone_device *tz = container_of(work, struct
692 thermal_zone_device,
693 poll_queue.work);
694 thermal_zone_device_update(tz);
695 }
696
697 /**
698 * thermal_zone_bind_cooling_device - bind a cooling device to a thermal zone
699 * @tz: thermal zone device
700 * @trip: indicates which trip point the cooling devices is
701 * associated with in this thermal zone.
702 * @cdev: thermal cooling device
703 *
704 * This function is usually called in the thermal zone device .bind callback.
705 */
706 int thermal_zone_bind_cooling_device(struct thermal_zone_device *tz,
707 int trip,
708 struct thermal_cooling_device *cdev)
709 {
710 struct thermal_cooling_device_instance *dev;
711 struct thermal_cooling_device_instance *pos;
712 struct thermal_zone_device *pos1;
713 struct thermal_cooling_device *pos2;
714 int result;
715
716 if (trip >= tz->trips || (trip < 0 && trip != THERMAL_TRIPS_NONE))
717 return -EINVAL;
718
719 list_for_each_entry(pos1, &thermal_tz_list, node) {
720 if (pos1 == tz)
721 break;
722 }
723 list_for_each_entry(pos2, &thermal_cdev_list, node) {
724 if (pos2 == cdev)
725 break;
726 }
727
728 if (tz != pos1 || cdev != pos2)
729 return -EINVAL;
730
731 dev =
732 kzalloc(sizeof(struct thermal_cooling_device_instance), GFP_KERNEL);
733 if (!dev)
734 return -ENOMEM;
735 dev->tz = tz;
736 dev->cdev = cdev;
737 dev->trip = trip;
738 result = get_idr(&tz->idr, &tz->lock, &dev->id);
739 if (result)
740 goto free_mem;
741
742 sprintf(dev->name, "cdev%d", dev->id);
743 result =
744 sysfs_create_link(&tz->device.kobj, &cdev->device.kobj, dev->name);
745 if (result)
746 goto release_idr;
747
748 sprintf(dev->attr_name, "cdev%d_trip_point", dev->id);
749 sysfs_attr_init(&dev->attr.attr);
750 dev->attr.attr.name = dev->attr_name;
751 dev->attr.attr.mode = 0444;
752 dev->attr.show = thermal_cooling_device_trip_point_show;
753 result = device_create_file(&tz->device, &dev->attr);
754 if (result)
755 goto remove_symbol_link;
756
757 mutex_lock(&tz->lock);
758 list_for_each_entry(pos, &tz->cooling_devices, node)
759 if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
760 result = -EEXIST;
761 break;
762 }
763 if (!result)
764 list_add_tail(&dev->node, &tz->cooling_devices);
765 mutex_unlock(&tz->lock);
766
767 if (!result)
768 return 0;
769
770 device_remove_file(&tz->device, &dev->attr);
771 remove_symbol_link:
772 sysfs_remove_link(&tz->device.kobj, dev->name);
773 release_idr:
774 release_idr(&tz->idr, &tz->lock, dev->id);
775 free_mem:
776 kfree(dev);
777 return result;
778 }
779
780 EXPORT_SYMBOL(thermal_zone_bind_cooling_device);
781
782 /**
783 * thermal_zone_unbind_cooling_device - unbind a cooling device from a thermal zone
784 * @tz: thermal zone device
785 * @trip: indicates which trip point the cooling devices is
786 * associated with in this thermal zone.
787 * @cdev: thermal cooling device
788 *
789 * This function is usually called in the thermal zone device .unbind callback.
790 */
791 int thermal_zone_unbind_cooling_device(struct thermal_zone_device *tz,
792 int trip,
793 struct thermal_cooling_device *cdev)
794 {
795 struct thermal_cooling_device_instance *pos, *next;
796
797 mutex_lock(&tz->lock);
798 list_for_each_entry_safe(pos, next, &tz->cooling_devices, node) {
799 if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
800 list_del(&pos->node);
801 mutex_unlock(&tz->lock);
802 goto unbind;
803 }
804 }
805 mutex_unlock(&tz->lock);
806
807 return -ENODEV;
808
809 unbind:
810 device_remove_file(&tz->device, &pos->attr);
811 sysfs_remove_link(&tz->device.kobj, pos->name);
812 release_idr(&tz->idr, &tz->lock, pos->id);
813 kfree(pos);
814 return 0;
815 }
816
817 EXPORT_SYMBOL(thermal_zone_unbind_cooling_device);
818
819 static void thermal_release(struct device *dev)
820 {
821 struct thermal_zone_device *tz;
822 struct thermal_cooling_device *cdev;
823
824 if (!strncmp(dev_name(dev), "thermal_zone", sizeof "thermal_zone" - 1)) {
825 tz = to_thermal_zone(dev);
826 kfree(tz);
827 } else {
828 cdev = to_cooling_device(dev);
829 kfree(cdev);
830 }
831 }
832
833 static struct class thermal_class = {
834 .name = "thermal",
835 .dev_release = thermal_release,
836 };
837
838 /**
839 * thermal_cooling_device_register - register a new thermal cooling device
840 * @type: the thermal cooling device type.
841 * @devdata: device private data.
842 * @ops: standard thermal cooling devices callbacks.
843 */
844 struct thermal_cooling_device *thermal_cooling_device_register(
845 char *type, void *devdata, const struct thermal_cooling_device_ops *ops)
846 {
847 struct thermal_cooling_device *cdev;
848 struct thermal_zone_device *pos;
849 int result;
850
851 if (strlen(type) >= THERMAL_NAME_LENGTH)
852 return ERR_PTR(-EINVAL);
853
854 if (!ops || !ops->get_max_state || !ops->get_cur_state ||
855 !ops->set_cur_state)
856 return ERR_PTR(-EINVAL);
857
858 cdev = kzalloc(sizeof(struct thermal_cooling_device), GFP_KERNEL);
859 if (!cdev)
860 return ERR_PTR(-ENOMEM);
861
862 result = get_idr(&thermal_cdev_idr, &thermal_idr_lock, &cdev->id);
863 if (result) {
864 kfree(cdev);
865 return ERR_PTR(result);
866 }
867
868 strcpy(cdev->type, type);
869 cdev->ops = ops;
870 cdev->device.class = &thermal_class;
871 cdev->devdata = devdata;
872 dev_set_name(&cdev->device, "cooling_device%d", cdev->id);
873 result = device_register(&cdev->device);
874 if (result) {
875 release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id);
876 kfree(cdev);
877 return ERR_PTR(result);
878 }
879
880 /* sys I/F */
881 if (type) {
882 result = device_create_file(&cdev->device, &dev_attr_cdev_type);
883 if (result)
884 goto unregister;
885 }
886
887 result = device_create_file(&cdev->device, &dev_attr_max_state);
888 if (result)
889 goto unregister;
890
891 result = device_create_file(&cdev->device, &dev_attr_cur_state);
892 if (result)
893 goto unregister;
894
895 mutex_lock(&thermal_list_lock);
896 list_add(&cdev->node, &thermal_cdev_list);
897 list_for_each_entry(pos, &thermal_tz_list, node) {
898 if (!pos->ops->bind)
899 continue;
900 result = pos->ops->bind(pos, cdev);
901 if (result)
902 break;
903
904 }
905 mutex_unlock(&thermal_list_lock);
906
907 if (!result)
908 return cdev;
909
910 unregister:
911 release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id);
912 device_unregister(&cdev->device);
913 return ERR_PTR(result);
914 }
915
916 EXPORT_SYMBOL(thermal_cooling_device_register);
917
918 /**
919 * thermal_cooling_device_unregister - removes the registered thermal cooling device
920 * @cdev: the thermal cooling device to remove.
921 *
922 * thermal_cooling_device_unregister() must be called when the device is no
923 * longer needed.
924 */
925 void thermal_cooling_device_unregister(struct
926 thermal_cooling_device
927 *cdev)
928 {
929 struct thermal_zone_device *tz;
930 struct thermal_cooling_device *pos = NULL;
931
932 if (!cdev)
933 return;
934
935 mutex_lock(&thermal_list_lock);
936 list_for_each_entry(pos, &thermal_cdev_list, node)
937 if (pos == cdev)
938 break;
939 if (pos != cdev) {
940 /* thermal cooling device not found */
941 mutex_unlock(&thermal_list_lock);
942 return;
943 }
944 list_del(&cdev->node);
945 list_for_each_entry(tz, &thermal_tz_list, node) {
946 if (!tz->ops->unbind)
947 continue;
948 tz->ops->unbind(tz, cdev);
949 }
950 mutex_unlock(&thermal_list_lock);
951 if (cdev->type[0])
952 device_remove_file(&cdev->device, &dev_attr_cdev_type);
953 device_remove_file(&cdev->device, &dev_attr_max_state);
954 device_remove_file(&cdev->device, &dev_attr_cur_state);
955
956 release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id);
957 device_unregister(&cdev->device);
958 return;
959 }
960
961 EXPORT_SYMBOL(thermal_cooling_device_unregister);
962
963 /**
964 * thermal_zone_device_update - force an update of a thermal zone's state
965 * @ttz: the thermal zone to update
966 */
967
968 void thermal_zone_device_update(struct thermal_zone_device *tz)
969 {
970 int count, ret = 0;
971 long temp, trip_temp;
972 enum thermal_trip_type trip_type;
973 struct thermal_cooling_device_instance *instance;
974 struct thermal_cooling_device *cdev;
975
976 mutex_lock(&tz->lock);
977
978 if (tz->ops->get_temp(tz, &temp)) {
979 /* get_temp failed - retry it later */
980 printk(KERN_WARNING PREFIX "failed to read out thermal zone "
981 "%d\n", tz->id);
982 goto leave;
983 }
984
985 for (count = 0; count < tz->trips; count++) {
986 tz->ops->get_trip_type(tz, count, &trip_type);
987 tz->ops->get_trip_temp(tz, count, &trip_temp);
988
989 switch (trip_type) {
990 case THERMAL_TRIP_CRITICAL:
991 if (temp >= trip_temp) {
992 if (tz->ops->notify)
993 ret = tz->ops->notify(tz, count,
994 trip_type);
995 if (!ret) {
996 printk(KERN_EMERG
997 "Critical temperature reached (%ld C), shutting down.\n",
998 temp/1000);
999 orderly_poweroff(true);
1000 }
1001 }
1002 break;
1003 case THERMAL_TRIP_HOT:
1004 if (temp >= trip_temp)
1005 if (tz->ops->notify)
1006 tz->ops->notify(tz, count, trip_type);
1007 break;
1008 case THERMAL_TRIP_ACTIVE:
1009 list_for_each_entry(instance, &tz->cooling_devices,
1010 node) {
1011 if (instance->trip != count)
1012 continue;
1013
1014 cdev = instance->cdev;
1015
1016 if (temp >= trip_temp)
1017 cdev->ops->set_cur_state(cdev, 1);
1018 else
1019 cdev->ops->set_cur_state(cdev, 0);
1020 }
1021 break;
1022 case THERMAL_TRIP_PASSIVE:
1023 if (temp >= trip_temp || tz->passive)
1024 thermal_zone_device_passive(tz, temp,
1025 trip_temp, count);
1026 break;
1027 }
1028 }
1029
1030 if (tz->forced_passive)
1031 thermal_zone_device_passive(tz, temp, tz->forced_passive,
1032 THERMAL_TRIPS_NONE);
1033
1034 tz->last_temperature = temp;
1035
1036 leave:
1037 if (tz->passive)
1038 thermal_zone_device_set_polling(tz, tz->passive_delay);
1039 else if (tz->polling_delay)
1040 thermal_zone_device_set_polling(tz, tz->polling_delay);
1041 else
1042 thermal_zone_device_set_polling(tz, 0);
1043 mutex_unlock(&tz->lock);
1044 }
1045 EXPORT_SYMBOL(thermal_zone_device_update);
1046
1047 /**
1048 * thermal_zone_device_register - register a new thermal zone device
1049 * @type: the thermal zone device type
1050 * @trips: the number of trip points the thermal zone support
1051 * @devdata: private device data
1052 * @ops: standard thermal zone device callbacks
1053 * @tc1: thermal coefficient 1 for passive calculations
1054 * @tc2: thermal coefficient 2 for passive calculations
1055 * @passive_delay: number of milliseconds to wait between polls when
1056 * performing passive cooling
1057 * @polling_delay: number of milliseconds to wait between polls when checking
1058 * whether trip points have been crossed (0 for interrupt
1059 * driven systems)
1060 *
1061 * thermal_zone_device_unregister() must be called when the device is no
1062 * longer needed. The passive cooling formula uses tc1 and tc2 as described in
1063 * section 11.1.5.1 of the ACPI specification 3.0.
1064 */
1065 struct thermal_zone_device *thermal_zone_device_register(char *type,
1066 int trips, void *devdata,
1067 const struct thermal_zone_device_ops *ops,
1068 int tc1, int tc2, int passive_delay, int polling_delay)
1069 {
1070 struct thermal_zone_device *tz;
1071 struct thermal_cooling_device *pos;
1072 enum thermal_trip_type trip_type;
1073 int result;
1074 int count;
1075 int passive = 0;
1076
1077 if (strlen(type) >= THERMAL_NAME_LENGTH)
1078 return ERR_PTR(-EINVAL);
1079
1080 if (trips > THERMAL_MAX_TRIPS || trips < 0)
1081 return ERR_PTR(-EINVAL);
1082
1083 if (!ops || !ops->get_temp)
1084 return ERR_PTR(-EINVAL);
1085
1086 tz = kzalloc(sizeof(struct thermal_zone_device), GFP_KERNEL);
1087 if (!tz)
1088 return ERR_PTR(-ENOMEM);
1089
1090 INIT_LIST_HEAD(&tz->cooling_devices);
1091 idr_init(&tz->idr);
1092 mutex_init(&tz->lock);
1093 result = get_idr(&thermal_tz_idr, &thermal_idr_lock, &tz->id);
1094 if (result) {
1095 kfree(tz);
1096 return ERR_PTR(result);
1097 }
1098
1099 strcpy(tz->type, type);
1100 tz->ops = ops;
1101 tz->device.class = &thermal_class;
1102 tz->devdata = devdata;
1103 tz->trips = trips;
1104 tz->tc1 = tc1;
1105 tz->tc2 = tc2;
1106 tz->passive_delay = passive_delay;
1107 tz->polling_delay = polling_delay;
1108
1109 dev_set_name(&tz->device, "thermal_zone%d", tz->id);
1110 result = device_register(&tz->device);
1111 if (result) {
1112 release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);
1113 kfree(tz);
1114 return ERR_PTR(result);
1115 }
1116
1117 /* sys I/F */
1118 if (type) {
1119 result = device_create_file(&tz->device, &dev_attr_type);
1120 if (result)
1121 goto unregister;
1122 }
1123
1124 result = device_create_file(&tz->device, &dev_attr_temp);
1125 if (result)
1126 goto unregister;
1127
1128 if (ops->get_mode) {
1129 result = device_create_file(&tz->device, &dev_attr_mode);
1130 if (result)
1131 goto unregister;
1132 }
1133
1134 for (count = 0; count < trips; count++) {
1135 TRIP_POINT_ATTR_ADD(&tz->device, count, result);
1136 if (result)
1137 goto unregister;
1138 tz->ops->get_trip_type(tz, count, &trip_type);
1139 if (trip_type == THERMAL_TRIP_PASSIVE)
1140 passive = 1;
1141 }
1142
1143 if (!passive)
1144 result = device_create_file(&tz->device,
1145 &dev_attr_passive);
1146
1147 if (result)
1148 goto unregister;
1149
1150 result = thermal_add_hwmon_sysfs(tz);
1151 if (result)
1152 goto unregister;
1153
1154 mutex_lock(&thermal_list_lock);
1155 list_add_tail(&tz->node, &thermal_tz_list);
1156 if (ops->bind)
1157 list_for_each_entry(pos, &thermal_cdev_list, node) {
1158 result = ops->bind(tz, pos);
1159 if (result)
1160 break;
1161 }
1162 mutex_unlock(&thermal_list_lock);
1163
1164 INIT_DELAYED_WORK(&(tz->poll_queue), thermal_zone_device_check);
1165
1166 thermal_zone_device_update(tz);
1167
1168 if (!result)
1169 return tz;
1170
1171 unregister:
1172 release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);
1173 device_unregister(&tz->device);
1174 return ERR_PTR(result);
1175 }
1176
1177 EXPORT_SYMBOL(thermal_zone_device_register);
1178
1179 /**
1180 * thermal_device_unregister - removes the registered thermal zone device
1181 * @tz: the thermal zone device to remove
1182 */
1183 void thermal_zone_device_unregister(struct thermal_zone_device *tz)
1184 {
1185 struct thermal_cooling_device *cdev;
1186 struct thermal_zone_device *pos = NULL;
1187 int count;
1188
1189 if (!tz)
1190 return;
1191
1192 mutex_lock(&thermal_list_lock);
1193 list_for_each_entry(pos, &thermal_tz_list, node)
1194 if (pos == tz)
1195 break;
1196 if (pos != tz) {
1197 /* thermal zone device not found */
1198 mutex_unlock(&thermal_list_lock);
1199 return;
1200 }
1201 list_del(&tz->node);
1202 if (tz->ops->unbind)
1203 list_for_each_entry(cdev, &thermal_cdev_list, node)
1204 tz->ops->unbind(tz, cdev);
1205 mutex_unlock(&thermal_list_lock);
1206
1207 thermal_zone_device_set_polling(tz, 0);
1208
1209 if (tz->type[0])
1210 device_remove_file(&tz->device, &dev_attr_type);
1211 device_remove_file(&tz->device, &dev_attr_temp);
1212 if (tz->ops->get_mode)
1213 device_remove_file(&tz->device, &dev_attr_mode);
1214
1215 for (count = 0; count < tz->trips; count++)
1216 TRIP_POINT_ATTR_REMOVE(&tz->device, count);
1217
1218 thermal_remove_hwmon_sysfs(tz);
1219 release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);
1220 idr_destroy(&tz->idr);
1221 mutex_destroy(&tz->lock);
1222 device_unregister(&tz->device);
1223 return;
1224 }
1225
1226 EXPORT_SYMBOL(thermal_zone_device_unregister);
1227
1228 int generate_netlink_event(u32 orig, enum events event)
1229 {
1230 struct sk_buff *skb;
1231 struct nlattr *attr;
1232 struct thermal_genl_event *thermal_event;
1233 void *msg_header;
1234 int size;
1235 int result;
1236
1237 /* allocate memory */
1238 size = nla_total_size(sizeof(struct thermal_genl_event)) + \
1239 nla_total_size(0);
1240
1241 skb = genlmsg_new(size, GFP_ATOMIC);
1242 if (!skb)
1243 return -ENOMEM;
1244
1245 /* add the genetlink message header */
1246 msg_header = genlmsg_put(skb, 0, thermal_event_seqnum++,
1247 &thermal_event_genl_family, 0,
1248 THERMAL_GENL_CMD_EVENT);
1249 if (!msg_header) {
1250 nlmsg_free(skb);
1251 return -ENOMEM;
1252 }
1253
1254 /* fill the data */
1255 attr = nla_reserve(skb, THERMAL_GENL_ATTR_EVENT, \
1256 sizeof(struct thermal_genl_event));
1257
1258 if (!attr) {
1259 nlmsg_free(skb);
1260 return -EINVAL;
1261 }
1262
1263 thermal_event = nla_data(attr);
1264 if (!thermal_event) {
1265 nlmsg_free(skb);
1266 return -EINVAL;
1267 }
1268
1269 memset(thermal_event, 0, sizeof(struct thermal_genl_event));
1270
1271 thermal_event->orig = orig;
1272 thermal_event->event = event;
1273
1274 /* send multicast genetlink message */
1275 result = genlmsg_end(skb, msg_header);
1276 if (result < 0) {
1277 nlmsg_free(skb);
1278 return result;
1279 }
1280
1281 result = genlmsg_multicast(skb, 0, thermal_event_mcgrp.id, GFP_ATOMIC);
1282 if (result)
1283 printk(KERN_INFO "failed to send netlink event:%d", result);
1284
1285 return result;
1286 }
1287 EXPORT_SYMBOL(generate_netlink_event);
1288
1289 static int genetlink_init(void)
1290 {
1291 int result;
1292
1293 result = genl_register_family(&thermal_event_genl_family);
1294 if (result)
1295 return result;
1296
1297 result = genl_register_mc_group(&thermal_event_genl_family,
1298 &thermal_event_mcgrp);
1299 if (result)
1300 genl_unregister_family(&thermal_event_genl_family);
1301 return result;
1302 }
1303
1304 static int __init thermal_init(void)
1305 {
1306 int result = 0;
1307
1308 result = class_register(&thermal_class);
1309 if (result) {
1310 idr_destroy(&thermal_tz_idr);
1311 idr_destroy(&thermal_cdev_idr);
1312 mutex_destroy(&thermal_idr_lock);
1313 mutex_destroy(&thermal_list_lock);
1314 }
1315 result = genetlink_init();
1316 return result;
1317 }
1318
1319 static void genetlink_exit(void)
1320 {
1321 genl_unregister_family(&thermal_event_genl_family);
1322 }
1323
1324 static void __exit thermal_exit(void)
1325 {
1326 class_unregister(&thermal_class);
1327 idr_destroy(&thermal_tz_idr);
1328 idr_destroy(&thermal_cdev_idr);
1329 mutex_destroy(&thermal_idr_lock);
1330 mutex_destroy(&thermal_list_lock);
1331 genetlink_exit();
1332 }
1333
1334 fs_initcall(thermal_init);
1335 module_exit(thermal_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree