1 files changed, 315 insertions, 0 deletions

diff --git a/drivers/input/touchscreen/rmi4/rmi_bus.c b/drivers/input/touchscreen/rmi4/rmi_bus.c
new file mode 100644
index 00000000000..6a269df4ff3
--- /dev/null
+++ b/drivers/input/touchscreen/rmi4/rmi_bus.c
@@ -0,0 +1,315 @@
+/*
+ * Copyright (c) 2011 Synaptics Incorporated
+ * Copyright (c) 2011 Unixphere
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/pm.h>
+#include <linux/slab.h>
+#include <linux/list.h>
+#include <linux/rmi.h>
+
+static struct rmi_function_list {
+        struct list_head list;
+        struct rmi_function_handler *fh;
+} rmi_supported_functions;
+
+static int rmi_bus_match(struct device *dev, struct device_driver *driver)
+{
+        struct rmi_driver *rmi_driver;
+        struct rmi_device *rmi_dev;
+        struct rmi_device_platform_data *pdata;
+
+        pr_info("in function ____%s____  \n", __func__);
+        rmi_driver = to_rmi_driver(driver);
+        rmi_dev = to_rmi_device(dev);
+        pdata = to_rmi_platform_data(rmi_dev);
+
+        pr_info("        rmi_driver->driver.name =  %s\n", rmi_driver->driver.name);
+        pr_info("        device:rmi_device = 0x%x \n", rmi_dev);
+        pr_info("             device:rmi_device:rmi_device_platform_data:driver_name = %s \n", pdata->driver_name);
+        pr_info("                    rmi_device:driver = 0x%x \n", rmi_dev->driver);
+
+        if (!strcmp(pdata->driver_name, rmi_driver->driver.name)) {
+                rmi_dev->driver = rmi_driver;
+                pr_info("             names match, so now rmi_device:driver = 0x%x \n",rmi_dev->driver);
+                return 1;
+        }
+        pr_info("             names DO NOT match, so return nothing \n");
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int rmi_bus_suspend(struct device *dev)
+{
+#ifdef GENERIC_SUBSYS_PM_OPS
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+
+        if (pm && pm->suspend)
+                return pm->suspend(dev);
+#endif
+
+        return 0;
+}
+
+static int rmi_bus_resume(struct device *dev)
+{
+#ifdef GENERIC_SUBSYS_PM_OPS
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+        pr_info("in function ____%s____  \n", __func__);
+
+        if (pm && pm->resume)
+                return pm->resume(dev);
+#endif
+
+        return 0;
+}
+#endif
+
+static int rmi_bus_probe(struct device *dev)
+{
+        struct rmi_driver *driver;
+        struct rmi_device *rmi_dev = to_rmi_device(dev);
+
+        pr_info("in function ____%s____  \n", __func__);
+        driver = rmi_dev->driver;
+        if (driver && driver->probe)
+                return driver->probe(rmi_dev);
+
+        return 0;
+}
+
+static int rmi_bus_remove(struct device *dev)
+{
+        struct rmi_driver *driver;
+        struct rmi_device *rmi_dev = to_rmi_device(dev);
+
+        pr_info("in function ____%s____  \n", __func__);
+        driver = rmi_dev->driver;
+        if (driver && driver->remove)
+                return driver->remove(rmi_dev);
+
+        return 0;
+}
+
+static void rmi_bus_shutdown(struct device *dev)
+{
+        struct rmi_driver *driver;
+        struct rmi_device *rmi_dev = to_rmi_device(dev);
+
+        driver = rmi_dev->driver;
+        if (driver && driver->shutdown)
+                driver->shutdown(rmi_dev);
+}
+
+static SIMPLE_DEV_PM_OPS(rmi_bus_pm_ops,
+                         rmi_bus_suspend, rmi_bus_resume);
+
+struct bus_type rmi_bus_type = {
+        .name           = "rmi",
+        .match          = rmi_bus_match,
+        .probe          = rmi_bus_probe,
+        .remove         = rmi_bus_remove,
+        .shutdown       = rmi_bus_shutdown,
+        .pm             = &rmi_bus_pm_ops
+};
+
+int rmi_register_phys_device(struct rmi_phys_device *phys)
+{
+        static int phys_device_num;
+        struct rmi_device_platform_data *pdata = phys->dev->platform_data;
+        struct rmi_device *rmi_dev;
+
+        pr_info("in function ____%s____  \n", __func__);
+
+        if (!pdata) {
+                dev_err(phys->dev, "no platform data!\n");
+                return -EINVAL;
+        }
+
+        rmi_dev = kzalloc(sizeof(struct rmi_device), GFP_KERNEL);
+        if (!rmi_dev)
+                return -ENOMEM;
+
+        rmi_dev->phys = phys;
+        rmi_dev->dev.bus = &rmi_bus_type;
+        dev_set_name(&rmi_dev->dev, "sensor%02d", phys_device_num++);
+
+        phys->rmi_dev = rmi_dev;
+        pr_info("                 registering physical device:\n");
+        pr_info("                 dev.init_name = \n", rmi_dev->dev.init_name);
+        pr_info("                 dev.bus->name = \n", rmi_dev->dev.bus->name);
+        return device_register(&rmi_dev->dev);
+}
+EXPORT_SYMBOL(rmi_register_phys_device);
+
+void rmi_unregister_phys_device(struct rmi_phys_device *phys)
+{
+        struct rmi_device *rmi_dev = phys->rmi_dev;
+        pr_info("in function ____%s____  \n", __func__);
+
+        device_unregister(&rmi_dev->dev);
+        kfree(rmi_dev);
+}
+EXPORT_SYMBOL(rmi_unregister_phys_device);
+
+int rmi_register_driver(struct rmi_driver *driver)
+{
+        pr_info("in function ____%s____  \n", __func__);
+        driver->driver.bus = &rmi_bus_type;
+        return driver_register(&driver->driver);
+}
+EXPORT_SYMBOL(rmi_register_driver);
+
+static int __rmi_driver_remove(struct device *dev, void *data)
+{
+        struct rmi_driver *driver = data;
+        struct rmi_device *rmi_dev = to_rmi_device(dev);
+
+        if (rmi_dev->driver == driver)
+                rmi_dev->driver = NULL;
+
+        return 0;
+}
+
+void rmi_unregister_driver(struct rmi_driver *driver)
+{
+        bus_for_each_dev(&rmi_bus_type, NULL, driver, __rmi_driver_remove);
+        driver_unregister(&driver->driver);
+}
+EXPORT_SYMBOL(rmi_unregister_driver);
+
+static int __rmi_bus_fh_add(struct device *dev, void *data)
+{
+        struct rmi_driver *driver;
+        struct rmi_device *rmi_dev = to_rmi_device(dev);
+        pr_info("in function ____%s____  \n", __func__);
+
+        driver = rmi_dev->driver;
+        if (driver && driver->fh_add)
+                driver->fh_add(rmi_dev, data);
+
+        return 0;
+}
+
+int rmi_register_function_driver(struct rmi_function_handler *fh)
+{
+        struct rmi_function_list *entry;
+        struct rmi_function_handler *fh_dup;
+
+        fh_dup = rmi_get_function_handler(fh->func);
+        if (fh_dup) {
+                pr_err("%s: function f%.2x already registered!\n", __func__,
+                        fh->func);
+                return -EINVAL;
+        }
+
+        entry = kzalloc(sizeof(struct rmi_function_list), GFP_KERNEL);
+        if (!entry)
+                return -ENOMEM;
+
+        entry->fh = fh;
+        list_add_tail(&entry->list, &rmi_supported_functions.list);
+
+        /* notify devices of the new function handler */
+        bus_for_each_dev(&rmi_bus_type, NULL, fh, __rmi_bus_fh_add);
+
+        return 0;
+}
+EXPORT_SYMBOL(rmi_register_function_driver);
+
+static int __rmi_bus_fh_remove(struct device *dev, void *data)
+{
+        struct rmi_driver *driver;
+        struct rmi_device *rmi_dev = to_rmi_device(dev);
+
+        pr_info("in function ____%s____  \n", __func__);
+        driver = rmi_dev->driver;
+        if (driver && driver->fh_remove)
+                driver->fh_remove(rmi_dev, data);
+
+        return 0;
+}
+
+void rmi_unregister_function_driver(struct rmi_function_handler *fh)
+{
+        struct rmi_function_list *entry, *n;
+        pr_info("in function ____%s____  \n", __func__);
+
+        /* notify devices of the removal of the function handler */
+        bus_for_each_dev(&rmi_bus_type, NULL, fh, __rmi_bus_fh_remove);
+
+        list_for_each_entry_safe(entry, n, &rmi_supported_functions.list, list)
+                if (entry->fh->func == fh->func) {
+                        list_del(&entry->list);
+                        kfree(entry);
+                }
+}
+EXPORT_SYMBOL(rmi_unregister_function_driver);
+
+struct rmi_function_handler *rmi_get_function_handler(int id)
+{
+        struct rmi_function_list *entry;
+        pr_info("in function ____%s____  \n", __func__);
+
+        list_for_each_entry(entry, &rmi_supported_functions.list, list)
+                if (entry->fh->func == id)
+                        return entry->fh;
+
+        return NULL;
+}
+EXPORT_SYMBOL(rmi_get_function_handler);
+
+static int __init rmi_bus_init(void)
+{
+        int error;
+
+        pr_info("in function ____%s____  \n", __func__);
+        INIT_LIST_HEAD(&rmi_supported_functions.list);
+
+        error = bus_register(&rmi_bus_type);
+        if (error < 0) {
+                pr_err("%s: error registering the RMI bus: %d\n", __func__,
+                       error);
+                return error;
+        }
+        pr_info("%s: successfully registered RMI bus.\n", __func__);
+
+        return 0;
+}
+
+static void __exit rmi_bus_exit(void)
+{
+        struct rmi_function_list *entry, *n;
+        pr_info("in function ____%s____  \n", __func__);
+
+        list_for_each_entry_safe(entry, n, &rmi_supported_functions.list,
+                                 list) {
+                list_del(&entry->list);
+                kfree(entry);
+        }
+
+        bus_unregister(&rmi_bus_type);
+}
+
+module_init(rmi_bus_init);
+module_exit(rmi_bus_exit);
+
+MODULE_AUTHOR("Eric Andersson <eric.andersson@unixphere.com>");
+MODULE_DESCRIPTION("RMI bus");
+MODULE_LICENSE("GPL");