git.sur5r.net Git - u-boot/blob - drivers/video/exynos/exynos_mipi_dsi.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2012 Samsung Electronics
   4  *
   5  * Author: InKi Dae <inki.dae@samsung.com>
   6  * Author: Donghwa Lee <dh09.lee@samsung.com>
   7  */
   8
   9 #include <common.h>
  10 #include <malloc.h>
  11 #include <fdtdec.h>
  12 #include <linux/libfdt.h>
  13 #include <linux/compat.h>
  14 #include <linux/err.h>
  15 #include <asm/arch/dsim.h>
  16 #include <asm/arch/mipi_dsim.h>
  17 #include <asm/arch/power.h>
  18 #include <asm/arch/cpu.h>
  19 #include <asm/arch/clk.h>
  20
  21 #include "exynos_mipi_dsi_lowlevel.h"
  22 #include "exynos_mipi_dsi_common.h"
  23
  24 #define master_to_driver(a)     (a->dsim_lcd_drv)
  25 #define master_to_device(a)     (a->dsim_lcd_dev)
  26
  27 DECLARE_GLOBAL_DATA_PTR;
  28
  29 struct mipi_dsim_ddi {
  30         int                             bus_id;
  31         struct list_head                list;
  32         struct mipi_dsim_lcd_device     *dsim_lcd_dev;
  33         struct mipi_dsim_lcd_driver     *dsim_lcd_drv;
  34 };
  35
  36 static LIST_HEAD(dsim_ddi_list);
  37 static LIST_HEAD(dsim_lcd_dev_list);
  38
  39 int exynos_mipi_dsi_register_lcd_device(struct mipi_dsim_lcd_device *lcd_dev)
  40 {
  41         struct mipi_dsim_ddi *dsim_ddi;
  42
  43         if (!lcd_dev) {
  44                 debug("mipi_dsim_lcd_device is NULL.\n");
  45                 return -EFAULT;
  46         }
  47
  48         if (!lcd_dev->name) {
  49                 debug("dsim_lcd_device name is NULL.\n");
  50                 return -EFAULT;
  51         }
  52
  53         dsim_ddi = kzalloc(sizeof(struct mipi_dsim_ddi), GFP_KERNEL);
  54         if (!dsim_ddi) {
  55                 debug("failed to allocate dsim_ddi object.\n");
  56                 return -EFAULT;
  57         }
  58
  59         dsim_ddi->dsim_lcd_dev = lcd_dev;
  60
  61         list_add_tail(&dsim_ddi->list, &dsim_ddi_list);
  62
  63         return 0;
  64 }
  65
  66 struct mipi_dsim_ddi
  67         *exynos_mipi_dsi_find_lcd_device(struct mipi_dsim_lcd_driver *lcd_drv)
  68 {
  69         struct mipi_dsim_ddi *dsim_ddi;
  70         struct mipi_dsim_lcd_device *lcd_dev;
  71
  72         list_for_each_entry(dsim_ddi, &dsim_ddi_list, list) {
  73                 lcd_dev = dsim_ddi->dsim_lcd_dev;
  74                 if (!lcd_dev)
  75                         continue;
  76
  77                 if (lcd_drv->id >= 0) {
  78                         if ((strcmp(lcd_drv->name, lcd_dev->name)) == 0 &&
  79                                         lcd_drv->id == lcd_dev->id) {
  80                                 /**
  81                                  * bus_id would be used to identify
  82                                  * connected bus.
  83                                  */
  84                                 dsim_ddi->bus_id = lcd_dev->bus_id;
  85
  86                                 return dsim_ddi;
  87                         }
  88                 } else {
  89                         if ((strcmp(lcd_drv->name, lcd_dev->name)) == 0) {
  90                                 /**
  91                                  * bus_id would be used to identify
  92                                  * connected bus.
  93                                  */
  94                                 dsim_ddi->bus_id = lcd_dev->bus_id;
  95
  96                                 return dsim_ddi;
  97                         }
  98                 }
  99
 100                 kfree(dsim_ddi);
 101                 list_del(&dsim_ddi_list);
 102         }
 103
 104         return NULL;
 105 }
 106
 107 int exynos_mipi_dsi_register_lcd_driver(struct mipi_dsim_lcd_driver *lcd_drv)
 108 {
 109         struct mipi_dsim_ddi *dsim_ddi;
 110
 111         if (!lcd_drv) {
 112                 debug("mipi_dsim_lcd_driver is NULL.\n");
 113                 return -EFAULT;
 114         }
 115
 116         if (!lcd_drv->name) {
 117                 debug("dsim_lcd_driver name is NULL.\n");
 118                 return -EFAULT;
 119         }
 120
 121         dsim_ddi = exynos_mipi_dsi_find_lcd_device(lcd_drv);
 122         if (!dsim_ddi) {
 123                 debug("mipi_dsim_ddi object not found.\n");
 124                 return -EFAULT;
 125         }
 126
 127         dsim_ddi->dsim_lcd_drv = lcd_drv;
 128
 129         debug("registered panel driver(%s) to mipi-dsi driver.\n",
 130                 lcd_drv->name);
 131
 132         return 0;
 133
 134 }
 135
 136 struct mipi_dsim_ddi
 137         *exynos_mipi_dsi_bind_lcd_ddi(struct mipi_dsim_device *dsim,
 138                         const char *name)
 139 {
 140         struct mipi_dsim_ddi *dsim_ddi;
 141         struct mipi_dsim_lcd_driver *lcd_drv;
 142         struct mipi_dsim_lcd_device *lcd_dev;
 143
 144         list_for_each_entry(dsim_ddi, &dsim_ddi_list, list) {
 145                 lcd_drv = dsim_ddi->dsim_lcd_drv;
 146                 lcd_dev = dsim_ddi->dsim_lcd_dev;
 147                 if (!lcd_drv || !lcd_dev)
 148                         continue;
 149
 150                 debug("lcd_drv->id = %d, lcd_dev->id = %d\n",
 151                                         lcd_drv->id, lcd_dev->id);
 152
 153                 if ((strcmp(lcd_drv->name, name) == 0)) {
 154                         lcd_dev->master = dsim;
 155
 156                         dsim->dsim_lcd_dev = lcd_dev;
 157                         dsim->dsim_lcd_drv = lcd_drv;
 158
 159                         return dsim_ddi;
 160                 }
 161         }
 162
 163         return NULL;
 164 }
 165
 166 /* define MIPI-DSI Master operations. */
 167 static struct mipi_dsim_master_ops master_ops = {
 168         .cmd_write                      = exynos_mipi_dsi_wr_data,
 169         .get_dsim_frame_done            = exynos_mipi_dsi_get_frame_done_status,
 170         .clear_dsim_frame_done          = exynos_mipi_dsi_clear_frame_done,
 171 };
 172
 173 int exynos_mipi_dsi_init(struct exynos_platform_mipi_dsim *dsim_pd)
 174 {
 175         struct mipi_dsim_device *dsim;
 176         struct mipi_dsim_config *dsim_config;
 177         struct mipi_dsim_ddi *dsim_ddi;
 178
 179         dsim = kzalloc(sizeof(struct mipi_dsim_device), GFP_KERNEL);
 180         if (!dsim) {
 181                 debug("failed to allocate dsim object.\n");
 182                 return -EFAULT;
 183         }
 184
 185         /* get mipi_dsim_config. */
 186         dsim_config = dsim_pd->dsim_config;
 187         if (dsim_config == NULL) {
 188                 debug("failed to get dsim config data.\n");
 189                 return -EFAULT;
 190         }
 191
 192         dsim->pd = dsim_pd;
 193         dsim->dsim_config = dsim_config;
 194         dsim->master_ops = &master_ops;
 195
 196         /* bind lcd ddi matched with panel name. */
 197         dsim_ddi = exynos_mipi_dsi_bind_lcd_ddi(dsim, dsim_pd->lcd_panel_name);
 198         if (!dsim_ddi) {
 199                 debug("mipi_dsim_ddi object not found.\n");
 200                 return -ENOSYS;
 201         }
 202         if (dsim_pd->lcd_power)
 203                 dsim_pd->lcd_power();
 204
 205         if (dsim_pd->mipi_power)
 206                 dsim_pd->mipi_power();
 207
 208         /* phy_enable(unsigned int dev_index, unsigned int enable) */
 209         if (dsim_pd->phy_enable)
 210                 dsim_pd->phy_enable(0, 1);
 211
 212         set_mipi_clk();
 213
 214         exynos_mipi_dsi_init_dsim(dsim);
 215         exynos_mipi_dsi_init_link(dsim);
 216         exynos_mipi_dsi_set_hs_enable(dsim);
 217
 218         /* set display timing. */
 219         exynos_mipi_dsi_set_display_mode(dsim, dsim->dsim_config);
 220
 221         /* initialize mipi-dsi client(lcd panel). */
 222         if (dsim_ddi->dsim_lcd_drv && dsim_ddi->dsim_lcd_drv->mipi_panel_init) {
 223                 dsim_ddi->dsim_lcd_drv->mipi_panel_init(dsim);
 224                 dsim_ddi->dsim_lcd_drv->mipi_display_on(dsim);
 225         }
 226
 227         debug("mipi-dsi driver(%s mode) has been probed.\n",
 228                 (dsim_config->e_interface == DSIM_COMMAND) ?
 229                         "CPU" : "RGB");
 230
 231         return 0;
 232 }
 233
 234 int exynos_dsim_config_parse_dt(const void *blob, struct mipi_dsim_config *dt,
 235                                 struct mipi_dsim_lcd_device *lcd_dt)
 236 {
 237         int node;
 238
 239         node = fdtdec_next_compatible(blob, 0, COMPAT_SAMSUNG_EXYNOS_MIPI_DSI);
 240         if (node <= 0) {
 241                 printf("exynos_mipi_dsi: Can't get device node for mipi dsi\n");
 242                 return -ENODEV;
 243         }
 244
 245         dt->e_interface = fdtdec_get_int(blob, node,
 246                                 "samsung,dsim-config-e-interface", 0);
 247
 248         dt->e_virtual_ch = fdtdec_get_int(blob, node,
 249                                 "samsung,dsim-config-e-virtual-ch", 0);
 250
 251         dt->e_pixel_format = fdtdec_get_int(blob, node,
 252                                 "samsung,dsim-config-e-pixel-format", 0);
 253
 254         dt->e_burst_mode = fdtdec_get_int(blob, node,
 255                                 "samsung,dsim-config-e-burst-mode", 0);
 256
 257         dt->e_no_data_lane = fdtdec_get_int(blob, node,
 258                                 "samsung,dsim-config-e-no-data-lane", 0);
 259
 260         dt->e_byte_clk = fdtdec_get_int(blob, node,
 261                                 "samsung,dsim-config-e-byte-clk", 0);
 262
 263         dt->hfp = fdtdec_get_int(blob, node,
 264                                 "samsung,dsim-config-hfp", 0);
 265
 266         dt->p = fdtdec_get_int(blob, node,
 267                                           "samsung,dsim-config-p", 0);
 268         dt->m = fdtdec_get_int(blob, node,
 269                                           "samsung,dsim-config-m", 0);
 270         dt->s = fdtdec_get_int(blob, node,
 271                                           "samsung,dsim-config-s", 0);
 272
 273         dt->pll_stable_time = fdtdec_get_int(blob, node,
 274                                 "samsung,dsim-config-pll-stable-time", 0);
 275
 276         dt->esc_clk = fdtdec_get_int(blob, node,
 277                                 "samsung,dsim-config-esc-clk", 0);
 278
 279         dt->stop_holding_cnt = fdtdec_get_int(blob, node,
 280                                 "samsung,dsim-config-stop-holding-cnt", 0);
 281
 282         dt->bta_timeout = fdtdec_get_int(blob, node,
 283                                 "samsung,dsim-config-bta-timeout", 0);
 284
 285         dt->rx_timeout = fdtdec_get_int(blob, node,
 286                                 "samsung,dsim-config-rx-timeout", 0);
 287
 288         lcd_dt->name = fdtdec_get_config_string(blob,
 289                                 "samsung,dsim-device-name");
 290
 291         lcd_dt->id = fdtdec_get_int(blob, node,
 292                                 "samsung,dsim-device-id", 0);
 293
 294         lcd_dt->bus_id = fdtdec_get_int(blob, node,
 295                                 "samsung,dsim-device-bus_id", 0);
 296
 297         lcd_dt->reverse_panel = fdtdec_get_int(blob, node,
 298                                 "samsung,dsim-device-reverse-panel", 0);
 299
 300         return 0;
 301 }
 302
 303 void exynos_init_dsim_platform_data(vidinfo_t *vid)
 304 {
 305         static struct mipi_dsim_config dsim_config_dt;
 306         static struct exynos_platform_mipi_dsim dsim_platform_data_dt;
 307         static struct mipi_dsim_lcd_device mipi_lcd_device_dt;
 308
 309         if (exynos_dsim_config_parse_dt(gd->fdt_blob, &dsim_config_dt,
 310                                         &mipi_lcd_device_dt))
 311                 debug("Can't get proper dsim config.\n");
 312
 313         strcpy(dsim_platform_data_dt.lcd_panel_name, mipi_lcd_device_dt.name);
 314         dsim_platform_data_dt.dsim_config = &dsim_config_dt;
 315         dsim_platform_data_dt.mipi_power = mipi_power;
 316         dsim_platform_data_dt.phy_enable = set_mipi_phy_ctrl;
 317         dsim_platform_data_dt.lcd_panel_info = (void *)vid;
 318
 319         mipi_lcd_device_dt.platform_data = (void *)&dsim_platform_data_dt;
 320         exynos_mipi_dsi_register_lcd_device(&mipi_lcd_device_dt);
 321
 322         vid->dsim_platform_data_dt = &dsim_platform_data_dt;
 323 }