2 * thermal.c - Generic Thermal Management Sysfs support.
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>
8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
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.
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
26 #include <linux/module.h>
27 #include <linux/device.h>
28 #include <linux/err.h>
29 #include <linux/kdev_t.h>
30 #include <linux/idr.h>
31 #include <linux/thermal.h>
32 #include <linux/spinlock.h>
34 MODULE_AUTHOR("Zhang Rui")
35 MODULE_DESCRIPTION("Generic thermal management sysfs support");
36 MODULE_LICENSE("GPL");
38 #define PREFIX "Thermal: "
40 struct thermal_cooling_device_instance
{
42 char name
[THERMAL_NAME_LENGTH
];
43 struct thermal_zone_device
*tz
;
44 struct thermal_cooling_device
*cdev
;
46 char attr_name
[THERMAL_NAME_LENGTH
];
47 struct device_attribute attr
;
48 struct list_head node
;
51 static DEFINE_IDR(thermal_tz_idr
);
52 static DEFINE_IDR(thermal_cdev_idr
);
53 static DEFINE_MUTEX(thermal_idr_lock
);
55 static LIST_HEAD(thermal_tz_list
);
56 static LIST_HEAD(thermal_cdev_list
);
57 static DEFINE_MUTEX(thermal_list_lock
);
59 static int get_idr(struct idr
*idr
, struct mutex
*lock
, int *id
)
64 if (unlikely(idr_pre_get(idr
, GFP_KERNEL
) == 0))
69 err
= idr_get_new(idr
, NULL
, id
);
72 if (unlikely(err
== -EAGAIN
))
74 else if (unlikely(err
))
77 *id
= *id
& MAX_ID_MASK
;
81 static void release_idr(struct idr
*idr
, struct mutex
*lock
, int id
)
90 /* sys I/F for thermal zone */
92 #define to_thermal_zone(_dev) \
93 container_of(_dev, struct thermal_zone_device, device)
96 type_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
98 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
100 return sprintf(buf
, "%s\n", tz
->type
);
104 temp_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
106 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
108 if (!tz
->ops
->get_temp
)
111 return tz
->ops
->get_temp(tz
, buf
);
115 mode_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
117 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
119 if (!tz
->ops
->get_mode
)
122 return tz
->ops
->get_mode(tz
, buf
);
126 mode_store(struct device
*dev
, struct device_attribute
*attr
,
127 const char *buf
, size_t count
)
129 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
132 if (!tz
->ops
->set_mode
)
135 result
= tz
->ops
->set_mode(tz
, buf
);
143 trip_point_type_show(struct device
*dev
, struct device_attribute
*attr
,
146 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
149 if (!tz
->ops
->get_trip_type
)
152 if (!sscanf(attr
->attr
.name
, "trip_point_%d_type", &trip
))
155 return tz
->ops
->get_trip_type(tz
, trip
, buf
);
159 trip_point_temp_show(struct device
*dev
, struct device_attribute
*attr
,
162 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
165 if (!tz
->ops
->get_trip_temp
)
168 if (!sscanf(attr
->attr
.name
, "trip_point_%d_temp", &trip
))
171 return tz
->ops
->get_trip_temp(tz
, trip
, buf
);
174 static DEVICE_ATTR(type
, 0444, type_show
, NULL
);
175 static DEVICE_ATTR(temp
, 0444, temp_show
, NULL
);
176 static DEVICE_ATTR(mode
, 0644, mode_show
, mode_store
);
178 static struct device_attribute trip_point_attrs
[] = {
179 __ATTR(trip_point_0_type
, 0444, trip_point_type_show
, NULL
),
180 __ATTR(trip_point_0_temp
, 0444, trip_point_temp_show
, NULL
),
181 __ATTR(trip_point_1_type
, 0444, trip_point_type_show
, NULL
),
182 __ATTR(trip_point_1_temp
, 0444, trip_point_temp_show
, NULL
),
183 __ATTR(trip_point_2_type
, 0444, trip_point_type_show
, NULL
),
184 __ATTR(trip_point_2_temp
, 0444, trip_point_temp_show
, NULL
),
185 __ATTR(trip_point_3_type
, 0444, trip_point_type_show
, NULL
),
186 __ATTR(trip_point_3_temp
, 0444, trip_point_temp_show
, NULL
),
187 __ATTR(trip_point_4_type
, 0444, trip_point_type_show
, NULL
),
188 __ATTR(trip_point_4_temp
, 0444, trip_point_temp_show
, NULL
),
189 __ATTR(trip_point_5_type
, 0444, trip_point_type_show
, NULL
),
190 __ATTR(trip_point_5_temp
, 0444, trip_point_temp_show
, NULL
),
191 __ATTR(trip_point_6_type
, 0444, trip_point_type_show
, NULL
),
192 __ATTR(trip_point_6_temp
, 0444, trip_point_temp_show
, NULL
),
193 __ATTR(trip_point_7_type
, 0444, trip_point_type_show
, NULL
),
194 __ATTR(trip_point_7_temp
, 0444, trip_point_temp_show
, NULL
),
195 __ATTR(trip_point_8_type
, 0444, trip_point_type_show
, NULL
),
196 __ATTR(trip_point_8_temp
, 0444, trip_point_temp_show
, NULL
),
197 __ATTR(trip_point_9_type
, 0444, trip_point_type_show
, NULL
),
198 __ATTR(trip_point_9_temp
, 0444, trip_point_temp_show
, NULL
),
199 __ATTR(trip_point_10_type
, 0444, trip_point_type_show
, NULL
),
200 __ATTR(trip_point_10_temp
, 0444, trip_point_temp_show
, NULL
),
201 __ATTR(trip_point_11_type
, 0444, trip_point_type_show
, NULL
),
202 __ATTR(trip_point_11_temp
, 0444, trip_point_temp_show
, NULL
),
205 #define TRIP_POINT_ATTR_ADD(_dev, _index, result) \
207 result = device_create_file(_dev, \
208 &trip_point_attrs[_index * 2]); \
211 result = device_create_file(_dev, \
212 &trip_point_attrs[_index * 2 + 1]); \
215 #define TRIP_POINT_ATTR_REMOVE(_dev, _index) \
217 device_remove_file(_dev, &trip_point_attrs[_index * 2]); \
218 device_remove_file(_dev, &trip_point_attrs[_index * 2 + 1]); \
221 /* sys I/F for cooling device */
222 #define to_cooling_device(_dev) \
223 container_of(_dev, struct thermal_cooling_device, device)
226 thermal_cooling_device_type_show(struct device
*dev
,
227 struct device_attribute
*attr
, char *buf
)
229 struct thermal_cooling_device
*cdev
= to_cooling_device(dev
);
231 return sprintf(buf
, "%s\n", cdev
->type
);
235 thermal_cooling_device_max_state_show(struct device
*dev
,
236 struct device_attribute
*attr
, char *buf
)
238 struct thermal_cooling_device
*cdev
= to_cooling_device(dev
);
240 return cdev
->ops
->get_max_state(cdev
, buf
);
244 thermal_cooling_device_cur_state_show(struct device
*dev
,
245 struct device_attribute
*attr
, char *buf
)
247 struct thermal_cooling_device
*cdev
= to_cooling_device(dev
);
249 return cdev
->ops
->get_cur_state(cdev
, buf
);
253 thermal_cooling_device_cur_state_store(struct device
*dev
,
254 struct device_attribute
*attr
,
255 const char *buf
, size_t count
)
257 struct thermal_cooling_device
*cdev
= to_cooling_device(dev
);
261 if (!sscanf(buf
, "%d\n", &state
))
267 result
= cdev
->ops
->set_cur_state(cdev
, state
);
273 static struct device_attribute dev_attr_cdev_type
=
274 __ATTR(type
, 0444, thermal_cooling_device_type_show
, NULL
);
275 static DEVICE_ATTR(max_state
, 0444,
276 thermal_cooling_device_max_state_show
, NULL
);
277 static DEVICE_ATTR(cur_state
, 0644,
278 thermal_cooling_device_cur_state_show
,
279 thermal_cooling_device_cur_state_store
);
282 thermal_cooling_device_trip_point_show(struct device
*dev
,
283 struct device_attribute
*attr
, char *buf
)
285 struct thermal_cooling_device_instance
*instance
;
288 container_of(attr
, struct thermal_cooling_device_instance
, attr
);
290 if (instance
->trip
== THERMAL_TRIPS_NONE
)
291 return sprintf(buf
, "-1\n");
293 return sprintf(buf
, "%d\n", instance
->trip
);
296 /* Device management */
299 * thermal_zone_bind_cooling_device - bind a cooling device to a thermal zone
300 * @tz: thermal zone device
301 * @trip: indicates which trip point the cooling devices is
302 * associated with in this thermal zone.
303 * @cdev: thermal cooling device
305 * This function is usually called in the thermal zone device .bind callback.
307 int thermal_zone_bind_cooling_device(struct thermal_zone_device
*tz
,
309 struct thermal_cooling_device
*cdev
)
311 struct thermal_cooling_device_instance
*dev
;
312 struct thermal_cooling_device_instance
*pos
;
313 struct thermal_zone_device
*pos1
;
314 struct thermal_cooling_device
*pos2
;
317 if (trip
>= tz
->trips
|| (trip
< 0 && trip
!= THERMAL_TRIPS_NONE
))
320 list_for_each_entry(pos1
, &thermal_tz_list
, node
) {
324 list_for_each_entry(pos2
, &thermal_cdev_list
, node
) {
329 if (tz
!= pos1
|| cdev
!= pos2
)
333 kzalloc(sizeof(struct thermal_cooling_device_instance
), GFP_KERNEL
);
339 result
= get_idr(&tz
->idr
, &tz
->lock
, &dev
->id
);
343 sprintf(dev
->name
, "cdev%d", dev
->id
);
345 sysfs_create_link(&tz
->device
.kobj
, &cdev
->device
.kobj
, dev
->name
);
349 sprintf(dev
->attr_name
, "cdev%d_trip_point", dev
->id
);
350 dev
->attr
.attr
.name
= dev
->attr_name
;
351 dev
->attr
.attr
.mode
= 0444;
352 dev
->attr
.show
= thermal_cooling_device_trip_point_show
;
353 result
= device_create_file(&tz
->device
, &dev
->attr
);
355 goto remove_symbol_link
;
357 mutex_lock(&tz
->lock
);
358 list_for_each_entry(pos
, &tz
->cooling_devices
, node
)
359 if (pos
->tz
== tz
&& pos
->trip
== trip
&& pos
->cdev
== cdev
) {
364 list_add_tail(&dev
->node
, &tz
->cooling_devices
);
365 mutex_unlock(&tz
->lock
);
370 device_remove_file(&tz
->device
, &dev
->attr
);
372 sysfs_remove_link(&tz
->device
.kobj
, dev
->name
);
374 release_idr(&tz
->idr
, &tz
->lock
, dev
->id
);
380 EXPORT_SYMBOL(thermal_zone_bind_cooling_device
);
383 * thermal_zone_unbind_cooling_device - unbind a cooling device from a thermal zone
384 * @tz: thermal zone device
385 * @trip: indicates which trip point the cooling devices is
386 * associated with in this thermal zone.
387 * @cdev: thermal cooling device
389 * This function is usually called in the thermal zone device .unbind callback.
391 int thermal_zone_unbind_cooling_device(struct thermal_zone_device
*tz
,
393 struct thermal_cooling_device
*cdev
)
395 struct thermal_cooling_device_instance
*pos
, *next
;
397 mutex_lock(&tz
->lock
);
398 list_for_each_entry_safe(pos
, next
, &tz
->cooling_devices
, node
) {
399 if (pos
->tz
== tz
&& pos
->trip
== trip
&& pos
->cdev
== cdev
) {
400 list_del(&pos
->node
);
401 mutex_unlock(&tz
->lock
);
405 mutex_unlock(&tz
->lock
);
410 device_remove_file(&tz
->device
, &pos
->attr
);
411 sysfs_remove_link(&tz
->device
.kobj
, pos
->name
);
412 release_idr(&tz
->idr
, &tz
->lock
, pos
->id
);
417 EXPORT_SYMBOL(thermal_zone_unbind_cooling_device
);
419 static void thermal_release(struct device
*dev
)
421 struct thermal_zone_device
*tz
;
422 struct thermal_cooling_device
*cdev
;
424 if (!strncmp(dev
->bus_id
, "thermal_zone", sizeof "thermal_zone" - 1)) {
425 tz
= to_thermal_zone(dev
);
428 cdev
= to_cooling_device(dev
);
433 static struct class thermal_class
= {
435 .dev_release
= thermal_release
,
439 * thermal_cooling_device_register - register a new thermal cooling device
440 * @type: the thermal cooling device type.
441 * @devdata: device private data.
442 * @ops: standard thermal cooling devices callbacks.
444 struct thermal_cooling_device
*thermal_cooling_device_register(char *type
,
447 thermal_cooling_device_ops
450 struct thermal_cooling_device
*cdev
;
451 struct thermal_zone_device
*pos
;
454 if (strlen(type
) >= THERMAL_NAME_LENGTH
)
455 return ERR_PTR(-EINVAL
);
457 if (!ops
|| !ops
->get_max_state
|| !ops
->get_cur_state
||
459 return ERR_PTR(-EINVAL
);
461 cdev
= kzalloc(sizeof(struct thermal_cooling_device
), GFP_KERNEL
);
463 return ERR_PTR(-ENOMEM
);
465 result
= get_idr(&thermal_cdev_idr
, &thermal_idr_lock
, &cdev
->id
);
468 return ERR_PTR(result
);
471 strcpy(cdev
->type
, type
);
473 cdev
->device
.class = &thermal_class
;
474 cdev
->devdata
= devdata
;
475 sprintf(cdev
->device
.bus_id
, "cooling_device%d", cdev
->id
);
476 result
= device_register(&cdev
->device
);
478 release_idr(&thermal_cdev_idr
, &thermal_idr_lock
, cdev
->id
);
480 return ERR_PTR(result
);
485 result
= device_create_file(&cdev
->device
, &dev_attr_cdev_type
);
490 result
= device_create_file(&cdev
->device
, &dev_attr_max_state
);
494 result
= device_create_file(&cdev
->device
, &dev_attr_cur_state
);
498 mutex_lock(&thermal_list_lock
);
499 list_add(&cdev
->node
, &thermal_cdev_list
);
500 list_for_each_entry(pos
, &thermal_tz_list
, node
) {
503 result
= pos
->ops
->bind(pos
, cdev
);
508 mutex_unlock(&thermal_list_lock
);
514 release_idr(&thermal_cdev_idr
, &thermal_idr_lock
, cdev
->id
);
515 device_unregister(&cdev
->device
);
516 return ERR_PTR(result
);
519 EXPORT_SYMBOL(thermal_cooling_device_register
);
522 * thermal_cooling_device_unregister - removes the registered thermal cooling device
523 * @cdev: the thermal cooling device to remove.
525 * thermal_cooling_device_unregister() must be called when the device is no
528 void thermal_cooling_device_unregister(struct
529 thermal_cooling_device
532 struct thermal_zone_device
*tz
;
533 struct thermal_cooling_device
*pos
= NULL
;
538 mutex_lock(&thermal_list_lock
);
539 list_for_each_entry(pos
, &thermal_cdev_list
, node
)
543 /* thermal cooling device not found */
544 mutex_unlock(&thermal_list_lock
);
547 list_del(&cdev
->node
);
548 list_for_each_entry(tz
, &thermal_tz_list
, node
) {
549 if (!tz
->ops
->unbind
)
551 tz
->ops
->unbind(tz
, cdev
);
553 mutex_unlock(&thermal_list_lock
);
555 device_remove_file(&cdev
->device
, &dev_attr_cdev_type
);
556 device_remove_file(&cdev
->device
, &dev_attr_max_state
);
557 device_remove_file(&cdev
->device
, &dev_attr_cur_state
);
559 release_idr(&thermal_cdev_idr
, &thermal_idr_lock
, cdev
->id
);
560 device_unregister(&cdev
->device
);
564 EXPORT_SYMBOL(thermal_cooling_device_unregister
);
567 * thermal_zone_device_register - register a new thermal zone device
568 * @type: the thermal zone device type
569 * @trips: the number of trip points the thermal zone support
570 * @devdata: private device data
571 * @ops: standard thermal zone device callbacks
573 * thermal_zone_device_unregister() must be called when the device is no
576 struct thermal_zone_device
*thermal_zone_device_register(char *type
,
578 void *devdata
, struct
579 thermal_zone_device_ops
582 struct thermal_zone_device
*tz
;
583 struct thermal_cooling_device
*pos
;
587 if (strlen(type
) >= THERMAL_NAME_LENGTH
)
588 return ERR_PTR(-EINVAL
);
590 if (trips
> THERMAL_MAX_TRIPS
|| trips
< 0)
591 return ERR_PTR(-EINVAL
);
593 if (!ops
|| !ops
->get_temp
)
594 return ERR_PTR(-EINVAL
);
596 tz
= kzalloc(sizeof(struct thermal_zone_device
), GFP_KERNEL
);
598 return ERR_PTR(-ENOMEM
);
600 INIT_LIST_HEAD(&tz
->cooling_devices
);
602 mutex_init(&tz
->lock
);
603 result
= get_idr(&thermal_tz_idr
, &thermal_idr_lock
, &tz
->id
);
606 return ERR_PTR(result
);
609 strcpy(tz
->type
, type
);
611 tz
->device
.class = &thermal_class
;
612 tz
->devdata
= devdata
;
614 sprintf(tz
->device
.bus_id
, "thermal_zone%d", tz
->id
);
615 result
= device_register(&tz
->device
);
617 release_idr(&thermal_tz_idr
, &thermal_idr_lock
, tz
->id
);
619 return ERR_PTR(result
);
624 result
= device_create_file(&tz
->device
, &dev_attr_type
);
629 result
= device_create_file(&tz
->device
, &dev_attr_temp
);
634 result
= device_create_file(&tz
->device
, &dev_attr_mode
);
639 for (count
= 0; count
< trips
; count
++) {
640 TRIP_POINT_ATTR_ADD(&tz
->device
, count
, result
);
645 mutex_lock(&thermal_list_lock
);
646 list_add_tail(&tz
->node
, &thermal_tz_list
);
648 list_for_each_entry(pos
, &thermal_cdev_list
, node
) {
649 result
= ops
->bind(tz
, pos
);
653 mutex_unlock(&thermal_list_lock
);
659 release_idr(&thermal_tz_idr
, &thermal_idr_lock
, tz
->id
);
660 device_unregister(&tz
->device
);
661 return ERR_PTR(result
);
664 EXPORT_SYMBOL(thermal_zone_device_register
);
667 * thermal_device_unregister - removes the registered thermal zone device
668 * @tz: the thermal zone device to remove
670 void thermal_zone_device_unregister(struct thermal_zone_device
*tz
)
672 struct thermal_cooling_device
*cdev
;
673 struct thermal_zone_device
*pos
= NULL
;
679 mutex_lock(&thermal_list_lock
);
680 list_for_each_entry(pos
, &thermal_tz_list
, node
)
684 /* thermal zone device not found */
685 mutex_unlock(&thermal_list_lock
);
690 list_for_each_entry(cdev
, &thermal_cdev_list
, node
)
691 tz
->ops
->unbind(tz
, cdev
);
692 mutex_unlock(&thermal_list_lock
);
695 device_remove_file(&tz
->device
, &dev_attr_type
);
696 device_remove_file(&tz
->device
, &dev_attr_temp
);
697 if (tz
->ops
->get_mode
)
698 device_remove_file(&tz
->device
, &dev_attr_mode
);
700 for (count
= 0; count
< tz
->trips
; count
++)
701 TRIP_POINT_ATTR_REMOVE(&tz
->device
, count
);
703 release_idr(&thermal_tz_idr
, &thermal_idr_lock
, tz
->id
);
704 idr_destroy(&tz
->idr
);
705 mutex_destroy(&tz
->lock
);
706 device_unregister(&tz
->device
);
710 EXPORT_SYMBOL(thermal_zone_device_unregister
);
712 static int __init
thermal_init(void)
716 result
= class_register(&thermal_class
);
718 idr_destroy(&thermal_tz_idr
);
719 idr_destroy(&thermal_cdev_idr
);
720 mutex_destroy(&thermal_idr_lock
);
721 mutex_destroy(&thermal_list_lock
);
726 static void __exit
thermal_exit(void)
728 class_unregister(&thermal_class
);
729 idr_destroy(&thermal_tz_idr
);
730 idr_destroy(&thermal_cdev_idr
);
731 mutex_destroy(&thermal_idr_lock
);
732 mutex_destroy(&thermal_list_lock
);
735 subsys_initcall(thermal_init
);
736 module_exit(thermal_exit
);