video: mmp display subsystem

Add mmp display subsystem to support Marvell MMP display controllers.

This subsystem contains 4 parts:
--fb folder
--core.c
--hw folder
--panel folder

1. fb folder contains implementation of fb.  fb get path and overlay
   from common interface and operates on these structures.

2. core.c provides common interface for a hardware abstraction.  Major
   parts of this interface are:

   a) Path: path is a output device connected to a panel or HDMI TV.  Main
      operations of the path is set/get timing/output color.  fb operates
      output device through path structure.

   b) Ovly: Ovly is a buffer shown on the path.

      Ovly describes frame buffer and its source/destination size, offset,
      input color, buffer address, z-order, and so on.  Each fb device maps
      to one overlay.

3. hw folder contains implementation of hardware operations defined by
   core.c.  It registers paths for fb use.

4. panel folder contains implementation of panels.  It's connected to
   path.  Panel drivers would also regiester panels and linked to path
   when probe.

Signed-off-by: Zhou Zhu <zzhu3@marvell.com>
Signed-off-by: Lisa Du <cldu@marvell.com>
Cc: Guoqing Li <ligq@marvell.com>
Acked-by: Haojian Zhuang <haojian.zhuang@gmail.com>
Cc: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

5 files changed, 266 insertions, 0 deletions

diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index a913997c7b75..6c2c991af6fa 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -2431,6 +2431,7 @@ config FB_PUV3_UNIGFX
 source "drivers/video/omap/Kconfig"
 source "drivers/video/omap2/Kconfig"
 source "drivers/video/exynos/Kconfig"
+source "drivers/video/mmp/Kconfig"
 source "drivers/video/backlight/Kconfig"
 
 if VT
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index 3363f674237f..0577f834fdcd 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -106,6 +106,7 @@ obj-$(CONFIG_FB_ASILIANT)	  += asiliantfb.o
 obj-$(CONFIG_FB_PXA)              += pxafb.o
 obj-$(CONFIG_FB_PXA168)           += pxa168fb.o
 obj-$(CONFIG_PXA3XX_GCU)          += pxa3xx-gcu.o
+obj-$(CONFIG_MMP_DISP)           += mmp/
 obj-$(CONFIG_FB_W100)             += w100fb.o
 obj-$(CONFIG_FB_TMIO)             += tmiofb.o
 obj-$(CONFIG_FB_AU1100)           += au1100fb.o
diff --git a/drivers/video/mmp/Kconfig b/drivers/video/mmp/Kconfig
new file mode 100644
index 000000000000..055433624526
--- /dev/null
+++ b/drivers/video/mmp/Kconfig
@@ -0,0 +1,5 @@
+menuconfig MMP_DISP
+        tristate "Marvell MMP Display Subsystem support"
+        depends on CPU_PXA910 || CPU_MMP2 || CPU_MMP3 || CPU_PXA988
+        help
+          Marvell Display Subsystem support.
diff --git a/drivers/video/mmp/Makefile b/drivers/video/mmp/Makefile
new file mode 100644
index 000000000000..820eb10ac2dd
--- /dev/null
+++ b/drivers/video/mmp/Makefile
@@ -0,0 +1 @@
+obj-y += core.o
diff --git a/drivers/video/mmp/core.c b/drivers/video/mmp/core.c
new file mode 100644
index 000000000000..9ed83419038b
--- /dev/null
+++ b/drivers/video/mmp/core.c
@@ -0,0 +1,258 @@
+/*
+ * linux/drivers/video/mmp/common.c
+ * This driver is a common framework for Marvell Display Controller
+ *
+ * Copyright (C) 2012 Marvell Technology Group Ltd.
+ * Authors: Zhou Zhu <zzhu3@marvell.com>
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <linux/slab.h>
+#include <linux/dma-mapping.h>
+#include <linux/export.h>
+#include <video/mmp_disp.h>
+
+static struct mmp_overlay *path_get_overlay(struct mmp_path *path,
+                int overlay_id)
+{
+        if (path && overlay_id < path->overlay_num)
+                return &path->overlays[overlay_id];
+        return 0;
+}
+
+static int path_check_status(struct mmp_path *path)
+{
+        int i;
+        for (i = 0; i < path->overlay_num; i++)
+                if (path->overlays[i].status)
+                        return 1;
+
+        return 0;
+}
+
+/*
+ * Get modelist write pointer of modelist.
+ * It also returns modelist number
+ * this function fetches modelist from phy/panel:
+ *   for HDMI/parallel or dsi to hdmi cases, get from phy
+ *   or get from panel
+ */
+static int path_get_modelist(struct mmp_path *path,
+                struct mmp_mode **modelist)
+{
+        BUG_ON(!path || !modelist);
+
+        if (path->panel && path->panel->get_modelist)
+                return path->panel->get_modelist(path->panel, modelist);
+
+        return 0;
+}
+
+/*
+ * panel list is used to pair panel/path when path/panel registered
+ * path list is used for both buffer driver and platdriver
+ * plat driver do path register/unregister
+ * panel driver do panel register/unregister
+ * buffer driver get registered path
+ */
+static LIST_HEAD(panel_list);
+static LIST_HEAD(path_list);
+static DEFINE_MUTEX(disp_lock);
+
+/*
+ * mmp_register_panel - register panel to panel_list and connect to path
+ * @p: panel to be registered
+ *
+ * this function provides interface for panel drivers to register panel
+ * to panel_list and connect to path which matchs panel->plat_path_name.
+ * no error returns when no matching path is found as path register after
+ * panel register is permitted.
+ */
+void mmp_register_panel(struct mmp_panel *panel)
+{
+        struct mmp_path *path;
+
+        mutex_lock(&disp_lock);
+
+        /* add */
+        list_add_tail(&panel->node, &panel_list);
+
+        /* try to register to path */
+        list_for_each_entry(path, &path_list, node) {
+                if (!strcmp(panel->plat_path_name, path->name)) {
+                        dev_info(panel->dev, "connect to path %s\n",
+                                path->name);
+                        path->panel = panel;
+                        break;
+                }
+        }
+
+        mutex_unlock(&disp_lock);
+}
+EXPORT_SYMBOL_GPL(mmp_register_panel);
+
+/*
+ * mmp_unregister_panel - unregister panel from panel_list and disconnect
+ * @p: panel to be unregistered
+ *
+ * this function provides interface for panel drivers to unregister panel
+ * from panel_list and disconnect from path.
+ */
+void mmp_unregister_panel(struct mmp_panel *panel)
+{
+        struct mmp_path *path;
+
+        mutex_lock(&disp_lock);
+        list_del(&panel->node);
+
+        list_for_each_entry(path, &path_list, node) {
+                if (path->panel && path->panel == panel) {
+                        dev_info(panel->dev, "disconnect from path %s\n",
+                                path->name);
+                        path->panel = NULL;
+                        break;
+                }
+        }
+        mutex_unlock(&disp_lock);
+}
+EXPORT_SYMBOL_GPL(mmp_unregister_panel);
+
+/*
+ * mmp_get_path - get path by name
+ * @p: path name
+ *
+ * this function checks path name in path_list and return matching path
+ * return NULL if no matching path
+ */
+struct mmp_path *mmp_get_path(const char *name)
+{
+        struct mmp_path *path;
+        int found = 0;
+
+        mutex_lock(&disp_lock);
+        list_for_each_entry(path, &path_list, node) {
+                if (!strcmp(name, path->name)) {
+                        found = 1;
+                        break;
+                }
+        }
+        mutex_unlock(&disp_lock);
+
+        return found ? path : NULL;
+}
+EXPORT_SYMBOL_GPL(mmp_get_path);
+
+/*
+ * mmp_register_path - init and register path by path_info
+ * @p: path info provided by display controller
+ *
+ * this function init by path info and register path to path_list
+ * this function also try to connect path with panel by name
+ */
+struct mmp_path *mmp_register_path(struct mmp_path_info *info)
+{
+        int i;
+        size_t size;
+        struct mmp_path *path = NULL;
+        struct mmp_panel *panel;
+
+        size = sizeof(struct mmp_path)
+                + sizeof(struct mmp_overlay) * info->overlay_num;
+        path = kzalloc(size, GFP_KERNEL);
+        if (!path)
+                goto failed;
+
+        /* path set */
+        mutex_init(&path->access_ok);
+        path->dev = info->dev;
+        path->id = info->id;
+        path->name = info->name;
+        path->output_type = info->output_type;
+        path->overlay_num = info->overlay_num;
+        path->plat_data = info->plat_data;
+        path->ops.set_mode = info->set_mode;
+
+        mutex_lock(&disp_lock);
+        /* get panel */
+        list_for_each_entry(panel, &panel_list, node) {
+                if (!strcmp(info->name, panel->plat_path_name)) {
+                        dev_info(path->dev, "get panel %s\n", panel->name);
+                        path->panel = panel;
+                        break;
+                }
+        }
+
+        dev_info(path->dev, "register %s, overlay_num %d\n",
+                        path->name, path->overlay_num);
+
+        /* default op set: if already set by driver, never cover it */
+        if (!path->ops.check_status)
+                path->ops.check_status = path_check_status;
+        if (!path->ops.get_overlay)
+                path->ops.get_overlay = path_get_overlay;
+        if (!path->ops.get_modelist)
+                path->ops.get_modelist = path_get_modelist;
+
+        /* step3: init overlays */
+        for (i = 0; i < path->overlay_num; i++) {
+                path->overlays[i].path = path;
+                path->overlays[i].id = i;
+                mutex_init(&path->overlays[i].access_ok);
+                path->overlays[i].ops = info->overlay_ops;
+        }
+
+        /* add to pathlist */
+        list_add_tail(&path->node, &path_list);
+
+        mutex_unlock(&disp_lock);
+        return path;
+
+failed:
+        kfree(path);
+        mutex_unlock(&disp_lock);
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(mmp_register_path);
+
+/*
+ * mmp_unregister_path - unregister and destory path
+ * @p: path to be destoried.
+ *
+ * this function registers path and destorys it.
+ */
+void mmp_unregister_path(struct mmp_path *path)
+{
+        int i;
+
+        if (!path)
+                return;
+
+        mutex_lock(&disp_lock);
+        /* del from pathlist */
+        list_del(&path->node);
+
+        /* deinit overlays */
+        for (i = 0; i < path->overlay_num; i++)
+                mutex_destroy(&path->overlays[i].access_ok);
+
+        mutex_destroy(&path->access_ok);
+
+        kfree(path);
+        mutex_unlock(&disp_lock);
+
+        dev_info(path->dev, "de-register %s\n", path->name);
+}
+EXPORT_SYMBOL_GPL(mmp_unregister_path);