firmware: Basic dmi-sysfs support

Introduce a new module "dmi-sysfs" that exports the broken out entries
of the DMI table through sysfs.

Entries are enumerated via dmi_walk() on module load, and are populated
as kobjects rooted at /sys/firmware/dmi/entries.

Entries are named "<type>-<instance>", where:
   <type>	: is the type of the entry, and
   <instance>	: is the ordinal count within the DMI table of that
		  entry type.  This instance is used in lieu the DMI
		  entry's handle as no assurances are made by the kernel
		  that handles are unique.

All entries export the following attributes:
   length	: The length of the formatted portion of the entry
   handle	: The handle given to this entry by the firmware
   raw		: The raw bytes of the entire entry, including the
		  formatted portion, the unformatted (strings) portion,
		  and the two terminating nul characters.
   type		: The DMI entry type
   instance	: The ordinal instance of this entry given its type.
   position	: The position ordinal of the entry within the table in
		  its entirety.

Entries in dmi-sysfs are kobject backed members called "struct
dmi_sysfs_entry" and belong to dmi_kset.  They are threaded through
entry_list (protected by entry_list_lock) so that we can find them at
cleanup time.

Signed-off-by: Mike Waychison <mikew@google.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

3 files changed, 408 insertions, 0 deletions

diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index e710424b59ea..3c56afc5eb1b 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -113,6 +113,17 @@ config DMIID
           information from userspace through /sys/class/dmi/id/ or if you want
           DMI-based module auto-loading.
 
+config DMI_SYSFS
+        tristate "DMI table support in sysfs"
+        depends on SYSFS && DMI
+        default n
+        help
+          Say Y or M here to enable the exporting of the raw DMI table
+          data via sysfs.  This is useful for consuming the data without
+          requiring any access to /dev/mem at all.  Tables are found
+          under /sys/firmware/dmi when this option is enabled and
+          loaded.
+
 config ISCSI_IBFT_FIND
         bool "iSCSI Boot Firmware Table Attributes"
         depends on X86
diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile
index 1c3c17343dbe..20c17fca1232 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -2,6 +2,7 @@
 # Makefile for the linux kernel.
 #
 obj-$(CONFIG_DMI)               += dmi_scan.o
+obj-$(CONFIG_DMI_SYSFS)         += dmi-sysfs.o
 obj-$(CONFIG_EDD)               += edd.o
 obj-$(CONFIG_EFI_VARS)          += efivars.o
 obj-$(CONFIG_EFI_PCDP)          += pcdp.o
diff --git a/drivers/firmware/dmi-sysfs.c b/drivers/firmware/dmi-sysfs.c
new file mode 100644
index 000000000000..2d8a04a95085
--- /dev/null
+++ b/drivers/firmware/dmi-sysfs.c
@@ -0,0 +1,396 @@
+/*
+ * dmi-sysfs.c
+ *
+ * This module exports the DMI tables read-only to userspace through the
+ * sysfs file system.
+ *
+ * Data is currently found below
+ *    /sys/firmware/dmi/...
+ *
+ * DMI attributes are presented in attribute files with names
+ * formatted using %d-%d, so that the first integer indicates the
+ * structure type (0-255), and the second field is the instance of that
+ * entry.
+ *
+ * Copyright 2011 Google, Inc.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kobject.h>
+#include <linux/dmi.h>
+#include <linux/capability.h>
+#include <linux/slab.h>
+#include <linux/list.h>
+#include <linux/io.h>
+
+#define MAX_ENTRY_TYPE 255 /* Most of these aren't used, but we consider
+                              the top entry type is only 8 bits */
+
+struct dmi_sysfs_entry {
+        struct dmi_header dh;
+        struct kobject kobj;
+        int instance;
+        int position;
+        struct list_head list;
+};
+
+/*
+ * Global list of dmi_sysfs_entry.  Even though this should only be
+ * manipulated at setup and teardown, the lazy nature of the kobject
+ * system means we get lazy removes.
+ */
+static LIST_HEAD(entry_list);
+static DEFINE_SPINLOCK(entry_list_lock);
+
+/* dmi_sysfs_attribute - Top level attribute. used by all entries. */
+struct dmi_sysfs_attribute {
+        struct attribute attr;
+        ssize_t (*show)(struct dmi_sysfs_entry *entry, char *buf);
+};
+
+#define DMI_SYSFS_ATTR(_entry, _name) \
+struct dmi_sysfs_attribute dmi_sysfs_attr_##_entry##_##_name = { \
+        .attr = {.name = __stringify(_name), .mode = 0400}, \
+        .show = dmi_sysfs_##_entry##_##_name, \
+}
+
+/*
+ * dmi_sysfs_mapped_attribute - Attribute where we require the entry be
+ * mapped in.  Use in conjunction with dmi_sysfs_specialize_attr_ops.
+ */
+struct dmi_sysfs_mapped_attribute {
+        struct attribute attr;
+        ssize_t (*show)(struct dmi_sysfs_entry *entry,
+                        const struct dmi_header *dh,
+                        char *buf);
+};
+
+#define DMI_SYSFS_MAPPED_ATTR(_entry, _name) \
+struct dmi_sysfs_mapped_attribute dmi_sysfs_attr_##_entry##_##_name = { \
+        .attr = {.name = __stringify(_name), .mode = 0400}, \
+        .show = dmi_sysfs_##_entry##_##_name, \
+}
+
+/*************************************************
+ * Generic DMI entry support.
+ *************************************************/
+
+static struct dmi_sysfs_entry *to_entry(struct kobject *kobj)
+{
+        return container_of(kobj, struct dmi_sysfs_entry, kobj);
+}
+
+static struct dmi_sysfs_attribute *to_attr(struct attribute *attr)
+{
+        return container_of(attr, struct dmi_sysfs_attribute, attr);
+}
+
+static ssize_t dmi_sysfs_attr_show(struct kobject *kobj,
+                                   struct attribute *_attr, char *buf)
+{
+        struct dmi_sysfs_entry *entry = to_entry(kobj);
+        struct dmi_sysfs_attribute *attr = to_attr(_attr);
+
+        /* DMI stuff is only ever admin visible */
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        return attr->show(entry, buf);
+}
+
+static const struct sysfs_ops dmi_sysfs_attr_ops = {
+        .show = dmi_sysfs_attr_show,
+};
+
+typedef ssize_t (*dmi_callback)(struct dmi_sysfs_entry *,
+                                const struct dmi_header *dh, void *);
+
+struct find_dmi_data {
+        struct dmi_sysfs_entry  *entry;
+        dmi_callback            callback;
+        void                    *private;
+        int                     instance_countdown;
+        ssize_t                 ret;
+};
+
+static void find_dmi_entry_helper(const struct dmi_header *dh,
+                                  void *_data)
+{
+        struct find_dmi_data *data = _data;
+        struct dmi_sysfs_entry *entry = data->entry;
+
+        /* Is this the entry we want? */
+        if (dh->type != entry->dh.type)
+                return;
+
+        if (data->instance_countdown != 0) {
+                /* try the next instance? */
+                data->instance_countdown--;
+                return;
+        }
+
+        /*
+         * Don't ever revisit the instance.  Short circuit later
+         * instances by letting the instance_countdown run negative
+         */
+        data->instance_countdown--;
+
+        /* Found the entry */
+        data->ret = data->callback(entry, dh, data->private);
+}
+
+/* State for passing the read parameters through dmi_find_entry() */
+struct dmi_read_state {
+        char *buf;
+        loff_t pos;
+        size_t count;
+};
+
+static ssize_t find_dmi_entry(struct dmi_sysfs_entry *entry,
+                              dmi_callback callback, void *private)