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 NULL; 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 return NULL; 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 EXPORT_SYMBOL_GPL(mmp_register_path); 224 225 /* 226 * mmp_unregister_path - unregister and destory path 227 * @p: path to be destoried. 228 * 229 * this function registers path and destorys it. 230 */ 231 void mmp_unregister_path(struct mmp_path *path) 232 { 233 int i; 234 235 if (!path) 236 return; 237 238 mutex_lock(&disp_lock); 239 /* del from pathlist */ 240 list_del(&path->node); 241 242 /* deinit overlays */ 243 for (i = 0; i < path->overlay_num; i++) 244 mutex_destroy(&path->overlays[i].access_ok); 245 246 mutex_destroy(&path->access_ok); 247 248 kfree(path); 249 mutex_unlock(&disp_lock); 250 } 251 EXPORT_SYMBOL_GPL(mmp_unregister_path); 252