CHROMIUMOS: chromeos_acpi: Introduce ability to handle buffers.

drivers/platform/x86/chromeos_acpi.c

 /*
  *  chromeos_acpi.c - ChromeOS specific ACPI support
  *
  *
  * Copyright (C) 2011 The Chromium OS Authors
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
@@ skipping 18 matching lines @@
  * All values are presented in the string form (numbers as decimal values) and
  * can be accessed as the contents of the appropriate read only files in the
  * sysfs directory tree originating in /sys/devices/platform/chromeos_acpi.
  */
 
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/acpi.h>
 
-MODULE_AUTHOR("Google Inc.");
-MODULE_DESCRIPTION("Chrome OS Extras Driver");
-MODULE_LICENSE("GPL");
+#include "chromeos_acpi.h"
 
 #define MY_LOGPREFIX "chromeos_acpi: "
 #define MY_ERR KERN_ERR MY_LOGPREFIX
 #define MY_NOTICE KERN_NOTICE MY_LOGPREFIX
 #define MY_INFO KERN_INFO MY_LOGPREFIX
 
 /* ACPI method name for MLST; the response for this method is a
  * package of strings listing the methods which should be reflected in
  * sysfs. */
 #define MLST_METHOD "MLST"
@@ skipping 54 matching lines @@
  */
 struct chromeos_acpi_dev {
         struct platform_device *p_dev;
         struct acpi_attribute *attributes;
         struct acpi_attribute_group *groups;
 };
 
 static struct chromeos_acpi_dev chromeos_acpi = { };
 
 
-/* Values set at probe time */
-int chromeos_acpi_chnv = -1;
-int chromeos_acpi_chsw = -1;
-
-bool chromeos_acpi_available;
-
-
 /*
  * To show attribute value just access the container structure's `value'
  * field.
  */
 static ssize_t show_acpi_attribute(struct device *dev,
                                    struct device_attribute *attr, char *buf)
 {
         struct acpi_attribute *paa;
 
         paa = container_of(attr, struct acpi_attribute, dev_attr);
@@ skipping 194 matching lines @@
                                element->type);
                         continue;
                 }
                 aag->ag.attrs[j++] = &paa->dev_attr.attr;
         }
 
         if (sysfs_create_group(&chromeos_acpi.p_dev->dev.kobj, &aag->ag))
                 printk(MY_ERR "failed to create group %s.%d\n", pm, instance);
 }
 
+
+#ifdef CONFIG_CHROMEOS
 /*
  * handle_single_int() extract a single int value
  *
  * @po: package contents as returned by ACPI
  * @found:      integer pointer to store the value in
  *
  */
 static void handle_single_int(union acpi_object *po, int *found)
 {
         union acpi_object *element = po->package.elements;
 
         if (!element) {
                 WARN_ON(1);
                 return;
         }
 
         if (element->type == ACPI_TYPE_INTEGER)
                 *found = (int) element->integer.value;
         else
                 printk(MY_ERR "acpi_object unexpected type %d, expected int\n",
                        element->type);
 }
-
+#endif
 
 /*
  * handle_acpi_package() create sysfs group including attributes
  *                       representing an ACPI package.
  *
  * @po: package contents as returned by ACPI
  * @pm: name of the group
  *
  * Scalar objects included in the package get sys fs attributes created for
  * them. Nested packages are passed to a function creating a sys fs group per
@@ skipping 16 matching lines @@
                         break;
 
                 case ACPI_TYPE_STRING:
                         copy_size = min(element->string.length,
                                         sizeof(attr_value) - 1);
                         memcpy(attr_value, element->string.pointer, copy_size);
                         attr_value[copy_size] = '\0';
                         add_sysfs_attribute(attr_value, pm, count, j);
                         break;
 
+                case ACPI_TYPE_BUFFER: {
+                        char *base, *p;
+                        int i;
+                        unsigned room_left;
+                        /* Include this many characters per line */
+                        unsigned char_per_line = 16;
+                        unsigned string_buffer_size =
+                                /* three characters to display one byte */
+                                element->buffer.length * 3 +
+                                /* one newline per line, all rounded up, plus
+                                 * extra newline in the end, plus terminating
+                                 * zero, hence + 4
+                                 */
+                                element->buffer.length/char_per_line + 4;
+
+                        if (string_buffer_size > sizeof(attr_value)) {
+                                p = kzalloc(string_buffer_size, GFP_KERNEL);
+                                if (!p) {
+                                        printk(MY_ERR "out of memory in %s!\n",
+                                               __func__);
+                                        break;
+                                }
+                        } else {
+                                p = attr_value;
+                        }
+
+                        base = p;
+                        room_left = string_buffer_size;
+                        for (i = 0; i < element->buffer.length; i++) {
+                                int printed;
+                                printed = snprintf(p, room_left, " %2.2x",
+                                                   element->buffer.pointer[i]);
+                                room_left -= printed;
+                                p += printed;
+                                if (((i + 1) % char_per_line) == 0) {
+                                        if (!room_left)
+                                                break;
+                                        room_left--;
+                                        *p++ = '\n';
+                                }
+                        }
+                        if (room_left < 2) {
+                                printk(MY_ERR "%s: no room in the buffer!\n",
+                                       __func__);
+                                *p = '\0';
+                        } else {
+                                *p++ = '\n';
+                                *p++ = '\0';
+                        }
+                        add_sysfs_attribute(base, pm, count, j);
+                        if (string_buffer_size > sizeof(attr_value))
+                                kfree(p);
+                        break;
+                }
                 case ACPI_TYPE_PACKAGE:
                         handle_nested_acpi_package(element, pm, count, j);
                         break;
 
                 default:
-                        printk(MY_ERR "ignoring type %d\n", element->type);
+                        printk(MY_ERR "ignoring type %d (%s)\n",
+                               element->type, pm);
                         break;
                 }
         }
 }
 
 
 /*
  * add_acpi_method() evaluate an ACPI method and create sysfs attributes.
  *
  * @device: ACPI device
@@ skipping 14 matching lines @@
                 printk(MY_ERR "failed to retrieve %s (%d)\n", pm, status);
                 return;
         }
 
         po = output.pointer;
 
         if (po->type != ACPI_TYPE_PACKAGE)
                 printk(MY_ERR "%s is not a package, ignored\n", pm);
         else
                 handle_acpi_package(po, pm);
-
+#ifdef CONFIG_CHROMEOS
         /* Need to export a couple of variables to chromeos.c */
         if (!strncmp(pm, "CHNV", 4))
                 handle_single_int(po, &chromeos_acpi_chnv);
         else if (!strncmp(pm, "CHSW", 4))
                 handle_single_int(po, &chromeos_acpi_chsw);
-
+#endif
         kfree(output.pointer);
 }
 
 /*
  * chromeos_process_mlst() Evaluate the MLST method and add methods listed
  *                         in the response.
  *
  * @device: ACPI device
  *
  * Returns: 0 if successful, non-zero if error.
@@ skipping 22 matching lines @@
                 kfree(output.pointer);
                 return -EINVAL;
         }
 
         for (j = 0; j < po->package.count; j++) {
                 union acpi_object *element = po->package.elements + j;
                 int copy_size = 0;
                 char method[ACPI_NAME_SIZE + 1];
 
                 if (element->type == ACPI_TYPE_STRING) {
-                        copy_size = min(element->string.length, ACPI_NAME_SIZE);
+                        copy_size = min(element->string.length,
+                                        (u32)ACPI_NAME_SIZE);
                         memcpy(method, element->string.pointer, copy_size);
                         method[copy_size] = '\0';
                         add_acpi_method(device, method);
                 } else {
                         pr_debug(MY_LOGPREFIX "ignoring type %d\n",
                                  element->type);
                 }
         }
 
         kfree(output.pointer);
@@ skipping 35 matching lines @@
         }
 
         ret = acpi_bus_register_driver(&chromeos_acpi_driver);
         if (ret < 0) {
                 printk(MY_ERR "failed to register driver (%d)\n", ret);
                 platform_device_unregister(chromeos_acpi.p_dev);
                 chromeos_acpi.p_dev = NULL;
                 return ret;
         }
 
+#ifdef CONFIG_CHROMEOS
         chromeos_acpi_available = true;
-
+#endif
         return 0;
 }
-subsys_initcall(chromeos_acpi_init);
+
+static void chromeos_acpi_exit(void)
+{
+#ifdef CONFIG_CHROMEOS
+        chromeos_acpi_available = false;
+#endif
+        acpi_bus_unregister_driver(&chromeos_acpi_driver);
+
+        while (chromeos_acpi.groups) {
+                struct acpi_attribute_group *aag;
+                aag = chromeos_acpi.groups;
+                chromeos_acpi.groups = aag->next_acpi_attr_group;
+                sysfs_remove_group(&chromeos_acpi.p_dev->dev.kobj, &aag->ag);
+                kfree(aag);
+        }
+
+        while (chromeos_acpi.attributes) {
+                struct acpi_attribute *aa = chromeos_acpi.attributes;
+                chromeos_acpi.attributes = aa->next_acpi_attr;
+                device_remove_file(&chromeos_acpi.p_dev->dev, &aa->dev_attr);
+                kfree(aa);
+        }
+
+        platform_device_unregister(chromeos_acpi.p_dev);
+        printk(MY_INFO "removed\n");
+}
+
+module_init(chromeos_acpi_init);
+module_exit(chromeos_acpi_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Google Inc.");
+MODULE_DESCRIPTION("Chrome OS ACPI Driver");