Merge tag 'char-misc-4.18-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc

Pull char/misc driver updates from Greg KH:
 "Here is the "big" char and misc driver patches for 4.18-rc1.

  It's not a lot of stuff here, but there are some highlights:

   - coreboot driver updates

   - soundwire driver updates

   - android binder updates

   - fpga big sync, mostly documentation

   - lots of minor driver updates

  All of these have been in linux-next for a while with no reported
  issues"

* tag 'char-misc-4.18-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc: (81 commits)
  vmw_balloon: fixing double free when batching mode is off
  MAINTAINERS: Add driver-api/fpga path
  fpga: clarify that unregister functions also free
  documentation: fpga: move fpga-region.txt to driver-api
  documentation: fpga: add bridge document to driver-api
  documentation: fpga: move fpga-mgr.txt to driver-api
  Documentation: fpga: move fpga overview to driver-api
  fpga: region: kernel-doc fixes
  fpga: bridge: kernel-doc fixes
  fpga: mgr: kernel-doc fixes
  fpga: use SPDX
  fpga: region: change api, add fpga_region_create/free
  fpga: bridge: change api, don't use drvdata
  fpga: manager: change api, don't use drvdata
  fpga: region: don't use drvdata in common fpga code
  Drivers: hv: vmbus: Removed an unnecessary cast from void *
  ver_linux: Drop redundant calls to system() to test if file is readable
  ver_linux: Move stderr redirection from function parameter to function body
  misc: IBM Virtual Management Channel Driver (VMC)
  rpmsg: Correct support for MODULE_DEVICE_TABLE()
  ...

1 files changed, 97 insertions, 33 deletions

diff --git a/drivers/firmware/google/coreboot_table.c b/drivers/firmware/google/coreboot_table.c
index 0019d3ec18dd..19db5709ae28 100644
--- a/drivers/firmware/google/coreboot_table.c
+++ b/drivers/firmware/google/coreboot_table.c
@@ -4,6 +4,7 @@
  * Module providing coreboot table access.
  *
  * Copyright 2017 Google Inc.
+ * Copyright 2017 Samuel Holland <samuel@sholland.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License v2.0 as published by
@@ -15,37 +16,96 @@
  * GNU General Public License for more details.
  */
 
+#include <linux/device.h>
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/io.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 
 #include "coreboot_table.h"
 
-struct coreboot_table_entry {
-        u32 tag;
-        u32 size;
-};
+#define CB_DEV(d) container_of(d, struct coreboot_device, dev)
+#define CB_DRV(d) container_of(d, struct coreboot_driver, drv)
 
 static struct coreboot_table_header __iomem *ptr_header;
 
-/*
- * This function parses the coreboot table for an entry that contains the base
- * address of the given entry tag. The coreboot table consists of a header
- * directly followed by a number of small, variable-sized entries, which each
- * contain an identifying tag and their length as the first two fields.
- */
-int coreboot_table_find(int tag, void *data, size_t data_size)
+static int coreboot_bus_match(struct device *dev, struct device_driver *drv)
 {
-        struct coreboot_table_header header;
-        struct coreboot_table_entry entry;
-        void *ptr_entry;
-        int i;
+        struct coreboot_device *device = CB_DEV(dev);
+        struct coreboot_driver *driver = CB_DRV(drv);
 
-        if (!ptr_header)
-                return -EPROBE_DEFER;
+        return device->entry.tag == driver->tag;
+}
 
+static int coreboot_bus_probe(struct device *dev)
+{
+        int ret = -ENODEV;
+        struct coreboot_device *device = CB_DEV(dev);
+        struct coreboot_driver *driver = CB_DRV(dev->driver);
+
+        if (driver->probe)
+                ret = driver->probe(device);
+
+        return ret;
+}
+
+static int coreboot_bus_remove(struct device *dev)
+{
+        int ret = 0;
+        struct coreboot_device *device = CB_DEV(dev);
+        struct coreboot_driver *driver = CB_DRV(dev->driver);
+
+        if (driver->remove)
+                ret = driver->remove(device);
+
+        return ret;
+}
+
+static struct bus_type coreboot_bus_type = {
+        .name           = "coreboot",
+        .match          = coreboot_bus_match,
+        .probe          = coreboot_bus_probe,
+        .remove         = coreboot_bus_remove,
+};
+
+static int __init coreboot_bus_init(void)
+{
+        return bus_register(&coreboot_bus_type);
+}
+module_init(coreboot_bus_init);
+
+static void coreboot_device_release(struct device *dev)
+{
+        struct coreboot_device *device = CB_DEV(dev);
+
+        kfree(device);
+}
+
+int coreboot_driver_register(struct coreboot_driver *driver)
+{
+        driver->drv.bus = &coreboot_bus_type;
+
+        return driver_register(&driver->drv);
+}
+EXPORT_SYMBOL(coreboot_driver_register);
+
+void coreboot_driver_unregister(struct coreboot_driver *driver)
+{
+        driver_unregister(&driver->drv);
+}
+EXPORT_SYMBOL(coreboot_driver_unregister);
+
+int coreboot_table_init(struct device *dev, void __iomem *ptr)
+{
+        int i, ret;
+        void *ptr_entry;
+        struct coreboot_device *device;
+        struct coreboot_table_entry entry;
+        struct coreboot_table_header header;
+
+        ptr_header = ptr;
         memcpy_fromio(&header, ptr_header, sizeof(header));
 
         if (strncmp(header.signature, "LBIO", sizeof(header.signature))) {
@@ -54,37 +114,41 @@ int coreboot_table_find(int tag, void *data, size_t data_size)
         }
 
         ptr_entry = (void *)ptr_header + header.header_bytes;
-
         for (i = 0; i < header.table_entries; i++) {
                 memcpy_fromio(&entry, ptr_entry, sizeof(entry));
-                if (entry.tag == tag) {
-                        if (data_size < entry.size)
-                                return -EINVAL;
 
-                        memcpy_fromio(data, ptr_entry, entry.size);
+                device = kzalloc(sizeof(struct device) + entry.size, GFP_KERNEL);
+                if (!device) {
+                        ret = -ENOMEM;
+                        break;
+                }
+
+                dev_set_name(&device->dev, "coreboot%d", i);
+                device->dev.parent = dev;
+                device->dev.bus = &coreboot_bus_type;
+                device->dev.release = coreboot_device_release;
+                memcpy_fromio(&device->entry, ptr_entry, entry.size);
 
-                        return 0;
+                ret = device_register(&device->dev);
+                if (ret) {
+                        put_device(&device->dev);
+                        break;
                 }
 
                 ptr_entry += entry.size;
         }
 
-        return -ENOENT;
-}
-EXPORT_SYMBOL(coreboot_table_find);
-
-int coreboot_table_init(void __iomem *ptr)
-{
-        ptr_header = ptr;
-
-        return 0;
+        return ret;
 }
 EXPORT_SYMBOL(coreboot_table_init);
 
 int coreboot_table_exit(void)
 {
-        if (ptr_header)
+        if (ptr_header) {
+                bus_unregister(&coreboot_bus_type);
                 iounmap(ptr_header);
+                ptr_header = NULL;
+        }
 
         return 0;
 }