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 "power_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 int 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 ro_sensor_template
{
112 ssize_t (*show
)(struct device
*dev
,
113 struct device_attribute
*devattr
,
118 struct rw_sensor_template
{
120 ssize_t (*show
)(struct device
*dev
,
121 struct device_attribute
*devattr
,
123 ssize_t (*set
)(struct device
*dev
,
124 struct device_attribute
*devattr
,
125 const char *buf
, size_t count
);
129 /* Averaging interval */
130 static int update_avg_interval(struct acpi_power_meter_resource
*resource
)
132 unsigned long long data
;
135 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_GAI",
137 if (ACPI_FAILURE(status
)) {
138 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _GAI"));
142 resource
->avg_interval
= data
;
146 static ssize_t
show_avg_interval(struct device
*dev
,
147 struct device_attribute
*devattr
,
150 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
151 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
153 mutex_lock(&resource
->lock
);
154 update_avg_interval(resource
);
155 mutex_unlock(&resource
->lock
);
157 return sprintf(buf
, "%llu\n", resource
->avg_interval
);
160 static ssize_t
set_avg_interval(struct device
*dev
,
161 struct device_attribute
*devattr
,
162 const char *buf
, size_t count
)
164 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
165 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
166 union acpi_object arg0
= { ACPI_TYPE_INTEGER
};
167 struct acpi_object_list args
= { 1, &arg0
};
170 unsigned long long data
;
173 res
= strict_strtoul(buf
, 10, &temp
);
177 if (temp
> resource
->caps
.max_avg_interval
||
178 temp
< resource
->caps
.min_avg_interval
)
180 arg0
.integer
.value
= temp
;
182 mutex_lock(&resource
->lock
);
183 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_PAI",
185 if (!ACPI_FAILURE(status
))
186 resource
->avg_interval
= temp
;
187 mutex_unlock(&resource
->lock
);
189 if (ACPI_FAILURE(status
)) {
190 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PAI"));
194 /* _PAI returns 0 on success, nonzero otherwise */
202 static int update_cap(struct acpi_power_meter_resource
*resource
)
204 unsigned long long data
;
207 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_GHL",
209 if (ACPI_FAILURE(status
)) {
210 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _GHL"));
214 resource
->cap
= data
;
218 static ssize_t
show_cap(struct device
*dev
,
219 struct device_attribute
*devattr
,
222 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
223 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
225 mutex_lock(&resource
->lock
);
226 update_cap(resource
);
227 mutex_unlock(&resource
->lock
);
229 return sprintf(buf
, "%llu\n", resource
->cap
* 1000);
232 static ssize_t
set_cap(struct device
*dev
, struct device_attribute
*devattr
,
233 const char *buf
, size_t count
)
235 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
236 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
237 union acpi_object arg0
= { ACPI_TYPE_INTEGER
};
238 struct acpi_object_list args
= { 1, &arg0
};
241 unsigned long long data
;
244 res
= strict_strtoul(buf
, 10, &temp
);
249 if (temp
> resource
->caps
.max_cap
|| temp
< resource
->caps
.min_cap
)
251 arg0
.integer
.value
= temp
;
253 mutex_lock(&resource
->lock
);
254 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_SHL",
256 if (!ACPI_FAILURE(status
))
257 resource
->cap
= temp
;
258 mutex_unlock(&resource
->lock
);
260 if (ACPI_FAILURE(status
)) {
261 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _SHL"));
265 /* _SHL returns 0 on success, nonzero otherwise */
272 /* Power meter trip points */
273 static int set_acpi_trip(struct acpi_power_meter_resource
*resource
)
275 union acpi_object arg_objs
[] = {
279 struct acpi_object_list args
= { 2, arg_objs
};
280 unsigned long long data
;
283 /* Both trip levels must be set */
284 if (resource
->trip
[0] < 0 || resource
->trip
[1] < 0)
287 /* This driver stores min, max; ACPI wants max, min. */
288 arg_objs
[0].integer
.value
= resource
->trip
[1];
289 arg_objs
[1].integer
.value
= resource
->trip
[0];
291 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_PTP",
293 if (ACPI_FAILURE(status
)) {
294 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PTP"));
298 /* _PTP returns 0 on success, nonzero otherwise */
305 static ssize_t
set_trip(struct device
*dev
, struct device_attribute
*devattr
,
306 const char *buf
, size_t count
)
308 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
309 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
310 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
314 res
= strict_strtoul(buf
, 10, &temp
);
322 mutex_lock(&resource
->lock
);
323 resource
->trip
[attr
->index
- 7] = temp
;
324 res
= set_acpi_trip(resource
);
325 mutex_unlock(&resource
->lock
);
334 static int update_meter(struct acpi_power_meter_resource
*resource
)
336 unsigned long long data
;
338 unsigned long local_jiffies
= jiffies
;
340 if (time_before(local_jiffies
, resource
->sensors_last_updated
+
341 msecs_to_jiffies(resource
->caps
.sampling_time
)) &&
342 resource
->sensors_valid
)
345 status
= acpi_evaluate_integer(resource
->acpi_dev
->handle
, "_PMM",
347 if (ACPI_FAILURE(status
)) {
348 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PMM"));
352 resource
->power
= data
;
353 resource
->sensors_valid
= 1;
354 resource
->sensors_last_updated
= jiffies
;
358 static ssize_t
show_power(struct device
*dev
,
359 struct device_attribute
*devattr
,
362 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
363 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
365 mutex_lock(&resource
->lock
);
366 update_meter(resource
);
367 mutex_unlock(&resource
->lock
);
369 return sprintf(buf
, "%llu\n", resource
->power
* 1000);
373 static ssize_t
show_str(struct device
*dev
,
374 struct device_attribute
*devattr
,
377 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
378 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
379 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
382 switch (attr
->index
) {
384 val
= resource
->model_number
;
387 val
= resource
->serial_number
;
390 val
= resource
->oem_info
;
396 return sprintf(buf
, "%s\n", val
);
399 static ssize_t
show_val(struct device
*dev
,
400 struct device_attribute
*devattr
,
403 struct sensor_device_attribute
*attr
= to_sensor_dev_attr(devattr
);
404 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
405 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
408 switch (attr
->index
) {
410 val
= resource
->caps
.min_avg_interval
;
413 val
= resource
->caps
.max_avg_interval
;
416 val
= resource
->caps
.min_cap
* 1000;
419 val
= resource
->caps
.max_cap
* 1000;
422 if (resource
->caps
.hysteresis
== UNKNOWN_HYSTERESIS
)
423 return sprintf(buf
, "unknown\n");
425 val
= resource
->caps
.hysteresis
* 1000;
428 if (resource
->caps
.flags
& POWER_METER_IS_BATTERY
)
434 if (resource
->power
> resource
->cap
)
441 if (resource
->trip
[attr
->index
- 7] < 0)
442 return sprintf(buf
, "unknown\n");
444 val
= resource
->trip
[attr
->index
- 7] * 1000;
450 return sprintf(buf
, "%llu\n", val
);
453 static ssize_t
show_accuracy(struct device
*dev
,
454 struct device_attribute
*devattr
,
457 struct acpi_device
*acpi_dev
= to_acpi_device(dev
);
458 struct acpi_power_meter_resource
*resource
= acpi_dev
->driver_data
;
459 unsigned int acc
= resource
->caps
.accuracy
;
461 return sprintf(buf
, "%u.%u%%\n", acc
/ 1000, acc
% 1000);
464 static ssize_t
show_name(struct device
*dev
,
465 struct device_attribute
*devattr
,
468 return sprintf(buf
, "%s\n", ACPI_POWER_METER_NAME
);
471 /* Sensor descriptions. If you add a sensor, update NUM_SENSORS above! */
472 static struct ro_sensor_template meter_ro_attrs
[] = {
473 {POWER_AVERAGE_NAME
, show_power
, 0},
474 {"power1_accuracy", show_accuracy
, 0},
475 {"power1_average_interval_min", show_val
, 0},
476 {"power1_average_interval_max", show_val
, 1},
477 {"power1_is_battery", show_val
, 5},
481 static struct rw_sensor_template meter_rw_attrs
[] = {
482 {POWER_AVG_INTERVAL_NAME
, show_avg_interval
, set_avg_interval
, 0},
483 {NULL
, NULL
, NULL
, 0},
486 static struct ro_sensor_template misc_cap_attrs
[] = {
487 {"power1_cap_min", show_val
, 2},
488 {"power1_cap_max", show_val
, 3},
489 {"power1_cap_hyst", show_val
, 4},
490 {POWER_ALARM_NAME
, show_val
, 6},
494 static struct ro_sensor_template ro_cap_attrs
[] = {
495 {POWER_CAP_NAME
, show_cap
, 0},
499 static struct rw_sensor_template rw_cap_attrs
[] = {
500 {POWER_CAP_NAME
, show_cap
, set_cap
, 0},
501 {NULL
, NULL
, NULL
, 0},
504 static struct rw_sensor_template trip_attrs
[] = {
505 {"power1_average_min", show_val
, set_trip
, 7},
506 {"power1_average_max", show_val
, set_trip
, 8},
507 {NULL
, NULL
, NULL
, 0},
510 static struct ro_sensor_template misc_attrs
[] = {
511 {"name", show_name
, 0},
512 {"power1_model_number", show_str
, 0},
513 {"power1_oem_info", show_str
, 2},
514 {"power1_serial_number", show_str
, 1},
518 /* Read power domain data */
519 static void remove_domain_devices(struct acpi_power_meter_resource
*resource
)
523 if (!resource
->num_domain_devices
)
526 for (i
= 0; i
< resource
->num_domain_devices
; i
++) {
527 struct acpi_device
*obj
= resource
->domain_devices
[i
];
531 sysfs_remove_link(resource
->holders_dir
,
532 kobject_name(&obj
->dev
.kobj
));
533 put_device(&obj
->dev
);
536 kfree(resource
->domain_devices
);
537 kobject_put(resource
->holders_dir
);
538 resource
->num_domain_devices
= 0;
541 static int read_domain_devices(struct acpi_power_meter_resource
*resource
)
545 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
546 union acpi_object
*pss
;
549 status
= acpi_evaluate_object(resource
->acpi_dev
->handle
, "_PMD", NULL
,
551 if (ACPI_FAILURE(status
)) {
552 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PMD"));
556 pss
= buffer
.pointer
;
558 pss
->type
!= ACPI_TYPE_PACKAGE
) {
559 dev_err(&resource
->acpi_dev
->dev
, ACPI_POWER_METER_NAME
560 "Invalid _PMD data\n");
565 if (!pss
->package
.count
)
568 resource
->domain_devices
= kzalloc(sizeof(struct acpi_device
*) *
569 pss
->package
.count
, GFP_KERNEL
);
570 if (!resource
->domain_devices
) {
575 resource
->holders_dir
= kobject_create_and_add("measures",
576 &resource
->acpi_dev
->dev
.kobj
);
577 if (!resource
->holders_dir
) {
582 resource
->num_domain_devices
= pss
->package
.count
;
584 for (i
= 0; i
< pss
->package
.count
; i
++) {
585 struct acpi_device
*obj
;
586 union acpi_object
*element
= &(pss
->package
.elements
[i
]);
588 /* Refuse non-references */
589 if (element
->type
!= ACPI_TYPE_LOCAL_REFERENCE
)
592 /* Create a symlink to domain objects */
593 resource
->domain_devices
[i
] = NULL
;
594 status
= acpi_bus_get_device(element
->reference
.handle
,
595 &resource
->domain_devices
[i
]);
596 if (ACPI_FAILURE(status
))
599 obj
= resource
->domain_devices
[i
];
600 get_device(&obj
->dev
);
602 res
= sysfs_create_link(resource
->holders_dir
, &obj
->dev
.kobj
,
603 kobject_name(&obj
->dev
.kobj
));
605 put_device(&obj
->dev
);
606 resource
->domain_devices
[i
] = NULL
;
614 kfree(resource
->domain_devices
);
616 kfree(buffer
.pointer
);
620 /* Registration and deregistration */
621 static int register_ro_attrs(struct acpi_power_meter_resource
*resource
,
622 struct ro_sensor_template
*ro
)
624 struct device
*dev
= &resource
->acpi_dev
->dev
;
625 struct sensor_device_attribute
*sensors
=
626 &resource
->sensors
[resource
->num_sensors
];
630 sensors
->dev_attr
.attr
.name
= ro
->label
;
631 sensors
->dev_attr
.attr
.mode
= S_IRUGO
;
632 sensors
->dev_attr
.show
= ro
->show
;
633 sensors
->index
= ro
->index
;
635 res
= device_create_file(dev
, &sensors
->dev_attr
);
637 sensors
->dev_attr
.attr
.name
= NULL
;
641 resource
->num_sensors
++;
649 static int register_rw_attrs(struct acpi_power_meter_resource
*resource
,
650 struct rw_sensor_template
*rw
)
652 struct device
*dev
= &resource
->acpi_dev
->dev
;
653 struct sensor_device_attribute
*sensors
=
654 &resource
->sensors
[resource
->num_sensors
];
658 sensors
->dev_attr
.attr
.name
= rw
->label
;
659 sensors
->dev_attr
.attr
.mode
= S_IRUGO
| S_IWUSR
;
660 sensors
->dev_attr
.show
= rw
->show
;
661 sensors
->dev_attr
.store
= rw
->set
;
662 sensors
->index
= rw
->index
;
664 res
= device_create_file(dev
, &sensors
->dev_attr
);
666 sensors
->dev_attr
.attr
.name
= NULL
;
670 resource
->num_sensors
++;
678 static void remove_attrs(struct acpi_power_meter_resource
*resource
)
682 for (i
= 0; i
< resource
->num_sensors
; i
++) {
683 if (!resource
->sensors
[i
].dev_attr
.attr
.name
)
685 device_remove_file(&resource
->acpi_dev
->dev
,
686 &resource
->sensors
[i
].dev_attr
);
689 remove_domain_devices(resource
);
691 resource
->num_sensors
= 0;
694 static int setup_attrs(struct acpi_power_meter_resource
*resource
)
698 res
= read_domain_devices(resource
);
702 if (resource
->caps
.flags
& POWER_METER_CAN_MEASURE
) {
703 res
= register_ro_attrs(resource
, meter_ro_attrs
);
706 res
= register_rw_attrs(resource
, meter_rw_attrs
);
711 if (resource
->caps
.flags
& POWER_METER_CAN_CAP
) {
712 if (!can_cap_in_hardware()) {
713 dev_err(&resource
->acpi_dev
->dev
,
714 "Ignoring unsafe software power cap!\n");
715 goto skip_unsafe_cap
;
718 if (resource
->caps
.configurable_cap
) {
719 res
= register_rw_attrs(resource
, rw_cap_attrs
);
723 res
= register_ro_attrs(resource
, ro_cap_attrs
);
727 res
= register_ro_attrs(resource
, misc_cap_attrs
);
733 if (resource
->caps
.flags
& POWER_METER_CAN_TRIP
) {
734 res
= register_rw_attrs(resource
, trip_attrs
);
739 res
= register_ro_attrs(resource
, misc_attrs
);
745 remove_attrs(resource
);
749 static void free_capabilities(struct acpi_power_meter_resource
*resource
)
754 str
= &resource
->model_number
;
755 for (i
= 0; i
< 3; i
++, str
++)
759 static int read_capabilities(struct acpi_power_meter_resource
*resource
)
763 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
764 struct acpi_buffer state
= { 0, NULL
};
765 struct acpi_buffer format
= { sizeof("NNNNNNNNNNN"), "NNNNNNNNNNN" };
766 union acpi_object
*pss
;
770 status
= acpi_evaluate_object(resource
->acpi_dev
->handle
, "_PMC", NULL
,
772 if (ACPI_FAILURE(status
)) {
773 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PMC"));
777 pss
= buffer
.pointer
;
779 pss
->type
!= ACPI_TYPE_PACKAGE
||
780 pss
->package
.count
!= 14) {
781 dev_err(&resource
->acpi_dev
->dev
, ACPI_POWER_METER_NAME
782 "Invalid _PMC data\n");
787 /* Grab all the integer data at once */
788 state
.length
= sizeof(struct acpi_power_meter_capabilities
);
789 state
.pointer
= &resource
->caps
;
791 status
= acpi_extract_package(pss
, &format
, &state
);
792 if (ACPI_FAILURE(status
)) {
793 ACPI_EXCEPTION((AE_INFO
, status
, "Invalid data"));
798 if (resource
->caps
.units
) {
799 dev_err(&resource
->acpi_dev
->dev
, ACPI_POWER_METER_NAME
800 "Unknown units %llu.\n",
801 resource
->caps
.units
);
806 /* Grab the string data */
807 str
= &resource
->model_number
;
809 for (i
= 11; i
< 14; i
++) {
810 union acpi_object
*element
= &(pss
->package
.elements
[i
]);
812 if (element
->type
!= ACPI_TYPE_STRING
) {
817 *str
= kzalloc(sizeof(u8
) * (element
->string
.length
+ 1),
824 strncpy(*str
, element
->string
.pointer
, element
->string
.length
);
828 dev_info(&resource
->acpi_dev
->dev
, "Found ACPI power meter.\n");
831 str
= &resource
->model_number
;
832 for (i
= 0; i
< 3; i
++, str
++)
835 kfree(buffer
.pointer
);
839 /* Handle ACPI event notifications */
840 static void acpi_power_meter_notify(struct acpi_device
*device
, u32 event
)
842 struct acpi_power_meter_resource
*resource
;
845 if (!device
|| !acpi_driver_data(device
))
848 resource
= acpi_driver_data(device
);
850 mutex_lock(&resource
->lock
);
852 case METER_NOTIFY_CONFIG
:
853 free_capabilities(resource
);
854 res
= read_capabilities(resource
);
858 remove_attrs(resource
);
859 setup_attrs(resource
);
861 case METER_NOTIFY_TRIP
:
862 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_AVERAGE_NAME
);
863 update_meter(resource
);
865 case METER_NOTIFY_CAP
:
866 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_CAP_NAME
);
867 update_cap(resource
);
869 case METER_NOTIFY_INTERVAL
:
870 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_AVG_INTERVAL_NAME
);
871 update_avg_interval(resource
);
873 case METER_NOTIFY_CAPPING
:
874 sysfs_notify(&device
->dev
.kobj
, NULL
, POWER_ALARM_NAME
);
875 dev_info(&device
->dev
, "Capping in progress.\n");
880 mutex_unlock(&resource
->lock
);
882 acpi_bus_generate_netlink_event(ACPI_POWER_METER_CLASS
,
883 dev_name(&device
->dev
), event
, 0);
886 static int acpi_power_meter_add(struct acpi_device
*device
)
889 struct acpi_power_meter_resource
*resource
;
894 resource
= kzalloc(sizeof(struct acpi_power_meter_resource
),
899 resource
->sensors_valid
= 0;
900 resource
->acpi_dev
= device
;
901 mutex_init(&resource
->lock
);
902 strcpy(acpi_device_name(device
), ACPI_POWER_METER_DEVICE_NAME
);
903 strcpy(acpi_device_class(device
), ACPI_POWER_METER_CLASS
);
904 device
->driver_data
= resource
;
906 free_capabilities(resource
);
907 res
= read_capabilities(resource
);
911 resource
->trip
[0] = resource
->trip
[1] = -1;
913 res
= setup_attrs(resource
);
917 resource
->hwmon_dev
= hwmon_device_register(&device
->dev
);
918 if (IS_ERR(resource
->hwmon_dev
)) {
919 res
= PTR_ERR(resource
->hwmon_dev
);
927 remove_attrs(resource
);
934 static int acpi_power_meter_remove(struct acpi_device
*device
, int type
)
936 struct acpi_power_meter_resource
*resource
;
938 if (!device
|| !acpi_driver_data(device
))
941 resource
= acpi_driver_data(device
);
942 hwmon_device_unregister(resource
->hwmon_dev
);
944 free_capabilities(resource
);
945 remove_attrs(resource
);
951 static int acpi_power_meter_resume(struct acpi_device
*device
)
953 struct acpi_power_meter_resource
*resource
;
955 if (!device
|| !acpi_driver_data(device
))
958 resource
= acpi_driver_data(device
);
959 free_capabilities(resource
);
960 read_capabilities(resource
);
965 static struct acpi_driver acpi_power_meter_driver
= {
966 .name
= "power_meter",
967 .class = ACPI_POWER_METER_CLASS
,
968 .ids
= power_meter_ids
,
970 .add
= acpi_power_meter_add
,
971 .remove
= acpi_power_meter_remove
,
972 .resume
= acpi_power_meter_resume
,
973 .notify
= acpi_power_meter_notify
,
977 /* Module init/exit routines */
978 static int __init
enable_cap_knobs(const struct dmi_system_id
*d
)
984 static struct dmi_system_id __initdata pm_dmi_table
[] = {
986 enable_cap_knobs
, "IBM Active Energy Manager",
988 DMI_MATCH(DMI_SYS_VENDOR
, "IBM")
994 static int __init
acpi_power_meter_init(void)
1001 dmi_check_system(pm_dmi_table
);
1003 result
= acpi_bus_register_driver(&acpi_power_meter_driver
);
1010 static void __exit
acpi_power_meter_exit(void)
1012 acpi_bus_unregister_driver(&acpi_power_meter_driver
);
1015 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1016 MODULE_DESCRIPTION("ACPI 4.0 power meter driver");
1017 MODULE_LICENSE("GPL");
1019 module_param(force_cap_on
, bool, 0644);
1020 MODULE_PARM_DESC(force_cap_on
, "Enable power cap even it is unsafe to do so.");
1022 module_init(acpi_power_meter_init
);
1023 module_exit(acpi_power_meter_exit
);