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