drivers/gpu/drm/sti/sti_plane.c

   1 /*
   2  * Copyright (C) STMicroelectronics SA 2014
   3  * Authors: Benjamin Gaignard <benjamin.gaignard@st.com>
   4  *          Fabien Dessenne <fabien.dessenne@st.com>
   5  *          for STMicroelectronics.
   6  * License terms:  GNU General Public License (GPL), version 2
   7  */
   8
   9 #include <drm/drmP.h>
  10 #include <drm/drm_fb_cma_helper.h>
  11 #include <drm/drm_gem_cma_helper.h>
  12
  13 #include "sti_compositor.h"
  14 #include "sti_drv.h"
  15 #include "sti_plane.h"
  16
  17 /* (Background) < GDP0 < GDP1 < HQVDP0 < GDP2 < GDP3 < (ForeGround) */
  18 enum sti_plane_desc sti_plane_default_zorder[] = {
  19         STI_GDP_0,
  20         STI_GDP_1,
  21         STI_HQVDP_0,
  22         STI_GDP_2,
  23         STI_GDP_3,
  24 };
  25
  26 const char *sti_plane_to_str(struct sti_plane *plane)
  27 {
  28         switch (plane->desc) {
  29         case STI_GDP_0:
  30                 return "GDP0";
  31         case STI_GDP_1:
  32                 return "GDP1";
  33         case STI_GDP_2:
  34                 return "GDP2";
  35         case STI_GDP_3:
  36                 return "GDP3";
  37         case STI_HQVDP_0:
  38                 return "HQVDP0";
  39         case STI_CURSOR:
  40                 return "CURSOR";
  41         default:
  42                 return "<UNKNOWN PLANE>";
  43         }
  44 }
  45
  46 #define STI_FPS_INTERVAL_MS     3000
  47
  48 static int sti_plane_timespec_ms_diff(struct timespec lhs, struct timespec rhs)
  49 {
  50         struct timespec tmp_ts = timespec_sub(lhs, rhs);
  51         u64 tmp_ns = (u64)timespec_to_ns(&tmp_ts);
  52
  53         do_div(tmp_ns, NSEC_PER_MSEC);
  54
  55         return (u32)tmp_ns;
  56 }
  57
  58 void sti_plane_update_fps(struct sti_plane *plane,
  59                           bool new_frame,
  60                           bool new_field)
  61 {
  62         struct timespec now;
  63         struct sti_fps_info *fps;
  64         int fpks, fipks, ms_since_last, num_frames, num_fields;
  65
  66         getrawmonotonic(&now);
  67
  68         /* Compute number of frame updates */
  69         fps = &plane->fps_info;
  70
  71         if (new_field)
  72                 fps->curr_field_counter++;
  73
  74         /* do not perform fps calcul if new_frame is false */
  75         if (!new_frame)
  76                 return;
  77
  78         fps->curr_frame_counter++;
  79         ms_since_last = sti_plane_timespec_ms_diff(now, fps->last_timestamp);
  80         num_frames = fps->curr_frame_counter - fps->last_frame_counter;
  81
  82         if (num_frames <= 0  || ms_since_last < STI_FPS_INTERVAL_MS)
  83                 return;
  84
  85         fps->last_timestamp = now;
  86         fps->last_frame_counter = fps->curr_frame_counter;
  87         fpks = (num_frames * 1000000) / ms_since_last;
  88         snprintf(plane->fps_info.fps_str, FPS_LENGTH, "%-6s @ %d.%.3d fps",
  89                  sti_plane_to_str(plane), fpks / 1000, fpks % 1000);
  90
  91         if (fps->curr_field_counter) {
  92                 /* Compute number of field updates */
  93                 num_fields = fps->curr_field_counter - fps->last_field_counter;
  94                 fps->last_field_counter = fps->curr_field_counter;
  95                 fipks = (num_fields * 1000000) / ms_since_last;
  96                 snprintf(plane->fps_info.fips_str,
  97                          FPS_LENGTH, " - %d.%.3d field/sec",
  98                          fipks / 1000, fipks % 1000);
  99         } else {
 100                 plane->fps_info.fips_str[0] = '\0';
 101         }
 102
 103         if (fps->output)
 104                 DRM_INFO("%s%s\n",
 105                          plane->fps_info.fps_str,
 106                          plane->fps_info.fips_str);
 107 }
 108
 109 static void sti_plane_destroy(struct drm_plane *drm_plane)
 110 {
 111         DRM_DEBUG_DRIVER("\n");
 112
 113         drm_plane_helper_disable(drm_plane);
 114         drm_plane_cleanup(drm_plane);
 115 }
 116
 117 static int sti_plane_set_property(struct drm_plane *drm_plane,
 118                                   struct drm_property *property,
 119                                   uint64_t val)
 120 {
 121         struct drm_device *dev = drm_plane->dev;
 122         struct sti_private *private = dev->dev_private;
 123         struct sti_plane *plane = to_sti_plane(drm_plane);
 124
 125         DRM_DEBUG_DRIVER("\n");
 126
 127         if (property == private->plane_zorder_property) {
 128                 plane->zorder = val;
 129                 return 0;
 130         }
 131
 132         return -EINVAL;
 133 }
 134
 135 static void sti_plane_attach_zorder_property(struct drm_plane *drm_plane)
 136 {
 137         struct drm_device *dev = drm_plane->dev;
 138         struct sti_private *private = dev->dev_private;
 139         struct sti_plane *plane = to_sti_plane(drm_plane);
 140         struct drm_property *prop;
 141
 142         prop = private->plane_zorder_property;
 143         if (!prop) {
 144                 prop = drm_property_create_range(dev, 0, "zpos", 1,
 145                                                  GAM_MIXER_NB_DEPTH_LEVEL);
 146                 if (!prop)
 147                         return;
 148
 149                 private->plane_zorder_property = prop;
 150         }
 151
 152         drm_object_attach_property(&drm_plane->base, prop, plane->zorder);
 153 }
 154
 155 void sti_plane_init_property(struct sti_plane *plane,
 156                              enum drm_plane_type type)
 157 {
 158         unsigned int i;
 159
 160         for (i = 0; i < ARRAY_SIZE(sti_plane_default_zorder); i++)
 161                 if (sti_plane_default_zorder[i] == plane->desc)
 162                         break;
 163
 164         plane->zorder = i + 1;
 165
 166         if (type == DRM_PLANE_TYPE_OVERLAY)
 167                 sti_plane_attach_zorder_property(&plane->drm_plane);
 168
 169         DRM_DEBUG_DRIVER("drm plane:%d mapped to %s with zorder:%d\n",
 170                          plane->drm_plane.base.id,
 171                          sti_plane_to_str(plane), plane->zorder);
 172 }
 173
 174 struct drm_plane_funcs sti_plane_helpers_funcs = {
 175         .update_plane = drm_atomic_helper_update_plane,
 176         .disable_plane = drm_atomic_helper_disable_plane,
 177         .destroy = sti_plane_destroy,
 178         .set_property = sti_plane_set_property,
 179         .reset = drm_atomic_helper_plane_reset,
 180         .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
 181         .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
 182 };