2 * A hwmon driver for ACPI 4.0 power meters
3 * Copyright (C) 2009 IBM
5 * Author: Darrick J. Wong <djwong@us.ibm.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 <acpi/acpi_drivers.h>
33 #include <acpi/acpi_bus.h>
35 #define ACPI_POWER_METER_NAME "power_meter"
36 ACPI_MODULE_NAME(ACPI_POWER_METER_NAME
);
37 #define ACPI_POWER_METER_DEVICE_NAME "Power Meter"
38 #define ACPI_POWER_METER_CLASS "pwr_meter_resource"
40 #define NUM_SENSORS 17
42 #define POWER_METER_CAN_MEASURE (1 << 0)
43 #define POWER_METER_CAN_TRIP (1 << 1)
44 #define POWER_METER_CAN_CAP (1 << 2)
45 #define POWER_METER_CAN_NOTIFY (1 << 3)
46 #define POWER_METER_IS_BATTERY (1 << 8)
47 #define UNKNOWN_HYSTERESIS 0xFFFFFFFF
49 #define METER_NOTIFY_CONFIG 0x80
50 #define METER_NOTIFY_TRIP 0x81
51 #define METER_NOTIFY_CAP 0x82
52 #define METER_NOTIFY_CAPPING 0x83
53 #define METER_NOTIFY_INTERVAL 0x84
55 #define POWER_AVERAGE_NAME "power1_average"
56 #define POWER_CAP_NAME "power1_cap"
57 #define POWER_AVG_INTERVAL_NAME "power1_average_interval"
58 #define POWER_ALARM_NAME "power1_alarm"
60 static int cap_in_hardware
;
61 static bool force_cap_on
;
63 static int can_cap_in_hardware(void)
65 return force_cap_on
|| cap_in_hardware
;
68 static const struct acpi_device_id power_meter_ids
[] = {
72 MODULE_DEVICE_TABLE(acpi
, power_meter_ids
);
74 struct acpi_power_meter_capabilities
{
88 struct acpi_power_meter_resource
{
89 struct acpi_device
*acpi_dev
;
92 struct device
*hwmon_dev
;
93 struct acpi_power_meter_capabilities caps
;
94 acpi_string model_number
;
95 acpi_string serial_number
;
101 unsigned long sensors_last_updated
;
102 struct sensor_device_attribute sensors
[NUM_SENSORS
];
105 int num_domain_devices
;
106 struct acpi_device
**domain_devices
;
107 struct kobject
*holders_dir
;
110 struct sensor_template
{
112 ssize_t (*show
)(struct device
*dev
,
113 struct device_attribute
*devattr
,
115 ssize_t (*set
)(struct device
*dev
,
116 struct device_attribute
*devattr
,
117 const char *buf
, size_t count
);
121 /* Averaging interval */
122 static int update_avg_interval(struct acpi_power_meter_resource
*resource
)
124 unsigned long long data
;
127 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_GAI",
129 if (ACPI_FAILURE(status
)) {
130 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _GAI"));
134 resource
->avg_interval
= data
;
138 static ssize_t
show_avg_interval(struct device
*dev
,
139 struct device_attribute
*devattr
,
142 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
143 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
145 mutex_lock(&resource
->lock
);
146 update_avg_interval(resource
);
147 mutex_unlock(&resource
->lock
);
149 return sprintf(buf
, "%llu\n", resource
->avg_interval
);
152 static ssize_t
set_avg_interval(struct device
*dev
,
153 struct device_attribute
*devattr
,
154 const char *buf
, size_t count
)
156 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
157 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
158 union acpi_object arg0
= { ACPI_TYPE_INTEGER
};
159 struct acpi_object_list args
= { 1, &arg0
};
162 unsigned long long data
;
165 res
= kstrtoul(buf
, 10, &temp
);
169 if (temp
> resource
->caps
.max_avg_interval
||
170 temp
< resource
->caps
.min_avg_interval
)
172 arg0
.integer
.value
= temp
;
174 mutex_lock(&resource
->lock
);
175 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_PAI",
177 if (!ACPI_FAILURE(status
))
178 resource
->avg_interval
= temp
;
179 mutex_unlock(&resource
->lock
);
181 if (ACPI_FAILURE(status
)) {
182 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PAI"));
186 /* _PAI returns 0 on success, nonzero otherwise */
194 static int update_cap(struct acpi_power_meter_resource
*resource
)
196 unsigned long long data
;
199 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_GHL",
201 if (ACPI_FAILURE(status
)) {
202 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _GHL"));
206 resource
->cap
= data
;
210 static ssize_t
show_cap(struct device
*dev
,
211 struct device_attribute
*devattr
,
214 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
215 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
217 mutex_lock(&resource
->lock
);
218 update_cap(resource
);
219 mutex_unlock(&resource
->lock
);
221 return sprintf(buf
, "%llu\n", resource
->cap
* 1000);
224 static ssize_t
set_cap(struct device
*dev
, struct device_attribute
*devattr
,
225 const char *buf
, size_t count
)
227 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
228 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
229 union acpi_object arg0
= { ACPI_TYPE_INTEGER
};
230 struct acpi_object_list args
= { 1, &arg0
};
233 unsigned long long data
;
236 res
= kstrtoul(buf
, 10, &temp
);
240 temp
= DIV_ROUND_CLOSEST(temp
, 1000);
241 if (temp
> resource
->caps
.max_cap
|| temp
< resource
->caps
.min_cap
)
243 arg0
.integer
.value
= temp
;
245 mutex_lock(&resource
->lock
);
246 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_SHL",
248 if (!ACPI_FAILURE(status
))
249 resource
->cap
= temp
;
250 mutex_unlock(&resource
->lock
);
252 if (ACPI_FAILURE(status
)) {
253 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _SHL"));
257 /* _SHL returns 0 on success, nonzero otherwise */
264 /* Power meter trip points */
265 static int set_acpi_trip(struct acpi_power_meter_resource
*resource
)
267 union acpi_object arg_objs
[] = {
271 struct acpi_object_list args
= { 2, arg_objs
};
272 unsigned long long data
;
275 /* Both trip levels must be set */
276 if (resource
->trip
[0] < 0 || resource
->trip
[1] < 0)
279 /* This driver stores min, max; ACPI wants max, min. */
280 arg_objs
[0].integer
.value
= resource
->trip
[1];
281 arg_objs
[1].integer
.value
= resource
->trip
[0];
283 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_PTP",
285 if (ACPI_FAILURE(status
)) {
286 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PTP"));
290 /* _PTP returns 0 on success, nonzero otherwise */
297 static ssize_t
set_trip(struct device
*dev
, struct device_attribute
*devattr
,
298 const char *buf
, size_t count
)
300 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
301 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
302 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
306 res
= kstrtoul(buf
, 10, &temp
);
310 temp
= DIV_ROUND_CLOSEST(temp
, 1000);
312 mutex_lock(&resource
->lock
);
313 resource
->trip
[attr
->index
- 7] = temp
;
314 res
= set_acpi_trip(resource
);
315 mutex_unlock(&resource
->lock
);
324 static int update_meter(struct acpi_power_meter_resource
*resource
)
326 unsigned long long data
;
328 unsigned long local_jiffies
= jiffies
;
330 if (time_before(local_jiffies
, resource
->sensors_last_updated
+
331 msecs_to_jiffies(resource
->caps
.sampling_time
)) &&
332 resource
->sensors_valid
)
335 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_PMM",
337 if (ACPI_FAILURE(status
)) {
338 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PMM"));
342 resource
->power
= data
;
343 resource
->sensors_valid
= 1;
344 resource
->sensors_last_updated
= jiffies
;
348 static ssize_t
show_power(struct device
*dev
,
349 struct device_attribute
*devattr
,
352 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
353 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
355 mutex_lock(&resource
->lock
);
356 update_meter(resource
);
357 mutex_unlock(&resource
->lock
);
359 return sprintf(buf
, "%llu\n", resource
->power
* 1000);
363 static ssize_t
show_str(struct device
*dev
,
364 struct device_attribute
*devattr
,
367 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
368 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
369 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
372 switch (attr
->index
) {
374 val
= resource
->model_number
;
377 val
= resource
->serial_number
;
380 val
= resource
->oem_info
;
387 return sprintf(buf
, "%s\n", val
);
390 static ssize_t
show_val(struct device
*dev
,
391 struct device_attribute
*devattr
,
394 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
395 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
396 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
399 switch (attr
->index
) {
401 val
= resource
->caps
.min_avg_interval
;
404 val
= resource
->caps
.max_avg_interval
;
407 val
= resource
->caps
.min_cap
* 1000;
410 val
= resource
->caps
.max_cap
* 1000;
413 if (resource
->caps
.hysteresis
== UNKNOWN_HYSTERESIS
)
414 return sprintf(buf
, "unknown\n");
416 val
= resource
->caps
.hysteresis
* 1000;
419 if (resource
->caps
.flags
& POWER_METER_IS_BATTERY
)
425 if (resource
->power
> resource
->cap
)
432 if (resource
->trip
[attr
->index
- 7] < 0)
433 return sprintf(buf
, "unknown\n");
435 val
= resource
->trip
[attr
->index
- 7] * 1000;
441 return sprintf(buf
, "%llu\n", val
);
444 static ssize_t
show_accuracy(struct device
*dev
,
445 struct device_attribute
*devattr
,
448 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
449 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
450 unsigned int acc
= resource
->caps
.accuracy
;
452 return sprintf(buf
, "%u.%u%%\n", acc
/ 1000, acc
% 1000);
455 static ssize_t
show_name(struct device
*dev
,
456 struct device_attribute
*devattr
,
459 return sprintf(buf
, "%s\n", ACPI_POWER_METER_NAME
);
462 #define RO_SENSOR_TEMPLATE(_label, _show, _index) \
469 #define RW_SENSOR_TEMPLATE(_label, _show, _set, _index) \
477 /* Sensor descriptions. If you add a sensor, update NUM_SENSORS above! */
478 static struct sensor_template meter_attrs
[] = {
479 RO_SENSOR_TEMPLATE(POWER_AVERAGE_NAME
, show_power
, 0),
480 RO_SENSOR_TEMPLATE("power1_accuracy", show_accuracy
, 0),
481 RO_SENSOR_TEMPLATE("power1_average_interval_min", show_val
, 0),
482 RO_SENSOR_TEMPLATE("power1_average_interval_max", show_val
, 1),
483 RO_SENSOR_TEMPLATE("power1_is_battery", show_val
, 5),
484 RW_SENSOR_TEMPLATE(POWER_AVG_INTERVAL_NAME
, show_avg_interval
,
485 set_avg_interval
, 0),
489 static struct sensor_template misc_cap_attrs
[] = {
490 RO_SENSOR_TEMPLATE("power1_cap_min", show_val
, 2),
491 RO_SENSOR_TEMPLATE("power1_cap_max", show_val
, 3),
492 RO_SENSOR_TEMPLATE("power1_cap_hyst", show_val
, 4),
493 RO_SENSOR_TEMPLATE(POWER_ALARM_NAME
, show_val
, 6),
497 static struct sensor_template ro_cap_attrs
[] = {
498 RO_SENSOR_TEMPLATE(POWER_CAP_NAME
, show_cap
, 0),
502 static struct sensor_template rw_cap_attrs
[] = {
503 RW_SENSOR_TEMPLATE(POWER_CAP_NAME
, show_cap
, set_cap
, 0),
507 static struct sensor_template trip_attrs
[] = {
508 RW_SENSOR_TEMPLATE("power1_average_min", show_val
, set_trip
, 7),
509 RW_SENSOR_TEMPLATE("power1_average_max", show_val
, set_trip
, 8),
513 static struct sensor_template misc_attrs
[] = {
514 RO_SENSOR_TEMPLATE("name", show_name
, 0),
515 RO_SENSOR_TEMPLATE("power1_model_number", show_str
, 0),
516 RO_SENSOR_TEMPLATE("power1_oem_info", show_str
, 2),
517 RO_SENSOR_TEMPLATE("power1_serial_number", show_str
, 1),
521 #undef RO_SENSOR_TEMPLATE
522 #undef RW_SENSOR_TEMPLATE
524 /* Read power domain data */
525 static void remove_domain_devices(struct acpi_power_meter_resource
*resource
)
529 if (!resource
->num_domain_devices
)
532 for (i
= 0; i
< resource
->num_domain_devices
; i
++) {
533 struct acpi_device
*obj
= resource
->domain_devices
[i
];
537 sysfs_remove_link(resource
->holders_dir
,
538 kobject_name(&obj
->dev
.kobj
));
539 put_device(&obj
->dev
);
542 kfree(resource
->domain_devices
);
543 kobject_put(resource
->holders_dir
);
544 resource
->num_domain_devices
= 0;
547 static int read_domain_devices(struct acpi_power_meter_resource
*resource
)
551 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
552 union acpi_object
*pss
;
555 status
= acpi_evaluate_object(resource
->acpi_dev
->handle
, "_PMD", NULL
,
557 if (ACPI_FAILURE(status
)) {
558 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PMD"));
562 pss
= buffer
.pointer
;
564 pss
->type
!= ACPI_TYPE_PACKAGE
) {
565 dev_err(&resource
->acpi_dev
->dev
, ACPI_POWER_METER_NAME
566 "Invalid _PMD data\n");
571 if (!pss
->package
.count
)
574 resource
->domain_devices
= kzalloc(sizeof(struct acpi_device
*) *
575 pss
->package
.count
, GFP_KERNEL
);
576 if (!resource
->domain_devices
) {
581 resource
->holders_dir
= kobject_create_and_add("measures",
582 &resource
->acpi_dev
->dev
.kobj
);
583 if (!resource
->holders_dir
) {
588 resource
->num_domain_devices
= pss
->package
.count
;
590 for (i
= 0; i
< pss
->package
.count
; i
++) {
591 struct acpi_device
*obj
;
592 union acpi_object
*element
= &(pss
->package
.elements
[i
]);
594 /* Refuse non-references */
595 if (element
->type
!= ACPI_TYPE_LOCAL_REFERENCE
)
598 /* Create a symlink to domain objects */
599 resource
->domain_devices
[i
] = NULL
;
600 status
= acpi_bus_get_device(element
->reference
.handle
,
601 &resource
->domain_devices
[i
]);
602 if (ACPI_FAILURE(status
))
605 obj
= resource
->domain_devices
[i
];
606 get_device(&obj
->dev
);
608 res
= sysfs_create_link(resource
->holders_dir
, &obj
->dev
.kobj
,
609 kobject_name(&obj
->dev
.kobj
));
611 put_device(&obj
->dev
);
612 resource
->domain_devices
[i
] = NULL
;
620 kfree(resource
->domain_devices
);
622 kfree(buffer
.pointer
);
626 /* Registration and deregistration */
627 static int register_attrs(struct acpi_power_meter_resource
*resource
,
628 struct sensor_template
*attrs
)
630 struct device
*dev
= &resource
->acpi_dev
->dev
;
631 struct sensor_device_attribute
*sensors
=
632 &resource
->sensors
[resource
->num_sensors
];
635 while (attrs
->label
) {
636 sensors
->dev_attr
.attr
.name
= attrs
->label
;
637 sensors
->dev_attr
.attr
.mode
= S_IRUGO
;
638 sensors
->dev_attr
.show
= attrs
->show
;
639 sensors
->index
= attrs
->index
;
642 sensors
->dev_attr
.attr
.mode
|= S_IWUSR
;
643 sensors
->dev_attr
.store
= attrs
->set
;
646 sysfs_attr_init(&sensors
->dev_attr
.attr
);
647 res
= device_create_file(dev
, &sensors
->dev_attr
);
649 sensors
->dev_attr
.attr
.name
= NULL
;
653 resource
->num_sensors
++;
661 static void remove_attrs(struct acpi_power_meter_resource
*resource
)
665 for (i
= 0; i
< resource
->num_sensors
; i
++) {
666 if (!resource
->sensors
[i
].dev_attr
.attr
.name
)
668 device_remove_file(&resource
->acpi_dev
->dev
,
669 &resource
->sensors
[i
].dev_attr
);
672 remove_domain_devices(resource
);
674 resource
->num_sensors
= 0;
677 static int setup_attrs(struct acpi_power_meter_resource
*resource
)
681 res
= read_domain_devices(resource
);
685 if (resource
->caps
.flags
& POWER_METER_CAN_MEASURE
) {
686 res
= register_attrs(resource
, meter_attrs
);
691 if (resource
->caps
.flags
& POWER_METER_CAN_CAP
) {
692 if (!can_cap_in_hardware()) {
693 dev_err(&resource
->acpi_dev
->dev
,
694 "Ignoring unsafe software power cap!\n");
695 goto skip_unsafe_cap
;
698 if (resource
->caps
.configurable_cap
)
699 res
= register_attrs(resource
, rw_cap_attrs
);
701 res
= register_attrs(resource
, ro_cap_attrs
);
706 res
= register_attrs(resource
, misc_cap_attrs
);
712 if (resource
->caps
.flags
& POWER_METER_CAN_TRIP
) {
713 res
= register_attrs(resource
, trip_attrs
);
718 res
= register_attrs(resource
, misc_attrs
);
724 remove_attrs(resource
);
728 static void free_capabilities(struct acpi_power_meter_resource
*resource
)
733 str
= &resource
->model_number
;
734 for (i
= 0; i
< 3; i
++, str
++)
738 static int read_capabilities(struct acpi_power_meter_resource
*resource
)
742 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
743 struct acpi_buffer state
= { 0, NULL
};
744 struct acpi_buffer format
= { sizeof("NNNNNNNNNNN"), "NNNNNNNNNNN" };
745 union acpi_object
*pss
;
749 status
= acpi_evaluate_object(resource
->acpi_dev
->handle
, "_PMC", NULL
,
751 if (ACPI_FAILURE(status
)) {
752 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PMC"));
756 pss
= buffer
.pointer
;
758 pss
->type
!= ACPI_TYPE_PACKAGE
||
759 pss
->package
.count
!= 14) {
760 dev_err(&resource
->acpi_dev
->dev
, ACPI_POWER_METER_NAME
761 "Invalid _PMC data\n");
766 /* Grab all the integer data at once */
767 state
.length
= sizeof(struct acpi_power_meter_capabilities
);
768 state
.pointer
= &resource
->caps
;
770 status
= acpi_extract_package(pss
, &format
, &state
);
771 if (ACPI_FAILURE(status
)) {
772 ACPI_EXCEPTION((AE_INFO
, status
, "Invalid data"));
777 if (resource
->caps
.units
) {
778 dev_err(&resource
->acpi_dev
->dev
, ACPI_POWER_METER_NAME
779 "Unknown units %llu.\n",
780 resource
->caps
.units
);
785 /* Grab the string data */
786 str
= &resource
->model_number
;
788 for (i
= 11; i
< 14; i
++) {
789 union acpi_object
*element
= &(pss
->package
.elements
[i
]);
791 if (element
->type
!= ACPI_TYPE_STRING
) {
796 *str
= kzalloc(sizeof(u8
) * (element
->string
.length
+ 1),
803 strncpy(*str
, element
->string
.pointer
, element
->string
.length
);
807 dev_info(&resource
->acpi_dev
->dev
, "Found ACPI power meter.\n");
810 str
= &resource
->model_number
;
811 for (i
= 0; i
< 3; i
++, str
++)
814 kfree(buffer
.pointer
);
818 /* Handle ACPI event notifications */
819 static void acpi_power_meter_notify(struct acpi_device
*device
, u32 event
)
821 struct acpi_power_meter_resource
*resource
;
824 if (!device
|| !acpi_driver_data(device
))
827 resource
= acpi_driver_data(device
);
829 mutex_lock(&resource
->lock
);
831 case METER_NOTIFY_CONFIG
:
832 free_capabilities(resource
);
833 res
= read_capabilities(resource
);
837 remove_attrs(resource
);
838 setup_attrs(resource
);
840 case METER_NOTIFY_TRIP
:
841 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_AVERAGE_NAME
);
842 update_meter(resource
);
844 case METER_NOTIFY_CAP
:
845 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_CAP_NAME
);
846 update_cap(resource
);
848 case METER_NOTIFY_INTERVAL
:
849 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_AVG_INTERVAL_NAME
);
850 update_avg_interval(resource
);
852 case METER_NOTIFY_CAPPING
:
853 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_ALARM_NAME
);
854 dev_info(&device
->dev
, "Capping in progress.\n");
859 mutex_unlock(&resource
->lock
);
861 acpi_bus_generate_netlink_event(ACPI_POWER_METER_CLASS
,
862 dev_name(&device
->dev
), event
, 0);
865 static int acpi_power_meter_add(struct acpi_device
*device
)
868 struct acpi_power_meter_resource
*resource
;
873 resource
= kzalloc(sizeof(struct acpi_power_meter_resource
),
878 resource
->sensors_valid
= 0;
879 resource
->acpi_dev
= device
;
880 mutex_init(&resource
->lock
);
881 strcpy(acpi_device_name(device
), ACPI_POWER_METER_DEVICE_NAME
);
882 strcpy(acpi_device_class(device
), ACPI_POWER_METER_CLASS
);
883 device
->driver_data
= resource
;
885 free_capabilities(resource
);
886 res
= read_capabilities(resource
);
890 resource
->trip
[0] = resource
->trip
[1] = -1;
892 res
= setup_attrs(resource
);
896 resource
->hwmon_dev
= hwmon_device_register(&device
->dev
);
897 if (IS_ERR(resource
->hwmon_dev
)) {
898 res
= PTR_ERR(resource
->hwmon_dev
);
906 remove_attrs(resource
);
913 static int acpi_power_meter_remove(struct acpi_device
*device
, int type
)
915 struct acpi_power_meter_resource
*resource
;
917 if (!device
|| !acpi_driver_data(device
))
920 resource
= acpi_driver_data(device
);
921 hwmon_device_unregister(resource
->hwmon_dev
);
923 free_capabilities(resource
);
924 remove_attrs(resource
);
930 static int acpi_power_meter_resume(struct device
*dev
)
932 struct acpi_power_meter_resource
*resource
;
937 resource
= acpi_driver_data(to_acpi_device(dev
));
941 free_capabilities(resource
);
942 read_capabilities(resource
);
947 static SIMPLE_DEV_PM_OPS(acpi_power_meter_pm
, NULL
, acpi_power_meter_resume
);
949 static struct acpi_driver acpi_power_meter_driver
= {
950 .name
= "power_meter",
951 .class = ACPI_POWER_METER_CLASS
,
952 .ids
= power_meter_ids
,
954 .add
= acpi_power_meter_add
,
955 .remove
= acpi_power_meter_remove
,
956 .notify
= acpi_power_meter_notify
,
958 .drv
.pm
= &acpi_power_meter_pm
,
961 /* Module init/exit routines */
962 static int __init
enable_cap_knobs(const struct dmi_system_id
*d
)
968 static struct dmi_system_id __initdata pm_dmi_table
[] = {
970 enable_cap_knobs
, "IBM Active Energy Manager",
972 DMI_MATCH(DMI_SYS_VENDOR
, "IBM")
978 static int __init
acpi_power_meter_init(void)
985 dmi_check_system(pm_dmi_table
);
987 result
= acpi_bus_register_driver(&acpi_power_meter_driver
);
994 static void __exit
acpi_power_meter_exit(void)
996 acpi_bus_unregister_driver(&acpi_power_meter_driver
);
999 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1000 MODULE_DESCRIPTION("ACPI 4.0 power meter driver");
1001 MODULE_LICENSE("GPL");
1003 module_param(force_cap_on
, bool, 0644);
1004 MODULE_PARM_DESC(force_cap_on
, "Enable power cap even it is unsafe to do so.");
1006 module_init(acpi_power_meter_init
);
1007 module_exit(acpi_power_meter_exit
);