video: mmp display subsystem
[~shefty/rdma-dev.git] / drivers / video / mmp / core.c
1 /*
2  * linux/drivers/video/mmp/common.c
3  * This driver is a common framework for Marvell Display Controller
4  *
5  * Copyright (C) 2012 Marvell Technology Group Ltd.
6  * Authors: Zhou Zhu <zzhu3@marvell.com>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by the
10  * Free Software Foundation; either version 2 of the License, or (at your
11  * option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  *
18  * You should have received a copy of the GNU General Public License along with
19  * this program.  If not, see <http://www.gnu.org/licenses/>.
20  *
21  */
22
23 #include <linux/slab.h>
24 #include <linux/dma-mapping.h>
25 #include <linux/export.h>
26 #include <video/mmp_disp.h>
27
28 static struct mmp_overlay *path_get_overlay(struct mmp_path *path,
29                 int overlay_id)
30 {
31         if (path && overlay_id < path->overlay_num)
32                 return &path->overlays[overlay_id];
33         return 0;
34 }
35
36 static int path_check_status(struct mmp_path *path)
37 {
38         int i;
39         for (i = 0; i < path->overlay_num; i++)
40                 if (path->overlays[i].status)
41                         return 1;
42
43         return 0;
44 }
45
46 /*
47  * Get modelist write pointer of modelist.
48  * It also returns modelist number
49  * this function fetches modelist from phy/panel:
50  *   for HDMI/parallel or dsi to hdmi cases, get from phy
51  *   or get from panel
52  */
53 static int path_get_modelist(struct mmp_path *path,
54                 struct mmp_mode **modelist)
55 {
56         BUG_ON(!path || !modelist);
57
58         if (path->panel && path->panel->get_modelist)
59                 return path->panel->get_modelist(path->panel, modelist);
60
61         return 0;
62 }
63
64 /*
65  * panel list is used to pair panel/path when path/panel registered
66  * path list is used for both buffer driver and platdriver
67  * plat driver do path register/unregister
68  * panel driver do panel register/unregister
69  * buffer driver get registered path
70  */
71 static LIST_HEAD(panel_list);
72 static LIST_HEAD(path_list);
73 static DEFINE_MUTEX(disp_lock);
74
75 /*
76  * mmp_register_panel - register panel to panel_list and connect to path
77  * @p: panel to be registered
78  *
79  * this function provides interface for panel drivers to register panel
80  * to panel_list and connect to path which matchs panel->plat_path_name.
81  * no error returns when no matching path is found as path register after
82  * panel register is permitted.
83  */
84 void mmp_register_panel(struct mmp_panel *panel)
85 {
86         struct mmp_path *path;
87
88         mutex_lock(&disp_lock);
89
90         /* add */
91         list_add_tail(&panel->node, &panel_list);
92
93         /* try to register to path */
94         list_for_each_entry(path, &path_list, node) {
95                 if (!strcmp(panel->plat_path_name, path->name)) {
96                         dev_info(panel->dev, "connect to path %s\n",
97                                 path->name);
98                         path->panel = panel;
99                         break;
100                 }
101         }
102
103         mutex_unlock(&disp_lock);
104 }
105 EXPORT_SYMBOL_GPL(mmp_register_panel);
106
107 /*
108  * mmp_unregister_panel - unregister panel from panel_list and disconnect
109  * @p: panel to be unregistered
110  *
111  * this function provides interface for panel drivers to unregister panel
112  * from panel_list and disconnect from path.
113  */
114 void mmp_unregister_panel(struct mmp_panel *panel)
115 {
116         struct mmp_path *path;
117
118         mutex_lock(&disp_lock);
119         list_del(&panel->node);
120
121         list_for_each_entry(path, &path_list, node) {
122                 if (path->panel && path->panel == panel) {
123                         dev_info(panel->dev, "disconnect from path %s\n",
124                                 path->name);
125                         path->panel = NULL;
126                         break;
127                 }
128         }
129         mutex_unlock(&disp_lock);
130 }
131 EXPORT_SYMBOL_GPL(mmp_unregister_panel);
132
133 /*
134  * mmp_get_path - get path by name
135  * @p: path name
136  *
137  * this function checks path name in path_list and return matching path
138  * return NULL if no matching path
139  */
140 struct mmp_path *mmp_get_path(const char *name)
141 {
142         struct mmp_path *path;
143         int found = 0;
144
145         mutex_lock(&disp_lock);
146         list_for_each_entry(path, &path_list, node) {
147                 if (!strcmp(name, path->name)) {
148                         found = 1;
149                         break;
150                 }
151         }
152         mutex_unlock(&disp_lock);
153
154         return found ? path : NULL;
155 }
156 EXPORT_SYMBOL_GPL(mmp_get_path);
157
158 /*
159  * mmp_register_path - init and register path by path_info
160  * @p: path info provided by display controller
161  *
162  * this function init by path info and register path to path_list
163  * this function also try to connect path with panel by name
164  */
165 struct mmp_path *mmp_register_path(struct mmp_path_info *info)
166 {
167         int i;
168         size_t size;
169         struct mmp_path *path = NULL;
170         struct mmp_panel *panel;
171
172         size = sizeof(struct mmp_path)
173                 + sizeof(struct mmp_overlay) * info->overlay_num;
174         path = kzalloc(size, GFP_KERNEL);
175         if (!path)
176                 goto failed;
177
178         /* path set */
179         mutex_init(&path->access_ok);
180         path->dev = info->dev;
181         path->id = info->id;
182         path->name = info->name;
183         path->output_type = info->output_type;
184         path->overlay_num = info->overlay_num;
185         path->plat_data = info->plat_data;
186         path->ops.set_mode = info->set_mode;
187
188         mutex_lock(&disp_lock);
189         /* get panel */
190         list_for_each_entry(panel, &panel_list, node) {
191                 if (!strcmp(info->name, panel->plat_path_name)) {
192                         dev_info(path->dev, "get panel %s\n", panel->name);
193                         path->panel = panel;
194                         break;
195                 }
196         }
197
198         dev_info(path->dev, "register %s, overlay_num %d\n",
199                         path->name, path->overlay_num);
200
201         /* default op set: if already set by driver, never cover it */
202         if (!path->ops.check_status)
203                 path->ops.check_status = path_check_status;
204         if (!path->ops.get_overlay)
205                 path->ops.get_overlay = path_get_overlay;
206         if (!path->ops.get_modelist)
207                 path->ops.get_modelist = path_get_modelist;
208
209         /* step3: init overlays */
210         for (i = 0; i < path->overlay_num; i++) {
211                 path->overlays[i].path = path;
212                 path->overlays[i].id = i;
213                 mutex_init(&path->overlays[i].access_ok);
214                 path->overlays[i].ops = info->overlay_ops;
215         }
216
217         /* add to pathlist */
218         list_add_tail(&path->node, &path_list);
219
220         mutex_unlock(&disp_lock);
221         return path;
222
223 failed:
224         kfree(path);
225         mutex_unlock(&disp_lock);
226         return NULL;
227 }
228 EXPORT_SYMBOL_GPL(mmp_register_path);
229
230 /*
231  * mmp_unregister_path - unregister and destory path
232  * @p: path to be destoried.
233  *
234  * this function registers path and destorys it.
235  */
236 void mmp_unregister_path(struct mmp_path *path)
237 {
238         int i;
239
240         if (!path)
241                 return;
242
243         mutex_lock(&disp_lock);
244         /* del from pathlist */
245         list_del(&path->node);
246
247         /* deinit overlays */
248         for (i = 0; i < path->overlay_num; i++)
249                 mutex_destroy(&path->overlays[i].access_ok);
250
251         mutex_destroy(&path->access_ok);
252
253         kfree(path);
254         mutex_unlock(&disp_lock);
255
256         dev_info(path->dev, "de-register %s\n", path->name);
257 }
258 EXPORT_SYMBOL_GPL(mmp_unregister_path);