misc: mic: add a bus driver for virtual MIC devices

This MIC virtual bus driver takes the responsibility of creating all
the virtual devices connected to the PCIe device on the host and the
platform device on the card. The MIC bus hardware operations provide
a way to abstract certain hardware details from the base physical devices.
Examples of devices added on the MIC virtual bus include host DMA and card DMA.
This abstraction enables using a common DMA driver on host and card.

Reviewed-by: Ashutosh Dixit <ashutosh.dixit@intel.com>
Reviewed-by: Nikhil Rao <nikhil.rao@intel.com>
Signed-off-by: Sudeep Dutt <sudeep.dutt@intel.com>
Signed-off-by: Siva Yerramreddy <yshivakrishna@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

4 files changed, 241 insertions, 0 deletions

diff --git a/drivers/misc/mic/Kconfig b/drivers/misc/mic/Kconfig
index 462a5b1d8651..ee1d2ac3cd09 100644
--- a/drivers/misc/mic/Kconfig
+++ b/drivers/misc/mic/Kconfig
@@ -1,3 +1,20 @@
+comment "Intel MIC Bus Driver"
+
+config INTEL_MIC_BUS
+        tristate "Intel MIC Bus Driver"
+        depends on 64BIT && PCI && X86 && X86_DEV_DMA_OPS
+        help
+          This option is selected by any driver which registers a
+          device or driver on the MIC Bus, such as CONFIG_INTEL_MIC_HOST,
+          CONFIG_INTEL_MIC_CARD, CONFIG_INTEL_MIC_X100_DMA etc.
+
+          If you are building a host/card kernel with an Intel MIC device
+          then say M (recommended) or Y, else say N. If unsure say N.
+
+          More information about the Intel MIC family as well as the Linux
+          OS and tools for MIC to use with this driver are available from
+          <http://software.intel.com/en-us/mic-developer>.
+
 comment "Intel MIC Host Driver"
 
 config INTEL_MIC_HOST
diff --git a/drivers/misc/mic/Makefile b/drivers/misc/mic/Makefile
index 05b34d683a58..e9bf148755e2 100644
--- a/drivers/misc/mic/Makefile
+++ b/drivers/misc/mic/Makefile
@@ -4,3 +4,4 @@
 #
 obj-$(CONFIG_INTEL_MIC_HOST) += host/
 obj-$(CONFIG_INTEL_MIC_CARD) += card/
+obj-$(CONFIG_INTEL_MIC_BUS) += bus/
diff --git a/drivers/misc/mic/bus/Makefile b/drivers/misc/mic/bus/Makefile
new file mode 100644
index 000000000000..d85c7f2a0af4
--- /dev/null
+++ b/drivers/misc/mic/bus/Makefile
@@ -0,0 +1,5 @@
+#
+# Makefile - Intel MIC Linux driver.
+# Copyright(c) 2014, Intel Corporation.
+#
+obj-$(CONFIG_INTEL_MIC_BUS) += mic_bus.o
diff --git a/drivers/misc/mic/bus/mic_bus.c b/drivers/misc/mic/bus/mic_bus.c
new file mode 100644
index 000000000000..961ae90aae47
--- /dev/null
+++ b/drivers/misc/mic/bus/mic_bus.c
@@ -0,0 +1,218 @@
+/*
+ * Intel MIC Platform Software Stack (MPSS)
+ *
+ * Copyright(c) 2014 Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Intel MIC Bus driver.
+ *
+ * This implementation is very similar to the the virtio bus driver
+ * implementation @ drivers/virtio/virtio.c
+ */
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/idr.h>
+#include <linux/mic_bus.h>
+
+/* Unique numbering for mbus devices. */
+static DEFINE_IDA(mbus_index_ida);
+
+static ssize_t device_show(struct device *d,
+                           struct device_attribute *attr, char *buf)
+{
+        struct mbus_device *dev = dev_to_mbus(d);
+        return sprintf(buf, "0x%04x\n", dev->id.device);
+}
+static DEVICE_ATTR_RO(device);
+
+static ssize_t vendor_show(struct device *d,
+                           struct device_attribute *attr, char *buf)
+{
+        struct mbus_device *dev = dev_to_mbus(d);
+        return sprintf(buf, "0x%04x\n", dev->id.vendor);
+}
+static DEVICE_ATTR_RO(vendor);
+
+static ssize_t modalias_show(struct device *d,
+                             struct device_attribute *attr, char *buf)
+{
+        struct mbus_device *dev = dev_to_mbus(d);
+        return sprintf(buf, "mbus:d%08Xv%08X\n",
+                       dev->id.device, dev->id.vendor);
+}
+static DEVICE_ATTR_RO(modalias);
+
+static struct attribute *mbus_dev_attrs[] = {
+        &dev_attr_device.attr,
+        &dev_attr_vendor.attr,
+        &dev_attr_modalias.attr,
+        NULL,
+};
+ATTRIBUTE_GROUPS(mbus_dev);
+
+static inline int mbus_id_match(const struct mbus_device *dev,
+                                const struct mbus_device_id *id)
+{
+        if (id->device != dev->id.device && id->device != MBUS_DEV_ANY_ID)
+                return 0;
+
+        return id->vendor == MBUS_DEV_ANY_ID || id->vendor == dev->id.vendor;
+}
+
+/*
+ * This looks through all the IDs a driver claims to support.  If any of them
+ * match, we return 1 and the kernel will call mbus_dev_probe().
+ */
+static int mbus_dev_match(struct device *dv, struct device_driver *dr)
+{
+        unsigned int i;
+        struct mbus_device *dev = dev_to_mbus(dv);
+        const struct mbus_device_id *ids;
+
+        ids = drv_to_mbus(dr)->id_table;
+        for (i = 0; ids[i].device; i++)
+                if (mbus_id_match(dev, &ids[i]))
+                        return 1;
+        return 0;
+}
+
+static int mbus_uevent(struct device *dv, struct kobj_uevent_env *env)
+{
+        struct mbus_device *dev = dev_to_mbus(dv);
+
+        return add_uevent_var(env, "MODALIAS=mbus:d%08Xv%08X",
+                              dev->id.device, dev->id.vendor);
+}
+
+static int mbus_dev_probe(struct device *d)
+{
+        int err;
+        struct mbus_device *dev = dev_to_mbus(d);
+        struct mbus_driver *drv = drv_to_mbus(dev->dev.driver);
+
+        err = drv->probe(dev);
+        if (!err)
+                if (drv->scan)
+                        drv->scan(dev);
+        return err;
+}
+
+static int mbus_dev_remove(struct device *d)
+{
+        struct mbus_device *dev = dev_to_mbus(d);
+        struct mbus_driver *drv = drv_to_mbus(dev->dev.driver);
+
+        drv->remove(dev);
+        return 0;
+}
+
+static struct bus_type mic_bus = {
+        .name  = "mic_bus",
+        .match = mbus_dev_match,
+        .dev_groups = mbus_dev_groups,
+        .uevent = mbus_uevent,
+        .probe = mbus_dev_probe,
+        .remove = mbus_dev_remove,
+};
+
+int mbus_register_driver(struct mbus_driver *driver)
+{
+        driver->driver.bus = &mic_bus;
+        return driver_register(&driver->driver);
+}
+EXPORT_SYMBOL_GPL(mbus_register_driver);
+
+void mbus_unregister_driver(struct mbus_driver *driver)
+{
+        driver_unregister(&driver->driver);
+}
+EXPORT_SYMBOL_GPL(mbus_unregister_driver);
+
+static void mbus_release_dev(struct device *d)
+{
+        struct mbus_device *mbdev = dev_to_mbus(d);
+        kfree(mbdev);
+}
+
+struct mbus_device *
+mbus_register_device(struct device *pdev, int id, struct dma_map_ops *dma_ops,
+                     struct mbus_hw_ops *hw_ops, void __iomem *mmio_va)
+{
+        int ret;
+        struct mbus_device *mbdev;
+
+        mbdev = kzalloc(sizeof(*mbdev), GFP_KERNEL);
+        if (!mbdev)
+                return ERR_PTR(-ENOMEM);
+
+        mbdev->mmio_va = mmio_va;
+        mbdev->dev.parent = pdev;
+        mbdev->id.device = id;
+        mbdev->id.vendor = MBUS_DEV_ANY_ID;
+        mbdev->dev.archdata.dma_ops = dma_ops;
+        mbdev->dev.dma_mask = &mbdev->dev.coherent_dma_mask;
+        dma_set_mask(&mbdev->dev, DMA_BIT_MASK(64));
+        mbdev->dev.release = mbus_release_dev;
+        mbdev->hw_ops = hw_ops;
+        mbdev->dev.bus = &mic_bus;
+
+        /* Assign a unique device index and hence name. */
+        ret = ida_simple_get(&mbus_index_ida, 0, 0, GFP_KERNEL);
+        if (ret < 0)
+                goto free_mbdev;
+
+        mbdev->index = ret;
+        dev_set_name(&mbdev->dev, "mbus-dev%u", mbdev->index);
+        /*
+         * device_register() causes the bus infrastructure to look for a
+         * matching driver.
+         */
+        ret = device_register(&mbdev->dev);
+        if (ret)
+                goto ida_remove;
+        return mbdev;
+ida_remove:
+        ida_simple_remove(&mbus_index_ida, mbdev->index);
+free_mbdev:
+        kfree(mbdev);
+        return ERR_PTR(ret);
+}
+EXPORT_SYMBOL_GPL(mbus_register_device);
+
+void mbus_unregister_device(struct mbus_device *mbdev)
+{
+        int index = mbdev->index; /* save for after device release */
+
+        device_unregister(&mbdev->dev);
+        ida_simple_remove(&mbus_index_ida, index);
+}
+EXPORT_SYMBOL_GPL(mbus_unregister_device);
+
+static int __init mbus_init(void)
+{
+        return bus_register(&mic_bus);
+}
+
+static void __exit mbus_exit(void)
+{
+        bus_unregister(&mic_bus);
+        ida_destroy(&mbus_index_ida);
+}
+
+core_initcall(mbus_init);
+module_exit(mbus_exit);
+
+MODULE_AUTHOR("Intel Corporation");
+MODULE_DESCRIPTION("Intel(R) MIC Bus driver");
+MODULE_LICENSE("GPL v2");