2 * A hwmon driver for ACPI 4.0 power meters
3 * Copyright (C) 2009 IBM
5 * Author: Darrick J. Wong <darrick.wong@oracle.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/module.h>
23 #include <linux/hwmon.h>
24 #include <linux/hwmon-sysfs.h>
25 #include <linux/jiffies.h>
26 #include <linux/mutex.h>
27 #include <linux/dmi.h>
28 #include <linux/slab.h>
29 #include <linux/kdev_t.h>
30 #include <linux/sched.h>
31 #include <linux/time.h>
32 #include <linux/err.h>
33 #include <acpi/acpi_drivers.h>
34 #include <acpi/acpi_bus.h>
36 #define ACPI_POWER_METER_NAME "power_meter"
37 ACPI_MODULE_NAME(ACPI_POWER_METER_NAME
);
38 #define ACPI_POWER_METER_DEVICE_NAME "Power Meter"
39 #define ACPI_POWER_METER_CLASS "pwr_meter_resource"
41 #define NUM_SENSORS 17
43 #define POWER_METER_CAN_MEASURE (1 << 0)
44 #define POWER_METER_CAN_TRIP (1 << 1)
45 #define POWER_METER_CAN_CAP (1 << 2)
46 #define POWER_METER_CAN_NOTIFY (1 << 3)
47 #define POWER_METER_IS_BATTERY (1 << 8)
48 #define UNKNOWN_HYSTERESIS 0xFFFFFFFF
50 #define METER_NOTIFY_CONFIG 0x80
51 #define METER_NOTIFY_TRIP 0x81
52 #define METER_NOTIFY_CAP 0x82
53 #define METER_NOTIFY_CAPPING 0x83
54 #define METER_NOTIFY_INTERVAL 0x84
56 #define POWER_AVERAGE_NAME "power1_average"
57 #define POWER_CAP_NAME "power1_cap"
58 #define POWER_AVG_INTERVAL_NAME "power1_average_interval"
59 #define POWER_ALARM_NAME "power1_alarm"
61 static int cap_in_hardware
;
62 static bool force_cap_on
;
64 static int can_cap_in_hardware(void)
66 return force_cap_on
|| cap_in_hardware
;
69 static const struct acpi_device_id power_meter_ids
[] = {
73 MODULE_DEVICE_TABLE(acpi
, power_meter_ids
);
75 struct acpi_power_meter_capabilities
{
89 struct acpi_power_meter_resource
{
90 struct acpi_device
*acpi_dev
;
93 struct device
*hwmon_dev
;
94 struct acpi_power_meter_capabilities caps
;
95 acpi_string model_number
;
96 acpi_string serial_number
;
102 unsigned long sensors_last_updated
;
103 struct sensor_device_attribute sensors
[NUM_SENSORS
];
106 int num_domain_devices
;
107 struct acpi_device
**domain_devices
;
108 struct kobject
*holders_dir
;
111 struct sensor_template
{
113 ssize_t (*show
)(struct device
*dev
,
114 struct device_attribute
*devattr
,
116 ssize_t (*set
)(struct device
*dev
,
117 struct device_attribute
*devattr
,
118 const char *buf
, size_t count
);
122 /* Averaging interval */
123 static int update_avg_interval(struct acpi_power_meter_resource
*resource
)
125 unsigned long long data
;
128 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_GAI",
130 if (ACPI_FAILURE(status
)) {
131 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _GAI"));
135 resource
->avg_interval
= data
;
139 static ssize_t
show_avg_interval(struct device
*dev
,
140 struct device_attribute
*devattr
,
143 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
144 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
146 mutex_lock(&resource
->lock
);
147 update_avg_interval(resource
);
148 mutex_unlock(&resource
->lock
);
150 return sprintf(buf
, "%llu\n", resource
->avg_interval
);
153 static ssize_t
set_avg_interval(struct device
*dev
,
154 struct device_attribute
*devattr
,
155 const char *buf
, size_t count
)
157 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
158 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
159 union acpi_object arg0
= { ACPI_TYPE_INTEGER
};
160 struct acpi_object_list args
= { 1, &arg0
};
163 unsigned long long data
;
166 res
= kstrtoul(buf
, 10, &temp
);
170 if (temp
> resource
->caps
.max_avg_interval
||
171 temp
< resource
->caps
.min_avg_interval
)
173 arg0
.integer
.value
= temp
;
175 mutex_lock(&resource
->lock
);
176 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_PAI",
178 if (!ACPI_FAILURE(status
))
179 resource
->avg_interval
= temp
;
180 mutex_unlock(&resource
->lock
);
182 if (ACPI_FAILURE(status
)) {
183 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PAI"));
187 /* _PAI returns 0 on success, nonzero otherwise */
195 static int update_cap(struct acpi_power_meter_resource
*resource
)
197 unsigned long long data
;
200 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_GHL",
202 if (ACPI_FAILURE(status
)) {
203 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _GHL"));
207 resource
->cap
= data
;
211 static ssize_t
show_cap(struct device
*dev
,
212 struct device_attribute
*devattr
,
215 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
216 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
218 mutex_lock(&resource
->lock
);
219 update_cap(resource
);
220 mutex_unlock(&resource
->lock
);
222 return sprintf(buf
, "%llu\n", resource
->cap
* 1000);
225 static ssize_t
set_cap(struct device
*dev
, struct device_attribute
*devattr
,
226 const char *buf
, size_t count
)
228 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
229 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
230 union acpi_object arg0
= { ACPI_TYPE_INTEGER
};
231 struct acpi_object_list args
= { 1, &arg0
};
234 unsigned long long data
;
237 res
= kstrtoul(buf
, 10, &temp
);
241 temp
= DIV_ROUND_CLOSEST(temp
, 1000);
242 if (temp
> resource
->caps
.max_cap
|| temp
< resource
->caps
.min_cap
)
244 arg0
.integer
.value
= temp
;
246 mutex_lock(&resource
->lock
);
247 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_SHL",
249 if (!ACPI_FAILURE(status
))
250 resource
->cap
= temp
;
251 mutex_unlock(&resource
->lock
);
253 if (ACPI_FAILURE(status
)) {
254 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _SHL"));
258 /* _SHL returns 0 on success, nonzero otherwise */
265 /* Power meter trip points */
266 static int set_acpi_trip(struct acpi_power_meter_resource
*resource
)
268 union acpi_object arg_objs
[] = {
272 struct acpi_object_list args
= { 2, arg_objs
};
273 unsigned long long data
;
276 /* Both trip levels must be set */
277 if (resource
->trip
[0] < 0 || resource
->trip
[1] < 0)
280 /* This driver stores min, max; ACPI wants max, min. */
281 arg_objs
[0].integer
.value
= resource
->trip
[1];
282 arg_objs
[1].integer
.value
= resource
->trip
[0];
284 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_PTP",
286 if (ACPI_FAILURE(status
)) {
287 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PTP"));
291 /* _PTP returns 0 on success, nonzero otherwise */
298 static ssize_t
set_trip(struct device
*dev
, struct device_attribute
*devattr
,
299 const char *buf
, size_t count
)
301 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
302 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
303 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
307 res
= kstrtoul(buf
, 10, &temp
);
311 temp
= DIV_ROUND_CLOSEST(temp
, 1000);
313 mutex_lock(&resource
->lock
);
314 resource
->trip
[attr
->index
- 7] = temp
;
315 res
= set_acpi_trip(resource
);
316 mutex_unlock(&resource
->lock
);
325 static int update_meter(struct acpi_power_meter_resource
*resource
)
327 unsigned long long data
;
329 unsigned long local_jiffies
= jiffies
;
331 if (time_before(local_jiffies
, resource
->sensors_last_updated
+
332 msecs_to_jiffies(resource
->caps
.sampling_time
)) &&
333 resource
->sensors_valid
)
336 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_PMM",
338 if (ACPI_FAILURE(status
)) {
339 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PMM"));
343 resource
->power
= data
;
344 resource
->sensors_valid
= 1;
345 resource
->sensors_last_updated
= jiffies
;
349 static ssize_t
show_power(struct device
*dev
,
350 struct device_attribute
*devattr
,
353 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
354 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
356 mutex_lock(&resource
->lock
);
357 update_meter(resource
);
358 mutex_unlock(&resource
->lock
);
360 return sprintf(buf
, "%llu\n", resource
->power
* 1000);
364 static ssize_t
show_str(struct device
*dev
,
365 struct device_attribute
*devattr
,
368 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
369 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
370 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
373 switch (attr
->index
) {
375 val
= resource
->model_number
;
378 val
= resource
->serial_number
;
381 val
= resource
->oem_info
;
384 WARN(1, "Implementation error: unexpected attribute index %d\n",
390 return sprintf(buf
, "%s\n", val
);
393 static ssize_t
show_val(struct device
*dev
,
394 struct device_attribute
*devattr
,
397 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
398 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
399 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
402 switch (attr
->index
) {
404 val
= resource
->caps
.min_avg_interval
;
407 val
= resource
->caps
.max_avg_interval
;
410 val
= resource
->caps
.min_cap
* 1000;
413 val
= resource
->caps
.max_cap
* 1000;
416 if (resource
->caps
.hysteresis
== UNKNOWN_HYSTERESIS
)
417 return sprintf(buf
, "unknown\n");
419 val
= resource
->caps
.hysteresis
* 1000;
422 if (resource
->caps
.flags
& POWER_METER_IS_BATTERY
)
428 if (resource
->power
> resource
->cap
)
435 if (resource
->trip
[attr
->index
- 7] < 0)
436 return sprintf(buf
, "unknown\n");
438 val
= resource
->trip
[attr
->index
- 7] * 1000;
441 WARN(1, "Implementation error: unexpected attribute index %d\n",
446 return sprintf(buf
, "%llu\n", val
);
449 static ssize_t
show_accuracy(struct device
*dev
,
450 struct device_attribute
*devattr
,
453 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
454 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
455 unsigned int acc
= resource
->caps
.accuracy
;
457 return sprintf(buf
, "%u.%u%%\n", acc
/ 1000, acc
% 1000);
460 static ssize_t
show_name(struct device
*dev
,
461 struct device_attribute
*devattr
,
464 return sprintf(buf
, "%s\n", ACPI_POWER_METER_NAME
);
467 #define RO_SENSOR_TEMPLATE(_label, _show, _index) \
474 #define RW_SENSOR_TEMPLATE(_label, _show, _set, _index) \
482 /* Sensor descriptions. If you add a sensor, update NUM_SENSORS above! */
483 static struct sensor_template meter_attrs
[] = {
484 RO_SENSOR_TEMPLATE(POWER_AVERAGE_NAME
, show_power
, 0),
485 RO_SENSOR_TEMPLATE("power1_accuracy", show_accuracy
, 0),
486 RO_SENSOR_TEMPLATE("power1_average_interval_min", show_val
, 0),
487 RO_SENSOR_TEMPLATE("power1_average_interval_max", show_val
, 1),
488 RO_SENSOR_TEMPLATE("power1_is_battery", show_val
, 5),
489 RW_SENSOR_TEMPLATE(POWER_AVG_INTERVAL_NAME
, show_avg_interval
,
490 set_avg_interval
, 0),
494 static struct sensor_template misc_cap_attrs
[] = {
495 RO_SENSOR_TEMPLATE("power1_cap_min", show_val
, 2),
496 RO_SENSOR_TEMPLATE("power1_cap_max", show_val
, 3),
497 RO_SENSOR_TEMPLATE("power1_cap_hyst", show_val
, 4),
498 RO_SENSOR_TEMPLATE(POWER_ALARM_NAME
, show_val
, 6),
502 static struct sensor_template ro_cap_attrs
[] = {
503 RO_SENSOR_TEMPLATE(POWER_CAP_NAME
, show_cap
, 0),
507 static struct sensor_template rw_cap_attrs
[] = {
508 RW_SENSOR_TEMPLATE(POWER_CAP_NAME
, show_cap
, set_cap
, 0),
512 static struct sensor_template trip_attrs
[] = {
513 RW_SENSOR_TEMPLATE("power1_average_min", show_val
, set_trip
, 7),
514 RW_SENSOR_TEMPLATE("power1_average_max", show_val
, set_trip
, 8),
518 static struct sensor_template misc_attrs
[] = {
519 RO_SENSOR_TEMPLATE("name", show_name
, 0),
520 RO_SENSOR_TEMPLATE("power1_model_number", show_str
, 0),
521 RO_SENSOR_TEMPLATE("power1_oem_info", show_str
, 2),
522 RO_SENSOR_TEMPLATE("power1_serial_number", show_str
, 1),
526 #undef RO_SENSOR_TEMPLATE
527 #undef RW_SENSOR_TEMPLATE
529 /* Read power domain data */
530 static void remove_domain_devices(struct acpi_power_meter_resource
*resource
)
534 if (!resource
->num_domain_devices
)
537 for (i
= 0; i
< resource
->num_domain_devices
; i
++) {
538 struct acpi_device
*obj
= resource
->domain_devices
[i
];
542 sysfs_remove_link(resource
->holders_dir
,
543 kobject_name(&obj
->dev
.kobj
));
544 put_device(&obj
->dev
);
547 kfree(resource
->domain_devices
);
548 kobject_put(resource
->holders_dir
);
549 resource
->num_domain_devices
= 0;
552 static int read_domain_devices(struct acpi_power_meter_resource
*resource
)
556 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
557 union acpi_object
*pss
;
560 status
= acpi_evaluate_object(resource
->acpi_dev
->handle
, "_PMD", NULL
,
562 if (ACPI_FAILURE(status
)) {
563 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PMD"));
567 pss
= buffer
.pointer
;
569 pss
->type
!= ACPI_TYPE_PACKAGE
) {
570 dev_err(&resource
->acpi_dev
->dev
, ACPI_POWER_METER_NAME
571 "Invalid _PMD data\n");
576 if (!pss
->package
.count
)
579 resource
->domain_devices
= kzalloc(sizeof(struct acpi_device
*) *
580 pss
->package
.count
, GFP_KERNEL
);
581 if (!resource
->domain_devices
) {
586 resource
->holders_dir
= kobject_create_and_add("measures",
587 &resource
->acpi_dev
->dev
.kobj
);
588 if (!resource
->holders_dir
) {
593 resource
->num_domain_devices
= pss
->package
.count
;
595 for (i
= 0; i
< pss
->package
.count
; i
++) {
596 struct acpi_device
*obj
;
597 union acpi_object
*element
= &(pss
->package
.elements
[i
]);
599 /* Refuse non-references */
600 if (element
->type
!= ACPI_TYPE_LOCAL_REFERENCE
)
603 /* Create a symlink to domain objects */
604 resource
->domain_devices
[i
] = NULL
;
605 status
= acpi_bus_get_device(element
->reference
.handle
,
606 &resource
->domain_devices
[i
]);
607 if (ACPI_FAILURE(status
))
610 obj
= resource
->domain_devices
[i
];
611 get_device(&obj
->dev
);
613 res
= sysfs_create_link(resource
->holders_dir
, &obj
->dev
.kobj
,
614 kobject_name(&obj
->dev
.kobj
));
616 put_device(&obj
->dev
);
617 resource
->domain_devices
[i
] = NULL
;
625 kfree(resource
->domain_devices
);
627 kfree(buffer
.pointer
);
631 /* Registration and deregistration */
632 static int register_attrs(struct acpi_power_meter_resource
*resource
,
633 struct sensor_template
*attrs
)
635 struct device
*dev
= &resource
->acpi_dev
->dev
;
636 struct sensor_device_attribute
*sensors
=
637 &resource
->sensors
[resource
->num_sensors
];
640 while (attrs
->label
) {
641 sensors
->dev_attr
.attr
.name
= attrs
->label
;
642 sensors
->dev_attr
.attr
.mode
= S_IRUGO
;
643 sensors
->dev_attr
.show
= attrs
->show
;
644 sensors
->index
= attrs
->index
;
647 sensors
->dev_attr
.attr
.mode
|= S_IWUSR
;
648 sensors
->dev_attr
.store
= attrs
->set
;
651 sysfs_attr_init(&sensors
->dev_attr
.attr
);
652 res
= device_create_file(dev
, &sensors
->dev_attr
);
654 sensors
->dev_attr
.attr
.name
= NULL
;
658 resource
->num_sensors
++;
666 static void remove_attrs(struct acpi_power_meter_resource
*resource
)
670 for (i
= 0; i
< resource
->num_sensors
; i
++) {
671 if (!resource
->sensors
[i
].dev_attr
.attr
.name
)
673 device_remove_file(&resource
->acpi_dev
->dev
,
674 &resource
->sensors
[i
].dev_attr
);
677 remove_domain_devices(resource
);
679 resource
->num_sensors
= 0;
682 static int setup_attrs(struct acpi_power_meter_resource
*resource
)
686 res
= read_domain_devices(resource
);
690 if (resource
->caps
.flags
& POWER_METER_CAN_MEASURE
) {
691 res
= register_attrs(resource
, meter_attrs
);
696 if (resource
->caps
.flags
& POWER_METER_CAN_CAP
) {
697 if (!can_cap_in_hardware()) {
698 dev_err(&resource
->acpi_dev
->dev
,
699 "Ignoring unsafe software power cap!\n");
700 goto skip_unsafe_cap
;
703 if (resource
->caps
.configurable_cap
)
704 res
= register_attrs(resource
, rw_cap_attrs
);
706 res
= register_attrs(resource
, ro_cap_attrs
);
711 res
= register_attrs(resource
, misc_cap_attrs
);
717 if (resource
->caps
.flags
& POWER_METER_CAN_TRIP
) {
718 res
= register_attrs(resource
, trip_attrs
);
723 res
= register_attrs(resource
, misc_attrs
);
729 remove_attrs(resource
);
733 static void free_capabilities(struct acpi_power_meter_resource
*resource
)
738 str
= &resource
->model_number
;
739 for (i
= 0; i
< 3; i
++, str
++)
743 static int read_capabilities(struct acpi_power_meter_resource
*resource
)
747 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
748 struct acpi_buffer state
= { 0, NULL
};
749 struct acpi_buffer format
= { sizeof("NNNNNNNNNNN"), "NNNNNNNNNNN" };
750 union acpi_object
*pss
;
754 status
= acpi_evaluate_object(resource
->acpi_dev
->handle
, "_PMC", NULL
,
756 if (ACPI_FAILURE(status
)) {
757 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PMC"));
761 pss
= buffer
.pointer
;
763 pss
->type
!= ACPI_TYPE_PACKAGE
||
764 pss
->package
.count
!= 14) {
765 dev_err(&resource
->acpi_dev
->dev
, ACPI_POWER_METER_NAME
766 "Invalid _PMC data\n");
771 /* Grab all the integer data at once */
772 state
.length
= sizeof(struct acpi_power_meter_capabilities
);
773 state
.pointer
= &resource
->caps
;
775 status
= acpi_extract_package(pss
, &format
, &state
);
776 if (ACPI_FAILURE(status
)) {
777 ACPI_EXCEPTION((AE_INFO
, status
, "Invalid data"));
782 if (resource
->caps
.units
) {
783 dev_err(&resource
->acpi_dev
->dev
, ACPI_POWER_METER_NAME
784 "Unknown units %llu.\n",
785 resource
->caps
.units
);
790 /* Grab the string data */
791 str
= &resource
->model_number
;
793 for (i
= 11; i
< 14; i
++) {
794 union acpi_object
*element
= &(pss
->package
.elements
[i
]);
796 if (element
->type
!= ACPI_TYPE_STRING
) {
801 *str
= kzalloc(sizeof(u8
) * (element
->string
.length
+ 1),
808 strncpy(*str
, element
->string
.pointer
, element
->string
.length
);
812 dev_info(&resource
->acpi_dev
->dev
, "Found ACPI power meter.\n");
815 str
= &resource
->model_number
;
816 for (i
= 0; i
< 3; i
++, str
++)
819 kfree(buffer
.pointer
);
823 /* Handle ACPI event notifications */
824 static void acpi_power_meter_notify(struct acpi_device
*device
, u32 event
)
826 struct acpi_power_meter_resource
*resource
;
829 if (!device
|| !acpi_driver_data(device
))
832 resource
= acpi_driver_data(device
);
834 mutex_lock(&resource
->lock
);
836 case METER_NOTIFY_CONFIG
:
837 free_capabilities(resource
);
838 res
= read_capabilities(resource
);
842 remove_attrs(resource
);
843 setup_attrs(resource
);
845 case METER_NOTIFY_TRIP
:
846 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_AVERAGE_NAME
);
847 update_meter(resource
);
849 case METER_NOTIFY_CAP
:
850 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_CAP_NAME
);
851 update_cap(resource
);
853 case METER_NOTIFY_INTERVAL
:
854 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_AVG_INTERVAL_NAME
);
855 update_avg_interval(resource
);
857 case METER_NOTIFY_CAPPING
:
858 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_ALARM_NAME
);
859 dev_info(&device
->dev
, "Capping in progress.\n");
862 WARN(1, "Unexpected event %d\n", event
);
865 mutex_unlock(&resource
->lock
);
867 acpi_bus_generate_netlink_event(ACPI_POWER_METER_CLASS
,
868 dev_name(&device
->dev
), event
, 0);
871 static int acpi_power_meter_add(struct acpi_device
*device
)
874 struct acpi_power_meter_resource
*resource
;
879 resource
= kzalloc(sizeof(struct acpi_power_meter_resource
),
884 resource
->sensors_valid
= 0;
885 resource
->acpi_dev
= device
;
886 mutex_init(&resource
->lock
);
887 strcpy(acpi_device_name(device
), ACPI_POWER_METER_DEVICE_NAME
);
888 strcpy(acpi_device_class(device
), ACPI_POWER_METER_CLASS
);
889 device
->driver_data
= resource
;
891 free_capabilities(resource
);
892 res
= read_capabilities(resource
);
896 resource
->trip
[0] = resource
->trip
[1] = -1;
898 res
= setup_attrs(resource
);
902 resource
->hwmon_dev
= hwmon_device_register(&device
->dev
);
903 if (IS_ERR(resource
->hwmon_dev
)) {
904 res
= PTR_ERR(resource
->hwmon_dev
);
912 remove_attrs(resource
);
919 static int acpi_power_meter_remove(struct acpi_device
*device
)
921 struct acpi_power_meter_resource
*resource
;
923 if (!device
|| !acpi_driver_data(device
))
926 resource
= acpi_driver_data(device
);
927 hwmon_device_unregister(resource
->hwmon_dev
);
929 free_capabilities(resource
);
930 remove_attrs(resource
);
936 #ifdef CONFIG_PM_SLEEP
938 static int acpi_power_meter_resume(struct device
*dev
)
940 struct acpi_power_meter_resource
*resource
;
945 resource
= acpi_driver_data(to_acpi_device(dev
));
949 free_capabilities(resource
);
950 read_capabilities(resource
);
955 #endif /* CONFIG_PM_SLEEP */
957 static SIMPLE_DEV_PM_OPS(acpi_power_meter_pm
, NULL
, acpi_power_meter_resume
);
959 static struct acpi_driver acpi_power_meter_driver
= {
960 .name
= "power_meter",
961 .class = ACPI_POWER_METER_CLASS
,
962 .ids
= power_meter_ids
,
964 .add
= acpi_power_meter_add
,
965 .remove
= acpi_power_meter_remove
,
966 .notify
= acpi_power_meter_notify
,
968 .drv
.pm
= &acpi_power_meter_pm
,
971 /* Module init/exit routines */
972 static int __init
enable_cap_knobs(const struct dmi_system_id
*d
)
978 static struct dmi_system_id __initdata pm_dmi_table
[] = {
980 enable_cap_knobs
, "IBM Active Energy Manager",
982 DMI_MATCH(DMI_SYS_VENDOR
, "IBM")
988 static int __init
acpi_power_meter_init(void)
995 dmi_check_system(pm_dmi_table
);
997 result
= acpi_bus_register_driver(&acpi_power_meter_driver
);
1004 static void __exit
acpi_power_meter_exit(void)
1006 acpi_bus_unregister_driver(&acpi_power_meter_driver
);
1009 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
1010 MODULE_DESCRIPTION("ACPI 4.0 power meter driver");
1011 MODULE_LICENSE("GPL");
1013 module_param(force_cap_on
, bool, 0644);
1014 MODULE_PARM_DESC(force_cap_on
, "Enable power cap even it is unsafe to do so.");
1016 module_init(acpi_power_meter_init
);
1017 module_exit(acpi_power_meter_exit
);