2 * intel_menlow.c - Intel menlow Driver for thermal management extension
4 * Copyright (C) 2008 Intel Corp
5 * Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
6 * Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; version 2 of the License.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24 * This driver creates the sys I/F for programming the sensors.
25 * It also implements the driver for intel menlow memory controller (hardware
26 * id is INT0002) which makes use of the platform specific ACPI methods
27 * to get/set bandwidth.
30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
32 #include <linux/kernel.h>
33 #include <linux/module.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
36 #include <linux/types.h>
37 #include <linux/pci.h>
39 #include <linux/thermal.h>
40 #include <linux/acpi.h>
42 MODULE_AUTHOR("Thomas Sujith");
43 MODULE_AUTHOR("Zhang Rui");
44 MODULE_DESCRIPTION("Intel Menlow platform specific driver");
45 MODULE_LICENSE("GPL");
48 * Memory controller device control
51 #define MEMORY_GET_BANDWIDTH "GTHS"
52 #define MEMORY_SET_BANDWIDTH "STHS"
53 #define MEMORY_ARG_CUR_BANDWIDTH 1
54 #define MEMORY_ARG_MAX_BANDWIDTH 0
56 static void intel_menlow_unregister_sensor(void);
59 * GTHS returning 'n' would mean that [0,n-1] states are supported
60 * In that case max_cstate would be n-1
61 * GTHS returning '0' would mean that no bandwidth control states are supported
63 static int memory_get_max_bandwidth(struct thermal_cooling_device
*cdev
,
64 unsigned long *max_state
)
66 struct acpi_device
*device
= cdev
->devdata
;
67 acpi_handle handle
= device
->handle
;
68 unsigned long long value
;
69 struct acpi_object_list arg_list
;
70 union acpi_object arg
;
71 acpi_status status
= AE_OK
;
74 arg_list
.pointer
= &arg
;
75 arg
.type
= ACPI_TYPE_INTEGER
;
76 arg
.integer
.value
= MEMORY_ARG_MAX_BANDWIDTH
;
77 status
= acpi_evaluate_integer(handle
, MEMORY_GET_BANDWIDTH
,
79 if (ACPI_FAILURE(status
))
85 *max_state
= value
- 1;
89 static int memory_get_cur_bandwidth(struct thermal_cooling_device
*cdev
,
92 struct acpi_device
*device
= cdev
->devdata
;
93 acpi_handle handle
= device
->handle
;
94 unsigned long long result
;
95 struct acpi_object_list arg_list
;
96 union acpi_object arg
;
97 acpi_status status
= AE_OK
;
100 arg_list
.pointer
= &arg
;
101 arg
.type
= ACPI_TYPE_INTEGER
;
102 arg
.integer
.value
= MEMORY_ARG_CUR_BANDWIDTH
;
103 status
= acpi_evaluate_integer(handle
, MEMORY_GET_BANDWIDTH
,
105 if (ACPI_FAILURE(status
))
112 static int memory_set_cur_bandwidth(struct thermal_cooling_device
*cdev
,
115 struct acpi_device
*device
= cdev
->devdata
;
116 acpi_handle handle
= device
->handle
;
117 struct acpi_object_list arg_list
;
118 union acpi_object arg
;
120 unsigned long long temp
;
121 unsigned long max_state
;
123 if (memory_get_max_bandwidth(cdev
, &max_state
))
126 if (state
> max_state
)
130 arg_list
.pointer
= &arg
;
131 arg
.type
= ACPI_TYPE_INTEGER
;
132 arg
.integer
.value
= state
;
135 acpi_evaluate_integer(handle
, MEMORY_SET_BANDWIDTH
, &arg_list
,
138 pr_info("Bandwidth value was %ld: status is %d\n", state
, status
);
139 if (ACPI_FAILURE(status
))
145 static struct thermal_cooling_device_ops memory_cooling_ops
= {
146 .get_max_state
= memory_get_max_bandwidth
,
147 .get_cur_state
= memory_get_cur_bandwidth
,
148 .set_cur_state
= memory_set_cur_bandwidth
,
152 * Memory Device Management
154 static int intel_menlow_memory_add(struct acpi_device
*device
)
156 int result
= -ENODEV
;
157 struct thermal_cooling_device
*cdev
;
162 if (!acpi_has_method(device
->handle
, MEMORY_GET_BANDWIDTH
))
165 if (!acpi_has_method(device
->handle
, MEMORY_SET_BANDWIDTH
))
168 cdev
= thermal_cooling_device_register("Memory controller", device
,
169 &memory_cooling_ops
);
171 result
= PTR_ERR(cdev
);
175 device
->driver_data
= cdev
;
176 result
= sysfs_create_link(&device
->dev
.kobj
,
177 &cdev
->device
.kobj
, "thermal_cooling");
181 result
= sysfs_create_link(&cdev
->device
.kobj
,
182 &device
->dev
.kobj
, "device");
184 sysfs_remove_link(&device
->dev
.kobj
, "thermal_cooling");
192 thermal_cooling_device_unregister(cdev
);
197 static int intel_menlow_memory_remove(struct acpi_device
*device
)
199 struct thermal_cooling_device
*cdev
= acpi_driver_data(device
);
201 if (!device
|| !cdev
)
204 sysfs_remove_link(&device
->dev
.kobj
, "thermal_cooling");
205 sysfs_remove_link(&cdev
->device
.kobj
, "device");
206 thermal_cooling_device_unregister(cdev
);
211 static const struct acpi_device_id intel_menlow_memory_ids
[] = {
216 static struct acpi_driver intel_menlow_memory_driver
= {
217 .name
= "intel_menlow_thermal_control",
218 .ids
= intel_menlow_memory_ids
,
220 .add
= intel_menlow_memory_add
,
221 .remove
= intel_menlow_memory_remove
,
226 * Sensor control on menlow platform
229 #define THERMAL_AUX0 0
230 #define THERMAL_AUX1 1
231 #define GET_AUX0 "GAX0"
232 #define GET_AUX1 "GAX1"
233 #define SET_AUX0 "SAX0"
234 #define SET_AUX1 "SAX1"
236 struct intel_menlow_attribute
{
237 struct device_attribute attr
;
238 struct device
*device
;
240 struct list_head node
;
243 static LIST_HEAD(intel_menlow_attr_list
);
244 static DEFINE_MUTEX(intel_menlow_attr_lock
);
247 * sensor_get_auxtrip - get the current auxtrip value from sensor
248 * @name: Thermalzone name
249 * @auxtype : AUX0/AUX1
252 static int sensor_get_auxtrip(acpi_handle handle
, int index
,
253 unsigned long long *value
)
257 if ((index
!= 0 && index
!= 1) || !value
)
260 status
= acpi_evaluate_integer(handle
, index
? GET_AUX1
: GET_AUX0
,
262 if (ACPI_FAILURE(status
))
269 * sensor_set_auxtrip - set the new auxtrip value to sensor
270 * @name: Thermalzone name
271 * @auxtype : AUX0/AUX1
274 static int sensor_set_auxtrip(acpi_handle handle
, int index
, int value
)
277 union acpi_object arg
= {
280 struct acpi_object_list args
= {
283 unsigned long long temp
;
285 if (index
!= 0 && index
!= 1)
288 status
= acpi_evaluate_integer(handle
, index
? GET_AUX0
: GET_AUX1
,
290 if (ACPI_FAILURE(status
))
292 if ((index
&& value
< temp
) || (!index
&& value
> temp
))
295 arg
.integer
.value
= value
;
296 status
= acpi_evaluate_integer(handle
, index
? SET_AUX1
: SET_AUX0
,
298 if (ACPI_FAILURE(status
))
301 /* do we need to check the return value of SAX0/SAX1 ? */
306 #define to_intel_menlow_attr(_attr) \
307 container_of(_attr, struct intel_menlow_attribute, attr)
309 static ssize_t
aux0_show(struct device
*dev
,
310 struct device_attribute
*dev_attr
, char *buf
)
312 struct intel_menlow_attribute
*attr
= to_intel_menlow_attr(dev_attr
);
313 unsigned long long value
;
316 result
= sensor_get_auxtrip(attr
->handle
, 0, &value
);
318 return result
? result
: sprintf(buf
, "%lu", DECI_KELVIN_TO_CELSIUS(value
));
321 static ssize_t
aux1_show(struct device
*dev
,
322 struct device_attribute
*dev_attr
, char *buf
)
324 struct intel_menlow_attribute
*attr
= to_intel_menlow_attr(dev_attr
);
325 unsigned long long value
;
328 result
= sensor_get_auxtrip(attr
->handle
, 1, &value
);
330 return result
? result
: sprintf(buf
, "%lu", DECI_KELVIN_TO_CELSIUS(value
));
333 static ssize_t
aux0_store(struct device
*dev
,
334 struct device_attribute
*dev_attr
,
335 const char *buf
, size_t count
)
337 struct intel_menlow_attribute
*attr
= to_intel_menlow_attr(dev_attr
);
341 /*Sanity check; should be a positive integer */
342 if (!sscanf(buf
, "%d", &value
))
348 result
= sensor_set_auxtrip(attr
->handle
, 0, CELSIUS_TO_DECI_KELVIN(value
));
349 return result
? result
: count
;
352 static ssize_t
aux1_store(struct device
*dev
,
353 struct device_attribute
*dev_attr
,
354 const char *buf
, size_t count
)
356 struct intel_menlow_attribute
*attr
= to_intel_menlow_attr(dev_attr
);
360 /*Sanity check; should be a positive integer */
361 if (!sscanf(buf
, "%d", &value
))
367 result
= sensor_set_auxtrip(attr
->handle
, 1, CELSIUS_TO_DECI_KELVIN(value
));
368 return result
? result
: count
;
371 /* BIOS can enable/disable the thermal user application in dabney platform */
372 #define BIOS_ENABLED "\\_TZ.GSTS"
373 static ssize_t
bios_enabled_show(struct device
*dev
,
374 struct device_attribute
*attr
, char *buf
)
377 unsigned long long bios_enabled
;
379 status
= acpi_evaluate_integer(NULL
, BIOS_ENABLED
, NULL
, &bios_enabled
);
380 if (ACPI_FAILURE(status
))
383 return sprintf(buf
, "%s\n", bios_enabled
? "enabled" : "disabled");
386 static int intel_menlow_add_one_attribute(char *name
, umode_t mode
, void *show
,
387 void *store
, struct device
*dev
,
390 struct intel_menlow_attribute
*attr
;
393 attr
= kzalloc(sizeof(struct intel_menlow_attribute
), GFP_KERNEL
);
397 sysfs_attr_init(&attr
->attr
.attr
); /* That is consistent naming :D */
398 attr
->attr
.attr
.name
= name
;
399 attr
->attr
.attr
.mode
= mode
;
400 attr
->attr
.show
= show
;
401 attr
->attr
.store
= store
;
403 attr
->handle
= handle
;
405 result
= device_create_file(dev
, &attr
->attr
);
411 mutex_lock(&intel_menlow_attr_lock
);
412 list_add_tail(&attr
->node
, &intel_menlow_attr_list
);
413 mutex_unlock(&intel_menlow_attr_lock
);
418 static acpi_status
intel_menlow_register_sensor(acpi_handle handle
, u32 lvl
,
419 void *context
, void **rv
)
423 struct thermal_zone_device
*thermal
;
426 result
= acpi_bus_get_private_data(handle
, (void **)&thermal
);
430 /* _TZ must have the AUX0/1 methods */
431 status
= acpi_get_handle(handle
, GET_AUX0
, &dummy
);
432 if (ACPI_FAILURE(status
))
433 return (status
== AE_NOT_FOUND
) ? AE_OK
: status
;
435 status
= acpi_get_handle(handle
, SET_AUX0
, &dummy
);
436 if (ACPI_FAILURE(status
))
437 return (status
== AE_NOT_FOUND
) ? AE_OK
: status
;
439 result
= intel_menlow_add_one_attribute("aux0", 0644,
440 aux0_show
, aux0_store
,
441 &thermal
->device
, handle
);
445 status
= acpi_get_handle(handle
, GET_AUX1
, &dummy
);
446 if (ACPI_FAILURE(status
))
449 status
= acpi_get_handle(handle
, SET_AUX1
, &dummy
);
450 if (ACPI_FAILURE(status
))
453 result
= intel_menlow_add_one_attribute("aux1", 0644,
454 aux1_show
, aux1_store
,
455 &thermal
->device
, handle
);
457 intel_menlow_unregister_sensor();
462 * create the "dabney_enabled" attribute which means the user app
463 * should be loaded or not
466 result
= intel_menlow_add_one_attribute("bios_enabled", 0444,
467 bios_enabled_show
, NULL
,
468 &thermal
->device
, handle
);
470 intel_menlow_unregister_sensor();
477 if (status
== AE_NOT_FOUND
)
480 intel_menlow_unregister_sensor();
484 static void intel_menlow_unregister_sensor(void)
486 struct intel_menlow_attribute
*pos
, *next
;
488 mutex_lock(&intel_menlow_attr_lock
);
489 list_for_each_entry_safe(pos
, next
, &intel_menlow_attr_list
, node
) {
490 list_del(&pos
->node
);
491 device_remove_file(pos
->device
, &pos
->attr
);
494 mutex_unlock(&intel_menlow_attr_lock
);
499 static int __init
intel_menlow_module_init(void)
501 int result
= -ENODEV
;
503 unsigned long long enable
;
508 /* Looking for the \_TZ.GSTS method */
509 status
= acpi_evaluate_integer(NULL
, BIOS_ENABLED
, NULL
, &enable
);
510 if (ACPI_FAILURE(status
) || !enable
)
513 /* Looking for ACPI device MEM0 with hardware id INT0002 */
514 result
= acpi_bus_register_driver(&intel_menlow_memory_driver
);
518 /* Looking for sensors in each ACPI thermal zone */
519 status
= acpi_walk_namespace(ACPI_TYPE_THERMAL
, ACPI_ROOT_OBJECT
,
521 intel_menlow_register_sensor
, NULL
, NULL
, NULL
);
522 if (ACPI_FAILURE(status
)) {
523 acpi_bus_unregister_driver(&intel_menlow_memory_driver
);
530 static void __exit
intel_menlow_module_exit(void)
532 acpi_bus_unregister_driver(&intel_menlow_memory_driver
);
533 intel_menlow_unregister_sensor();
536 module_init(intel_menlow_module_init
);
537 module_exit(intel_menlow_module_exit
);