Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/hwmon/acpi_power_meter.c

  1 /*
  2  * A hwmon driver for ACPI 4.0 power meters
  3  * Copyright (C) 2009 IBM
  4  *
  5  * Author: Darrick J. Wong <darrick.wong@oracle.com>
  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 <linux/acpi.h>
 34 
 35 #define ACPI_POWER_METER_NAME           "power_meter"
 36 ACPI_MODULE_NAME(ACPI_POWER_METER_NAME);
 37 #define ACPI_POWER_METER_DEVICE_NAME    "Power Meter"
 38 #define ACPI_POWER_METER_CLASS          "pwr_meter_resource"
 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 
 60 static int cap_in_hardware;
 61 static bool force_cap_on;
 62 
 63 static int can_cap_in_hardware(void)
 64 {
 65         return force_cap_on || cap_in_hardware;
 66 }
 67 
 68 static const struct acpi_device_id power_meter_ids[] = {
 69         {"ACPI000D", 0},
 70         {"", 0},
 71 };
 72 MODULE_DEVICE_TABLE(acpi, power_meter_ids);
 73 
 74 struct 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 
 88 struct 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 
110 struct 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 /* Averaging interval */
122 static 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 
138 static 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 
152 static 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         /* _PAI returns 0 on success, nonzero otherwise */
187         if (data)
188                 return -EINVAL;
189 
190         return count;
191 }
192 
193 /* Cap functions */
194 static 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 
210 static 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 
224 static 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         /* _SHL returns 0 on success, nonzero otherwise */
258         if (data)
259                 return -EINVAL;
260 
261         return count;
262 }
263 
264 /* Power meter trip points */
265 static 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         /* Both trip levels must be set */
276         if (resource->trip[0] < 0 || resource->trip[1] < 0)
277                 return 0;
278 
279         /* This driver stores min, max; ACPI wants max, min. */
280         arg_objs[0].integer.value = resource->trip[1];
281         arg_objs[1].integer.value = resource->trip[0];
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         /* _PTP returns 0 on success, nonzero otherwise */
291         if (data)
292                 return -EINVAL;
293 
294         return 0;
295 }
296 
297 static 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 /* Power meter */
324 static 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 
348 static 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 /* Miscellaneous */
363 static 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 
392 static 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 
448 static 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 
459 static 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 /* Sensor descriptions.  If you add a sensor, update NUM_SENSORS above! */
482 static 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 
493 static 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 
501 static struct sensor_template ro_cap_attrs[] = {
502         RO_SENSOR_TEMPLATE(POWER_CAP_NAME, show_cap, 0),
503         {},
504 };
505 
506 static struct sensor_template rw_cap_attrs[] = {
507         RW_SENSOR_TEMPLATE(POWER_CAP_NAME, show_cap, set_cap, 0),
508         {},
509 };
510 
511 static 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 
517 static 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 /* Read power domain data */
529 static 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 
551 static 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 = kzalloc(sizeof(struct acpi_device *) *
579                                            pss->package.count, GFP_KERNEL);
580         if (!resource->domain_devices) {
581                 res = -ENOMEM;
582                 goto end;
583         }
584 
585         resource->holders_dir = kobject_create_and_add("measures",
586                                         &resource->acpi_dev->dev.kobj);
587         if (!resource->holders_dir) {
588                 res = -ENOMEM;
589                 goto exit_free;
590         }
591 
592         resource->num_domain_devices = pss->package.count;
593 
594         for (i = 0; i < pss->package.count; i++) {
595                 struct acpi_device *obj;
596                 union acpi_object *element = &(pss->package.elements[i]);
597 
598                 /* Refuse non-references */
599                 if (element->type != ACPI_TYPE_LOCAL_REFERENCE)
600                         continue;
601 
602                 /* Create a symlink to domain objects */
603                 resource->domain_devices[i] = NULL;
604                 if (acpi_bus_get_device(element->reference.handle,
605                                         &resource->domain_devices[i]))
606                         continue;
607 
608                 obj = resource->domain_devices[i];
609                 get_device(&obj->dev);
610 
611                 res = sysfs_create_link(resource->holders_dir, &obj->dev.kobj,
612                                       kobject_name(&obj->dev.kobj));
613                 if (res) {
614                         put_device(&obj->dev);
615                         resource->domain_devices[i] = NULL;
616                 }
617         }
618 
619         res = 0;
620         goto end;
621 
622 exit_free:
623         kfree(resource->domain_devices);
624 end:
625         kfree(buffer.pointer);
626         return res;
627 }
628 
629 /* Registration and deregistration */
630 static int register_attrs(struct acpi_power_meter_resource *resource,
631                           struct sensor_template *attrs)
632 {
633         struct device *dev = &resource->acpi_dev->dev;
634         struct sensor_device_attribute *sensors =
635                 &resource->sensors[resource->num_sensors];
636         int res = 0;
637 
638         while (attrs->label) {
639                 sensors->dev_attr.attr.name = attrs->label;
640                 sensors->dev_attr.attr.mode = S_IRUGO;
641                 sensors->dev_attr.show = attrs->show;
642                 sensors->index = attrs->index;
643 
644                 if (attrs->set) {
645                         sensors->dev_attr.attr.mode |= S_IWUSR;
646                         sensors->dev_attr.store = attrs->set;
647                 }
648 
649                 sysfs_attr_init(&sensors->dev_attr.attr);
650                 res = device_create_file(dev, &sensors->dev_attr);
651                 if (res) {
652                         sensors->dev_attr.attr.name = NULL;
653                         goto error;
654                 }
655                 sensors++;
656                 resource->num_sensors++;
657                 attrs++;
658         }
659 
660 error:
661         return res;
662 }
663 
664 static void remove_attrs(struct acpi_power_meter_resource *resource)
665 {
666         int i;
667 
668         for (i = 0; i < resource->num_sensors; i++) {
669                 if (!resource->sensors[i].dev_attr.attr.name)
670                         continue;
671                 device_remove_file(&resource->acpi_dev->dev,
672                                    &resource->sensors[i].dev_attr);
673         }
674 
675         remove_domain_devices(resource);
676 
677         resource->num_sensors = 0;
678 }
679 
680 static int setup_attrs(struct acpi_power_meter_resource *resource)
681 {
682         int res = 0;
683 
684         res = read_domain_devices(resource);
685         if (res)
686                 return res;
687 
688         if (resource->caps.flags & POWER_METER_CAN_MEASURE) {
689                 res = register_attrs(resource, meter_attrs);
690                 if (res)
691                         goto error;
692         }
693 
694         if (resource->caps.flags & POWER_METER_CAN_CAP) {
695                 if (!can_cap_in_hardware()) {
696                         dev_err(&resource->acpi_dev->dev,
697                                 "Ignoring unsafe software power cap!\n");
698                         goto skip_unsafe_cap;
699                 }
700 
701                 if (resource->caps.configurable_cap)
702                         res = register_attrs(resource, rw_cap_attrs);
703                 else
704                         res = register_attrs(resource, ro_cap_attrs);
705 
706                 if (res)
707                         goto error;
708 
709                 res = register_attrs(resource, misc_cap_attrs);
710                 if (res)
711                         goto error;
712         }
713 
714 skip_unsafe_cap:
715         if (resource->caps.flags & POWER_METER_CAN_TRIP) {
716                 res = register_attrs(resource, trip_attrs);
717                 if (res)
718                         goto error;
719         }
720 
721         res = register_attrs(resource, misc_attrs);
722         if (res)
723                 goto error;
724 
725         return res;
726 error:
727         remove_attrs(resource);
728         return res;
729 }
730 
731 static void free_capabilities(struct acpi_power_meter_resource *resource)
732 {
733         acpi_string *str;
734         int i;
735 
736         str = &resource->model_number;
737         for (i = 0; i < 3; i++, str++)
738                 kfree(*str);
739 }
740 
741 static int read_capabilities(struct acpi_power_meter_resource *resource)
742 {
743         int res = 0;
744         int i;
745         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
746         struct acpi_buffer state = { 0, NULL };
747         struct acpi_buffer format = { sizeof("NNNNNNNNNNN"), "NNNNNNNNNNN" };
748         union acpi_object *pss;
749         acpi_string *str;
750         acpi_status status;
751 
752         status = acpi_evaluate_object(resource->acpi_dev->handle, "_PMC", NULL,
753                                       &buffer);
754         if (ACPI_FAILURE(status)) {
755                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PMC"));
756                 return -ENODEV;
757         }
758 
759         pss = buffer.pointer;
760         if (!pss ||
761             pss->type != ACPI_TYPE_PACKAGE ||
762             pss->package.count != 14) {
763                 dev_err(&resource->acpi_dev->dev, ACPI_POWER_METER_NAME
764                         "Invalid _PMC data\n");
765                 res = -EFAULT;
766                 goto end;
767         }
768 
769         /* Grab all the integer data at once */
770         state.length = sizeof(struct acpi_power_meter_capabilities);
771         state.pointer = &resource->caps;
772 
773         status = acpi_extract_package(pss, &format, &state);
774         if (ACPI_FAILURE(status)) {
775                 ACPI_EXCEPTION((AE_INFO, status, "Invalid data"));
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 = kzalloc(sizeof(u8) * (element->string.length + 1),
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         str = &resource->model_number;
814         for (i = 0; i < 3; i++, str++)
815                 kfree(*str);
816 end:
817         kfree(buffer.pointer);
818         return res;
819 }
820 
821 /* Handle ACPI event notifications */
822 static void acpi_power_meter_notify(struct acpi_device *device, u32 event)
823 {
824         struct acpi_power_meter_resource *resource;
825         int res;
826 
827         if (!device || !acpi_driver_data(device))
828                 return;
829 
830         resource = acpi_driver_data(device);
831 
832         mutex_lock(&resource->lock);
833         switch (event) {
834         case METER_NOTIFY_CONFIG:
835                 free_capabilities(resource);
836                 res = read_capabilities(resource);
837                 if (res)
838                         break;
839 
840                 remove_attrs(resource);
841                 setup_attrs(resource);
842                 break;
843         case METER_NOTIFY_TRIP:
844                 sysfs_notify(&device->dev.kobj, NULL, POWER_AVERAGE_NAME);
845                 update_meter(resource);
846                 break;
847         case METER_NOTIFY_CAP:
848                 sysfs_notify(&device->dev.kobj, NULL, POWER_CAP_NAME);
849                 update_cap(resource);
850                 break;
851         case METER_NOTIFY_INTERVAL:
852                 sysfs_notify(&device->dev.kobj, NULL, POWER_AVG_INTERVAL_NAME);
853                 update_avg_interval(resource);
854                 break;
855         case METER_NOTIFY_CAPPING:
856                 sysfs_notify(&device->dev.kobj, NULL, POWER_ALARM_NAME);
857                 dev_info(&device->dev, "Capping in progress.\n");
858                 break;
859         default:
860                 WARN(1, "Unexpected event %d\n", event);
861                 break;
862         }
863         mutex_unlock(&resource->lock);
864 
865         acpi_bus_generate_netlink_event(ACPI_POWER_METER_CLASS,
866                                         dev_name(&device->dev), event, 0);
867 }
868 
869 static int acpi_power_meter_add(struct acpi_device *device)
870 {
871         int res;
872         struct acpi_power_meter_resource *resource;
873 
874         if (!device)
875                 return -EINVAL;
876 
877         resource = kzalloc(sizeof(struct acpi_power_meter_resource),
878                            GFP_KERNEL);
879         if (!resource)
880                 return -ENOMEM;
881 
882         resource->sensors_valid = 0;
883         resource->acpi_dev = device;
884         mutex_init(&resource->lock);
885         strcpy(acpi_device_name(device), ACPI_POWER_METER_DEVICE_NAME);
886         strcpy(acpi_device_class(device), ACPI_POWER_METER_CLASS);
887         device->driver_data = resource;
888 
889         free_capabilities(resource);
890         res = read_capabilities(resource);
891         if (res)
892                 goto exit_free;
893 
894         resource->trip[0] = resource->trip[1] = -1;
895 
896         res = setup_attrs(resource);
897         if (res)
898                 goto exit_free;
899 
900         resource->hwmon_dev = hwmon_device_register(&device->dev);
901         if (IS_ERR(resource->hwmon_dev)) {
902                 res = PTR_ERR(resource->hwmon_dev);
903                 goto exit_remove;
904         }
905 
906         res = 0;
907         goto exit;
908 
909 exit_remove:
910         remove_attrs(resource);
911 exit_free:
912         kfree(resource);
913 exit:
914         return res;
915 }
916 
917 static int acpi_power_meter_remove(struct acpi_device *device)
918 {
919         struct acpi_power_meter_resource *resource;
920 
921         if (!device || !acpi_driver_data(device))
922                 return -EINVAL;
923 
924         resource = acpi_driver_data(device);
925         hwmon_device_unregister(resource->hwmon_dev);
926 
927         free_capabilities(resource);
928         remove_attrs(resource);
929 
930         kfree(resource);
931         return 0;
932 }
933 
934 #ifdef CONFIG_PM_SLEEP
935 
936 static int acpi_power_meter_resume(struct device *dev)
937 {
938         struct acpi_power_meter_resource *resource;
939 
940         if (!dev)
941                 return -EINVAL;
942 
943         resource = acpi_driver_data(to_acpi_device(dev));
944         if (!resource)
945                 return -EINVAL;
946 
947         free_capabilities(resource);
948         read_capabilities(resource);
949 
950         return 0;
951 }
952 
953 #endif /* CONFIG_PM_SLEEP */
954 
955 static SIMPLE_DEV_PM_OPS(acpi_power_meter_pm, NULL, acpi_power_meter_resume);
956 
957 static struct acpi_driver acpi_power_meter_driver = {
958         .name = "power_meter",
959         .class = ACPI_POWER_METER_CLASS,
960         .ids = power_meter_ids,
961         .ops = {
962                 .add = acpi_power_meter_add,
963                 .remove = acpi_power_meter_remove,
964                 .notify = acpi_power_meter_notify,
965                 },
966         .drv.pm = &acpi_power_meter_pm,
967 };
968 
969 /* Module init/exit routines */
970 static int __init enable_cap_knobs(const struct dmi_system_id *d)
971 {
972         cap_in_hardware = 1;
973         return 0;
974 }
975 
976 static struct dmi_system_id __initdata pm_dmi_table[] = {
977         {
978                 enable_cap_knobs, "IBM Active Energy Manager",
979                 {
980                         DMI_MATCH(DMI_SYS_VENDOR, "IBM")
981                 },
982         },
983         {}
984 };
985 
986 static int __init acpi_power_meter_init(void)
987 {
988         int result;
989 
990         if (acpi_disabled)
991                 return -ENODEV;
992 
993         dmi_check_system(pm_dmi_table);
994 
995         result = acpi_bus_register_driver(&acpi_power_meter_driver);
996         if (result < 0)
997                 return result;
998 
999         return 0;
1000 }
1001 
1002 static void __exit acpi_power_meter_exit(void)
1003 {
1004         acpi_bus_unregister_driver(&acpi_power_meter_driver);
1005 }
1006 
1007 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>");
1008 MODULE_DESCRIPTION("ACPI 4.0 power meter driver");
1009 MODULE_LICENSE("GPL");
1010 
1011 module_param(force_cap_on, bool, 0644);
1012 MODULE_PARM_DESC(force_cap_on, "Enable power cap even it is unsafe to do so.");
1013 
1014 module_init(acpi_power_meter_init);
1015 module_exit(acpi_power_meter_exit);
1016 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us