1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * A hwmon driver for ACPI 4.0 power meters
4  * Copyright (C) 2009 IBM
5  *
6  * Author: Darrick J. Wong <darrick.wong@oracle.com>
7  */
8 
9 #include <linux/module.h>
10 #include <linux/hwmon.h>
11 #include <linux/hwmon-sysfs.h>
12 #include <linux/jiffies.h>
13 #include <linux/mutex.h>
14 #include <linux/dmi.h>
15 #include <linux/slab.h>
16 #include <linux/kdev_t.h>
17 #include <linux/sched.h>
18 #include <linux/time.h>
19 #include <linux/err.h>
20 #include <linux/acpi.h>
21 
22 #define ACPI_POWER_METER_NAME		"power_meter"
23 #define ACPI_POWER_METER_DEVICE_NAME	"Power Meter"
24 #define ACPI_POWER_METER_CLASS		"pwr_meter_resource"
25 
26 #define NUM_SENSORS			17
27 
28 #define POWER_METER_CAN_MEASURE	(1 << 0)
29 #define POWER_METER_CAN_TRIP	(1 << 1)
30 #define POWER_METER_CAN_CAP	(1 << 2)
31 #define POWER_METER_CAN_NOTIFY	(1 << 3)
32 #define POWER_METER_IS_BATTERY	(1 << 8)
33 #define UNKNOWN_HYSTERESIS	0xFFFFFFFF
34 
35 #define METER_NOTIFY_CONFIG	0x80
36 #define METER_NOTIFY_TRIP	0x81
37 #define METER_NOTIFY_CAP	0x82
38 #define METER_NOTIFY_CAPPING	0x83
39 #define METER_NOTIFY_INTERVAL	0x84
40 
41 #define POWER_AVERAGE_NAME	"power1_average"
42 #define POWER_CAP_NAME		"power1_cap"
43 #define POWER_AVG_INTERVAL_NAME	"power1_average_interval"
44 #define POWER_ALARM_NAME	"power1_alarm"
45 
46 static int cap_in_hardware;
47 static bool force_cap_on;
48 
49 static int can_cap_in_hardware(void)
50 {
51 	return force_cap_on || cap_in_hardware;
52 }
53 
54 static const struct acpi_device_id power_meter_ids[] = {
55 	{"ACPI000D", 0},
56 	{"", 0},
57 };
58 MODULE_DEVICE_TABLE(acpi, power_meter_ids);
59 
60 struct acpi_power_meter_capabilities {
61 	u64		flags;
62 	u64		units;
63 	u64		type;
64 	u64		accuracy;
65 	u64		sampling_time;
66 	u64		min_avg_interval;
67 	u64		max_avg_interval;
68 	u64		hysteresis;
69 	u64		configurable_cap;
70 	u64		min_cap;
71 	u64		max_cap;
72 };
73 
74 struct acpi_power_meter_resource {
75 	struct acpi_device	*acpi_dev;
76 	acpi_bus_id		name;
77 	struct mutex		lock;
78 	struct device		*hwmon_dev;
79 	struct acpi_power_meter_capabilities	caps;
80 	acpi_string		model_number;
81 	acpi_string		serial_number;
82 	acpi_string		oem_info;
83 	u64		power;
84 	u64		cap;
85 	u64		avg_interval;
86 	int			sensors_valid;
87 	unsigned long		sensors_last_updated;
88 	struct sensor_device_attribute	sensors[NUM_SENSORS];
89 	int			num_sensors;
90 	s64			trip[2];
91 	int			num_domain_devices;
92 	struct acpi_device	**domain_devices;
93 	struct kobject		*holders_dir;
94 };
95 
96 struct sensor_template {
97 	char *label;
98 	ssize_t (*show)(struct device *dev,
99 			struct device_attribute *devattr,
100 			char *buf);
101 	ssize_t (*set)(struct device *dev,
102 		       struct device_attribute *devattr,
103 		       const char *buf, size_t count);
104 	int index;
105 };
106 
107 /* Averaging interval */
108 static int update_avg_interval(struct acpi_power_meter_resource *resource)
109 {
110 	unsigned long long data;
111 	acpi_status status;
112 
113 	status = acpi_evaluate_integer(resource->acpi_dev->handle, "_GAI",
114 				       NULL, &data);
115 	if (ACPI_FAILURE(status)) {
116 		acpi_evaluation_failure_warn(resource->acpi_dev->handle, "_GAI",
117 					     status);
118 		return -ENODEV;
119 	}
120 
121 	resource->avg_interval = data;
122 	return 0;
123 }
124 
125 static ssize_t show_avg_interval(struct device *dev,
126 				 struct device_attribute *devattr,
127 				 char *buf)
128 {
129 	struct acpi_device *acpi_dev = to_acpi_device(dev);
130 	struct acpi_power_meter_resource *resource = acpi_dev->driver_data;
131 
132 	mutex_lock(&resource->lock);
133 	update_avg_interval(resource);
134 	mutex_unlock(&resource->lock);
135 
136 	return sprintf(buf, "%llu\n", resource->avg_interval);
137 }
138 
139 static ssize_t set_avg_interval(struct device *dev,
140 				struct device_attribute *devattr,
141 				const char *buf, size_t count)
142 {
143 	struct acpi_device *acpi_dev = to_acpi_device(dev);
144 	struct acpi_power_meter_resource *resource = acpi_dev->driver_data;
145 	union acpi_object arg0 = { ACPI_TYPE_INTEGER };
146 	struct acpi_object_list args = { 1, &arg0 };
147 	int res;
148 	unsigned long temp;
149 	unsigned long long data;
150 	acpi_status status;
151 
152 	res = kstrtoul(buf, 10, &temp);
153 	if (res)
154 		return res;
155 
156 	if (temp > resource->caps.max_avg_interval ||
157 	    temp < resource->caps.min_avg_interval)
158 		return -EINVAL;
159 	arg0.integer.value = temp;
160 
161 	mutex_lock(&resource->lock);
162 	status = acpi_evaluate_integer(resource->acpi_dev->handle, "_PAI",
163 				       &args, &data);
164 	if (ACPI_SUCCESS(status))
165 		resource->avg_interval = temp;
166 	mutex_unlock(&resource->lock);
167 
168 	if (ACPI_FAILURE(status)) {
169 		acpi_evaluation_failure_warn(resource->acpi_dev->handle, "_PAI",
170 					     status);
171 		return -EINVAL;
172 	}
173 
174 	/* _PAI returns 0 on success, nonzero otherwise */
175 	if (data)
176 		return -EINVAL;
177 
178 	return count;
179 }
180 
181 /* Cap functions */
182 static int update_cap(struct acpi_power_meter_resource *resource)
183 {
184 	unsigned long long data;
185 	acpi_status status;
186 
187 	status = acpi_evaluate_integer(resource->acpi_dev->handle, "_GHL",
188 				       NULL, &data);
189 	if (ACPI_FAILURE(status)) {
190 		acpi_evaluation_failure_warn(resource->acpi_dev->handle, "_GHL",
191 					     status);
192 		return -ENODEV;
193 	}
194 
195 	resource->cap = data;
196 	return 0;
197 }
198 
199 static ssize_t show_cap(struct device *dev,
200 			struct device_attribute *devattr,
201 			char *buf)
202 {
203 	struct acpi_device *acpi_dev = to_acpi_device(dev);
204 	struct acpi_power_meter_resource *resource = acpi_dev->driver_data;
205 
206 	mutex_lock(&resource->lock);
207 	update_cap(resource);
208 	mutex_unlock(&resource->lock);
209 
210 	return sprintf(buf, "%llu\n", resource->cap * 1000);
211 }
212 
213 static ssize_t set_cap(struct device *dev, struct device_attribute *devattr,
214 		       const char *buf, size_t count)
215 {
216 	struct acpi_device *acpi_dev = to_acpi_device(dev);
217 	struct acpi_power_meter_resource *resource = acpi_dev->driver_data;
218 	union acpi_object arg0 = { ACPI_TYPE_INTEGER };
219 	struct acpi_object_list args = { 1, &arg0 };
220 	int res;
221 	unsigned long temp;
222 	unsigned long long data;
223 	acpi_status status;
224 
225 	res = kstrtoul(buf, 10, &temp);
226 	if (res)
227 		return res;
228 
229 	temp = DIV_ROUND_CLOSEST(temp, 1000);
230 	if (temp > resource->caps.max_cap || temp < resource->caps.min_cap)
231 		return -EINVAL;
232 	arg0.integer.value = temp;
233 
234 	mutex_lock(&resource->lock);
235 	status = acpi_evaluate_integer(resource->acpi_dev->handle, "_SHL",
236 				       &args, &data);
237 	if (ACPI_SUCCESS(status))
238 		resource->cap = temp;
239 	mutex_unlock(&resource->lock);
240 
241 	if (ACPI_FAILURE(status)) {
242 		acpi_evaluation_failure_warn(resource->acpi_dev->handle, "_SHL",
243 					     status);
244 		return -EINVAL;
245 	}
246 
247 	/* _SHL returns 0 on success, nonzero otherwise */
248 	if (data)
249 		return -EINVAL;
250 
251 	return count;
252 }
253 
254 /* Power meter trip points */
255 static int set_acpi_trip(struct acpi_power_meter_resource *resource)
256 {
257 	union acpi_object arg_objs[] = {
258 		{ACPI_TYPE_INTEGER},
259 		{ACPI_TYPE_INTEGER}
260 	};
261 	struct acpi_object_list args = { 2, arg_objs };
262 	unsigned long long data;
263 	acpi_status status;
264 
265 	/* Both trip levels must be set */
266 	if (resource->trip[0] < 0 || resource->trip[1] < 0)
267 		return 0;
268 
269 	/* This driver stores min, max; ACPI wants max, min. */
270 	arg_objs[0].integer.value = resource->trip[1];
271 	arg_objs[1].integer.value = resource->trip[0];
272 
273 	status = acpi_evaluate_integer(resource->acpi_dev->handle, "_PTP",
274 				       &args, &data);
275 	if (ACPI_FAILURE(status)) {
276 		acpi_evaluation_failure_warn(resource->acpi_dev->handle, "_PTP",
277 					     status);
278 		return -EINVAL;
279 	}
280 
281 	/* _PTP returns 0 on success, nonzero otherwise */
282 	if (data)
283 		return -EINVAL;
284 
285 	return 0;
286 }
287 
288 static ssize_t set_trip(struct device *dev, struct device_attribute *devattr,
289 			const char *buf, size_t count)
290 {
291 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
292 	struct acpi_device *acpi_dev = to_acpi_device(dev);
293 	struct acpi_power_meter_resource *resource = acpi_dev->driver_data;
294 	int res;
295 	unsigned long temp;
296 
297 	res = kstrtoul(buf, 10, &temp);
298 	if (res)
299 		return res;
300 
301 	temp = DIV_ROUND_CLOSEST(temp, 1000);
302 
303 	mutex_lock(&resource->lock);
304 	resource->trip[attr->index - 7] = temp;
305 	res = set_acpi_trip(resource);
306 	mutex_unlock(&resource->lock);
307 
308 	if (res)
309 		return res;
310 
311 	return count;
312 }
313 
314 /* Power meter */
315 static int update_meter(struct acpi_power_meter_resource *resource)
316 {
317 	unsigned long long data;
318 	acpi_status status;
319 	unsigned long local_jiffies = jiffies;
320 
321 	if (time_before(local_jiffies, resource->sensors_last_updated +
322 			msecs_to_jiffies(resource->caps.sampling_time)) &&
323 			resource->sensors_valid)
324 		return 0;
325 
326 	status = acpi_evaluate_integer(resource->acpi_dev->handle, "_PMM",
327 				       NULL, &data);
328 	if (ACPI_FAILURE(status)) {
329 		acpi_evaluation_failure_warn(resource->acpi_dev->handle, "_PMM",
330 					     status);
331 		return -ENODEV;
332 	}
333 
334 	resource->power = data;
335 	resource->sensors_valid = 1;
336 	resource->sensors_last_updated = jiffies;
337 	return 0;
338 }
339 
340 static ssize_t show_power(struct device *dev,
341 			  struct device_attribute *devattr,
342 			  char *buf)
343 {
344 	struct acpi_device *acpi_dev = to_acpi_device(dev);
345 	struct acpi_power_meter_resource *resource = acpi_dev->driver_data;
346 
347 	mutex_lock(&resource->lock);
348 	update_meter(resource);
349 	mutex_unlock(&resource->lock);
350 
351 	return sprintf(buf, "%llu\n", resource->power * 1000);
352 }
353 
354 /* Miscellaneous */
355 static ssize_t show_str(struct device *dev,
356 			struct device_attribute *devattr,
357 			char *buf)
358 {
359 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
360 	struct acpi_device *acpi_dev = to_acpi_device(dev);
361 	struct acpi_power_meter_resource *resource = acpi_dev->driver_data;
362 	acpi_string val;
363 	int ret;
364 
365 	mutex_lock(&resource->lock);
366 	switch (attr->index) {
367 	case 0:
368 		val = resource->model_number;
369 		break;
370 	case 1:
371 		val = resource->serial_number;
372 		break;
373 	case 2:
374 		val = resource->oem_info;
375 		break;
376 	default:
377 		WARN(1, "Implementation error: unexpected attribute index %d\n",
378 		     attr->index);
379 		val = "";
380 		break;
381 	}
382 	ret = sprintf(buf, "%s\n", val);
383 	mutex_unlock(&resource->lock);
384 	return ret;
385 }
386 
387 static ssize_t show_val(struct device *dev,
388 			struct device_attribute *devattr,
389 			char *buf)
390 {
391 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
392 	struct acpi_device *acpi_dev = to_acpi_device(dev);
393 	struct acpi_power_meter_resource *resource = acpi_dev->driver_data;
394 	u64 val = 0;
395 
396 	switch (attr->index) {
397 	case 0:
398 		val = resource->caps.min_avg_interval;
399 		break;
400 	case 1:
401 		val = resource->caps.max_avg_interval;
402 		break;
403 	case 2:
404 		val = resource->caps.min_cap * 1000;
405 		break;
406 	case 3:
407 		val = resource->caps.max_cap * 1000;
408 		break;
409 	case 4:
410 		if (resource->caps.hysteresis == UNKNOWN_HYSTERESIS)
411 			return sprintf(buf, "unknown\n");
412 
413 		val = resource->caps.hysteresis * 1000;
414 		break;
415 	case 5:
416 		if (resource->caps.flags & POWER_METER_IS_BATTERY)
417 			val = 1;
418 		else
419 			val = 0;
420 		break;
421 	case 6:
422 		if (resource->power > resource->cap)
423 			val = 1;
424 		else
425 			val = 0;
426 		break;
427 	case 7:
428 	case 8:
429 		if (resource->trip[attr->index - 7] < 0)
430 			return sprintf(buf, "unknown\n");
431 
432 		val = resource->trip[attr->index - 7] * 1000;
433 		break;
434 	default:
435 		WARN(1, "Implementation error: unexpected attribute index %d\n",
436 		     attr->index);
437 		break;
438 	}
439 
440 	return sprintf(buf, "%llu\n", val);
441 }
442 
443 static ssize_t show_accuracy(struct device *dev,
444 			     struct device_attribute *devattr,
445 			     char *buf)
446 {
447 	struct acpi_device *acpi_dev = to_acpi_device(dev);
448 	struct acpi_power_meter_resource *resource = acpi_dev->driver_data;
449 	unsigned int acc = resource->caps.accuracy;
450 
451 	return sprintf(buf, "%u.%u%%\n", acc / 1000, acc % 1000);
452 }
453 
454 static ssize_t show_name(struct device *dev,
455 			 struct device_attribute *devattr,
456 			 char *buf)
457 {
458 	return sprintf(buf, "%s\n", ACPI_POWER_METER_NAME);
459 }
460 
461 #define RO_SENSOR_TEMPLATE(_label, _show, _index)	\
462 	{						\
463 		.label = _label,			\
464 		.show  = _show,				\
465 		.index = _index,			\
466 	}
467 
468 #define RW_SENSOR_TEMPLATE(_label, _show, _set, _index)	\
469 	{						\
470 		.label = _label,			\
471 		.show  = _show,				\
472 		.set   = _set,				\
473 		.index = _index,			\
474 	}
475 
476 /* Sensor descriptions.  If you add a sensor, update NUM_SENSORS above! */
477 static struct sensor_template meter_attrs[] = {
478 	RO_SENSOR_TEMPLATE(POWER_AVERAGE_NAME, show_power, 0),
479 	RO_SENSOR_TEMPLATE("power1_accuracy", show_accuracy, 0),
480 	RO_SENSOR_TEMPLATE("power1_average_interval_min", show_val, 0),
481 	RO_SENSOR_TEMPLATE("power1_average_interval_max", show_val, 1),
482 	RO_SENSOR_TEMPLATE("power1_is_battery", show_val, 5),
483 	RW_SENSOR_TEMPLATE(POWER_AVG_INTERVAL_NAME, show_avg_interval,
484 			   set_avg_interval, 0),
485 	{},
486 };
487 
488 static struct sensor_template misc_cap_attrs[] = {
489 	RO_SENSOR_TEMPLATE("power1_cap_min", show_val, 2),
490 	RO_SENSOR_TEMPLATE("power1_cap_max", show_val, 3),
491 	RO_SENSOR_TEMPLATE("power1_cap_hyst", show_val, 4),
492 	RO_SENSOR_TEMPLATE(POWER_ALARM_NAME, show_val, 6),
493 	{},
494 };
495 
496 static struct sensor_template ro_cap_attrs[] = {
497 	RO_SENSOR_TEMPLATE(POWER_CAP_NAME, show_cap, 0),
498 	{},
499 };
500 
501 static struct sensor_template rw_cap_attrs[] = {
502 	RW_SENSOR_TEMPLATE(POWER_CAP_NAME, show_cap, set_cap, 0),
503 	{},
504 };
505 
506 static struct sensor_template trip_attrs[] = {
507 	RW_SENSOR_TEMPLATE("power1_average_min", show_val, set_trip, 7),
508 	RW_SENSOR_TEMPLATE("power1_average_max", show_val, set_trip, 8),
509 	{},
510 };
511 
512 static struct sensor_template misc_attrs[] = {
513 	RO_SENSOR_TEMPLATE("name", show_name, 0),
514 	RO_SENSOR_TEMPLATE("power1_model_number", show_str, 0),
515 	RO_SENSOR_TEMPLATE("power1_oem_info", show_str, 2),
516 	RO_SENSOR_TEMPLATE("power1_serial_number", show_str, 1),
517 	{},
518 };
519 
520 #undef RO_SENSOR_TEMPLATE
521 #undef RW_SENSOR_TEMPLATE
522 
523 /* Read power domain data */
524 static void remove_domain_devices(struct acpi_power_meter_resource *resource)
525 {
526 	int i;
527 
528 	if (!resource->num_domain_devices)
529 		return;
530 
531 	for (i = 0; i < resource->num_domain_devices; i++) {
532 		struct acpi_device *obj = resource->domain_devices[i];
533 
534 		if (!obj)
535 			continue;
536 
537 		sysfs_remove_link(resource->holders_dir,
538 				  kobject_name(&obj->dev.kobj));
539 		acpi_dev_put(obj);
540 	}
541 
542 	kfree(resource->domain_devices);
543 	kobject_put(resource->holders_dir);
544 	resource->num_domain_devices = 0;
545 }
546 
547 static int read_domain_devices(struct acpi_power_meter_resource *resource)
548 {
549 	int res = 0;
550 	int i;
551 	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
552 	union acpi_object *pss;
553 	acpi_status status;
554 
555 	status = acpi_evaluate_object(resource->acpi_dev->handle, "_PMD", NULL,
556 				      &buffer);
557 	if (ACPI_FAILURE(status)) {
558 		acpi_evaluation_failure_warn(resource->acpi_dev->handle, "_PMD",
559 					     status);
560 		return -ENODEV;
561 	}
562 
563 	pss = buffer.pointer;
564 	if (!pss ||
565 	    pss->type != ACPI_TYPE_PACKAGE) {
566 		dev_err(&resource->acpi_dev->dev, ACPI_POWER_METER_NAME
567 			"Invalid _PMD data\n");
568 		res = -EFAULT;
569 		goto end;
570 	}
571 
572 	if (!pss->package.count)
573 		goto end;
574 
575 	resource->domain_devices = kcalloc(pss->package.count,
576 					   sizeof(struct acpi_device *),
577 					   GFP_KERNEL);
578 	if (!resource->domain_devices) {
579 		res = -ENOMEM;
580 		goto end;
581 	}
582 
583 	resource->holders_dir = kobject_create_and_add("measures",
584 						       &resource->acpi_dev->dev.kobj);
585 	if (!resource->holders_dir) {
586 		res = -ENOMEM;
587 		goto exit_free;
588 	}
589 
590 	resource->num_domain_devices = pss->package.count;
591 
592 	for (i = 0; i < pss->package.count; i++) {
593 		struct acpi_device *obj;
594 		union acpi_object *element = &pss->package.elements[i];
595 
596 		/* Refuse non-references */
597 		if (element->type != ACPI_TYPE_LOCAL_REFERENCE)
598 			continue;
599 
600 		/* Create a symlink to domain objects */
601 		obj = acpi_get_acpi_dev(element->reference.handle);
602 		resource->domain_devices[i] = obj;
603 		if (!obj)
604 			continue;
605 
606 		res = sysfs_create_link(resource->holders_dir, &obj->dev.kobj,
607 					kobject_name(&obj->dev.kobj));
608 		if (res) {
609 			acpi_dev_put(obj);
610 			resource->domain_devices[i] = NULL;
611 		}
612 	}
613 
614 	res = 0;
615 	goto end;
616 
617 exit_free:
618 	kfree(resource->domain_devices);
619 end:
620 	kfree(buffer.pointer);
621 	return res;
622 }
623 
624 /* Registration and deregistration */
625 static int register_attrs(struct acpi_power_meter_resource *resource,
626 			  struct sensor_template *attrs)
627 {
628 	struct device *dev = &resource->acpi_dev->dev;
629 	struct sensor_device_attribute *sensors =
630 		&resource->sensors[resource->num_sensors];
631 	int res = 0;
632 
633 	while (attrs->label) {
634 		sensors->dev_attr.attr.name = attrs->label;
635 		sensors->dev_attr.attr.mode = 0444;
636 		sensors->dev_attr.show = attrs->show;
637 		sensors->index = attrs->index;
638 
639 		if (attrs->set) {
640 			sensors->dev_attr.attr.mode |= 0200;
641 			sensors->dev_attr.store = attrs->set;
642 		}
643 
644 		sysfs_attr_init(&sensors->dev_attr.attr);
645 		res = device_create_file(dev, &sensors->dev_attr);
646 		if (res) {
647 			sensors->dev_attr.attr.name = NULL;
648 			goto error;
649 		}
650 		sensors++;
651 		resource->num_sensors++;
652 		attrs++;
653 	}
654 
655 error:
656 	return res;
657 }
658 
659 static void remove_attrs(struct acpi_power_meter_resource *resource)
660 {
661 	int i;
662 
663 	for (i = 0; i < resource->num_sensors; i++) {
664 		if (!resource->sensors[i].dev_attr.attr.name)
665 			continue;
666 		device_remove_file(&resource->acpi_dev->dev,
667 				   &resource->sensors[i].dev_attr);
668 	}
669 
670 	remove_domain_devices(resource);
671 
672 	resource->num_sensors = 0;
673 }
674 
675 static int setup_attrs(struct acpi_power_meter_resource *resource)
676 {
677 	int res = 0;
678 
679 	res = read_domain_devices(resource);
680 	if (res)
681 		return res;
682 
683 	if (resource->caps.flags & POWER_METER_CAN_MEASURE) {
684 		res = register_attrs(resource, meter_attrs);
685 		if (res)
686 			goto error;
687 	}
688 
689 	if (resource->caps.flags & POWER_METER_CAN_CAP) {
690 		if (!can_cap_in_hardware()) {
691 			dev_warn(&resource->acpi_dev->dev,
692 				 "Ignoring unsafe software power cap!\n");
693 			goto skip_unsafe_cap;
694 		}
695 
696 		if (resource->caps.configurable_cap)
697 			res = register_attrs(resource, rw_cap_attrs);
698 		else
699 			res = register_attrs(resource, ro_cap_attrs);
700 
701 		if (res)
702 			goto error;
703 
704 		res = register_attrs(resource, misc_cap_attrs);
705 		if (res)
706 			goto error;
707 	}
708 
709 skip_unsafe_cap:
710 	if (resource->caps.flags & POWER_METER_CAN_TRIP) {
711 		res = register_attrs(resource, trip_attrs);
712 		if (res)
713 			goto error;
714 	}
715 
716 	res = register_attrs(resource, misc_attrs);
717 	if (res)
718 		goto error;
719 
720 	return res;
721 error:
722 	remove_attrs(resource);
723 	return res;
724 }
725 
726 static void free_capabilities(struct acpi_power_meter_resource *resource)
727 {
728 	acpi_string *str;
729 	int i;
730 
731 	str = &resource->model_number;
732 	for (i = 0; i < 3; i++, str++) {
733 		kfree(*str);
734 		*str = NULL;
735 	}
736 }
737 
738 static int read_capabilities(struct acpi_power_meter_resource *resource)
739 {
740 	int res = 0;
741 	int i;
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;
746 	acpi_string *str;
747 	acpi_status status;
748 
749 	status = acpi_evaluate_object(resource->acpi_dev->handle, "_PMC", NULL,
750 				      &buffer);
751 	if (ACPI_FAILURE(status)) {
752 		acpi_evaluation_failure_warn(resource->acpi_dev->handle, "_PMC",
753 					     status);
754 		return -ENODEV;
755 	}
756 
757 	pss = buffer.pointer;
758 	if (!pss ||
759 	    pss->type != ACPI_TYPE_PACKAGE ||
760 	    pss->package.count != 14) {
761 		dev_err(&resource->acpi_dev->dev, ACPI_POWER_METER_NAME
762 			"Invalid _PMC data\n");
763 		res = -EFAULT;
764 		goto end;
765 	}
766 
767 	/* Grab all the integer data at once */
768 	state.length = sizeof(struct acpi_power_meter_capabilities);
769 	state.pointer = &resource->caps;
770 
771 	status = acpi_extract_package(pss, &format, &state);
772 	if (ACPI_FAILURE(status)) {
773 		dev_err(&resource->acpi_dev->dev, ACPI_POWER_METER_NAME
774 			"_PMC package parsing failed: %s\n",
775 			acpi_format_exception(status));
776 		res = -EFAULT;
777 		goto end;
778 	}
779 
780 	if (resource->caps.units) {
781 		dev_err(&resource->acpi_dev->dev, ACPI_POWER_METER_NAME
782 			"Unknown units %llu.\n",
783 			resource->caps.units);
784 		res = -EINVAL;
785 		goto end;
786 	}
787 
788 	/* Grab the string data */
789 	str = &resource->model_number;
790 
791 	for (i = 11; i < 14; i++) {
792 		union acpi_object *element = &pss->package.elements[i];
793 
794 		if (element->type != ACPI_TYPE_STRING) {
795 			res = -EINVAL;
796 			goto error;
797 		}
798 
799 		*str = kcalloc(element->string.length + 1, sizeof(u8),
800 			       GFP_KERNEL);
801 		if (!*str) {
802 			res = -ENOMEM;
803 			goto error;
804 		}
805 
806 		strncpy(*str, element->string.pointer, element->string.length);
807 		str++;
808 	}
809 
810 	dev_info(&resource->acpi_dev->dev, "Found ACPI power meter.\n");
811 	goto end;
812 error:
813 	free_capabilities(resource);
814 end:
815 	kfree(buffer.pointer);
816 	return res;
817 }
818 
819 /* Handle ACPI event notifications */
820 static void acpi_power_meter_notify(struct acpi_device *device, u32 event)
821 {
822 	struct acpi_power_meter_resource *resource;
823 	int res;
824 
825 	if (!device || !acpi_driver_data(device))
826 		return;
827 
828 	resource = acpi_driver_data(device);
829 
830 	switch (event) {
831 	case METER_NOTIFY_CONFIG:
832 		mutex_lock(&resource->lock);
833 		free_capabilities(resource);
834 		res = read_capabilities(resource);
835 		mutex_unlock(&resource->lock);
836 		if (res)
837 			break;
838 
839 		remove_attrs(resource);
840 		setup_attrs(resource);
841 		break;
842 	case METER_NOTIFY_TRIP:
843 		sysfs_notify(&device->dev.kobj, NULL, POWER_AVERAGE_NAME);
844 		break;
845 	case METER_NOTIFY_CAP:
846 		sysfs_notify(&device->dev.kobj, NULL, POWER_CAP_NAME);
847 		break;
848 	case METER_NOTIFY_INTERVAL:
849 		sysfs_notify(&device->dev.kobj, NULL, POWER_AVG_INTERVAL_NAME);
850 		break;
851 	case METER_NOTIFY_CAPPING:
852 		sysfs_notify(&device->dev.kobj, NULL, POWER_ALARM_NAME);
853 		dev_info(&device->dev, "Capping in progress.\n");
854 		break;
855 	default:
856 		WARN(1, "Unexpected event %d\n", event);
857 		break;
858 	}
859 
860 	acpi_bus_generate_netlink_event(ACPI_POWER_METER_CLASS,
861 					dev_name(&device->dev), event, 0);
862 }
863 
864 static int acpi_power_meter_add(struct acpi_device *device)
865 {
866 	int res;
867 	struct acpi_power_meter_resource *resource;
868 
869 	if (!device)
870 		return -EINVAL;
871 
872 	resource = kzalloc(sizeof(*resource), GFP_KERNEL);
873 	if (!resource)
874 		return -ENOMEM;
875 
876 	resource->sensors_valid = 0;
877 	resource->acpi_dev = device;
878 	mutex_init(&resource->lock);
879 	strcpy(acpi_device_name(device), ACPI_POWER_METER_DEVICE_NAME);
880 	strcpy(acpi_device_class(device), ACPI_POWER_METER_CLASS);
881 	device->driver_data = resource;
882 
883 	res = read_capabilities(resource);
884 	if (res)
885 		goto exit_free;
886 
887 	resource->trip[0] = -1;
888 	resource->trip[1] = -1;
889 
890 	res = setup_attrs(resource);
891 	if (res)
892 		goto exit_free_capability;
893 
894 	resource->hwmon_dev = hwmon_device_register(&device->dev);
895 	if (IS_ERR(resource->hwmon_dev)) {
896 		res = PTR_ERR(resource->hwmon_dev);
897 		goto exit_remove;
898 	}
899 
900 	res = 0;
901 	goto exit;
902 
903 exit_remove:
904 	remove_attrs(resource);
905 exit_free_capability:
906 	free_capabilities(resource);
907 exit_free:
908 	kfree(resource);
909 exit:
910 	return res;
911 }
912 
913 static void acpi_power_meter_remove(struct acpi_device *device)
914 {
915 	struct acpi_power_meter_resource *resource;
916 
917 	if (!device || !acpi_driver_data(device))
918 		return;
919 
920 	resource = acpi_driver_data(device);
921 	hwmon_device_unregister(resource->hwmon_dev);
922 
923 	remove_attrs(resource);
924 	free_capabilities(resource);
925 
926 	kfree(resource);
927 }
928 
929 static int acpi_power_meter_resume(struct device *dev)
930 {
931 	struct acpi_power_meter_resource *resource;
932 
933 	if (!dev)
934 		return -EINVAL;
935 
936 	resource = acpi_driver_data(to_acpi_device(dev));
937 	if (!resource)
938 		return -EINVAL;
939 
940 	free_capabilities(resource);
941 	read_capabilities(resource);
942 
943 	return 0;
944 }
945 
946 static DEFINE_SIMPLE_DEV_PM_OPS(acpi_power_meter_pm, NULL,
947 				acpi_power_meter_resume);
948 
949 static struct acpi_driver acpi_power_meter_driver = {
950 	.name = "power_meter",
951 	.class = ACPI_POWER_METER_CLASS,
952 	.ids = power_meter_ids,
953 	.ops = {
954 		.add = acpi_power_meter_add,
955 		.remove = acpi_power_meter_remove,
956 		.notify = acpi_power_meter_notify,
957 		},
958 	.drv.pm = pm_sleep_ptr(&acpi_power_meter_pm),
959 };
960 
961 /* Module init/exit routines */
962 static int __init enable_cap_knobs(const struct dmi_system_id *d)
963 {
964 	cap_in_hardware = 1;
965 	return 0;
966 }
967 
968 static const struct dmi_system_id pm_dmi_table[] __initconst = {
969 	{
970 		enable_cap_knobs, "IBM Active Energy Manager",
971 		{
972 			DMI_MATCH(DMI_SYS_VENDOR, "IBM")
973 		},
974 	},
975 	{}
976 };
977 
978 static int __init acpi_power_meter_init(void)
979 {
980 	int result;
981 
982 	if (acpi_disabled)
983 		return -ENODEV;
984 
985 	dmi_check_system(pm_dmi_table);
986 
987 	result = acpi_bus_register_driver(&acpi_power_meter_driver);
988 	if (result < 0)
989 		return result;
990 
991 	return 0;
992 }
993 
994 static void __exit acpi_power_meter_exit(void)
995 {
996 	acpi_bus_unregister_driver(&acpi_power_meter_driver);
997 }
998 
999 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
1000 MODULE_DESCRIPTION("ACPI 4.0 power meter driver");
1001 MODULE_LICENSE("GPL");
1002 
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.");
1005 
1006 module_init(acpi_power_meter_init);
1007 module_exit(acpi_power_meter_exit);
1008