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 if (acpi_bus_get_device(element
->reference
.handle
,
606 &resource
->domain_devices
[i
]))
609 obj
= resource
->domain_devices
[i
];
610 get_device(&obj
->dev
);
612 res
= sysfs_create_link(resource
->holders_dir
, &obj
->dev
.kobj
,
613 kobject_name(&obj
->dev
.kobj
));
615 put_device(&obj
->dev
);
616 resource
->domain_devices
[i
] = NULL
;
624 kfree(resource
->domain_devices
);
626 kfree(buffer
.pointer
);
630 /* Registration and deregistration */
631 static int register_attrs(struct acpi_power_meter_resource
*resource
,
632 struct sensor_template
*attrs
)
634 struct device
*dev
= &resource
->acpi_dev
->dev
;
635 struct sensor_device_attribute
*sensors
=
636 &resource
->sensors
[resource
->num_sensors
];
639 while (attrs
->label
) {
640 sensors
->dev_attr
.attr
.name
= attrs
->label
;
641 sensors
->dev_attr
.attr
.mode
= S_IRUGO
;
642 sensors
->dev_attr
.show
= attrs
->show
;
643 sensors
->index
= attrs
->index
;
646 sensors
->dev_attr
.attr
.mode
|= S_IWUSR
;
647 sensors
->dev_attr
.store
= attrs
->set
;
650 sysfs_attr_init(&sensors
->dev_attr
.attr
);
651 res
= device_create_file(dev
, &sensors
->dev_attr
);
653 sensors
->dev_attr
.attr
.name
= NULL
;
657 resource
->num_sensors
++;
665 static void remove_attrs(struct acpi_power_meter_resource
*resource
)
669 for (i
= 0; i
< resource
->num_sensors
; i
++) {
670 if (!resource
->sensors
[i
].dev_attr
.attr
.name
)
672 device_remove_file(&resource
->acpi_dev
->dev
,
673 &resource
->sensors
[i
].dev_attr
);
676 remove_domain_devices(resource
);
678 resource
->num_sensors
= 0;
681 static int setup_attrs(struct acpi_power_meter_resource
*resource
)
685 res
= read_domain_devices(resource
);
689 if (resource
->caps
.flags
& POWER_METER_CAN_MEASURE
) {
690 res
= register_attrs(resource
, meter_attrs
);
695 if (resource
->caps
.flags
& POWER_METER_CAN_CAP
) {
696 if (!can_cap_in_hardware()) {
697 dev_err(&resource
->acpi_dev
->dev
,
698 "Ignoring unsafe software power cap!\n");
699 goto skip_unsafe_cap
;
702 if (resource
->caps
.configurable_cap
)
703 res
= register_attrs(resource
, rw_cap_attrs
);
705 res
= register_attrs(resource
, ro_cap_attrs
);
710 res
= register_attrs(resource
, misc_cap_attrs
);
716 if (resource
->caps
.flags
& POWER_METER_CAN_TRIP
) {
717 res
= register_attrs(resource
, trip_attrs
);
722 res
= register_attrs(resource
, misc_attrs
);
728 remove_attrs(resource
);
732 static void free_capabilities(struct acpi_power_meter_resource
*resource
)
737 str
= &resource
->model_number
;
738 for (i
= 0; i
< 3; i
++, str
++)
742 static int read_capabilities(struct acpi_power_meter_resource
*resource
)
746 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
747 struct acpi_buffer state
= { 0, NULL
};
748 struct acpi_buffer format
= { sizeof("NNNNNNNNNNN"), "NNNNNNNNNNN" };
749 union acpi_object
*pss
;
753 status
= acpi_evaluate_object(resource
->acpi_dev
->handle
, "_PMC", NULL
,
755 if (ACPI_FAILURE(status
)) {
756 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PMC"));
760 pss
= buffer
.pointer
;
762 pss
->type
!= ACPI_TYPE_PACKAGE
||
763 pss
->package
.count
!= 14) {
764 dev_err(&resource
->acpi_dev
->dev
, ACPI_POWER_METER_NAME
765 "Invalid _PMC data\n");
770 /* Grab all the integer data at once */
771 state
.length
= sizeof(struct acpi_power_meter_capabilities
);
772 state
.pointer
= &resource
->caps
;
774 status
= acpi_extract_package(pss
, &format
, &state
);
775 if (ACPI_FAILURE(status
)) {
776 ACPI_EXCEPTION((AE_INFO
, status
, "Invalid data"));
781 if (resource
->caps
.units
) {
782 dev_err(&resource
->acpi_dev
->dev
, ACPI_POWER_METER_NAME
783 "Unknown units %llu.\n",
784 resource
->caps
.units
);
789 /* Grab the string data */
790 str
= &resource
->model_number
;
792 for (i
= 11; i
< 14; i
++) {
793 union acpi_object
*element
= &(pss
->package
.elements
[i
]);
795 if (element
->type
!= ACPI_TYPE_STRING
) {
800 *str
= kzalloc(sizeof(u8
) * (element
->string
.length
+ 1),
807 strncpy(*str
, element
->string
.pointer
, element
->string
.length
);
811 dev_info(&resource
->acpi_dev
->dev
, "Found ACPI power meter.\n");
814 str
= &resource
->model_number
;
815 for (i
= 0; i
< 3; i
++, str
++)
818 kfree(buffer
.pointer
);
822 /* Handle ACPI event notifications */
823 static void acpi_power_meter_notify(struct acpi_device
*device
, u32 event
)
825 struct acpi_power_meter_resource
*resource
;
828 if (!device
|| !acpi_driver_data(device
))
831 resource
= acpi_driver_data(device
);
833 mutex_lock(&resource
->lock
);
835 case METER_NOTIFY_CONFIG
:
836 free_capabilities(resource
);
837 res
= read_capabilities(resource
);
841 remove_attrs(resource
);
842 setup_attrs(resource
);
844 case METER_NOTIFY_TRIP
:
845 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_AVERAGE_NAME
);
846 update_meter(resource
);
848 case METER_NOTIFY_CAP
:
849 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_CAP_NAME
);
850 update_cap(resource
);
852 case METER_NOTIFY_INTERVAL
:
853 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_AVG_INTERVAL_NAME
);
854 update_avg_interval(resource
);
856 case METER_NOTIFY_CAPPING
:
857 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_ALARM_NAME
);
858 dev_info(&device
->dev
, "Capping in progress.\n");
861 WARN(1, "Unexpected event %d\n", event
);
864 mutex_unlock(&resource
->lock
);
866 acpi_bus_generate_netlink_event(ACPI_POWER_METER_CLASS
,
867 dev_name(&device
->dev
), event
, 0);
870 static int acpi_power_meter_add(struct acpi_device
*device
)
873 struct acpi_power_meter_resource
*resource
;
878 resource
= kzalloc(sizeof(struct acpi_power_meter_resource
),
883 resource
->sensors_valid
= 0;
884 resource
->acpi_dev
= device
;
885 mutex_init(&resource
->lock
);
886 strcpy(acpi_device_name(device
), ACPI_POWER_METER_DEVICE_NAME
);
887 strcpy(acpi_device_class(device
), ACPI_POWER_METER_CLASS
);
888 device
->driver_data
= resource
;
890 free_capabilities(resource
);
891 res
= read_capabilities(resource
);
895 resource
->trip
[0] = resource
->trip
[1] = -1;
897 res
= setup_attrs(resource
);
901 resource
->hwmon_dev
= hwmon_device_register(&device
->dev
);
902 if (IS_ERR(resource
->hwmon_dev
)) {
903 res
= PTR_ERR(resource
->hwmon_dev
);
911 remove_attrs(resource
);
918 static int acpi_power_meter_remove(struct acpi_device
*device
)
920 struct acpi_power_meter_resource
*resource
;
922 if (!device
|| !acpi_driver_data(device
))
925 resource
= acpi_driver_data(device
);
926 hwmon_device_unregister(resource
->hwmon_dev
);
928 free_capabilities(resource
);
929 remove_attrs(resource
);
935 #ifdef CONFIG_PM_SLEEP
937 static int acpi_power_meter_resume(struct device
*dev
)
939 struct acpi_power_meter_resource
*resource
;
944 resource
= acpi_driver_data(to_acpi_device(dev
));
948 free_capabilities(resource
);
949 read_capabilities(resource
);
954 #endif /* CONFIG_PM_SLEEP */
956 static SIMPLE_DEV_PM_OPS(acpi_power_meter_pm
, NULL
, acpi_power_meter_resume
);
958 static struct acpi_driver acpi_power_meter_driver
= {
959 .name
= "power_meter",
960 .class = ACPI_POWER_METER_CLASS
,
961 .ids
= power_meter_ids
,
963 .add
= acpi_power_meter_add
,
964 .remove
= acpi_power_meter_remove
,
965 .notify
= acpi_power_meter_notify
,
967 .drv
.pm
= &acpi_power_meter_pm
,
970 /* Module init/exit routines */
971 static int __init
enable_cap_knobs(const struct dmi_system_id
*d
)
977 static struct dmi_system_id __initdata pm_dmi_table
[] = {
979 enable_cap_knobs
, "IBM Active Energy Manager",
981 DMI_MATCH(DMI_SYS_VENDOR
, "IBM")
987 static int __init
acpi_power_meter_init(void)
994 dmi_check_system(pm_dmi_table
);
996 result
= acpi_bus_register_driver(&acpi_power_meter_driver
);
1003 static void __exit
acpi_power_meter_exit(void)
1005 acpi_bus_unregister_driver(&acpi_power_meter_driver
);
1008 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
1009 MODULE_DESCRIPTION("ACPI 4.0 power meter driver");
1010 MODULE_LICENSE("GPL");
1012 module_param(force_cap_on
, bool, 0644);
1013 MODULE_PARM_DESC(force_cap_on
, "Enable power cap even it is unsafe to do so.");
1015 module_init(acpi_power_meter_init
);
1016 module_exit(acpi_power_meter_exit
);