drivers/gpu/drm/i915/display/intel_dsi.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright © 2018 Intel Corporation
   4  */
   5
   6 #include <drm/drm_mipi_dsi.h>
   7
   8 #include "i915_drv.h"
   9 #include "intel_dsi.h"
  10 #include "intel_panel.h"
  11
  12 void intel_dsi_wait_panel_power_cycle(struct intel_dsi *intel_dsi)
  13 {
  14         ktime_t panel_power_on_time;
  15         s64 panel_power_off_duration;
  16
  17         panel_power_on_time = ktime_get_boottime();
  18         panel_power_off_duration = ktime_ms_delta(panel_power_on_time,
  19                                                   intel_dsi->panel_power_off_time);
  20
  21         if (panel_power_off_duration < (s64)intel_dsi->panel_pwr_cycle_delay)
  22                 msleep(intel_dsi->panel_pwr_cycle_delay - panel_power_off_duration);
  23 }
  24
  25 void intel_dsi_shutdown(struct intel_encoder *encoder)
  26 {
  27         struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
  28
  29         intel_dsi_wait_panel_power_cycle(intel_dsi);
  30 }
  31
  32 int intel_dsi_bitrate(const struct intel_dsi *intel_dsi)
  33 {
  34         int bpp = mipi_dsi_pixel_format_to_bpp(intel_dsi->pixel_format);
  35
  36         if (WARN_ON(bpp < 0))
  37                 bpp = 16;
  38
  39         return intel_dsi->pclk * bpp / intel_dsi->lane_count;
  40 }
  41
  42 int intel_dsi_tlpx_ns(const struct intel_dsi *intel_dsi)
  43 {
  44         switch (intel_dsi->escape_clk_div) {
  45         default:
  46         case 0:
  47                 return 50;
  48         case 1:
  49                 return 100;
  50         case 2:
  51                 return 200;
  52         }
  53 }
  54
  55 int intel_dsi_get_modes(struct drm_connector *connector)
  56 {
  57         return intel_panel_get_modes(to_intel_connector(connector));
  58 }
  59
  60 enum drm_mode_status intel_dsi_mode_valid(struct drm_connector *connector,
  61                                           struct drm_display_mode *mode)
  62 {
  63         struct drm_i915_private *dev_priv = to_i915(connector->dev);
  64         struct intel_connector *intel_connector = to_intel_connector(connector);
  65         const struct drm_display_mode *fixed_mode =
  66                 intel_panel_fixed_mode(intel_connector, mode);
  67         int max_dotclk = to_i915(connector->dev)->display.cdclk.max_dotclk_freq;
  68         enum drm_mode_status status;
  69
  70         drm_dbg_kms(&dev_priv->drm, "\n");
  71
  72         status = intel_panel_mode_valid(intel_connector, mode);
  73         if (status != MODE_OK)
  74                 return status;
  75
  76         if (fixed_mode->clock > max_dotclk)
  77                 return MODE_CLOCK_HIGH;
  78
  79         return intel_mode_valid_max_plane_size(dev_priv, mode, 1);
  80 }
  81
  82 struct intel_dsi_host *intel_dsi_host_init(struct intel_dsi *intel_dsi,
  83                                            const struct mipi_dsi_host_ops *funcs,
  84                                            enum port port)
  85 {
  86         struct intel_dsi_host *host;
  87         struct mipi_dsi_device *device;
  88
  89         host = kzalloc(sizeof(*host), GFP_KERNEL);
  90         if (!host)
  91                 return NULL;
  92
  93         host->base.ops = funcs;
  94         host->intel_dsi = intel_dsi;
  95         host->port = port;
  96
  97         /*
  98          * We should call mipi_dsi_host_register(&host->base) here, but we don't
  99          * have a host->dev, and we don't have OF stuff either. So just use the
 100          * dsi framework as a library and hope for the best. Create the dsi
 101          * devices by ourselves here too. Need to be careful though, because we
 102          * don't initialize any of the driver model devices here.
 103          */
 104         device = kzalloc(sizeof(*device), GFP_KERNEL);
 105         if (!device) {
 106                 kfree(host);
 107                 return NULL;
 108         }
 109
 110         device->host = &host->base;
 111         host->device = device;
 112
 113         return host;
 114 }
 115
 116 enum drm_panel_orientation
 117 intel_dsi_get_panel_orientation(struct intel_connector *connector)
 118 {
 119         struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
 120         enum drm_panel_orientation orientation;
 121
 122         orientation = connector->panel.vbt.dsi.orientation;
 123         if (orientation != DRM_MODE_PANEL_ORIENTATION_UNKNOWN)
 124                 return orientation;
 125
 126         orientation = dev_priv->display.vbt.orientation;
 127         if (orientation != DRM_MODE_PANEL_ORIENTATION_UNKNOWN)
 128                 return orientation;
 129
 130         return DRM_MODE_PANEL_ORIENTATION_NORMAL;
 131 }