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