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