Branch data     Line data    Source code

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